Python Router.deliver方法代码示例

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
    def test_routes_deliver_to_not_existing_address(self):
        Router.load(['inboxen.router.app.server'])

        message = MailRequest("locahost", "[email protected]", "[email protected]", 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")

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
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

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_Router_undeliverable_queue():
    Router.clear_routes()
    Router.clear_states()

    Router.UNDELIVERABLE_QUEUE = Mock()
    msg = MailRequest('fakepeer', '[email protected]', '[email protected]', "Nothing")

    Router.deliver(msg)
    assert Router.UNDELIVERABLE_QUEUE.push.called

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
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)

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
    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", "[email protected]", "[email protected]", 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))

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
    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", "[email protected]", "[email protected]", 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])

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
    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", "[email protected]", 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)

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
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)

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
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."

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
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', '[email protected]', '[email protected]', "")
    Router.deliver(message)
    assert Router.in_state(simple_fsm_mod.CONFIRM, message)

    confirm = MailRequest('fakepeer', '"Zed Shaw" <[email protected]>',  '[email protected]', "")
    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', '<[email protected]>', '[email protected]', "")
    Router.deliver(explosion)

    assert Router.in_error(simple_fsm_mod.END, explosion)

    Router.clear_states()
    Router.LOG_EXCEPTIONS = False
    explosion = MailRequest('fakepeer',  '[email protected]', '[email protected]', "")
    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)

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_queue_handler():
    import salmon.handlers.queue  # noqa
    Router.deliver(create_message())

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_log_handler():
    import salmon.handlers.log  # noqa
    Router.deliver(create_message())

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_queue_handler():
    Router.deliver(message_tests.test_mail_request())

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_queue_handler():
    import salmon.handlers.queue  # noqa
    Router.deliver(message_tests.test_mail_request())

# 需要导入模块: from salmon.routing import Router [as 别名]
# 或者: from salmon.routing.Router import deliver [as 别名]
def test_spam_sent_by_confirmed_user():
    test_confirmed_user_comments()
    clear_queue("run/posts")

    Router.deliver(make_spam())