def ssl_preset_client(request, ssl_preset_server, event_loop):
client = SMTP(
hostname=ssl_preset_server.hostname, port=ssl_preset_server.port,
loop=ssl_preset_server.loop, use_ssl=True, validate_certs=False)
client.server = ssl_preset_server
return client
def smtpd_client(request, smtpd_server, event_loop):
client = SMTP(
hostname=smtpd_server.hostname, port=smtpd_server.port,
loop=event_loop, timeout=1)
client.server = smtpd_server
return client
def tls_preset_client(request, tls_preset_server, event_loop):
client = SMTP(
hostname=tls_preset_server.hostname, port=tls_preset_server.port,
loop=event_loop, use_tls=True, validate_certs=False, timeout=1)
client.server = tls_preset_server
return client
def preset_client(request, preset_server, event_loop):
client = SMTP(
hostname=preset_server.hostname, port=preset_server.port,
loop=event_loop, timeout=1)
client.server = preset_server
return client
def aiosmtpd_client(request, aiosmtpd_server, event_loop):
client = SMTP(
hostname=aiosmtpd_server.hostname, port=aiosmtpd_server.port,
loop=event_loop)
client.server = aiosmtpd_server
return client
def preset_client(request, preset_server, event_loop):
client = SMTP(
hostname=preset_server.hostname, port=preset_server.port,
loop=preset_server.loop)
client.server = preset_server
return client
def __init__(self, queue, delay, loop):
self.loop = loop
self.delay = delay
self.queue = queue
self.smtp = SMTP(hostname="127.0.0.1", port=25)
self.timer = None
self.task = asyncio.ensure_future(self.process_queue())
async def send(mail: Mail, templates: Templates) -> str:
"""Send one email over smtp.
Raises:
CannotSendMessages: when cannot connect to smtp server
FailedToSendMessage: - when cannot send the message
Args:
mail (Mail): mail to be sent
templates (Dict[str, str]): dictionary of templates
"""
smtp = SMTP(
hostname=settings.smtp_host,
port=int(settings.smtp_port),
use_tls=settings.smtp_tls,
)
message = EmailMessage()
message["From"] = settings.mail_from
message["Return-Path"] = settings.mail_return
message["Subject"] = mail.subject
message["To"] = ", ".join(mail.to)
if mail.cc:
message["CC"] = ", ".join(mail.cc)
if mail.bcc:
message["BCC"] = ", ".join(mail.bcc)
message = await attach_content(mail, templates, message)
try:
try:
await smtp.connect()
if settings.smtp_user:
await smtp.ehlo()
await smtp.auth_plain(
settings.smtp_user,
settings.smtp_password.get_secret_value(),
)
except (SMTPConnectError, SMTPAuthenticationError) as e:
log.error(e)
if log.getEffectiveLevel() == logging.DEBUG:
log.exception(e)
raise CannotSendMessages()
await smtp.send_message(message)
smtp.close()
return str(message)
except (SMTPRecipientsRefused, SMTPResponseException) as e:
log.exception(e)
raise FailedToSendMessage()
async def test_close_works_on_stopped_loop(smtpd_server, event_loop, hostname, port):
client = SMTP(hostname=hostname, port=port, loop=event_loop)
await client.connect()
assert client.is_connected
assert client.transport is not None
event_loop.stop()
client.close()
assert not client.is_connected
async def test_bad_connect_response_raises_error(preset_server, event_loop):
preset_client = SMTP(hostname=preset_server.hostname,
port=preset_server.port,
loop=event_loop,
timeout=1.0)
preset_server.greeting = b'421 Please come back in 204232430 seconds.\n'
with pytest.raises(SMTPConnectError):
await preset_client.connect()
preset_client.close()
async def test_default_port_on_connect(event_loop):
client = SMTP(loop=event_loop)
try:
await client.connect(use_tls=False, timeout=0.000000001)
except SMTPTimeoutError:
pass # Ignore connection failure
assert client.port == 25
client.close()
async def test_default_tls_port_on_connect(event_loop):
client = SMTP(loop=event_loop)
try:
await client.connect(use_tls=True, timeout=0.01)
except Exception:
pass # Ignore connection failure
assert client.port == 465
client.close()
async def test_close_works_on_stopped_loop(preset_server, event_loop):
preset_client = SMTP(hostname=preset_server.hostname,
port=preset_server.port,
loop=event_loop)
await preset_client.connect()
assert preset_client.is_connected
assert preset_client.transport is not None
event_loop.stop()
preset_client.close()
assert not preset_client.is_connected
async def test_default_port_on_connect(event_loop, bind_address, use_tls,
start_tls, expected_port):
client = SMTP()
try:
await client.connect(hostname=bind_address,
use_tls=use_tls,
start_tls=start_tls,
timeout=0.001)
except (asyncio.TimeoutError, OSError):
pass
assert client.port == expected_port
client.close()
async def test_quit_then_connect_ok_with_preset_server(preset_server,
event_loop):
preset_client = SMTP(
hostname=preset_server.hostname,
port=preset_server.port,
loop=event_loop,
timeout=1.0,
)
response = await preset_client.connect()
assert response.code == 220
response = await preset_client.quit()
assert response.code == 221
# Next command should fail
with pytest.raises(SMTPServerDisconnected):
await preset_client.noop()
response = await preset_client.connect()
assert response.code == 220
# after reconnect, it should work again
preset_server.responses.append(b"250 noop")
response = await preset_client.noop()
assert response.code == 250
await preset_client.quit()
async def test_config_via_connect_kwargs(preset_server, event_loop):
client = SMTP(
hostname="",
use_tls=True,
port=preset_server.port + 1,
source_address="example.com",
)
source_address = socket.getfqdn()
await client.connect(
hostname=preset_server.hostname,
port=preset_server.port,
loop=event_loop,
use_tls=False,
source_address=source_address,
)
assert client.is_connected
assert client.hostname == preset_server.hostname
assert client.port == preset_server.port
assert client.loop == event_loop
assert client.use_tls is False
assert client.source_address == source_address
await client.quit()
async def connect_and_run_commands(*args, **kwargs):
async with SMTP(hostname=hostname, port=port) as client:
await client.ehlo()
await client.help()
response = await client.noop()
return response
async def test_connect_and_sendmail_multiple_times_with_gather(
smtpd_server, event_loop):
sender = '*****@*****.**'
recipients = [
'*****@*****.**',
'*****@*****.**',
'*****@*****.**',
]
mail_text = """
Hello world!
-a tester
"""
client = SMTP(hostname=smtpd_server.hostname,
port=smtpd_server.port,
loop=event_loop)
async def connect_and_send(*args, **kwargs):
async with client:
response = await client.sendmail(*args, **kwargs)
return response
tasks = [
connect_and_send(sender, [recipient], mail_text)
for recipient in recipients
]
results = await asyncio.gather(*tasks, loop=event_loop)
for errors, message in results:
assert not errors
assert isinstance(errors, dict)
assert message != ''
async def test_connect_timeout_takes_precedence(hostname, smtpd_server_port):
client = SMTP(hostname=hostname, port=smtpd_server_port, timeout=0.66)
await client.connect(timeout=0.99)
assert client.timeout == 0.99
await client.quit()
async def test_connect_port_takes_precedence(event_loop, hostname, smtpd_server_port):
client = SMTP(hostname=hostname, port=17)
await client.connect(port=smtpd_server_port)
assert client.port == smtpd_server_port
await client.quit()
async def send_with_send_message(message, recipients):
"""Send email."""
smtp_client = SMTP(hostname=app_config.MAIL_SERVER,
port=app_config.MAIL_PORT)
await smtp_client.connect()
await smtp_client.send_message(message=message, recipients=recipients)
await smtp_client.quit()
def smtp_client_smtputf8(request, event_loop, hostname,
smtpd_server_smtputf8_port):
client = SMTP(hostname=hostname,
port=smtpd_server_smtputf8_port,
timeout=1.0)
return client
async def send_verify_email(target_email: str, token: str):
"""Send an auth email."""
subject = "LUHack Discord Verification Bot Authentication Email"
body = textwrap.dedent(f"""
Hello!
You are receiving this email because you have requested to authenticate yourself as a valid Lancaster University student on the LUHack Discord server.
Your authentication token is: {token}
DM the bot and use the command: "!verify {token}"
""")
message = EmailMessage()
message["From"] = from_email_address
message["To"] = target_email
message["Subject"] = subject
message.set_content(body)
smtp_client = SMTP(hostname="smtp.lancs.ac.uk")
async with smtp_client:
await smtp_client.send_message(message)
logger.info(f"Sent auth email to: {target_email}")
def tls_smtp_client(request, event_loop, hostname, port):
tls_client = SMTP(hostname=hostname,
port=port,
use_tls=True,
validate_certs=False)
return tls_client
async def send_mail(to_mails: Sequence[EmailStr], text: str, subject: str,
email_type: str):
"""
发送邮件
:param to_mails:
:param text:
:param subject:
:param email_type:
:return:
"""
to_mails = to_mails
text = text
subject = subject
# config = await get_config_by_key('email_config')
# client = SMTP(hostname=config.get('mail_host'), port=config.get('mail_port'), username=config.get('mail_user'),
# password=config.get('mail_password'), use_tls=True)
client = SMTP(hostname="smtp.office365.com",
port=587,
username="******",
password="******",
start_tls=True)
if email_type == "html":
message = MIMEText(text, 'html', 'utf-8')
else:
message = EmailMessage()
message.set_content(text)
message['From'] = "*****@*****.**"
message['Subject'] = subject
async with client:
ret = await client.send_message(
message,
recipients=to_mails,
)
return ret
async def test_connect_error_with_no_server(hostname, unused_tcp_port):
client = SMTP(hostname=hostname, port=unused_tcp_port)
with pytest.raises(SMTPConnectError):
# SMTPConnectTimeoutError vs SMTPConnectError here depends on
# processing time.
await client.connect(timeout=1.0)
async def test_starttls_certificate_options_take_precedence(
event_loop, hostname, port, smtpd_server, valid_cert_path,
valid_key_path):
client = SMTP(
hostname=hostname,
port=port,
validate_certs=False,
client_cert="test1",
client_key="test1",
cert_bundle="test1",
)
await client.connect(
validate_certs=False,
client_cert="test2",
client_key="test2",
cert_bundle="test2",
)
await client.starttls(
client_cert=valid_cert_path,
client_key=valid_key_path,
cert_bundle=valid_cert_path,
validate_certs=True,
)
assert client.client_cert == valid_cert_path
assert client.client_key == valid_key_path
assert client.cert_bundle == valid_cert_path
assert client.validate_certs is True
await client.quit()
async def test_connect_error_second_attempt(event_loop):
client = SMTP(hostname="127.0.0.1", port=65534, loop=event_loop)
with pytest.raises(SMTPConnectError):
await client.connect(timeout=0.1)
with pytest.raises(SMTPConnectError):
await client.connect(timeout=0.1)
async def test_loop_kwarg_deprecation_warning_connect(event_loop, hostname,
port, smtpd_server):
client = SMTP(hostname=hostname, port=port)
with pytest.warns(DeprecationWarning):
await client.connect(loop=event_loop)
assert client.loop == event_loop
async def test_connect_source_address_takes_precedence(event_loop, hostname,
port, smtpd_server):
client = SMTP(hostname=hostname, port=port, source_address="example.com")
await client.connect(source_address=socket.getfqdn())
assert client.source_address != "example.com"
await client.quit()
async def test_connect_hostname_takes_precedence(event_loop, hostname, port,
smtpd_server):
client = SMTP(hostname="example.com", port=port)
await client.connect(hostname=hostname)
assert client.hostname == hostname
await client.quit()
