def test_forward(smtp_mock):
smtp_mock.return_value = Mock()
import salmon.handlers.forward # noqa
Router.deliver(create_message())
assert smtp_mock.return_value.sendmail.called
assert smtp_mock.return_value.quit.called
def test_forward(smtp_mock):
smtp_mock.return_value = Mock()
import salmon.handlers.forward # noqa
Router.deliver(create_message())
assert smtp_mock.return_value.sendmail.called
assert smtp_mock.return_value.quit.called
def test_forward(self):
utils.import_settings(False)
import salmon.handlers.forward # noqa
salmon.handlers.forward.settings.relay = Mock()
Router.deliver(create_message())
self.assertEqual(salmon.handlers.forward.settings.relay.deliver.call_count, 1)
def test_routes_deliver_to_not_existing_address(self):
Router.load(['inboxen.router.app.server'])
message = MailRequest("locahost", "test@localhost", "root1@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 550)
self.assertEqual(excp.exception.message, "No such address")
def test_routes_deliver_to_not_existing_address(self):
Router.load(['inboxen.router.app.server'])
message = MailRequest("locahost", "test@localhost", "root1@localhost",
TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 550)
self.assertEqual(excp.exception.message, "No such address")
def test_Router_undeliverable_queue():
Router.clear_routes()
Router.clear_states()
Router.UNDELIVERABLE_QUEUE = Mock()
msg = MailRequest('fakepeer', 'from@localhost', 'to@localhost', "Nothing")
Router.deliver(msg)
assert Router.UNDELIVERABLE_QUEUE.push.called
def test_Router_undeliverable_queue(self):
Router.clear_routes()
Router.clear_states()
Router.UNDELIVERABLE_QUEUE = Mock()
msg = MailRequest('fakepeer', 'from@localhost', 'to@localhost', "Nothing")
Router.deliver(msg)
self.assertEqual(Router.UNDELIVERABLE_QUEUE.push.call_count, 1)
def test_forward(smtp_mock):
smtp_mock.return_value = Mock()
utils.import_settings(False)
import salmon.handlers.forward # noqa
Router.deliver(create_message())
assert_equal(smtp_mock.return_value.sendmail.call_count, 1)
assert_equal(smtp_mock.return_value.quit.call_count, 1)
def test_forward(smtp_mock):
smtp_mock.return_value = Mock()
utils.import_settings(False)
import salmon.handlers.forward # noqa
Router.deliver(create_message())
assert_equal(smtp_mock.return_value.sendmail.call_count, 1)
assert_equal(smtp_mock.return_value.quit.call_count, 1)
def test_routes_deliver_to_admin_raise_smtperror_on_other_errors(self):
Router.load(['inboxen.router.app.server'])
with mock.patch("salmon.server.smtplib.SMTP") as smtp_mock:
smtp_mock.return_value.sendmail.side_effect = Exception()
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 450)
self.assertEqual(excp.exception.message, "Error while forwarding admin message %s" % id(message))
def test_routes_deliver_to_admin_raise_smtperror_on_other_errors(self):
Router.load(['inboxen.router.app.server'])
with mock.patch("salmon.server.smtplib.SMTP") as smtp_mock:
smtp_mock.return_value.sendmail.side_effect = Exception()
message = MailRequest("locahost", "test@localhost",
"root@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 450)
self.assertEqual(
excp.exception.message,
"Error while forwarding admin message %s" % id(message))
def test_routes_deliver_to_admin(self):
Router.load(['inboxen.router.app.server'])
with mock.patch("inboxen.router.app.server.Relay") as relay_mock, \
mock.patch("inboxen.router.app.server.make_email") as mock_make_email:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 1)
self.assertEqual(deliver_mock.call_count, 1)
self.assertEqual(message, deliver_mock.call_args[0][0])
def test_routes_deliver_to_admin(self):
Router.load(['inboxen.router.app.server'])
with mock.patch("inboxen.router.app.server.Relay") as relay_mock, \
mock.patch("inboxen.router.app.server.make_email") as mock_make_email:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost",
"root@localhost", TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 1)
self.assertEqual(deliver_mock.call_count, 1)
self.assertEqual(message, deliver_mock.call_args[0][0])
def test_routes_deliver_to_inbox(self):
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
Router.load(['inboxen.router.app.server'])
with mock.patch("inboxen.router.app.server.Relay") as relay_mock, \
mock.patch("inboxen.router.app.server.make_email") as mock_make_email:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", str(inbox), TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 1)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
def test_routes_deliver_to_inbox(self):
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
Router.load(['inboxen.router.app.server'])
with mock.patch("inboxen.router.app.server.Relay") as relay_mock, \
mock.patch("inboxen.router.app.server.make_email") as mock_make_email:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", str(inbox),
TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 1)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
def test_routes(self):
from salmon.routing import Router
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
Router.load(['app.server'])
with mock.patch("router.app.server.Relay") as relay_mock, \
mock.patch("router.app.server.make_email") as mock_make_email, \
mock.patch("salmon.server.smtplib.SMTP") as smtp_mock:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", str(inbox), TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 1)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 1)
self.assertEqual(deliver_mock.call_count, 1)
self.assertEqual(message, deliver_mock.call_args[0][0])
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
message = MailRequest("locahost", "test@localhost", "root1@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 550)
self.assertEqual(excp.exception.message, "No such address")
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
smtp_mock.return_value.sendmail.side_effect = Exception()
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 450)
self.assertEqual(excp.exception.message, "Error while forwarding admin message %s" % id(message))
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
def test_soft_bounce_tells_them():
setup()
# get them into a posting state
admin_tests.test_existing_user_posts_message()
assert_in_state('app.handlers.admin', list_addr, sender, 'POSTING')
clear_queue()
assert mailinglist.find_subscriptions(sender, list_addr)
# force them to soft bounce
msg = create_bounce(list_addr, sender)
msg.bounce.primary_status = (3, bounce.PRIMARY_STATUS_CODES[u'3'])
assert msg.bounce.is_soft()
Router.deliver(msg)
assert_in_state('app.handlers.admin', list_addr, sender, 'BOUNCING')
assert_in_state('app.handlers.bounce', list_addr, sender, 'BOUNCING')
assert delivered('unbounce'), "Looks like unbounce didn't go out."
assert_equal(len(queue(queue_dir=settings.BOUNCE_ARCHIVE).keys()), 1)
assert not mailinglist.find_subscriptions(sender, list_addr)
# make sure that any attempts to post return a "you're bouncing dude" message
unbounce = client.say(list_addr, 'So anyway as I was saying.', 'unbounce')
assert_in_state('app.handlers.admin', list_addr, sender, 'BOUNCING')
# now have them try to unbounce
msg = client.say(unbounce['from'], "Please put me back on, I'll be good.",
'unbounce-confirm')
# handle the bounce confirmation
client.say(msg['from'], "Confirmed to unbounce.", 'noreply')
# alright they should be in the unbounce state for the global bounce handler
assert_in_state('app.handlers.bounce', list_addr, sender,
'UNBOUNCED')
# and they need to be back to POSTING for regular operations
assert_in_state('app.handlers.admin', list_addr, sender, 'POSTING')
assert mailinglist.find_subscriptions(sender, list_addr)
# and make sure that only the original bounce is in the bounce archive
assert_equal(len(queue(queue_dir=settings.BOUNCE_ARCHIVE).keys()), 1)
def test_bounce_to_decorator():
msg = mail.MailRequest(None, None, None, open("tests/bounce.msg").read())
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.START, msg)
assert bounce_filtered_mod.HARD_RAN, "Hard bounce state didn't actually run: %r" % msg.route_to
msg.bounce.primary_status = (4, u'Persistent Transient Failure')
Router.clear_states()
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.START, msg)
assert bounce_filtered_mod.SOFT_RAN, "Soft bounce didn't actually run."
msg = mail.MailRequest(None, None, None, open("tests/signed.msg").read())
Router.clear_states()
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.END, msg), "Regular messages aren't delivering."
def test_bounce_to_decorator():
msg = mail.MailRequest(None, Data=open("tests/bounce.msg").read())
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.START, msg)
assert bounce_filtered_mod.HARD_RAN, "Hard bounce state didn't actually run: %r" % msg.route_to
msg.bounce.primary_status = (4, u'Persistent Transient Failure')
Router.clear_states()
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.START, msg)
assert bounce_filtered_mod.SOFT_RAN, "Soft bounce didn't actually run."
msg = mail.MailRequest(None, Data=open("tests/signed.msg").read())
Router.clear_states()
Router.deliver(msg)
assert Router.in_state(bounce_filtered_mod.END, msg), "Regular messages aren't delivering."
def test_routes(self):
from salmon.routing import Router
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
Router.load(['app.server'])
with mock.patch("router.app.server.Relay") as relay_mock, \
mock.patch("router.app.server.make_email") as mock_make_email:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", str(inbox), TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 1)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
mock_make_email.reset_mock()
relay_mock.reset_mock();
deliver_mock.reset_mock();
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 1)
self.assertEqual(deliver_mock.call_count, 1)
self.assertEqual(message, deliver_mock.call_args[0][0])
mock_make_email.reset_mock()
relay_mock.reset_mock();
deliver_mock.reset_mock();
message = MailRequest("locahost", "test@localhost", "root1@localhost", TEST_MSG)
with self.assertRaises(SMTPError):
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
def test_queue_handler():
Router.deliver(message_tests.test_mail_request())
def test_spam_sent_by_unconfirmed_user():
setup()
client.begin()
Router.deliver(make_spam())
def test_RoutingBase():
assert len(Router.ORDER) == 0
assert len(Router.REGISTERED) == 0
setup_router(['salmon_tests.handlers.simple_fsm_mod'])
from handlers import simple_fsm_mod
assert len(Router.ORDER) > 0
assert len(Router.REGISTERED) > 0
message = MailRequest('fakepeer', 'zedshaw@localhost', 'users-subscribe@localhost', "")
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.CONFIRM, message)
confirm = MailRequest('fakepeer', '"Zed Shaw" <zedshaw@localhost>', 'users-confirm-1@localhost', "")
Router.deliver(confirm)
assert Router.in_state(simple_fsm_mod.POSTING, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.NEXT, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.END, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.START, message)
Router.clear_states()
Router.LOG_EXCEPTIONS = True
explosion = MailRequest('fakepeer', '<hacker@localhost>', 'start-explode@localhost', "")
Router.deliver(explosion)
assert Router.in_error(simple_fsm_mod.END, explosion)
Router.clear_states()
Router.LOG_EXCEPTIONS = False
explosion = MailRequest('fakepeer', 'hacker@localhost', 'start-explode@localhost', "")
assert_raises(RuntimeError, Router.deliver, explosion)
Router.reload()
assert 'salmon_tests.handlers.simple_fsm_mod' in Router.HANDLERS
assert len(Router.ORDER)
assert len(Router.REGISTERED)
def test_spam_sent_by_confirmed_user():
test_confirmed_user_comments()
clear_queue("run/posts")
Router.deliver(make_spam())
def test_log_handler():
Router.deliver(message_tests.test_mail_request())
def test_spam_sent_by_unconfirmed_user():
setup()
client.begin()
Router.deliver(make_spam())
def test_spam_sent_by_confirmed_user():
test_confirmed_user_comments()
clear_queue("run/posts")
Router.deliver(make_spam())
def test_queue_handler():
import salmon.handlers.queue # noqa
Router.deliver(create_message())
def test_RoutingBase(self):
# check that Router is in a pristine state
self.assertEqual(len(Router.ORDER), 0)
self.assertEqual(len(Router.REGISTERED), 0)
setup_router(['tests.handlers.simple_fsm_mod'])
self.assertEqual(len(Router.ORDER), 5)
self.assertEqual(len(Router.REGISTERED), 5)
message = MailRequest('fakepeer', 'zedshaw@localhost', 'users-subscribe@localhost', "")
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.CONFIRM, message)
confirm = MailRequest('fakepeer', '"Zed Shaw" <zedshaw@localhost>', 'users-confirm-1@localhost', "")
Router.deliver(confirm)
assert Router.in_state(simple_fsm_mod.POSTING, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.NEXT, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.END, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.START, message)
Router.clear_states()
Router.LOG_EXCEPTIONS = True
explosion = MailRequest('fakepeer', '<hacker@localhost>', 'start-explode@localhost', "")
Router.deliver(explosion)
assert Router.in_error(simple_fsm_mod.END, explosion)
Router.clear_states()
Router.LOG_EXCEPTIONS = False
explosion = MailRequest('fakepeer', 'hacker@localhost', 'start-explode@localhost', "")
with self.assertRaises(RuntimeError):
Router.deliver(explosion)
Router.reload()
assert 'tests.handlers.simple_fsm_mod' in Router.HANDLERS
self.assertEqual(len(Router.ORDER), 5)
self.assertEqual(len(Router.REGISTERED), 5)
def test_log_handler():
import salmon.handlers.log # noqa
Router.deliver(create_message())
def test_queue_handler():
import salmon.handlers.queue # noqa
Router.deliver(message_tests.test_mail_request())
def test_queue_handler():
import salmon.handlers.queue # noqa
Router.deliver(create_message())
def test_log_handler():
import salmon.handlers.log # noqa
Router.deliver(create_message())
def test_RoutingBase():
assert len(Router.ORDER) == 0
assert len(Router.REGISTERED) == 0
setup_router(['salmon_tests.handlers.simple_fsm_mod'])
from handlers import simple_fsm_mod
assert len(Router.ORDER) > 0
assert len(Router.REGISTERED) > 0
message = MailRequest('fakepeer', 'zedshaw@localhost',
'users-subscribe@localhost', "")
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.CONFIRM, message)
confirm = MailRequest('fakepeer', '"Zed Shaw" <zedshaw@localhost>',
'users-confirm-1@localhost', "")
Router.deliver(confirm)
assert Router.in_state(simple_fsm_mod.POSTING, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.NEXT, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.END, message)
Router.deliver(message)
assert Router.in_state(simple_fsm_mod.START, message)
Router.clear_states()
Router.LOG_EXCEPTIONS = True
explosion = MailRequest('fakepeer', '<hacker@localhost>',
'start-explode@localhost', "")
Router.deliver(explosion)
assert Router.in_error(simple_fsm_mod.END, explosion)
Router.clear_states()
Router.LOG_EXCEPTIONS = False
explosion = MailRequest('fakepeer', 'hacker@localhost',
'start-explode@localhost', "")
assert_raises(RuntimeError, Router.deliver, explosion)
Router.reload()
assert 'salmon_tests.handlers.simple_fsm_mod' in Router.HANDLERS
assert len(Router.ORDER)
assert len(Router.REGISTERED)
