Exemplo n.º 1
0
def test_mail_to_you_is_bouncing():
    msg = MailRequest("fakepeer", None, None, open("tests/bounce.msg").read())
    assert msg.is_bounce()

    bounce_rep = bounce.mail_to_you_is_bouncing(msg)
    assert bounce_rep
    assert_equal(bounce_rep['to'], msg.bounce.final_recipient)
Exemplo n.º 2
0
def test_craft_response_attachment():
    sample = MailResponse(To=list_name + "@librelist.com",
                          From=user_full_address,
                          Subject="Test message with attachments.",
                          Body="The body as one attachment.")

    sample.attach(filename="tests/model/mailinglist_tests.py",
                  content_type="text/plain",
                  disposition="attachment")

    sample['message-id'] = '123545666'

    im = sample.to_message()
    assert_equal(len([x for x in im.walk()]), 3)

    inmsg = MailRequest("fakepeer", None, None, str(sample))
    assert_equal(len(inmsg.all_parts()), 2)

    outmsg = craft_response(inmsg, list_name, list_name + "@librelist.com")

    om = outmsg.to_message()

    assert_equal(len([x for x in om.walk()]), len([x for x in im.walk()]))

    assert 'message-id' in outmsg
Exemplo n.º 3
0
def test_craft_response_attachment():
    sample = MailResponse(To=list_name + "@librelist.com",
                          From=user_full_address,
                          Subject="Test message with attachments.",
                          Body="The body as one attachment.")

    sample.attach(filename="tests/model/mailinglist_tests.py",
                  content_type="text/plain",
                  disposition="attachment")

    sample['message-id'] = '123545666'

    im = sample.to_message()
    assert_equal(len([x for x in im.walk()]), 3)
    
    inmsg = MailRequest("fakepeer", None, None, str(sample))
    assert_equal(len(inmsg.all_parts()), 2)

    outmsg = craft_response(inmsg, list_name, list_name +
                                        "@librelist.com")
  
    om = outmsg.to_message()

    assert_equal(len([x for x in om.walk()]),
                 len([x for x in im.walk()]))

    assert 'message-id' in outmsg
Exemplo n.º 4
0
def test_RoutingBase():
    assert len(Router.ORDER) == 0
    assert len(Router.REGISTERED) == 0

    Router.load(['salmon_tests.simple_fsm_mod'])
    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()
    explosion = MailRequest('fakepeer', '<hacker@localhost>',
                            'start-explode@localhost', "")
    Router.LOG_EXCEPTIONS = True
    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.simple_fsm_mod' in Router.HANDLERS
    assert len(Router.ORDER)
    assert len(Router.REGISTERED)

    message = MailRequest(
        'fakepeer', 'zedshaw@localhost',
        ['users-subscribe@localhost', 'users-confirm-1@localhost'],
        "Fake body.")

    Router.deliver(message)

    assert Router.in_state(simple_fsm_mod.POSTING,
                           message), "Router state: %r" % Router.get_state(
                               'simple_fsm_mod', message)
Exemplo n.º 5
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)
Exemplo n.º 6
0
def create_bounce(To, From):
    msg = MailRequest("fakepeer", From, To, open("tests/bounce.msg").read())
    assert msg.is_bounce()

    msg.bounce.final_recipient = From
    msg.bounce.headers['Final-Recipient'] = From
    msg.bounce.original['from'] = From
    msg.bounce.original['to'] = To
    msg.bounce.original.To = set([To])
    msg.bounce.original.From = From

    return msg
Exemplo n.º 7
0
def test_RoutingBase():
    # check that Router is in a pristine state
    assert_equal(len(Router.ORDER), 0)
    assert_equal(len(Router.REGISTERED), 0)

    setup_router(['salmon_tests.handlers.simple_fsm_mod'])
    from .handlers import simple_fsm_mod

    assert_equal(len(Router.ORDER), 5)
    assert_equal(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', "")
    assert_raises(RuntimeError, Router.deliver, explosion)

    Router.reload()
    assert 'salmon_tests.handlers.simple_fsm_mod' in Router.HANDLERS
    assert_equal(len(Router.ORDER), 5)
    assert_equal(len(Router.REGISTERED), 5)
Exemplo n.º 8
0
 def test_eml_without_attachment(self):
     mail_request = MailRequest(
         self.eml_file1, None, None, self.eml_content(self.eml_file1)
     )
     mail_fields = process_email(self.eml_file1, mail_request)
     assert isinstance(mail_fields, dict)
     assert len(mail_fields["attachmentFileName"]) == 0
Exemplo n.º 9
0
 def test_eml_with_inline(self):
     mail_request = MailRequest(
         self.eml_file4, None, None, self.eml_content(self.eml_file4)
     )
     mail_fields = process_email(self.eml_file4, mail_request)
     assert len(mail_fields["attachmentFileName"]) == 1
     assert mail_fields["attachmentFileName"][0] == None
Exemplo n.º 10
0
 def test_bad_reply_to(self):
     mail_request = MailRequest(
         self.eml_file2, None, None, self.eml_content(self.eml_file2)
     )
     mail_fields = process_email(self.eml_file2, mail_request)
     assert isinstance(mail_fields, dict)
     assert mail_fields["reply-to"] == "-"
Exemplo n.º 11
0
 def setup_method(self):
     utils.import_settings(True, boot_module="tests.testing_boot")
     self.ip = "127.0.0.1"
     utils.settings.data["receiver"]["listenhost"] = self.ip
     self.fake_mail_request = MailRequest("", None, None, "")
     self.fake_eml_file = "{ip}-salmon-user".format(ip=self.ip)
     self.file1 = "./rawspams/{}".format(self.eml_file1)
Exemplo n.º 12
0
 def test_eml_with_attachment(self):
     mail_request = MailRequest(
         self.eml_file2, None, None, self.eml_content(self.eml_file2)
     )
     mail_fields = process_email(self.eml_file2, mail_request)
     assert isinstance(mail_fields, dict)
     assert len(mail_fields["attachmentFileName"]) == 1
     assert mail_fields["attachmentFileName"][0] == "my_attach.doc"
Exemplo n.º 13
0
 def test_link_in_eml(self):
     mail_request = MailRequest(
         self.eml_file3, None, None, self.eml_content(self.eml_file3)
     )
     mail_fields = process_email(self.eml_file3, mail_request)
     assert isinstance(mail_fields, dict)
     assert len(mail_fields["links"]) > 0
     assert mail_fields["links"][0] == "www.test.cz"
Exemplo n.º 14
0
def test_post():
    message = MailRequest("fakepeer", user,
                          "*****@*****.**" % blog, "Fake body")
    message['Subject'] = 'Test subject'

    post.post(blog, user, "localhost", message)

    assert post.user_exists(user), "User dir not created."
    assert os.path.exists(post.blog_file_name(blog, user)), "File not made."
Exemplo n.º 15
0
    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")
Exemplo n.º 16
0
    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)
Exemplo n.º 17
0
def test_craft_response_no_attachment():
    sample = MailResponse(To=list_name + "@librelist.com",
                          From=user_full_address,
                          Subject="Test message with attachments.",
                          Body="The body as one attachment.")

    im = sample.to_message()
    assert_equal(len([x for x in im.walk()]), 1)
    assert_equal(im.get_payload(), sample.Body)

    inmsg = MailRequest("fakepeer", None, None, str(sample))
    assert_equal(len(inmsg.all_parts()), 0)
    assert_equal(inmsg.body(), sample.Body)

    outmsg = craft_response(inmsg, list_name, list_name + "@librelist.com")

    om = outmsg.to_message()
    assert_equal(om.get_payload(), sample.Body)

    assert_equal(len([x for x in om.walk()]), len([x for x in im.walk()]))
Exemplo n.º 18
0
    def test_make_email(self):
        inbox = factories.InboxFactory()
        message = MailRequest("locahost", "test@localhost", str(inbox), TEST_MSG)

        make_email(message, inbox)
        self.assertEqual(models.Email.objects.count(), 1)
        self.assertEqual(models.PartList.objects.count(), 6)

        bodies = [six.binary_type(part.body.data) for part in
                  models.PartList.objects.select_related("body").order_by("level", "lft")]
        self.assertEqual(bodies, BODIES)
Exemplo n.º 19
0
 def test_rating_100_1(self, f_password):
     """Test email with the password in body_plain"""
     self.password4 = "changeme"
     self.username4 = "changeme"
     self.settings4 = Settings(username=self.username4,
                               password=self.password4)
     push_into_db(self.settings4)
     mail_request = MailRequest(self.eml_file1, None, None,
                                self.eml_content(self.eml_file1))
     mail_fields = process_email(self.eml_file1, mail_request)
     rating = conclude(mail_fields, self.eml_file1, mail_request)
     assert rating == 100
Exemplo n.º 20
0
 def test_mail_fields(self):
     mail_request = MailRequest(
         self.eml_file1, None, None, self.eml_content(self.eml_file1)
     )
     mail_fields = process_email(self.eml_file1, mail_request)
     assert isinstance(mail_fields, dict)
     assert mail_fields["to"][0][0] == "*****@*****.**"
     assert mail_fields["reply-to"] == "*****@*****.**"
     assert mail_fields["from"] == "*****@*****.**"
     assert mail_fields["from_name"] == "Test Test"
     assert mail_fields["subject"] == "Hello"
     assert mail_fields["text"] == "test"
Exemplo n.º 21
0
def run(files, directory, mtimes):
    mail_fields = None
    for file_name in files:
        mail_request = MailRequest(
            file_name, None, None, eml_content(file_name, directory)
        )
        mail_fields = process_email(file_name, mail_request)
        if mail_fields:
            mtime = mtimes[file_name]
            mail_fields["date"] = mtime
            rating = conclude(mail_fields, file_name, mail_request)
            if rating >= 70 and RELAYED < 13:
                RELAYED += 1
Exemplo n.º 22
0
def test_craft_response_no_attachment():
    sample = MailResponse(To=list_name + "@librelist.com",
                          From=user_full_address,
                          Subject="Test message with attachments.",
                          Body="The body as one attachment.")

    im = sample.to_message()
    assert_equal(len([x for x in im.walk()]), 1)
    assert_equal(im.get_payload(), sample.Body)
    
    inmsg = MailRequest("fakepeer", None, None, str(sample))
    assert_equal(len(inmsg.all_parts()), 0)
    assert_equal(inmsg.body(), sample.Body)

    outmsg = craft_response(inmsg, list_name, list_name +
                                        "@librelist.com")
  
    om = outmsg.to_message()
    assert_equal(om.get_payload(), sample.Body)

    assert_equal(len([x for x in om.walk()]),
                 len([x for x in im.walk()]))
Exemplo n.º 23
0
def test_post_message():
    for i in range(0, 3):
        add_subscriber(user_full_address, list_name)

    sample = MailResponse(To=list_name + "@librelist.com",
                          From=user_full_address,
                          Subject="Test post message.",
                          Body="I am telling you guys you are wrong.")

    sample['Message-Id'] = '12313123123123123'

    msg = MailRequest("fakepeer", sample['from'], sample['to'], str(sample))
    post_message(relay(port=8825), msg, list_name, "librelist.com")
Exemplo n.º 24
0
def test_white_list_cleanse():
    msg = MailRequest('fakepeer', None, None,
                      open('tests/lots_of_headers.msg').read())
    resp = mailinglist.craft_response(msg, 'test.list',
                                      '*****@*****.**')

    archive.white_list_cleanse(resp)

    for key in resp.keys():
        assert key in archive.ALLOWED_HEADERS

    assert '@' not in resp['from']
    assert str(resp)
Exemplo n.º 25
0
def test_remove_from_queue():
    message = MailRequest("fakepeer", user,
                          "*****@*****.**" % blog, "Fake body")
    message['Subject'] = 'Test subject'

    post_q = post.get_user_post_queue(post.get_user_dir(user))

    post.post(blog, user, 'localhost', message)

    assert post_q.count(), "No messages in the post queue."
    count = post_q.count()

    post.remove_from_queue(blog, user)
    assert post_q.count() == count-1, "It didn't get removed."
Exemplo n.º 26
0
    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))
Exemplo n.º 27
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])
Exemplo n.º 28
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)
Exemplo n.º 29
0
def test_to_json():
    msg = MailRequest('fakeperr', None, None, open("tests/bounce.msg").read())

    resp = mailinglist.craft_response(msg, 'test.list',
                                      '*****@*****.**')
    # attach an the message back but fake it as an image it'll be garbage
    resp.attach(filename="tests/bounce.msg",
                content_type="image/png",
                disposition="attachment")
    resp.to_message()  # prime the pump

    js = archive.to_json(resp.base)
    assert js

    rtjs = json.loads(js)
    assert rtjs
    assert rtjs['parts'][-1]['encoding']['format'] == 'base64'
Exemplo n.º 30
0
    def test_forwarding(self):
        from router.app.server import forward_to_admins

        with mock.patch("router.app.server.Relay") as relay_mock:
            deliver_mock = relay_mock.return_value.deliver
            message = MailRequest("", "", "", "")
            forward_to_admins(message, "user", "example.com")

            self.assertEqual(deliver_mock.call_count, 1)
            self.assertEqual(deliver_mock.call_args[0], (message,))
            self.assertEqual(deliver_mock.call_args[1], {"To": ["root@localhost"], "From": "django@localhost"})

            deliver_mock.reset_mock()
            with mock.patch.object(message, "is_bounce", lambda: True):
                forward_to_admins(message, "user", "example.com")

                self.assertEqual(deliver_mock.call_count, 0)
Exemplo n.º 31
0
def convert_queue(arg, dirname, names):
    if dirname.endswith("new"):
        print dirname, names

        jpath = dirname + "/../../json"
        if not os.path.exists(jpath):
            os.mkdir(jpath)

        for key in names:
            json_file = key + ".json"
            json_archive = os.path.join(jpath, json_file)

            fpath = os.path.join(dirname, key)
            msg = MailRequest('librelist.com', None, None, open(fpath).read())
            f = open(json_archive, "w")
            f.write(archive.to_json(msg.base))
            f.close()
Exemplo n.º 32
0
    def test_make_email(self):
        inbox = factories.InboxFactory()
        message = MailRequest("locahost", "test@localhost", str(inbox),
                              TEST_MSG)

        router_utils.make_email(message, inbox)
        self.assertEqual(models.Email.objects.count(), 1)
        self.assertEqual(models.PartList.objects.count(), 6)

        email = models.Email.objects.first()
        self.assertEqual(email.inbox, inbox)
        self.assertNotEqual(email.search_tsv, None)

        bodies = [
            bytes(part.body.data)
            for part in models.PartList.objects.select_related(
                "body").order_by("level", "lft")
        ]
        self.assertEqual(bodies, BODIES)