8292053873

Committed 15 Mar 2024 06:07AM UTC coverage: 73.083% (+0.09%) from 72.995%

Build # 8292053873

Build Type

push

github

Committed by

mborsetti

Commit Message

Version 3.20rc0

Run Details

1468 of 2275 branches covered (64.53%)

Branch coverage included in aggregate %.

21 of 32 new or added lines in 5 files covered. (65.63%)

2 existing lines in 2 files now uncovered.

3737 of 4847 relevant lines covered (77.1%)

6.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.6

/webchanges/mailer.py

"""Email handler."""

# The code below is subject to the license contained in the LICENSE file, which is part of the source code.

from __future__ import annotations

import getpass
import logging
import smtplib
import subprocess  # noqa: S404 Consider possible security implications associated with the subprocess module.
from dataclasses import dataclass
from email import policy
from email.errors import InvalidHeaderDefect
from email.headerregistry import Address
from email.message import EmailMessage
from email.utils import formatdate
from pathlib import Path
from types import ModuleType
from typing import Optional, Union

try:
    import keyring
except ImportError as e:
    keyring = e.msg  # type: ignore[assignment]

logger = logging.getLogger(__name__)


class Mailer:
    """Mailer class."""

    def send(self, msg: Union[EmailMessage]) -> None:
        """Send a message.

        :param msg: The message to be sent.
        :raises NotImplementedError: Use a subclass of EmailMessage to send a message.
        """
        raise NotImplementedError

    @staticmethod
    def msg(
        from_email: str, to_email: str, subject: str, text_body: str, html_body: Optional[str] = None
    ) -> EmailMessage:
        """Create an Email object for a message.

        :param from_email: The 'From' email address
        :param to_email: The 'To' email address
        :param subject: The 'Subject' of the email
        :param text_body: The body in text format
        :param html_body: The body in html format (optional)
        """
        msg = EmailMessage(policy=policy.SMTPUTF8)
        try:
            msg['From'] = Address(from_email)  # type: ignore[assignment]  # mypy bug
        except InvalidHeaderDefect as e:
            raise ValueError(f"Reporter email's 'from' email address is incorrect: {e.args[0]}")
        try:
            msg['To'] = (Address(addr.strip()) for addr in to_email.split(','))  # type: ignore[assignment]  # mypy bug
        except InvalidHeaderDefect as e:
            raise ValueError(f"Reporter email's 'to' email address is incorrect: {e.args[0]}")
        msg['Subject'] = subject
        msg['Date'] = formatdate(localtime=True)
        msg.set_content(text_body, subtype='plain')
        if html_body is not None:
            msg.add_alternative(html_body, subtype='html')

        return msg


@dataclass
class SMTPMailer(Mailer):
    """The Mailer class for SMTP.

    :param smtp_user: The username for the SMTP server.
    :param smtp_server: The address of the SMTP server.
    :param smtp_port: The port of the SMTP server.
    :param tls: Whether tls is to be used to connect to the SMTP server.
    :param auth: Whether authentication is to be used with the SMTP server.
    :param insecure_password: The password for the SMTP server (optional, to be used only if no keyring is present).
    """

    smtp_user: str
    smtp_server: str
    smtp_port: int
    tls: bool
    auth: bool
    insecure_password: Optional[str] = None

    def send(self, msg: Optional[EmailMessage]) -> None:
        """Send a message via the SMTP server.

        :param msg: The message to be sent. Optional in order to allow server login testing.
        """
        passwd = ''  # noqa: S105 Possible hardcoded password.
        if self.auth:
            if self.insecure_password:
                passwd = self.insecure_password
            elif isinstance(keyring, ModuleType):
                key_pass = keyring.get_password(self.smtp_server, self.smtp_user)
                if key_pass is None:
                    raise ValueError(f'No password available in keyring for {self.smtp_server} {self.smtp_user}')
                else:
                    passwd = key_pass
            else:
                raise ValueError(f'No password available for {self.smtp_server} {self.smtp_user}')

        with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
            server.ehlo()
            if self.tls:
                server.starttls()
            if self.auth:
                server.login(self.smtp_user, passwd)
            if msg:
                server.send_message(msg)
                logger.info(f"SMTP email sent to {msg.get('to')} via {self.smtp_server}")


@dataclass
class SendmailMailer(Mailer):
    """The Mailer class to use sendmail executable."""

    sendmail_path: Union[str, Path]

    def send(self, msg: Union[EmailMessage]) -> None:
        """Send a message via the sendmail executable.

        :param msg: The message to be sent.
        """
        if msg['From']:
            command = [self.sendmail_path, '-oi', msg['To'] + [addr.strip() for addr in msg['To'].split(',')]]
        else:
            command = [
                self.sendmail_path,
                '-oi',
                '-f',
                msg['From'] + [addr.strip() for addr in msg['To'].split(',')],
            ]
        p = subprocess.run(  # noqa: S603 subprocess call - check for execution of untrusted input.
            command,
            input=msg.as_string(),
            capture_output=True,
            text=True,
        )
        if p.returncode:
            logger.error(f'Sendmail failed with {p.stderr}')


def smtp_have_password(smtp_server: str, from_email: str) -> bool:
    """Check whether the keyring password is set for the email service.

    :param smtp_server: The address of the SMTP server.
    :param from_email: The email address of the sender.
    :returns: True if the keyring password is set.
    """
    if isinstance(keyring, str):
        return False

    return keyring.get_password(smtp_server, from_email) is not None


def smtp_set_password(smtp_server: str, from_email: str) -> None:
    """Set the keyring password for the email service. Interactive.

    :param smtp_server: The address of the SMTP server.
    :param from_email: The email address of the sender.
    """
    if isinstance(keyring, str):
        raise ImportError(f"Python package 'keyring' cannot be loaded - service unsupported\n{keyring}")

    password = getpass.getpass(prompt=f'Enter password for {from_email} using {smtp_server}: ')
    keyring.set_password(smtp_server, from_email, password)

1	"""Email handler."""
2
3	# The code below is subject to the license contained in the LICENSE file, which is part of the source code.
4
5	from __future__ import annotations	8✔
6
7	import getpass	8✔
8	import logging	8✔
9	import smtplib	8✔
10	import subprocess # noqa: S404 Consider possible security implications associated with the subprocess module.	8✔
11	from dataclasses import dataclass	8✔
12	from email import policy	8✔
13	from email.errors import InvalidHeaderDefect	8✔
14	from email.headerregistry import Address	8✔
15	from email.message import EmailMessage	8✔
16	from email.utils import formatdate	8✔
17	from pathlib import Path	8✔
18	from types import ModuleType	8✔
19	from typing import Optional, Union	8✔
20
21	try:	8✔
22	import keyring	8✔
23	except ImportError as e:	×
24	keyring = e.msg # type: ignore[assignment]	×
25
26	logger = logging.getLogger(__name__)	8✔
27
28
29	class Mailer:	8✔
30	"""Mailer class."""
31
32	def send(self, msg: Union[EmailMessage]) -> None:	8✔
33	"""Send a message.
34
35	:param msg: The message to be sent.
36	:raises NotImplementedError: Use a subclass of EmailMessage to send a message.
37	"""
38	raise NotImplementedError
39
40	@staticmethod	8✔
41	def msg(	8✔
42	from_email: str, to_email: str, subject: str, text_body: str, html_body: Optional[str] = None
43	) -> EmailMessage:
44	"""Create an Email object for a message.
45
46	:param from_email: The 'From' email address
47	:param to_email: The 'To' email address
48	:param subject: The 'Subject' of the email
49	:param text_body: The body in text format
50	:param html_body: The body in html format (optional)
51	"""
52	msg = EmailMessage(policy=policy.SMTPUTF8)	8✔
53	try:	8✔
54	msg['From'] = Address(from_email) # type: ignore[assignment] # mypy bug	8✔
NEW 55	except InvalidHeaderDefect as e:	×
NEW 56	raise ValueError(f"Reporter email's 'from' email address is incorrect: {e.args[0]}")	×
57	try:	8✔
58	msg['To'] = (Address(addr.strip()) for addr in to_email.split(',')) # type: ignore[assignment] # mypy bug	8✔
NEW 59	except InvalidHeaderDefect as e:	×
NEW 60	raise ValueError(f"Reporter email's 'to' email address is incorrect: {e.args[0]}")	×
61	msg['Subject'] = subject	8✔
62	msg['Date'] = formatdate(localtime=True)	8✔
63	msg.set_content(text_body, subtype='plain')	8✔
64	if html_body is not None:	8!
65	msg.add_alternative(html_body, subtype='html')	8✔
66
67	return msg	8✔
68
69
70	@dataclass	8✔
71	class SMTPMailer(Mailer):	8✔
72	"""The Mailer class for SMTP.
73
74	:param smtp_user: The username for the SMTP server.
75	:param smtp_server: The address of the SMTP server.
76	:param smtp_port: The port of the SMTP server.
77	:param tls: Whether tls is to be used to connect to the SMTP server.
78	:param auth: Whether authentication is to be used with the SMTP server.
79	:param insecure_password: The password for the SMTP server (optional, to be used only if no keyring is present).
80	"""
81
82	smtp_user: str	8✔
83	smtp_server: str	8✔
84	smtp_port: int	8✔
85	tls: bool	8✔
86	auth: bool	8✔
87	insecure_password: Optional[str] = None	8✔
88
89	def send(self, msg: Optional[EmailMessage]) -> None:	8✔
90	"""Send a message via the SMTP server.
91
92	:param msg: The message to be sent. Optional in order to allow server login testing.
93	"""
94	passwd = '' # noqa: S105 Possible hardcoded password.	8✔
95	if self.auth:	8!
96	if self.insecure_password:	8✔
97	passwd = self.insecure_password	8✔
98	elif isinstance(keyring, ModuleType):	8!
99	key_pass = keyring.get_password(self.smtp_server, self.smtp_user)	8✔
100	if key_pass is None:	4!
101	raise ValueError(f'No password available in keyring for {self.smtp_server} {self.smtp_user}')	4✔
102	else:
103	passwd = key_pass	×
104	else:
105	raise ValueError(f'No password available for {self.smtp_server} {self.smtp_user}')	×
106
107	with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:	8✔
108	server.ehlo()	8✔
109	if self.tls:	8!
110	server.starttls()	8✔
111	if self.auth:	8!
112	server.login(self.smtp_user, passwd)	8✔
113	if msg:	×
114	server.send_message(msg)	×
115	logger.info(f"SMTP email sent to {msg.get('to')} via {self.smtp_server}")	2✔
116
117
118	@dataclass	8✔
119	class SendmailMailer(Mailer):	8✔
120	"""The Mailer class to use sendmail executable."""
121
122	sendmail_path: Union[str, Path]	8✔
123
124	def send(self, msg: Union[EmailMessage]) -> None:	8✔
125	"""Send a message via the sendmail executable.
126
127	:param msg: The message to be sent.
128	"""
129	if msg['From']:	×
NEW 130	command = [self.sendmail_path, '-oi', msg['To'] + [addr.strip() for addr in msg['To'].split(',')]]	×
131	else:
NEW 132	command = [	×
133	self.sendmail_path,
134	'-oi',
135	'-f',
136	msg['From'] + [addr.strip() for addr in msg['To'].split(',')],
137	]
UNCOV 138	p = subprocess.run( # noqa: S603 subprocess call - check for execution of untrusted input.	×
139	command,
140	input=msg.as_string(),
141	capture_output=True,
142	text=True,
143	)
144	if p.returncode:	×
145	logger.error(f'Sendmail failed with {p.stderr}')	×
146
147
148	def smtp_have_password(smtp_server: str, from_email: str) -> bool:	8✔
149	"""Check whether the keyring password is set for the email service.
150
151	:param smtp_server: The address of the SMTP server.
152	:param from_email: The email address of the sender.
153	:returns: True if the keyring password is set.
154	"""
155	if isinstance(keyring, str):	8!
156	return False	×
157
158	return keyring.get_password(smtp_server, from_email) is not None	8✔
159
160
161	def smtp_set_password(smtp_server: str, from_email: str) -> None:	8✔
162	"""Set the keyring password for the email service. Interactive.
163
164	:param smtp_server: The address of the SMTP server.
165	:param from_email: The email address of the sender.
166	"""
167	if isinstance(keyring, str):	8!
168	raise ImportError(f"Python package 'keyring' cannot be loaded - service unsupported\n{keyring}")	×
169
170	password = getpass.getpass(prompt=f'Enter password for {from_email} using {smtp_server}: ')	8✔
171	keyring.set_password(smtp_server, from_email, password)	×

mborsetti / webchanges / 8292053873

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous