Exemplo n.º 1
0
 def mk_envelope(self, data, sender=None, recipients=None):
     env = Envelope(sender=sender)
     env.parse(data)
     if not recipients:
         recipients = ['root@localhost']
     env.recipients = recipients
     return env
Exemplo n.º 2
0
 def test_add_date_header_existing(self):
     env = Envelope()
     env.parse('Date: testing\r\n')
     adh = AddDateHeader()
     self.assertEqual('testing', env.headers['Date'])
     adh.apply(env)
     self.assertEqual('testing', env.headers['Date'])
Exemplo n.º 3
0
 def as_envelope(self):
     message = self.as_message()
     envelope = Envelope()
     envelope.parse(message.message().as_bytes())
     envelope.sender = message.from_email
     envelope.recipients.append(self.recipient)
     return envelope
Exemplo n.º 4
0
 def test_deliver_multircpt(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope(
         '*****@*****.**',
         ['*****@*****.**', '*****@*****.**', '*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     self.sock.sendall(b'LHLO test\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         b'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(IsA(int)).AndReturn(
         b'250 Ok\r\n250 Ok\r\n550 Nope\r\n250 Ok\r\n354 Go ahead\r\n')
     self.sock.sendall(
         b'From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n450 Yikes\r\n')
     result.set({
         '*****@*****.**': None,
         '*****@*****.**': IsA(PermanentRelayError),
         '*****@*****.**': IsA(TransientRelayError)
     })
     self.sock.sendall(b'RSET\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.mox.ReplayAll()
     client = LmtpRelayClient('addr',
                              self.queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='test')
     client._connect()
     client._ehlo()
     client._deliver(result, env)
Exemplo n.º 5
0
 def test_deliver_conversion(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall(b'LHLO test\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         b'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(
         IsA(int)).AndReturn(b'250 Ok\r\n250 Ok\r\n354 Go ahead\r\n')
     self.sock.sendall(
         b'From: [email protected]\r\nContent-Transfer-Encoding: base64\r\n\r\ndGVzdCB0ZXN0IIENCg==\n\r\n.\r\n'
     )
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     result.set({'*****@*****.**': None})
     self.mox.ReplayAll()
     client = LmtpRelayClient('addr',
                              self.queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='test',
                              binary_encoder=encode_base64)
     client._connect()
     client._ehlo()
     client._deliver(result, env)
Exemplo n.º 6
0
 def test_enqueue_wait_splitpolicy(self):
     splitpolicy1 = self.mox.CreateMock(QueuePolicy)
     splitpolicy2 = self.mox.CreateMock(QueuePolicy)
     regpolicy = self.mox.CreateMock(QueuePolicy)
     env1 = Envelope('*****@*****.**', ['*****@*****.**'])
     env2 = Envelope('*****@*****.**', ['*****@*****.**'])
     env3 = Envelope('*****@*****.**', ['*****@*****.**'])
     splitpolicy1.apply(self.env).AndReturn([env1, env2])
     regpolicy.apply(env1)
     splitpolicy2.apply(env1)
     regpolicy.apply(env2)
     splitpolicy2.apply(env2).AndReturn([env2, env3])
     self.store.write(env1, IsA(float)).AndReturn('1234')
     self.store.write(env2, IsA(float)).AndReturn('5678')
     self.store.write(env3, IsA(float)).AndReturn('90AB')
     self.relay._attempt(env1, 0).InAnyOrder('relay')
     self.relay._attempt(env2, 0).InAnyOrder('relay')
     self.relay._attempt(env3, 0).InAnyOrder('relay')
     self.store.remove('1234').InAnyOrder('relay')
     self.store.remove('5678').InAnyOrder('relay')
     self.store.remove('90AB').InAnyOrder('relay')
     self.mox.ReplayAll()
     queue = Queue(self.store, self.relay, relay_pool=5)
     queue.add_policy(splitpolicy1)
     queue.add_policy(regpolicy)
     queue.add_policy(splitpolicy2)
     self.assertEqual([(env1, '1234'), (env2, '5678'), (env3, '90AB')],
                      queue.enqueue(self.env))
     queue.relay_pool.join()
    def test_write(self):
        self.storage.redis.hsetnx(Func(_is_prefixed_id), 'envelope',
                                  IsA(bytes)).AndReturn(0)
        self.storage.redis.hsetnx(Func(_is_prefixed_id), 'envelope',
                                  IsA(bytes)).AndReturn(1)
        pipe = self.mox.CreateMockAnything()
        self.storage.redis.pipeline().AndReturn(pipe)

        def _verify_hmset(val):
            self.assertEqual(1234567890, val['timestamp'])
            self.assertEqual(0, val['attempts'])
            self.assertFalse('envelope' in val)
            return True

        pipe.hmset(Func(_is_prefixed_id), Func(_verify_hmset))

        def _verify_rpush(val):
            timestamp, id = cPickle.loads(val)
            self.assertEqual(1234567890, timestamp)
            self.assertTrue(_is_id(id))
            return True

        pipe.rpush('test:queue', Func(_verify_rpush))
        pipe.execute()
        self.mox.ReplayAll()
        env = Envelope('*****@*****.**', ['*****@*****.**'])
        env.timestamp = 9876543210
        self.storage.write(env, 1234567890)
    def test_recipientsplit_apply(self):
        env = Envelope('*****@*****.**', ['*****@*****.**',
                                              '*****@*****.**'])
        env.parse(b"""\
From: [email protected]
To: [email protected]
To: [email protected]

test test\r
""")
        policy = RecipientSplit()
        env1, env2 = policy.apply(env)

        self.assertEqual('*****@*****.**', env1.sender)
        self.assertEqual(['*****@*****.**'], env1.recipients)
        self.assertEqual('*****@*****.**', env1.headers['from'])
        self.assertEqual(['*****@*****.**', '*****@*****.**'],
                         env1.headers.get_all('To'))
        self.assertEqual(b'test test\r\n', env1.message)

        self.assertEqual('*****@*****.**', env2.sender)
        self.assertEqual(['*****@*****.**'], env2.recipients)
        self.assertEqual('*****@*****.**', env2.headers['from'])
        self.assertEqual(['*****@*****.**', '*****@*****.**'],
                         env2.headers.get_all('To'))
        self.assertEqual(b'test test\r\n', env2.message)
Exemplo n.º 9
0
 def test_deliver_conversion(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall(b'EHLO there\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         b'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(
         IsA(int)).AndReturn(b'250 Ok\r\n250 Ok\r\n354 Go ahead\r\n')
     if pycompat.PY3:
         self.sock.sendall(
             b'From: [email protected]\r\nContent-Transfer-Encoding: base64\r\n\r\ndGVzdCB0ZXN0IIEK\r\n.\r\n'
         )
     else:
         self.sock.sendall(
             b'From: [email protected]\r\nContent-Transfer-Encoding: base64\r\n\r\ndGVzdCB0ZXN0IIENCg==\r\n.\r\n'
         )
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.mox.ReplayAll()
     client = SmtpRelayClient(('addr', 0),
                              self.queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='there',
                              binary_encoder=encode_base64)
     client._connect()
     client._ehlo()
     client._deliver(result, env)
     self.assertEqual({'*****@*****.**': Reply('250', 'Ok')},
                      result.get_nowait())
Exemplo n.º 10
0
 def test_deliver_baddata(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     self.sock.sendall(b'EHLO there\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         b'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(
         IsA(int)).AndReturn(b'250 Ok\r\n250 Ok\r\n354 Go ahead\r\n')
     self.sock.sendall(
         b'From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'450 Yikes\r\n')
     self.sock.sendall(b'RSET\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.mox.ReplayAll()
     client = SmtpRelayClient(('addr', 0),
                              self.queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='there')
     client._connect()
     client._ehlo()
     client._deliver(result, env)
     with self.assertRaises(TransientRelayError):
         result.get_nowait()
Exemplo n.º 11
0
 def test_run(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     queue = BlockingDeque()
     queue.append((result, env))
     self.sock.recv(IsA(int)).AndReturn(b'220 Welcome\r\n')
     self.sock.sendall(b'EHLO there\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         b'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(
         IsA(int)).AndReturn(b'250 Ok\r\n250 Ok\r\n354 Go ahead\r\n')
     self.sock.sendall(
         b'From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.sock.sendall(b'QUIT\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'221 Goodbye\r\n')
     self.sock.close()
     self.mox.ReplayAll()
     client = SmtpRelayClient(('addr', 0),
                              queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='there')
     client._run()
     self.assertEqual({'*****@*****.**': Reply('250', 'Ok')},
                      result.get_nowait())
 def test_add_message_id_header_existing(self):
     env = Envelope()
     env.parse(b'Message-Id: testing\r\n')
     amih = AddMessageIdHeader()
     self.assertEqual('testing', env.headers['Message-Id'])
     amih.apply(env)
     self.assertEqual('testing', env.headers['Message-Id'])
Exemplo n.º 13
0
def message_to_envelope(message):
    generated_message = message.message()
    envelope = Envelope()
    envelope.parse(generated_message.as_bytes())
    envelope.sender = message.from_email
    envelope.recipients.append(message.to[0])
    return envelope
Exemplo n.º 14
0
    def test_recipientsplit_apply(self):
        env = Envelope('*****@*****.**',
                       ['*****@*****.**', '*****@*****.**'])
        env.parse("""\
From: [email protected]
To: [email protected]
To: [email protected]

test test\r
""")
        policy = RecipientSplit()
        env1, env2 = policy.apply(env)

        assert_equal('*****@*****.**', env1.sender)
        assert_equal(['*****@*****.**'], env1.recipients)
        assert_equal('*****@*****.**', env1.headers['from'])
        assert_equal(['*****@*****.**', '*****@*****.**'],
                     env1.headers.get_all('To'))
        assert_equal('test test\r\n', env1.message)

        assert_equal('*****@*****.**', env2.sender)
        assert_equal(['*****@*****.**'], env2.recipients)
        assert_equal('*****@*****.**', env2.headers['from'])
        assert_equal(['*****@*****.**', '*****@*****.**'],
                     env2.headers.get_all('To'))
        assert_equal('test test\r\n', env2.message)
 def test_add_message_id_header_existing(self):
     env = Envelope()
     env.parse('Message-Id: testing\r\n')
     amih = AddMessageIdHeader()
     self.assertEqual('testing', env.headers['Message-Id'])
     amih.apply(env)
     self.assertEqual('testing', env.headers['Message-Id'])
Exemplo n.º 16
0
    def as_envelope(self, must_raise=True):
        envelope = Envelope()

        headers_filters.process(
            self.headers, self,
            settings.TRANSACTIONAL['HEADERS_FILTERS_PARAMS'])

        headers = ""
        for key, value in self.headers.items():
            if key in ('Subject', ):
                header = make_header(decode_header(value),
                                     header_name=key,
                                     maxlinelen=78)
                value = header.encode(linesep='\r\n')
            headers += "{}: {}\n".format(key, value)

        message = ""
        if self.message:
            message = self.message.content or ""

        if self.message is None and must_raise:
            raise Exception("Can't build this envelope because "
                            "there is no RawMail attached to it.")
        envelope.parse(headers.encode('utf-8') + message.encode('utf-8'))
        envelope.sender = self.sender
        envelope.recipients.append(self.recipient)
        return envelope
 def test_add_date_header_existing(self):
     env = Envelope()
     env.parse('Date: testing\r\n')
     adh = AddDateHeader()
     self.assertEqual('testing', env.headers['Date'])
     adh.apply(env)
     self.assertEqual('testing', env.headers['Date'])
Exemplo n.º 18
0
 def test_attempt(self):
     self.mox.StubOutWithMock(subprocess, 'Popen')
     env = Envelope('*****@*****.**', ['*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     self._mock_popen('*****@*****.**', 0, '')
     self._mock_popen('*****@*****.**', 1337, 'transient')
     self._mock_popen('*****@*****.**', 1337, '5.0.0 permanent')
     subprocess.Popen(['relaytest', '-f', '*****@*****.**', '*****@*****.**'],
                      stdin=subprocess.PIPE,
                      stdout=subprocess.PIPE,
                      stderr=subprocess.PIPE).AndRaise(Timeout)
     self.mox.ReplayAll()
     m = PipeRelay(['relaytest', '-f', '{sender}', '{recipient}'])
     results = m.attempt(env, 0)
     self.assertEqual(4, len(results))
     self.assertEqual(None, results['*****@*****.**'])
     self.assertIsInstance(results['*****@*****.**'], TransientRelayError)
     self.assertEqual('transient', str(results['*****@*****.**']))
     self.assertEqual('450', results['*****@*****.**'].reply.code)
     self.assertIsInstance(results['*****@*****.**'], PermanentRelayError)
     self.assertEqual('5.0.0 permanent', str(results['*****@*****.**']))
     self.assertEqual('550', results['*****@*****.**'].reply.code)
     self.assertIsInstance(results['*****@*****.**'], TransientRelayError)
     self.assertEqual('Delivery timed out', str(results['*****@*****.**']))
     self.assertEqual('450', results['*****@*****.**'].reply.code)
Exemplo n.º 19
0
 def test_parse_nonascii_headers(self):
     env = Envelope()
     env.parse(b'Subject: \xc3\xa9\xc3\xa9\n')
     try:
         self.assertEqual(b'\xc3\xa9\xc3\xa9', env.headers['subject'].encode())
     except UnicodeDecodeError:
         self.assertEqual(b'\xc3\xa9\xc3\xa9', env.headers['subject'])
Exemplo n.º 20
0
 def test_deliver(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall(b'EHLO there\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 8BITMIME\r\n')
     self.sock.sendall(b'MAIL FROM:<*****@*****.**>\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.sock.sendall(b'RCPT TO:<*****@*****.**>\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.sock.sendall(b'DATA\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'354 Go ahead\r\n')
     self.sock.sendall(
         b'From: [email protected]\r\n\r\ntest test \x81\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.mox.ReplayAll()
     client = SmtpRelayClient(('addr', 0),
                              self.queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='there')
     client._connect()
     client._ehlo()
     client._deliver(result, env)
     self.assertEqual({'*****@*****.**': Reply('250', 'Ok')},
                      result.get_nowait())
Exemplo n.º 21
0
 def test_run(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse('From: [email protected]\r\n\r\ntest test\r\n')
     queue = BlockingDeque()
     queue.append((result, env))
     self.sock.recv(IsA(int)).AndReturn('220 Welcome\r\n')
     self.sock.sendall('EHLO test\r\n')
     self.sock.recv(IsA(int)).AndReturn('250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(
         'MAIL FROM:<*****@*****.**>\r\nRCPT TO:<*****@*****.**>\r\nDATA\r\n'
     )
     self.sock.recv(
         IsA(int)).AndReturn('250 Ok\r\n250 Ok\r\n354 Go ahead\r\n')
     self.sock.sendall('From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn('250 Ok\r\n')
     result.set(True)
     self.sock.sendall('QUIT\r\n')
     self.sock.recv(IsA(int)).AndReturn('221 Goodbye\r\n')
     self.sock.close()
     self.mox.ReplayAll()
     client = SmtpRelayClient(None,
                              queue,
                              socket_creator=self._socket_creator,
                              ehlo_as='test')
     client._run()
Exemplo n.º 22
0
 def test_parse_nonascii_headers(self):
     env = Envelope()
     env.parse(b'Subject: \xc3\xa9\xc3\xa9\n')
     try:
         self.assertEqual(b'\xc3\xa9\xc3\xa9',
                          env.headers['subject'].encode())
     except UnicodeDecodeError:
         self.assertEqual(b'\xc3\xa9\xc3\xa9', env.headers['subject'])
 def test_add_date_header(self):
     env = Envelope()
     env.parse('')
     env.timestamp = 1234567890
     adh = AddDateHeader()
     self.assertEqual(None, env.headers['Date'])
     adh.apply(env)
     self.assertTrue(env.headers['Date'])
Exemplo n.º 24
0
 def test_encode_7bit(self):
     headers = Message()
     headers['From'] = '*****@*****.**'
     headers['To'] = '*****@*****.**'
     body = bytes(bytearray(range(129, 256)))
     env = Envelope(headers=headers, message=body)
     with self.assertRaises(UnicodeError):
         env.encode_7bit()
Exemplo n.º 25
0
 def MAIL(self, reply, address, params):
     try:
         self._call_validator('mail', reply, address, params)
     except TypeError:
         # XXX: Temporary for backwards-compatibility.
         self._call_validator('mail', reply, address)
     if reply.code == '250':
         self.envelope = Envelope(sender=address)
 def test_add_headers(self):
     self.data['*****@*****.**'] = {'add_headers': '{"X-Test-A": "one"}'}
     self.data['*****@*****.**'] = {'add_headers': '{"X-Test-B": "two"}'}
     env = Envelope('*****@*****.**', ['*****@*****.**', '*****@*****.**'])
     env.parse(b"""\n\n""")
     self.policy.apply(env)
     self.assertEquals('one', env.headers['x-test-a'])
     self.assertEquals('two', env.headers['x-test-b'])
Exemplo n.º 27
0
 def test_encode_7bit(self):
     headers = Message()
     headers['From'] = '*****@*****.**'
     headers['To'] = '*****@*****.**'
     body = bytes(bytearray(range(129, 256)))
     env = Envelope(headers=headers, message=body)
     with self.assertRaises(UnicodeError):
         env.encode_7bit()
 def test_add_date_header_existing(self):
     env = Envelope()
     epoch = 'Thu, 01 Jan 1970 00:00:00 -0000'
     env.parse(b'Date: '+epoch.encode()+b'\r\n')
     adh = AddDateHeader()
     self.assertEqual(epoch, env.headers['Date'])
     adh.apply(env)
     self.assertEqual(epoch, env.headers['Date'])
 def test_add_date_header(self):
     env = Envelope()
     env.parse(b'')
     env.timestamp = 1234567890
     adh = AddDateHeader()
     self.assertEqual(None, env.headers['Date'])
     adh.apply(env)
     self.assertTrue(env.headers['Date'])
 def test_add_date_header_existing(self):
     env = Envelope()
     epoch = 'Thu, 01 Jan 1970 00:00:00 -0000'
     env.parse(b'Date: ' + epoch.encode() + b'\r\n')
     adh = AddDateHeader()
     self.assertEqual(epoch, env.headers['Date'])
     adh.apply(env)
     self.assertEqual(epoch, env.headers['Date'])
 def test_add_message_id_header(self):
     env = Envelope()
     env.parse('')
     env.timestamp = 1234567890
     amih = AddMessageIdHeader('example.com')
     self.assertEqual(None, env.headers['Message-Id'])
     amih.apply(env)
     pattern = r'^<[0-9a-fA-F]{32}\[email protected]>$'
     self.assertRegexpMatches(env.headers['Message-Id'], pattern)
Exemplo n.º 32
0
 def test_valid_prefix(self):
     recipient = '*****@*****.**'
     dsn = DSN_REPORT.replace('||TO||', recipient)
     dsn = dsn.replace('||RETURNPATH||', 'foo@bar')
     message = email.message_from_string(dsn)
     envelope = Envelope()
     envelope.parse_msg(message)
     envelope.recipients = [recipient]
     BackMuncherQueuePolicy().apply(envelope)
    def test_parse_onlyheaders(self):
        env = Envelope()
        env.parse("""\
From: [email protected]
Subject: important things
""")
        assert_equal('*****@*****.**', env.headers['from'])
        assert_equal('important things', env.headers['subject'])
        assert_equal('', env.message)
Exemplo n.º 34
0
 def test_apply(self):
     env = Envelope()
     env.parse(b"""X-Spam-Status: NO\r\n\r\n""")
     self.mox.StubOutWithMock(self.sa, 'scan')
     self.sa.scan(env).AndReturn((True, ['one', 'two']))
     self.mox.ReplayAll()
     self.sa.apply(env)
     self.assertEqual('YES', env.headers['X-Spam-Status'])
     self.assertEqual('one, two', env.headers['X-Spam-Symbols'])
 def test_add_message_id_header(self):
     env = Envelope()
     env.parse(b'')
     env.timestamp = 1234567890
     amih = AddMessageIdHeader('example.com')
     self.assertEqual(None, env.headers['Message-Id'])
     amih.apply(env)
     pattern = r'^<[0-9a-fA-F]{32}\[email protected]>$'
     self.assertRegexpMatches(env.headers['Message-Id'], pattern)
Exemplo n.º 36
0
    def test_parse_onlyheaders(self):
        env = Envelope()
        env.parse(b"""\
From: [email protected]
Subject: important things
""".replace(b'\n', b'\r\n'))
        self.assertEqual('*****@*****.**', env.headers['from'])
        self.assertEqual('important things', env.headers['subject'])
        self.assertEqual(b'', env.message)
Exemplo n.º 37
0
    def test_parse_onlyheaders(self):
        env = Envelope()
        env.parse("""\
From: [email protected]
Subject: important things
""")
        self.assertEqual('*****@*****.**', env.headers['from'])
        self.assertEqual('important things', env.headers['subject'])
        self.assertEqual('', env.message)
Exemplo n.º 38
0
    def _get_envelope(self, environ):
        sender = self._get_sender(environ)
        recipients = self._get_recipients(environ)
        env = Envelope(sender, recipients)

        content_length = int(environ.get('CONTENT_LENGTH', 0))
        data = environ['wsgi.input'].read(content_length)
        env.parse(data)
        return env
Exemplo n.º 39
0
    def _get_envelope(self, environ):
        sender = self._get_sender(environ)
        recipients = self._get_recipients(environ)
        env = Envelope(sender, recipients)

        content_length = int(environ.get('CONTENT_LENGTH', 0))
        data = environ['wsgi.input'].read(content_length)
        env.parse(data)
        return env
Exemplo n.º 40
0
 def test_invalide_returnpath(self):
     recipient = '*****@*****.**'
     arf = ARF_REPORT.replace('||TO||', '*****@*****.**')
     arf = arf.replace('||RETURNPATH||', recipient)
     message = email.message_from_string(arf)
     envelope = Envelope()
     envelope.parse_msg(message)
     envelope.recipients = [recipient]
     handler = ARFHandler(envelope, message)
     self.assertIsNone(handler.apply())
Exemplo n.º 41
0
 def test_invalid_recipient(self):
     recipient = '*****@*****.**'
     dsn = DSN_REPORT.replace('||TO||', recipient)
     dsn = dsn.replace('||RETURNPATH||', recipient)
     message = email.message_from_string(dsn)
     envelope = Envelope()
     envelope.parse_msg(message)
     with self.assertRaises(QueueError) as exc:
         BackMuncherQueuePolicy().apply(envelope)
     self.assertEqual(str(exc.exception), 'Missing recipient')
Exemplo n.º 42
0
 def test_invalide_returnpath(self):
     recipient = '*****@*****.**'
     unsubscribe = UNSUBSCRIBE_EMAIL.replace('||TO||', recipient)
     unsubscribe = unsubscribe.replace('||RETURNPATH||', recipient)
     message = email.message_from_string(unsubscribe)
     envelope = Envelope()
     envelope.parse_msg(message)
     envelope.recipients = [recipient]
     handler = UnsubscribeHandler(envelope, message)
     self.assertIsNone(handler.apply())
 def test_parse_message_object(self):
     data = Message()
     data['From'] = '*****@*****.**'
     data['To'] = '*****@*****.**'
     data['To'] = '*****@*****.**'
     data.set_payload('test test\r\n')
     env = Envelope()
     env.parse(data)
     assert_equal('*****@*****.**', env.headers['from'])
     assert_equal(['*****@*****.**', '*****@*****.**'], env.headers.get_all('to'))
     assert_equal('test test\r\n', env.message)
Exemplo n.º 44
0
 def test_parse_message_object(self):
     msg = Message()
     msg['From'] = '*****@*****.**'
     msg['To'] = '*****@*****.**'
     msg['To'] = '*****@*****.**'
     msg.set_payload(b'test test\r\n')
     env = Envelope()
     env.parse_msg(msg)
     self.assertEqual('*****@*****.**', env.headers['from'])
     self.assertEqual(['*****@*****.**', '*****@*****.**'], env.headers.get_all('to'))
     self.assertEqual(b'test test\r\n', env.message)
 def test_encode_7bit(self):
     headers = Message()
     headers['From'] = '*****@*****.**'
     headers['To'] = '*****@*****.**'
     body = ''.join([chr(i) for i in range(129, 256)])
     env = Envelope(headers=headers, message=body)
     header_str = '\r\n'.join(['From: [email protected]',
                               'To: [email protected]',
                               '', ''])
     with assert_raises(UnicodeDecodeError):
         env.encode_7bit()
 def test_send_envelope_conversion_failure(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse('From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall('EHLO test\r\n')
     self.sock.recv(IsA(int)).AndReturn('250-Hello\r\n250 PIPELINING\r\n')
     result.set_exception(IsA(PermanentRelayError))
     self.mox.ReplayAll()
     client = SmtpRelayClient(None, self.queue, socket_creator=self._socket_creator, ehlo_as='test')
     client._connect()
     client._ehlo()
     client._send_envelope(result, env)
Exemplo n.º 47
0
 def test_attempt_timeout(self):
     self.mox.StubOutWithMock(subprocess, 'Popen')
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     subprocess.Popen(['maildrop', '-f', '*****@*****.**'],
                      stdin=subprocess.PIPE,
                      stdout=subprocess.PIPE,
                      stderr=subprocess.PIPE).AndRaise(Timeout)
     self.mox.ReplayAll()
     m = MaildropRelay()
     with self.assertRaises(TransientRelayError):
         m.attempt(env, 0)
 def test_send_message_data(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     self.sock.sendall(b'From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.sock.sendall(b'From: [email protected]\r\n\r\ntest test\r\n.\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'550 Ok\r\n')
     self.mox.ReplayAll()
     client = SmtpRelayClient('addr', self.queue, socket_creator=self._socket_creator)
     client._connect()
     client._send_message_data(env)
     with self.assertRaises(PermanentRelayError):
         client._send_message_data(env)
    def test_recipientdomainsplit_apply_allbadrcpts(self):
        env = Envelope('*****@*****.**', ['rcpt1', 'rcpt2@'])
        env.parse(b"""\r\ntest test\r\n""")
        policy = RecipientDomainSplit()
        env1, env2 = policy.apply(env)

        self.assertEqual('*****@*****.**', env1.sender)
        self.assertEqual(['rcpt1'], env1.recipients)
        self.assertEqual(b'test test\r\n', env1.message)

        self.assertEqual('*****@*****.**', env2.sender)
        self.assertEqual(['rcpt2@'], env2.recipients)
        self.assertEqual(b'test test\r\n', env2.message)
Exemplo n.º 50
0
    def test_flatten(self):
        header_str = b"""\
From: [email protected]
To: [email protected]
To: [email protected]

""".replace(b'\n', b'\r\n')
        body_str = b'test test\r\n'
        env = Envelope()
        env.parse(header_str + body_str)
        ret_headers, ret_body = env.flatten()
        self.assertEqual(header_str, ret_headers)
        self.assertEqual(body_str, ret_body)
Exemplo n.º 51
0
    def test_parse(self):
        env = Envelope()
        env.parse(b"""\
From: [email protected]
To: [email protected]
To: [email protected]

test test
""".replace(b'\n', b'\r\n'))
        self.assertEqual('*****@*****.**', env.headers['from'])
        self.assertEqual(['*****@*****.**', '*****@*****.**'],
                         env.headers.get_all('To'))
        self.assertEqual(b'test test\r\n', env.message)
    def test_parse(self):
        env = Envelope()
        env.parse("""\
From: [email protected]
To: [email protected]
To: [email protected]

test test\r
""")
        assert_equal('*****@*****.**', env.headers['from'])
        assert_equal(['*****@*****.**', '*****@*****.**'],
                         env.headers.get_all('To'))
        assert_equal('test test\r\n', env.message)
 def test_deliver_conversion_failure(self):
     result = self.mox.CreateMockAnything()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall(b'LHLO there\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(b'RSET\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     result.set_exception(IsA(PermanentRelayError))
     self.mox.ReplayAll()
     client = LmtpRelayClient('addr', self.queue, socket_creator=self._socket_creator, ehlo_as='there')
     client._connect()
     client._ehlo()
     client._deliver(result, env)
 def test_flatten(self):
     headers = Message()
     headers['From'] = '*****@*****.**'
     headers['To'] = '*****@*****.**'
     headers['To'] = '*****@*****.**'
     body = 'test test\r\n'
     env = Envelope(headers=headers, message=body)
     header_str = '\r\n'.join(['From: [email protected]',
                               'To: [email protected]',
                               'To: [email protected]',
                               '', ''])
     ret_headers, ret_body = env.flatten()
     assert_equal(header_str, ret_headers)
     assert_equal(body, ret_body)
 def test_run_banner_failure(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse('From: [email protected]\r\n\r\ntest test\r\n')
     queue = BlockingDeque()
     queue.append((result, env))
     self.sock.recv(IsA(int)).AndReturn('520 Not Welcome\r\n')
     result.set_exception(IsA(PermanentRelayError))
     self.sock.sendall('QUIT\r\n')
     self.sock.recv(IsA(int)).AndReturn('221 Goodbye\r\n')
     self.sock.close()
     self.mox.ReplayAll()
     client = SmtpRelayClient(None, queue, socket_creator=self._socket_creator, ehlo_as='test')
     client._run()
 def test_run_banner_failure(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test\r\n')
     queue = BlockingDeque()
     queue.append((result, env))
     self.sock.recv(IsA(int)).AndReturn(b'520 Not Welcome\r\n')
     self.sock.sendall(b'QUIT\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'221 Goodbye\r\n')
     self.sock.close()
     self.mox.ReplayAll()
     client = SmtpRelayClient('addr', queue, socket_creator=self._socket_creator, ehlo_as='test')
     client._run()
     with self.assertRaises(PermanentRelayError):
         result.get_nowait()
 def test_deliver_conversion_failure(self):
     result = AsyncResult()
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse(b'From: [email protected]\r\n\r\ntest test \x81\r\n')
     self.sock.sendall(b'EHLO test\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250-Hello\r\n250 PIPELINING\r\n')
     self.sock.sendall(b'RSET\r\n')
     self.sock.recv(IsA(int)).AndReturn(b'250 Ok\r\n')
     self.mox.ReplayAll()
     client = SmtpRelayClient('addr', self.queue, socket_creator=self._socket_creator, ehlo_as='test')
     client._connect()
     client._ehlo()
     client._deliver(result, env)
     with self.assertRaises(PermanentRelayError):
         result.get_nowait()
 def test_run_timeout(self):
     result = self.mox.CreateMock(AsyncResult)
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     env.parse('From: [email protected]\r\n\r\ntest test\r\n')
     queue = BlockingDeque()
     queue.append((result, env))
     self.sock.recv(IsA(int)).AndRaise(Timeout(0.0))
     result.ready().AndReturn(False)
     result.set_exception(IsA(TransientRelayError))
     self.sock.sendall('QUIT\r\n')
     self.sock.recv(IsA(int)).AndReturn('221 Goodbye\r\n')
     self.sock.close()
     self.mox.ReplayAll()
     client = SmtpRelayClient(None, queue, socket_creator=self._socket_creator, ehlo_as='test')
     client._run()