def test_sendmail_onerror(): from_addr = '*****@*****.**' to_addresses = ['*****@*****.**', '*****@*****.**'] msg_as_string = 'test mail content' msg_size_exceed = "A" * 1200 result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_size_exceed, ['smtp.localhost'], max_size=8 / 1024) assert result is False with mock.patch('smtplib.SMTP') as mock_smtp: mock_smtp.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost']) assert result is False with mock.patch('smtplib.SMTP') as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost']) assert result is False with mock.patch('smtplib.SMTP') as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.return_value = {} result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost']) assert result is True
def _connect_to_exchange(self, smtp): code, response = smtp.ehlo() if code != SMTP_EHLO_OKAY: logging.error("Server did not respond as expected to EHLO command") raise smtplib.SMTPException( "Server did not respond as expected to EHLO command") sspiclient = sspi.ClientAuth('NTLM') # Generate the NTLM Type 1 message sec_buffer = None err, sec_buffer = sspiclient.authorize(sec_buffer) ntlm_message = asbase64(sec_buffer[0].Buffer) # Send the NTLM Type 1 message -- Authentication Request code, response = smtp.docmd("AUTH", "NTLM " + ntlm_message) # Verify the NTLM Type 2 response -- Challenge Message if code != SMTP_AUTH_CHALLENGE: logging.error( "Server did not respond as expected to NTLM negotiate message") raise smtplib.SMTPException( "Server did not respond as expected to NTLM negotiate message") # Generate the NTLM Type 3 message err, sec_buffer = sspiclient.authorize(base64.decodebytes(response)) ntlm_message = asbase64(sec_buffer[0].Buffer) # Send the NTLM Type 3 message -- Response Message code, response = smtp.docmd("", ntlm_message) if code != SMTP_AUTH_OKAY: logging.error("SMTPAuthenticationError") raise smtplib.SMTPAuthenticationError(code, response) # if this part is reached, the authentication was succesfull and emails can be sent. pass
def test_sendmail_onerror(caplog): from_addr = "*****@*****.**" to_addresses = ["*****@*****.**", "*****@*****.**"] msg_as_string = "test mail content" msg_size_exceed = "A" * 1200 result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_size_exceed, ["smtp.localhost"], max_size=1 / 1024) assert result is False assert "message file too big" in caplog.text with mock.patch("smtplib.SMTP_SSL") as mock_smtp: mock_smtp.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ["smtp.localhost"]) assert result is False with mock.patch("smtplib.SMTP_SSL") as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ["smtp.localhost"]) assert result is False with mock.patch("smtplib.SMTP_SSL") as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.return_value = {} mid = make_msgid() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ["smtp.localhost"], message_id=mid) assert result is True assert "Message-ID: %s sent successfully" % mid in caplog.text assert "smtp quit" in caplog.text with mock.patch("smtplib.SMTP_SSL") as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.return_value = {} def error_on_quit(): raise smtplib.SMTPException("error on quit ignored") smtp_mock.quit = error_on_quit mid = make_msgid() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ["smtp.localhost"], message_id=mid) assert result is True assert "Message-ID: %s sent successfully" % mid in caplog.text
def login(self, user, password): def encode_cram_md5(challenge, user, password): challenge = encode_base64.decodestring(challenge) response = user + " " + smtplib.hmac.HMAC(password, challenge).hexdigest() return encode_base64(response) def encode_plain(user, password): s = "\0%s\0%s" % (user, password) return encode_base64(s.encode('ascii'), eol='') AUTH_PLAIN = "PLAIN" AUTH_CRAM_MD5 = "CRAM-MD5" AUTH_LOGIN = "******" self.ehlo_or_helo_if_needed() if not self.has_extn("auth"): raise smtplib.SMTPException( "SMTP AUTH extension not supported by server.") authlist = self.esmtp_features["auth"].split() preferred_auths = [AUTH_CRAM_MD5, AUTH_PLAIN, AUTH_LOGIN] authmethod = None for method in preferred_auths: if method in authlist: authmethod = method break if authmethod == AUTH_LOGIN: (code, resp) = self.docmd("AUTH", "%s %s" % (AUTH_LOGIN, encode_base64(user))) if code != 334: raise smtplib.SMTPAuthenticationError(code, resp) (code, resp) = self.docmd(encode_base64(password)) elif authmethod == AUTH_PLAIN: temp_encode_plain = str(encode_plain(user, password)) temp_encode_plain = temp_encode_plain.replace("\n", "") (code, resp) = self.docmd("AUTH", AUTH_PLAIN + " " + temp_encode_plain) elif authmethod == AUTH_CRAM_MD5: (code, resp) = self.docmd("AUTH", AUTH_CRAM_MD5) if code == 503: return (code, resp) (code, resp) = self.docmd(encode_cram_md5(resp, user, password)) elif authmethod is None: raise smtplib.SMTPException( "No suitable authentication method found.") if code not in (235, 503): raise smtplib.SMTPAuthenticationError(code, resp) return (code, resp)
def test_sendmail_onerror(caplog): from_addr = '*****@*****.**' to_addresses = ['*****@*****.**', '*****@*****.**'] msg_as_string = 'test mail content' msg_size_exceed = "A" * 1200 result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_size_exceed, ['smtp.localhost'], max_size=1 / 1024) assert result is False assert 'message file too big' in caplog.text with mock.patch('smtplib.SMTP_SSL') as mock_smtp: mock_smtp.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost']) assert result is False with mock.patch('smtplib.SMTP_SSL') as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.side_effect = smtplib.SMTPException() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost']) assert result is False with mock.patch('smtplib.SMTP_SSL') as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.return_value = {} mid = make_msgid() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost'], message_id=mid) assert result is True assert 'Message-ID: %s sent successfully' % mid in caplog.text assert 'smtp quit' in caplog.text with mock.patch('smtplib.SMTP_SSL') as mock_smtp: smtp_mock = mock_smtp.return_value smtp_mock.sendmail.return_value = {} def error_on_quit(): raise smtplib.SMTPException('error on quit ignored') smtp_mock.quit = error_on_quit mid = make_msgid() result = e3.net.smtp.sendmail(from_addr, to_addresses, msg_as_string, ['smtp.localhost'], message_id=mid) assert result is True assert 'Message-ID: %s sent successfully' % mid in caplog.text
def ntlm_authenticate(smtp, username, password): code, response = smtp.docmd( "AUTH", "NTLM " + ntlm.create_NTLM_NEGOTIATE_MESSAGE(username)) if code != 334: raise smtplib.SMTPException( "Server did not respond as expected to NTLM negotiate message") challenge, flags = ntlm.parse_NTLM_CHALLENGE_MESSAGE(response) user_parts = username.split("\\", 1) code, response = smtp.docmd( "", ntlm.create_NTLM_AUTHENTICATE_MESSAGE(challenge, user_parts[1], user_parts[0], password, flags)) if code != 235: raise smtplib.SMTPException(code, response)
def login(self, username, password): def encode_cram_md5(challenge, username, password): challenge = base64.decodebytes(challenge) response = username + " " + hmac.HMAC(password.encode('ascii'), challenge, 'md5').hexdigest() return encode_base64(response.encode('ascii'), eol="") def encode_plain(user, password): return encode_base64(("\0%s\0%s" % (user, password)).encode('ascii'), eol="") AUTH_PLAIN = "PLAIN" AUTH_CRAM_MD5 = "CRAM-MD5" AUTH_LOGIN = "******" yield self.ehlo_or_helo_if_needed() if not self.has_extn('auth'): raise smtplib.SMTPException("SMTP Auth extension not supported by server ") advertised_authlist = self.esmtp_features["auth"].split() preferred_auths = [AUTH_CRAM_MD5, AUTH_PLAIN, AUTH_LOGIN] authlist = [auth for auth in preferred_auths if auth in advertised_authlist] if not authlist: raise smtplib.SMTPException("No suitable authentication method found.") # Some servers advertise authentication methods they don't really # support, so if authentication fails, we continue until we've tried # all methods. for authmethod in authlist: if authmethod == AUTH_CRAM_MD5: (code, resp) = yield self.docmd(b'AUTH', AUTH_CRAM_MD5) if code == 334: (code, resp) =yield self.docmd(encode_cram_md5(resp, username, password).encode('ascii')) elif authmethod == AUTH_PLAIN: (code, resp) =yield self.docmd(b'AUTH', (AUTH_PLAIN + " " + encode_plain(username, password)).encode('ascii')) elif authmethod == AUTH_LOGIN: (code, resp) = yield self.docmd(b'AUTH', ("%s %s" % (AUTH_LOGIN, encode_base64(username.encode('ascii'), eol=''))).encode('ascii')) if code == 334: (code, resp) = yield self.docmd(encode_base64(password.encode('ascii'), eol='').encode('ascii')) # 235 == 'Authentication successful' # 503 == 'Error: already authenticated' if code in (235, 503): raise gen.Return((code, resp)) # We could not login sucessfully. Return result of last attempt. raise smtplib.SMTPAuthenticationError(code, resp)
def verify_pass(self): '''Verify the password we got works for SMTPAUTH.''' try: smtp = smtplib.SMTP(self.host, self.port) except socket.error as msg: raise MailSendError(msg) # NOTE WELL: SECURITY IMPORTANT NOTE! # In python 2.6 if you attempt to starttls() and the server doesn't # understand an exception is raised. However before that, it just carried on # and one could attempt to auth over a plain-text session. This is BAD! # # So, in order be secure on older pythons we ehlo() and then check the # response before attempting startls. try: smtp.ehlo() if not smtp.has_extn('STARTTLS'): # Emulate 2.6 behavior raise smtplib.SMTPException('Server does not support STARTTLS') smtp.starttls() # must ehlo after startls smtp.ehlo() smtp.login(self.user, self.password) except smtplib.SMTPAuthenticationError: return False except (smtplib.SMTPException, socket.error) as msg: raise MailSendError(msg) finally: smtp.quit() return True
def send_email(to_email, subject, msg): rcinfo = netrc.netrc(os.path.expanduser('~/.netrc')) auth = rcinfo.authenticators('gmail') email = auth[0] name = auth[1].replace('+', ' ') # put a + for space in the .netrc file password = auth[2] server = 'smtp.gmail.com' port = 587 LOG.info('Connecting to %s:%s', server, port) server = smtplib.SMTP(server, port) server.ehlo() server.starttls() server.ehlo() LOG.info('Logging in using email %s', email) server.login(email, password) full_message = ['To: %s' % to_email, 'From: %s <%s>' % (name, email), 'Reply-To: %s' % to_email, 'Subject: %s' % subject, '', msg] LOG.info('Full Message\n%s', '\n'.join(full_message)) result = server.sendmail(email, to_email, '\n'.join(full_message)) if result: errs = [] for recip in result: errs.append( 'Could not deliver mail to: %s\n' 'Server said: %s\n%s' % (recip, result[recip][0], result[recip][1])) raise smtplib.SMTPException('\n'.join(errs)) server.close()
def sendmail(self, from_addr, to_addrs, msg, mail_options=()): """invoke sendmail program to send a message. `from_addr' is envelope sender string (may be empty) `to_addrs' is list of envelope recipient addresses `msg' is headers and body of message to be sent `mail_options' is list of options ('8bitmime')""" cmd = [self.SENDMAIL] if from_addr: cmd.append('-f%s' % from_addr) if '8bitmime' in mail_options: cmd.append('-B8BITMIME') # avoid shell / quoting issues proc = subprocess.Popen(cmd + to_addrs, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) proc.stdin.write(msg.replace('\n.\n', '\n..\n')) proc.stdin.close() ret = proc.wait() out = proc.stdout.readlines() err = proc.stderr.readlines() if self.debug: for line in out: print("stdout:", line) for line in err: print("stderr:", line) # complain if out or error are non-empty? if ret != OS_OK: raise smtplib.SMTPException() return {}
def test_smtp_sendmail_error(mock_getpass, mock_SMTP_SSL, tmp_path): """Failure during SMTP protocol.""" # Config for SSL SMTP server config_path = tmp_path/"server.conf" config_path.write_text(textwrap.dedent(u"""\ [smtp_server] host = smtp.gmail.com port = 465 security = SSL/TLS username = awdeorio """)) # Simple template sendmail_client = SendmailClient(config_path, dry_run=False) message = email.message_from_string(u"Hello world") # Mock the password entry mock_getpass.return_value = "password" # Configure SMTP sendmail() to raise an exception mock_SMTP_SSL.return_value.__enter__.return_value.sendmail = mock.Mock( side_effect=smtplib.SMTPException("Dummy error message") ) # Send a message with pytest.raises(MailmergeError) as err: sendmail_client.sendmail( sender="*****@*****.**", recipients=["*****@*****.**"], message=message, ) # Verify exception string assert "Dummy error message" in str(err.value)
def test_error_handling(self): # pytest.raises exists: pylint: disable=E1101 smtp_client_helper = smtp_client.SmtpClientHelper("servername", "80") self._smtp_client.sendmail.side_effect = smtplib.SMTPException() pytest.raises(smtplib.SMTPException, smtp_client_helper.send_mail, "*****@*****.**", ["*****@*****.**"], "subject", "message")
def register_authentication(self, sender, recipient): chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' secret_key = get_random_string(self.key_length, chars) msg = MIMEText("Vulture authentication\r\nThis is your secret key: {}".format(secret_key)) msg['Subject'] = 'Vulture OTP Authentication' msg['From'] = sender msg['To'] = recipient cluster = Cluster.objects.get() node = cluster.get_current_node() smtp_settings = getattr(node.system_settings, 'smtp_settings') if not smtp_settings: """ Not found, use cluster settings for configuration """ smtp_settings = getattr(cluster.system_settings, 'smtp_settings') if not smtp_settings: logger.error("VultureMailClient::register_authentication: Cluster and Node SMTP settings not configured") raise smtplib.SMTPException("Vulture mail service not configured") server = smtplib.SMTP(smtp_settings.smtp_server) message = "Subject: " + unicode (msg['Subject']) + "\n\n" + unicode (msg) server.sendmail(msg['from'], recipient, message) server.quit() return secret_key
def test_smtplib_init_fail(mock_smtplib): """ API: Test exception handling when calling smtplib.SMTP() """ from apprise.plugins import NotifyEmailBase obj = Apprise.instantiate('mailto://*****:*****@gmail.com', suppress_exceptions=False) assert (isinstance(obj, plugins.NotifyEmail)) # Support Exception handling of smtplib.SMTP mock_smtplib.side_effect = TypeError('Test') try: obj.notify(title='test', body='body', notify_type=NotifyType.INFO) # We should have thrown an exception assert False except TypeError: # Exception thrown as expected assert True except Exception: # Un-Expected assert False # A handled and expected exception mock_smtplib.side_effect = smtplib.SMTPException('Test') assert obj.notify(title='test', body='body', notify_type=NotifyType.INFO) is False
def test_expecting_general_SMTP_error(self) -> None: check = UnitTestSmtpCredentials._create_mocked_method_raising( smtplib.SMTPException()) status, message = UnitTestSmtpCredentials._run_mocked_check( self.test_expecting_general_SMTP_error.__name__, check) self.assertEqual((status, message), (False, smtpcheck.Messages.GENERAL_SMTP_ERROR.value))
def test_send_failed(self): with patch('django.core.mail.message.EmailMessage.send') as mock_send: mock_send.side_effect = smtplib.SMTPException("No server") self.bulk.send() self.assertEqual(len(mail.outbox), 0) # we mocked the actual send, so... bulk = BulkEmail.objects.get(pk=self.bulk.pk) self.assertEqual(ERROR, bulk.status) self.assertEqual("No server", bulk.error)
def _send_mail(self, to, msg): '''Given a to and Message object, send email.''' # We don't duplicate the header logic in the sub functions, we # do that here debug("send_mail called with to (%s), subject (%s)" % (to, msg['subject'])) if self.display_name: msg['From'] = self.display_name + ' <' + self.mail + '>' else: msg['From'] = self.mail if self.address_override: msg['To'] = self.address_override else: msg['To'] = to msg['Date'] = formatdate(localtime=True) try: smtp = smtplib.SMTP(self.host, self.port) if self.tls: # NOTE WELL: SECURITY IMPORTANT NOTE! # In python 2.6 if you attempt to starttls() and the server doesn't # understand an exception is raised. However before that, it just # carried on and one could attempt to auth over a plain-text session. # This is BAD! # # So, in order be secure on older pythons we ehlo() and then check the # response before attempting startls. smtp.ehlo() if not smtp.has_extn('STARTTLS'): # Emulate 2.6 behavior raise smtplib.SMTPException( 'Server does not support STARTTLS') smtp.starttls() # must re-ehlo after STARTTLS smtp.ehlo() # Don't want to send auth information unless we're TLS'd if self.user: smtp.login(self.user, self.password) if self.address_override: env_to = self.address_override else: # BCC the user... env_to = [msg['To'], self.mail] smtp.sendmail(self.mail, env_to, msg.as_string()) smtp.quit() except smtplib.SMTPException as emsg: raise MailSendError(emsg) except socket.error as emsg: raise MailSendError(emsg)
def starttls(self, keyfile=None, certfile=None): if not self.has_extn("starttls"): msg = "STARTTLS extension not supported by server" raise smtplib.SMTPException(msg) (resp, reply) = self.docmd("STARTTLS") if resp == 220: self.sock = sslutil.wrapsocket(self.sock, keyfile, certfile, **self._sslkwargs) self.file = smtplib.SSLFakeFile(self.sock) self.helo_resp = None self.ehlo_resp = None self.esmtp_features = {} self.does_esmtp = 0 return (resp, reply)
def test_wraps_mail_server_exceptions(self, messenger, dummy_mailer, message): import smtplib from dallinger.notifications import MessengerError dummy_mailer.login.side_effect = smtplib.SMTPException("Boom!") with pytest.raises(MessengerError) as ex_info: messenger.send(message) assert ex_info.match("SMTP error") dummy_mailer.login.side_effect = Exception("Boom!") with pytest.raises(MessengerError) as ex_info: messenger.send(message) assert ex_info.match("Unknown error")
def test_send_fail(self, connection_mock): exception = smtplib.SMTPException("Something failed", 101) connection_mock.return_value.send_messages.side_effect = exception result = toolkit.members.tasks.send_mailout( u"The \xa31 Subject!", u"The Body!\nThat will be $1, please\nTa!", None) # Overall, operation succeeded: self.assertEqual((False, 6, "Ok"), result) # Check errors are in the report message: report = connection_mock.return_value.send_messages.call_args[0][0][0] expected = "6 errors:\n" + "\n".join([str(exception)] * 6) self.assertIn(expected, report.body)
def send_mail(self,to_addrs_list = None, content = None, subject = None): """发送邮件,功能设计的只能发送纯文本的邮件内容 :param to_addrs_list: 需要发给的地址,是一个list,每一个邮箱地址是list的一个元素。 :param content: 邮件的内容,是一个string。 :param subject: 邮件的主题。 :return: 无返回内容。 """ if to_addrs_list != None: to_addrs_str = to_addrs_list[0] for index in range(1, len(to_addrs_list),1): to_addrs_str = to_addrs_str + ',' + to_addrs_list[index] to_addrs = list([to_addrs_str]) else: print 'no Email address to send to!' raise smtplib.SMTPException() if content != None: msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n" % (SENDER_MAIL['sent_from'], ", ".join(to_addrs), subject)) msg = msg + content self.server.sendmail(from_addr=SENDER_MAIL['user'],to_addrs=to_addrs,msg=msg) else: print 'No content in the email!' raise smtplib.SMTPException()
def starttls(self, keyfile=None, certfile=None): if not self.has_extn("starttls"): msg = "STARTTLS extension not supported by server" raise smtplib.SMTPException(msg) (resp, reply) = self.docmd("STARTTLS") if resp == 220: self.sock = sslutil.wrapsocket(self.sock, keyfile, certfile, **self._sslkwargs) if not util.safehasattr(self.sock, "read"): # using httplib.FakeSocket with Python 2.5.x or earlier self.sock.read = self.sock.recv self.file = smtplib.SSLFakeFile(self.sock) self.helo_resp = None self.ehlo_resp = None self.esmtp_features = {} self.does_esmtp = 0 return (resp, reply)
def starttls(self): #TODO: check how to read the local computer name yield self.ehlo_or_helo_if_needed() if not self.has_extn('starttls'): raise smtplib.SMTPException('STARTTLS extension not supported ') code, msg = yield self.docmd(b'STARTTLS') if code == 220: if not _have_ssl: raise RuntimeError("No SSL support included in this Python ") server_hostname = self.host if hasattr(ssl, 'HAS_SNI') and ssl.HAS_SNI else None self.stream = yield self.stream.start_tls(False, server_hostname = server_hostname) self.helo_resp = None self.ehlo_resp = None self.esmtp_features = {} self.does_esmtp = 0 raise gen.Return((code, msg))
def process_message(self, peer, mailfrom, rcpttos, data): """Handle incoming message""" if '*****@*****.**' in rcpttos: raise smtplib.SMTPException('Server crashed, try again') try: with open('message.json') as fh: email_list = json.loads(fh.read()) except IOError: # File does not yet exist, new list email_list = [] email_list.append( dict(origin=peer, sender=mailfrom, receiver=rcpttos, contents=data)) with open('message.json', 'wb') as fh: fh.write(json.dumps(email_list))
def connect(cls): """Connect or reconnect if a connection has timed out""" def reconnect(): if cls.connection is None or cls.connection.noop()[0] == 421: return True else: return False count = 0 for i in range(cls.reconnect_attempts + 1): if reconnect(): count += 1 cls.connection = cls._connect() else: break if count > cls.reconnect_attempts: raise smtplib.SMTPException("Unable to connect")
def starttls(self, keyfile=None, certfile=None, **sslargs): """Puts the connection to the SMTP server into TLS mode. If there has been no previous EHLO or HELO command this session, this method tries ESMTP EHLO first. If the server supports TLS, this will encrypt the rest of the SMTP session. If you provide the keyfile and certfile parameters, the identity of the SMTP server and client can be checked. This, however, depends on whether the socket module really checks the certificates. :param sslargs: a dict with further SSL arguments, see ssl module (default: {}); :param ca_certs: PEM formatted file for permitted certificates (default: None), if specified, and the default for cert_reqs is CERT_REQUIRED; This method may raise the following exceptions: SMTPHeloError The server didn't reply properly to the helo greeting. """ import ssl self.ehlo_or_helo_if_needed() if not self.has_extn("starttls"): raise smtplib.SMTPException( "STARTTLS extension not supported by server.") (resp, reply) = self.docmd("STARTTLS") if resp == 220: if not sslargs.get('ssl_version'): sslargs['ssl_version'] = ssl.PROTOCOL_TLSv1 if not sslargs.get('cert_reqs'): sslargs['cert_reqs'] = ssl.CERT_REQUIRED if sslargs.get( 'ca_certs') else ssl.CERT_NONE self.sock = ssl.wrap_socket(self.sock, keyfile, certfile, **sslargs) self.file = smtplib.SSLFakeFile(self.sock) # RFC 3207: # The client MUST discard any knowledge obtained from # the server, such as the list of SMTP service extensions, # which was not obtained from the TLS negotiation itself. self.helo_resp = None self.ehlo_resp = None self.esmtp_features = {} self.does_esmtp = 0 return (resp, reply)
def test_do_config_checks_socket_type_errors(self): # Set up our mock expectations. # Our configuration is using STARTTLS. If we return it supports SSL and # it doesn't support STARTTLS, do_config_checks should return 1 error # and 1 warning for each server (incoming and outgoing) # IMAP SSL server = imaplib.IMAP4_SSL('mail.test.com', 993) server.capabilities = ('IMAP4REV1', 'SASL-IR', 'SORT', 'THREAD=REFERENCES', 'MULTIAPPEND', 'UNSELECT', 'LITERAL+', 'IDLE', 'CHILDREN', 'NAMESPACE', 'LOGIN-REFERRALS', 'QUOTA', 'AUTH=PLAIN', 'AUTH=LOGIN') server.shutdown() # IMAP STARTTLS server = imaplib.IMAP4('mail.test.com', 995) server.starttls().AndRaise(Exception("STARTTLS extension not supported" "by server.")) server.shutdown() # SMTP SSL server = smtplib.SMTP_SSL('mail.test.com', 465, timeout=TIMEOUT) server.ehlo().AndReturn((250, 'mx2.mail.corp.phx1.test.com\nPIPELINING\nSIZE ' '31457280\nETRN\nAUTH LOGIN PLAIN NTLM CRAM-MD5 GSSAPI UNSUPPORTED' '\nENHANCEDSTATUSCODES\n8BITMIME\nDSN')) server.quit() # SMTP STARTTLS server = smtplib.SMTP('mail.test.com', 465, timeout=TIMEOUT) server.ehlo() server.starttls().AndRaise(smtplib.SMTPException("STARTTLS extension" "not supported by server.")) server.quit() self.mox.ReplayAll() #Test methods config = Config.objects.get(pk=1) config.incoming_socket_type = 'STARTTLS' config.outgoing_socket_type = 'STARTTLS' config.save() errors, warnings = do_config_checks(config) # Verify the results (and the mock expectations.) self.mox.VerifyAll() assert_equal(len(errors), 2) assert_equal(len(warnings), 2)
def test_send_reminders_send_email_fails(self): """send_mail fails, we make sure the error is raised and should_send_reminders is disabled.""" video = VideoFactory( live_state=IDLE, live_type=RAW, starting_at=timezone.now() + timedelta(days=2), ) registration = LiveRegistrationFactory( anonymous_id=uuid.uuid4(), created_on=timezone.now() - timedelta(days=32), email="*****@*****.**", is_registered=True, should_send_reminders=True, video=video, ) with mock.patch.object( send_reminders, "send_mail", side_effect=smtplib.SMTPException("Error SMTPException"), ): out = StringIO() err_out = StringIO() call_command("send_reminders", stdout=out, stderr=err_out) self.assertEqual(len(mail.outbox), 0) self.assertIn( f"Sending email for liveregistration {registration.id} for video " f"{registration.video.id} step {settings.REMINDER_3}", out.getvalue(), ) self.assertIn("Mail failed [email protected]", err_out.getvalue()) registration.refresh_from_db() # key has been added self.assertEqual( [settings.REMINDER_3, settings.REMINDER_ERROR], registration.reminders ) out.close() # we call the command, no email should be sent call_command("send_reminders") self.assertEqual(len(mail.outbox), 0)
def test_email_notification(self, mock_mail): skul = self.create_school() skul.settlement_school = 'edmc' noti = self.create_notification(skul) msg = noti.notify_school() self.assertTrue('failed' in msg) contact = self.create_contact() contact.endpoint = '' contact.save() skul.contact = contact skul.save() noti2 = self.create_notification(skul) msg1 = noti2.notify_school() self.assertTrue(mock_mail.call_count == 1) self.assertTrue('email' in msg1) noti3 = self.create_notification(skul) mock_mail.side_effect = smtplib.SMTPException('fail') msg = noti3.notify_school() self.assertTrue(mock_mail.call_count == 2)
def starttls(self, keyfile=None, certfile=None): if not self.has_extn("starttls"): msg = b"STARTTLS extension not supported by server" raise smtplib.SMTPException(msg) (resp, reply) = self.docmd("STARTTLS") if resp == 220: self.sock = sslutil.wrapsocket( self.sock, keyfile, certfile, ui=self._ui, serverhostname=self._host, ) self.file = self.sock.makefile("rb") self.helo_resp = None self.ehlo_resp = None self.esmtp_features = {} self.does_esmtp = 0 return (resp, reply)