def test_relay_smtp(client_mock):
relay = server.Relay("localhost", port=0)
relay.deliver(test_mail_response_plain_text())
assert_equal(client_mock.return_value.sendmail.call_count, 1)
assert_equal(client_mock.return_value.starttls.call_count, 0)
client_mock.reset_mock()
relay = server.Relay("localhost", port=0, starttls=True)
relay.deliver(test_mail_response_plain_text())
assert_equal(client_mock.return_value.sendmail.call_count, 1)
assert_equal(client_mock.return_value.starttls.call_count, 1)
def test_relay_smtp(self, client_mock):
relay = server.Relay("localhost", port=0)
relay.deliver(generate_mail(factory=mail.MailResponse, attachment=True))
self.assertEqual(client_mock.return_value.sendmail.call_count, 1)
self.assertEqual(client_mock.return_value.starttls.call_count, 0)
client_mock.reset_mock()
relay = server.Relay("localhost", port=0, starttls=True)
relay.deliver(generate_mail(factory=mail.MailResponse, attachment=True))
self.assertEqual(client_mock.return_value.sendmail.call_count, 1)
self.assertEqual(client_mock.return_value.starttls.call_count, 1)
def test_Relay_asserts_ssl_options():
"""Relay raises an AssertionError if the ssl option is used in combination with starttls or lmtp"""
with assert_raises(AssertionError):
server.Relay("localhost", ssl=True, starttls=True)
with assert_raises(AssertionError):
server.Relay("localhost", ssl=True, lmtp=True)
with assert_raises(AssertionError):
server.Relay("localhost", ssl=True, starttls=True, lmtp=True)
# no error
server.Relay("localhost", starttls=True, lmtp=True)
def command(port,
host,
username=None,
password=None,
ssl=None,
starttls=None,
lmtp=None,
sender=None,
to=None,
subject=None,
body=None,
attach=None):
message = mail.MailResponse(From=sender,
To=to,
Subject=subject,
Body=body)
if attach:
message.attach(attach)
relay = server.Relay(host,
port=port,
username=username,
password=password,
ssl=ssl,
starttls=starttls,
lmtp=lmtp,
debug=False)
relay.deliver(message)
def send(port,
host,
username=None,
password=None,
ssl=None,
starttls=None,
lmtp=None,
sender=None,
to=None,
subject=None,
body=None,
attach=None):
"""
Sends an email to someone as a test message.
See the sendmail command for a sendmail replacement.
"""
message = mail.MailResponse(From=sender, To=to, Subject=subject, Body=body)
if attach:
message.attach(attach)
relay = server.Relay(host,
port=port,
username=username,
password=password,
ssl=ssl,
starttls=starttls,
lmtp=lmtp,
debug=False)
relay.deliver(message)
def blast(inbox, host, port, lmtp, debug):
"""
Given a Maildir, this command will go through each email
and blast it at your server. It does nothing to the message, so
it will be real messages hitting your server, not cleansed ones.
"""
try:
inbox = mailbox.mbox(inbox, create=False)
except (mailbox.Error, IOError):
try:
inbox = mailbox.Maildir(inbox, factory=None, create=False)
except (mailbox.Error, IOError):
raise click.ClickException(
"{} does not exist or is not a valid MBox or Maildir".format(
inbox))
relay = server.Relay(host, port=port, lmtp=lmtp, debug=debug)
for key in inbox.keys():
msgfile = inbox.get_file(key)
msg = encoding.from_file(msgfile)
try:
relay.deliver(msg)
except socket.error as exp:
raise click.ClickException(str(exp))
finally:
msgfile.close()
def test_relay_deliver():
relay = server.Relay("localhost", port=8899)
relay.deliver(test_mail_response_plain_text())
relay.deliver(test_mail_response_html())
relay.deliver(test_mail_response_html_and_plain_text())
relay.deliver(test_mail_response_attachments())
def test_relay_deliver_mx_hosts(DNS_mxlookup):
DNS_mxlookup.return_value = [[100, "localhost"]]
relay = server.Relay(None, port=8899)
msg = test_mail_response_plain_text()
msg['to'] = 'zedshaw@localhost'
relay.deliver(msg)
assert DNS_mxlookup.called
def test_relay_deliver_mx_hosts(self, client_mock, query):
query.return_value = [Mock()]
query.return_value[0].exchange = "localhost"
relay = server.Relay(None, port=0)
msg = generate_mail(factory=mail.MailResponse, attachment=True)
msg['to'] = 'user@localhost'
relay.deliver(msg)
self.assertEqual(query.call_count, 1)
def test_relay_deliver_mx_hosts(client_mock, query):
query.return_value = [Mock()]
query.return_value[0].exchange = "localhost"
relay = server.Relay(None, port=0)
msg = test_mail_response_plain_text()
msg['to'] = 'user@localhost'
relay.deliver(msg)
assert_equal(query.call_count, 1)
def test_relay_deliver_mx_hosts(query):
query.return_value = [Mock()]
query.return_value[0].exchange = "localhost"
relay = server.Relay(None, port=8899)
msg = test_mail_response_plain_text()
msg['to'] = 'user@localhost'
relay.deliver(msg)
assert query.called
def sendmail(port, host, recipients, debug=False, lmtp=False):
"""
Used as a testing sendmail replacement for use in programs
like mutt as an MTA. It reads the email to send on the stdin
and then delivers it based on the port and host settings.
"""
relay = server.Relay(host, port=port, debug=debug, lmtp=lmtp)
data = sys.stdin.read()
msg = mail.MailRequest(None, recipients, None, data)
relay.deliver(msg)
def test_relay_resolve_relay_host(DNS_mxlookup):
DNS_mxlookup.return_value = []
relay = server.Relay(None, port=8899)
host = relay.resolve_relay_host('zedshaw@localhost')
assert_equal(host, 'localhost')
assert DNS_mxlookup.called
DNS_mxlookup.reset_mock()
DNS_mxlookup.return_value = [[100, "mail.zedshaw.com"]]
host = relay.resolve_relay_host('*****@*****.**')
assert_equal(host, 'mail.zedshaw.com')
assert DNS_mxlookup.called
def sendmail_command(port=8825, host='127.0.0.1', debug=0, TRAILING=None):
"""
Used as a testing sendmail replacement for use in programs
like mutt as an MTA. It reads the email to send on the stdin
and then delivers it based on the port and host settings.
salmon sendmail -port 8825 -host 127.0.0.1 -debug 0 -- [recipients]
"""
relay = server.Relay(host, port=port, debug=debug)
data = sys.stdin.read()
msg = mail.MailRequest(None, TRAILING, None, data)
relay.deliver(msg)
def command(input, host, port, lmtp=None, debug=False):
try:
inbox = mailbox.mbox(input)
except IOError:
inbox = mailbox.Maildir(input, factory=None)
relay = server.Relay(host, port=port, lmtp=lmtp, debug=debug)
for key in inbox.keys():
msgfile = inbox.get_file(key)
msg = email.message_from_file(msgfile)
relay.deliver(msg)
def blast_command(input=None, host='127.0.0.1', port=8823, debug=0):
"""
Given a maildir, this command will go through each email
and blast it at your server. It does nothing to the message, so
it will be real messages hitting your server, not cleansed ones.
"""
inbox = mailbox.Maildir(input)
relay = server.Relay(host, port=port, debug=debug)
for key in inbox.keys():
msgfile = inbox.get_file(key)
msg = email.message_from_file(msgfile)
relay.deliver(msg)
def test_relay_deliver(client_mock):
# test that relay will actually call smtplib.SMTP
relay = server.Relay("localhost", port=0)
relay.deliver(test_mail_response_plain_text())
assert_equal(client_mock.return_value.sendmail.call_count, 1)
relay.deliver(test_mail_response_html())
assert_equal(client_mock.return_value.sendmail.call_count, 2)
relay.deliver(test_mail_response_html_and_plain_text())
assert_equal(client_mock.return_value.sendmail.call_count, 3)
relay.deliver(test_mail_response_attachments())
assert_equal(client_mock.return_value.sendmail.call_count, 4)
def test_relay_resolve_relay_host(query):
from dns import resolver
query.side_effect = resolver.NoAnswer
relay = server.Relay(None, port=0)
host = relay.resolve_relay_host('user@localhost')
assert_equal(host, 'localhost')
assert_equal(query.call_count, 1)
query.reset_mock()
query.side_effect = None # reset_mock doens't clear return_value or side_effect
query.return_value = [Mock()]
query.return_value[0].exchange = "mx.example.com"
host = relay.resolve_relay_host('*****@*****.**')
assert_equal(host, 'mx.example.com')
assert_equal(query.call_count, 1)
def blast(input, host, port, lmtp=None, debug=False):
"""
Given a Maildir, this command will go through each email
and blast it at your server. It does nothing to the message, so
it will be real messages hitting your server, not cleansed ones.
"""
try:
inbox = mailbox.mbox(input)
except IOError:
inbox = mailbox.Maildir(input, factory=None)
relay = server.Relay(host, port=port, lmtp=lmtp, debug=debug)
for key in inbox.keys():
msgfile = inbox.get_file(key)
msg = email.message_from_file(msgfile)
relay.deliver(msg)
def test_relay_deliver(self, client_mock):
# test that relay will actually call smtplib.SMTP
relay = server.Relay("localhost", port=0)
msg = generate_mail(factory=mail.MailResponse, attachment=True)
relay.deliver(msg)
self.assertEqual(client_mock.return_value.sendmail.call_count, 1)
msg = generate_mail(factory=mail.MailResponse, attachment=True)
relay.deliver(msg)
self.assertEqual(client_mock.return_value.sendmail.call_count, 2)
msg = generate_mail(factory=mail.MailResponse, attachment=True)
relay.deliver(msg)
self.assertEqual(client_mock.return_value.sendmail.call_count, 3)
msg = generate_mail(factory=mail.MailResponse, attachment=True)
relay.deliver(msg)
self.assertEqual(client_mock.return_value.sendmail.call_count, 4)
def send_command(port=8825,
host='127.0.0.1',
username=False,
password=False,
ssl=False,
starttls=False,
debug=1,
sender=None,
to=None,
subject=None,
body=None,
attach=False):
"""
Sends an email to someone as a test message.
See the sendmail command for a sendmail replacement.
salmon send -port 8825 -host 127.0.0.1 -debug 1 \\
-sender EMAIL -to EMAIL -subject STR -body STR -attach False'
There is also a username, password, and starttls option for those
who need it.
"""
message = mail.MailResponse(From=sender, To=to, Subject=subject, Body=body)
if attach:
message.attach(attach)
if username == False:
username = None
if password == False:
password = None
relay = server.Relay(host,
port=port,
username=username,
password=password,
ssl=ssl,
starttls=starttls,
debug=debug)
relay.deliver(message)
def test_relay_reply(self, client_mock):
relay = server.Relay("localhost", port=0)
print("Relay: %r" % relay)
relay.reply(generate_mail(), 'from@localhost', 'Test subject', 'Body')
self.assertEqual(client_mock.return_value.sendmail.call_count, 1)
def test_relay_reply():
relay = server.Relay("localhost", port=8899)
print "Relay: %r" % relay
relay.reply(test_mail_request(), 'from@localhost', 'Test subject', 'Body')
def command(port, host, recipients, debug=False, lmtp=False):
relay = server.Relay(host, port=port, debug=debug, lmtp=lmtp)
data = sys.stdin.read()
msg = mail.MailRequest(None, recipients, None, data)
relay.deliver(msg)
def test_relay_raises_exception(create_mock):
# previously, salmon would eat up socket errors and just log something. Not cool!
create_mock.side_effect = socket.error
relay = server.Relay("example.com", port=0)
with assert_raises(socket.error):
relay.deliver(test_mail_response_plain_text())
def test_relay_reply(client_mock):
relay = server.Relay("localhost", port=0)
print("Relay: %r" % relay)
relay.reply(test_mail_request(), 'from@localhost', 'Test subject', 'Body')
assert_equal(client_mock.return_value.sendmail.call_count, 1)
def test_relay_raises_exception(self, create_mock):
# previously, salmon would eat up socket errors and just log something. Not cool!
create_mock.side_effect = socket.error
relay = server.Relay("example.com", port=0)
with self.assertRaises(socket.error):
relay.deliver(generate_mail(factory=mail.MailResponse))
def relay(hostname="127.0.0.1", port=8824):
"""Wires up a default relay on port 8824 (the default salmon log port)."""
return server.Relay(hostname, port, debug=0)
def test_relay_smtp_ssl(client_mock):
relay = server.Relay("localhost", port=8899, ssl=True)
relay.deliver(test_mail_response_plain_text())
assert_equal(client_mock.return_value.sendmail.call_count, 1)
