[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [bridgedb/master] Remove moved unittests from bridgedb.test.test_email_server.



commit c509a0abb5df5e355f1acc8185fe285e33763dca
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date:   Mon Jun 2 21:11:51 2014 +0000

    Remove moved unittests from bridgedb.test.test_email_server.
---
 lib/bridgedb/test/test_email_server.py |  507 +++++++++-----------------------
 1 file changed, 140 insertions(+), 367 deletions(-)

diff --git a/lib/bridgedb/test/test_email_server.py b/lib/bridgedb/test/test_email_server.py
index 198cb27..f79f603 100644
--- a/lib/bridgedb/test/test_email_server.py
+++ b/lib/bridgedb/test/test_email_server.py
@@ -13,351 +13,99 @@
 
 from __future__ import print_function
 
-import io
-import copy
-import os
-import shutil
 import socket
+import string
 import types
 
-from bridgedb.Dist import EmailBasedDistributor
-from bridgedb.email import server
-from bridgedb.parse.addr import BadEmail
-from bridgedb.persistent import Conf
-from bridgedb.schedule import Unscheduled
-from bridgedb.test.test_HTTPServer import DummyBridge
-from bridgedb.test.util import fileCheckDecorator
-from bridgedb.test.util import TestCaseMixin
-
 from twisted.python import log
 from twisted.internet import defer
 from twisted.internet import reactor
+from twisted.mail.smtp import IMessage
 from twisted.mail.smtp import SMTPBadRcpt
 from twisted.mail.smtp import SMTPBadSender
 from twisted.mail.smtp import User
 from twisted.mail.smtp import Address
+from twisted.mail.smtp import rfc822
 from twisted.test import proto_helpers
 from twisted.trial import unittest
 
+from zope.interface import implementedBy
 
+from bridgedb.Dist import EmailBasedDistributor
+from bridgedb.Dist import TooSoonEmail
+from bridgedb.email import server
+from bridgedb.parse.addr import BadEmail
+from bridgedb.schedule import Unscheduled
+from bridgedb.test.util import fileCheckDecorator
+from bridgedb.test.util import TestCaseMixin
+from bridgedb.test.email_helpers import _createConfig
+from bridgedb.test.email_helpers import _createMailServerContext
 
 
-class CheckDKIMTests(unittest.TestCase):
-    """Tests for :func:`email.server.checkDKIM`."""
+class SMTPMessageTests(unittest.TestCase):
+    """Unittests for :class:`bridgedb.email.server.SMTPMessage`."""
 
     def setUp(self):
-        """Create fake email, distributor, and associated context data."""
-        self.goodMessage = io.StringIO(unicode("""\
-From: user@xxxxxxxxx
-To: bridges@localhost
-X-DKIM-Authentication-Results: pass
-Subject: testing
-
-get bridges
-"""))
-        self.badMessage = io.StringIO(unicode("""\
-From: user@xxxxxxxxx
-To: bridges@localhost
-Subject: testing
-
-get bridges
-"""))
         self.config = _createConfig()
-        self.domainRules = self.config.EMAIL_DOMAIN_RULES
-
-    def test_checkDKIM_good(self):
-        message = server.smtp.rfc822.Message(self.goodMessage)
-        self.assertTrue(server.checkDKIM(message,
-                                         self.domainRules.get("gmail.com")))
-
-    def test_checkDKIM_bad(self):
-        message = server.smtp.rfc822.Message(self.badMessage)
-        result = server.checkDKIM(message, self.domainRules.get("gmail.com"))
-        self.assertIs(result, False)
-
+        self.context = _createMailServerContext(self.config)
+        self.message = server.SMTPMessage(self.context,
+                                          canonicalFromSMTP='localhost')
+        self.line = string.ascii_lowercase
 
-class CreateResponseBodyTests(unittest.TestCase):
-    """Tests for :func:`bridgedb.email.server.createResponseBody`."""
-
-    def _moveGPGTestKeyfile(self):
-        here          = os.getcwd()
-        topDir        = here.rstrip('_trial_temp')
-        self.gpgFile  = os.path.join(topDir, 'gnupghome', 'TESTING.subkeys.sec')
-        self.gpgMoved = os.path.join(here, 'TESTING.subkeys.sec')
-        shutil.copy(self.gpgFile, self.gpgMoved)
+    def tearDown(self):
+        """Re-enable safelogging in between test runs."""
+        server.safelog.setSafeLogging(True)
 
-    def setUp(self):
-        """Create fake email, distributor, and associated context data."""
-        self._moveGPGTestKeyfile()
-        self.toAddress = "user@xxxxxxxxxxx"
-        self.config = _createConfig()
-        self.ctx = _createMailContext(self.config)
-        self.distributor = self.ctx.distributor
-
-    def _getIncomingLines(self, clientAddress="user@xxxxxxxxxxx"):
-        """Generate the lines of an incoming email from **clientAddress**."""
-        self.toAddress = server.smtp.Address(clientAddress)
-        lines = [
-            "From: %s" % clientAddress,
-            "To: bridges@localhost",
-            "Subject: testing",
-            "",
-            "get bridges",
-        ]
-        return lines
-
-    def test_createResponseBody_getKey(self):
-        """A request for 'get key' should receive our GPG key."""
-        lines = self._getIncomingLines()
-        lines[4] = "get key"
-        ret = server.createResponseBody(lines, self.ctx, self.toAddress)
-        self.assertSubstring('-----BEGIN PGP PUBLIC KEY BLOCK-----', ret)
-
-    def test_createResponseBody_bridges_invalid(self):
-        """An invalid request for 'transport obfs3' should get help text."""
-        lines = self._getIncomingLines("testing@localhost")
-        lines[4] = "transport obfs3"
-        ret = server.createResponseBody(lines, self.ctx, self.toAddress)
-        self.assertSubstring("COMMANDs", ret)
-
-    def test_createResponseBody_bridges_obfs3(self):
-        """A request for 'get transport obfs3' should receive a response."""
-        lines = self._getIncomingLines("testing@localhost")
-        lines[4] = "get transport obfs3"
-        ret = server.createResponseBody(lines, self.ctx, self.toAddress)
-        self.assertSubstring("Here are your bridges", ret)
-        self.assertSubstring("obfs3", ret)
-
-    def test_createResponseBody_bridges_obfsobfswebz(self):
-        """We should only pay attention to the *last* in a crazy request."""
-        lines = self._getIncomingLines("testing@localhost")
-        lines[4] = "get unblocked webz"
-        lines.append("get transport obfs2")
-        lines.append("get transport obfs3")
-        ret = server.createResponseBody(lines, self.ctx, self.toAddress)
-        self.assertSubstring("Here are your bridges", ret)
-        self.assertSubstring("obfs3", ret)
-
-    def test_createResponseBody_bridges_obfsobfswebzipv6(self):
-        """We should *still* only pay attention to the *last* request."""
-        lines = self._getIncomingLines("testing@localhost")
-        lines[4] = "transport obfs3"
-        lines.append("get unblocked webz")
-        lines.append("get ipv6")
-        lines.append("get transport obfs2")
-        ret = server.createResponseBody(lines, self.ctx, self.toAddress)
-        self.assertSubstring("Here are your bridges", ret)
-        self.assertSubstring("obfs2", ret)
-
-
-class MailResponseTests(unittest.TestCase):
-    """Tests for ``generateResponse()`` and ``MailResponse``."""
+    def test_SMTPMessage_init(self):
+        """Our ``message`` attribute should be a ``SMTPMessage`` object, and
+        ``message.responder`` should be a
+        :class:`bridgedb.email.autoresponder.SMTPAutoresponder`.
+        """
+        self.assertIsInstance(self.message, server.SMTPMessage)
+        self.assertIsInstance(self.message.responder,
+                              server.autoresponder.SMTPAutoresponder)
 
-    def setUp(self):
-        self.fromAddr = "bridges@xxxxxxxxxxxxxx"
-        self.clientAddr = "user@xxxxxxxxxxx"
-        self.body = """\
-People think that time is strictly linear, but, in reality, it's actually just
-a ball of timey-wimey, wibbly-warbly... stuff."""
+    def test_SMTPMessage_IMessage_interface(self):
+        """``SMTPMessage`` should implement ``twisted.mail.smtp.IMessage``."""
+        self.assertTrue(IMessage.implementedBy(server.SMTPMessage))
 
-    def tearDown(self):
-        server.safelog.safe_logging = True
-
-    def test_MailResponse_generateResponse(self):
-        response = server.generateResponse(self.fromAddr, self.clientAddr,
-                                           self.body)
-        self.assertIsInstance(response, server.MailResponse)
-
-    def test_MailResponse_generateResponse_noSafelog(self):
-        server.safelog.safe_logging = False
-        response = server.generateResponse(self.fromAddr, self.clientAddr,
-                                           self.body)
-        self.assertIsInstance(response, server.MailResponse)
-
-    def test_MailResponse_generateResponse_mailfile(self):
-        response = server.generateResponse(self.fromAddr, self.clientAddr,
-                                           self.body)
-        self.assertIsInstance(response.mailfile, (io.BytesIO, io.StringIO))
-
-    def test_MailResponse_generateResponse_withInReplyTo(self):
-        response = server.generateResponse(self.fromAddr, self.clientAddr,
-                                           self.body, messageID="NSA")
-        contents = str(response.readContents()).replace('\x00', '')
-        self.assertIsInstance(response.mailfile, (io.BytesIO, io.StringIO))
-        self.assertSubstring("In-Reply-To: NSA", contents)
-
-    def test_MailResponse_generateResponse_readContents(self):
-        response = server.generateResponse(self.fromAddr, self.clientAddr,
-                                           self.body)
-        contents = str(response.readContents()).replace('\x00', '')
-        self.assertSubstring('timey-wimey, wibbly-warbly... stuff.', contents)
-
-    def test_MailResponse_additionalHeaders(self):
-        response = server.MailResponse()
-        response.writeHeaders(self.fromAddr, self.clientAddr,
-                              subject="Re: echelon", inReplyTo="NSA",
-                              X_been_there="They were so 2004")
-        contents = str(response.readContents()).replace('\x00', '')
-        self.assertIsInstance(response.mailfile, (io.BytesIO, io.StringIO))
-        self.assertSubstring("In-Reply-To: NSA", contents)
-        self.assertSubstring("X-been-there: They were so 2004", contents)
-
-    def test_MailResponse_close(self):
-        """Calling MailResponse.close() should close the ``mailfile`` and set
-        ``closed=True``.
+    def test_SMTPMessage_lineReceived_withSafelog(self):
+        """Test sending a line of text to ``SMTPMessage.lineReceived`` with
+        safelogging enabled.
         """
-        response = server.MailResponse()
-        self.assertEqual(response.closed, False)
-        response.close()
-        self.assertEqual(response.closed, True)
-        self.assertRaises(ValueError, response.write, self.body)
-
-    def test_MailResponse_write(self):
-        """Calling MailResponse.write() should write to the mailfile."""
-        response = server.MailResponse()
-        response.write(self.body)
-        contents = str(response.readContents()).replace('\x00', '')
-        self.assertEqual(self.body.replace('\n', '\r\n') + '\r\n', contents)
-
-    def test_MailResponse_writelines(self):
-        """Calling MailResponse.writelines() with a list should write the
-        concatenated contents of the list into the mailfile.
+        server.safelog.setSafeLogging(True)
+        self.message.lineReceived(self.line)
+        self.assertEqual(self.message.nBytes, 26)
+        self.assertTrue(self.line in self.message.lines)
+
+    def test_SMTPMessage_lineReceived_withoutSafelog(self):
+        """Test sending a line of text to ``SMTPMessage.lineReceived`` with
+        safelogging disnabled.
         """
-        response = server.MailResponse()
-        response.writelines(self.body.split('\n'))
-        contents = str(response.readContents()).replace('\x00', '')
-        self.assertEqual(self.body.replace('\n', '\r\n') + '\r\n', contents)
+        server.safelog.setSafeLogging(False)
+        for _ in range(3):
+            self.message.lineReceived(self.line)
+        self.assertEqual(self.message.nBytes, 3*26)
+        self.assertTrue(self.line in self.message.lines)
 
+    def test_SMTPMessage_eomReceived(self):
+        """Calling ``oemReceived`` should return a deferred."""
+        self.message.lineReceived(self.line)
+        self.assertIsInstance(self.message.eomReceived(),
+                              defer.Deferred)
 
-class MailMessageTests(unittest.TestCase):
-    """Unittests for :class:`bridgedb.email.server.MailMessage`."""
+    def test_SMTPMessage_getIncomingMessage(self):
+        """``getIncomingMessage`` should return a ``rfc822.Message``."""
+        self.message.lineReceived(self.line)
+        self.assertIsInstance(self.message.getIncomingMessage(),
+                              rfc822.Message)
 
-    def setUp(self):
-        self.config = _createConfig()
-        self.context = _createMailContext(self.config)
-        self.message = server.MailMessage(self.context)
-
-    def _getIncomingLines(self, clientAddress="user@xxxxxxxxxxx"):
-        """Generate the lines of an incoming email from **clientAddress**."""
-        lines = [
-            "From: %s" % clientAddress,
-            "To: bridges@localhost",
-            "Subject: testing",
-            "",
-            "get bridges",
-        ]
-        self.message.lines = lines
-
-    def test_MailMessage_getMailFrom_notbridgedb_at_yikezors_dot_net(self):
-        """MailMessage.getMailFrom() for an incoming email sent to any email
-        address other than the one we're listening for should return our
-        configured address, not the one in the incoming email.
-        """
-        self._getIncomingLines()
-        self.message.lines[1] = 'To: notbridgedb@xxxxxxxxxxxx'
-        incoming = self.message.getIncomingMessage()
-        recipient = str(self.message.getMailFrom(incoming))
-        self.assertEqual(recipient, self.context.fromAddr)
-
-    def test_MailMessage_getMailFrom_givemebridges_at_seriously(self):
-        """MailMessage.getMailFrom() for an incoming email sent to any email
-        address other than the one we're listening for should return our
-        configured address, not the one in the incoming email.
-        """
-        self._getIncomingLines()
-        self.message.lines[1] = 'To: givemebridges@xxxxxxxxxx'
-        incoming = self.message.getIncomingMessage()
-        recipient = str(self.message.getMailFrom(incoming))
-        self.assertEqual(recipient, self.context.fromAddr)
-
-    def test_MailMessage_getMailFrom_bad_address(self):
-        """MailMessage.getMailFrom() for an incoming email sent to a malformed
-        email address should log an smtp.AddressError and then return our
-        configured email address.
-        """
-        self._getIncomingLines()
-        self.message.lines[1] = 'To: ><@><<<>>.foo'
-        incoming = self.message.getIncomingMessage()
-        recipient = str(self.message.getMailFrom(incoming))
-        self.assertEqual(recipient, self.context.fromAddr)
-
-    def test_MailMessage_reply_noFrom(self):
-        """A received email without a "From:" or "Sender:" header shouldn't
-        receive a response.
-        """
-        self._getIncomingLines()
-        self.message.lines[0] = ""
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_badAddress(self):
-        """Don't respond to RFC2822 malformed source addresses."""
-        self._getIncomingLines("testing*.?\"@example.com")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_anotherBadAddress(self):
-        """Don't respond to RFC2822 malformed source addresses."""
-        self._getIncomingLines("Mallory <>>@example.com")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_invalidDomain(self):
-        """Don't respond to RFC2822 malformed source addresses."""
-        self._getIncomingLines("testing@exa#mple.com")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_anotherInvalidDomain(self):
-        """Don't respond to RFC2822 malformed source addresses."""
-        self._getIncomingLines("testing@exam+ple.com")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_DKIM_badDKIMheader(self):
-        """An email with an 'X-DKIM-Authentication-Result:' header appended
-        after the body should not receive a response.
-        """
-        self._getIncomingLines("testing@xxxxxxxxx")
-        self.message.lines.append("X-DKIM-Authentication-Result: ")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_goodDKIMheader(self):
-        """An email with a good DKIM header should be responded to."""
-        self._getIncomingLines("testing@xxxxxxxxx")
-        self.message.lines.insert(3, "X-DKIM-Authentication-Result: pass")
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-
-    def test_MailMessage_reply_transport_invalid(self):
-        """An invalid request for 'transport obfs3' should get help text."""
-        self.skip = True
-        raise unittest.SkipTest("We need to fake the reactor for this one")
-
-        self._getIncomingLines("testing@xxxxxxxxxxx")
-        self.message.lines[4] = "transport obfs3"
-        ret = self.message.reply()
-        self.assertSubstring("COMMANDs", ret)
-
-    def test_MailMessage_reply_transport_valid(self):
-        """An valid request for 'get transport obfs3' should get obfs3."""
-        self.skip = True
-        raise unittest.SkipTest("We need to fake the reactor for this one")
-
-        self._getIncomingLines("testing@xxxxxxxxxxx")
-        self.message.lines[4] = "transport obfs3"
-        ret = self.message.reply()
-        self.assertIsInstance(ret, defer.Deferred)
-        self.assertSubstring("obfs3", ret)
-        return ret
-
-
-class MailDeliveryTests(unittest.TestCase):
-    """Unittests for :class:`email.server.MailDelivery`."""
+
+class SMTPIncomingDeliveryTests(unittest.TestCase):
+    """Unittests for :class:`email.server.SMTPIncomingDelivery`."""
 
     def setUp(self):
-        """Set up our :class:`server.MailDelivery` instance, and reset the
+        """Set up our :class:`server.SMTPIncomingDelivery` instance, and reset the
         following ``TestCase`` attributes to ``None``:
             - ``helo``
             - ``proto``
@@ -365,8 +113,8 @@ class MailDeliveryTests(unittest.TestCase):
             - ``user``
         """
         self.config = _createConfig()
-        self.context = _createMailContext(self.config)
-        self.delivery = server.MailDelivery()
+        self.context = _createMailServerContext(self.config)
+        self.delivery = server.SMTPIncomingDelivery()
 
         self.helo = None
         self.proto = None
@@ -417,39 +165,41 @@ class MailDeliveryTests(unittest.TestCase):
         """
         self.helo = ('localhost', '127.0.0.1')
         self.origin = server.smtp.Address('client@xxxxxxxxxxx')
-        self.delivery.setBridgeDBContext(self.context)
+        self.delivery.setContext(self.context)
 
-    def _setUpRCPTTO(self, username=None):
+    def _setUpRCPTTO(self, username=None, domain=None, ip=None):
         """Set up the parameters for emulating a connected client sending a
         SMTP 'RCPT TO:' command to us.
 
         The default is to emulate sending: ``RCPT TO: bridges@localhost``.
         """
         name = username if username is not None else self.config.EMAIL_USERNAME
-        self._createUser(name, 'localhost', '127.0.0.1')
-        self.delivery.setBridgeDBContext(self.context)
-
-    def test_MailDelivery_init(self):
-        """After calling :meth:`server.MailDelivery.__init__`, we should have a
-        :class:`server.MailDelivery` object instance.
+        host = domain if domain is not None else 'localhost'
+        addr = ip if ip is not None else '127.0.0.1'
+        self._createUser(name, host, ip)
+        self.delivery.setContext(self.context)
+
+    def test_SMTPIncomingDelivery_init(self):
+        """After calling :meth:`server.SMTPIncomingDelivery.__init__`, we should have a
+        :class:`server.SMTPIncomingDelivery` object instance.
         """
-        self.assertIsInstance(self.delivery, server.MailDelivery)
+        self.assertIsInstance(self.delivery, server.SMTPIncomingDelivery)
 
-    def test_MailDelivery_setBridgeDBContext(self):
-        """Calling :meth:`server.MailDelivery.setBridgeDBContext` should set
-        the :ivar:`MailDelivery.context` attribute.
+    def test_SMTPIncomingDelivery_setContext(self):
+        """Calling :meth:`server.SMTPIncomingDelivery.setContext` should set
+        the :ivar:`SMTPIncomingDelivery.context` attribute.
 
-        The ``MailDelivery.context`` should be a :class:`server.MailContext`,
+        The ``SMTPIncomingDelivery.context`` should be a :class:`server.MailServerContext`,
         and it should have relevant settings from the config file stored
         within it.
         """
-        self.delivery.setBridgeDBContext(self.context)
-        self.assertIsInstance(self.delivery.context, server.MailContext)
+        self.delivery.setContext(self.context)
+        self.assertIsInstance(self.delivery.context, server.MailServerContext)
         self.assertEqual(self.delivery.context.smtpFromAddr,
                          self.config.EMAIL_SMTP_FROM_ADDR)
 
-    def test_MailDelivery_receivedHeader(self):
-        """The email resulting from a MailDelivery, the latter received from
+    def test_SMTPIncomingDelivery_receivedHeader(self):
+        """The email resulting from a SMTPIncomingDelivery, the latter received from
         ``'client@xxxxxxxxxxx'`` should contain a header stating:
         ``'Received: from example.com'``.
         """
@@ -457,20 +207,20 @@ class MailDeliveryTests(unittest.TestCase):
         hdr = self.delivery.receivedHeader(self.helo, self.origin, [self.user,])
         self.assertSubstring("Received: from example.com", hdr)
 
-    def test_MailDelivery_validateFrom(self):
-        """A valid origin should be stored as ``MailDelivery.fromCanonical``."""
+    def test_SMTPIncomingDelivery_validateFrom(self):
+        """A valid origin should be stored as ``SMTPIncomingDelivery.fromCanonical``."""
         self._setUpMAILFROM()
         self.delivery.validateFrom(self.helo, self.origin)
-        self.assertEqual(self.delivery.fromCanonical, 'example.com')
+        self.assertEqual(self.delivery.fromCanonicalSMTP, 'example.com')
 
-    def test_MailDelivery_validateFrom_unsupportedDomain(self):
+    def test_SMTPIncomingDelivery_validateFrom_unsupportedDomain(self):
         """A domain not in our canon should raise a SMTPBadSender."""
         self._setUpMAILFROM()
         origin = server.smtp.Address('throwing.pickles@xxxxxxx')
         self.assertRaises(SMTPBadSender,
                           self.delivery.validateFrom, self.helo, origin)
 
-    def test_MailDelivery_validateFrom_origin_notAdressType(self):
+    def test_SMTPIncomingDelivery_validateFrom_origin_notAdressType(self):
         """A non ``twisted.mail.smtp.Address`` origin should raise an
         AttributeError exception.
         """
@@ -478,28 +228,48 @@ class MailDeliveryTests(unittest.TestCase):
         origin = 'throwing.pickles@xxxxxxx'
         self.delivery.validateFrom(self.helo, origin)
 
-    def test_MailDelivery_validateTo(self):
-        """Should return a callable that results in a MailMessage."""
+    def test_SMTPIncomingDelivery_validateTo(self):
+        """Should return a callable that results in a SMTPMessage."""
         self._setUpRCPTTO()
         validated = self.delivery.validateTo(self.user)
         self.assertIsInstance(validated, types.FunctionType)
-        self.assertIsInstance(validated(), server.MailMessage)
+        self.assertIsInstance(validated(), server.SMTPMessage)
 
-    def test_MailDelivery_validateTo_plusAddress(self):
-        """Should return a callable that results in a MailMessage."""
+    def test_SMTPIncomingDelivery_validateTo_plusAddress(self):
+        """Should return a callable that results in a SMTPMessage."""
         self._setUpRCPTTO('bridges+ar')
         validated = self.delivery.validateTo(self.user)
         self.assertIsInstance(validated, types.FunctionType)
-        self.assertIsInstance(validated(), server.MailMessage)
+        self.assertIsInstance(validated(), server.SMTPMessage)
 
-    def test_MailDelivery_validateTo_badUsername(self):
-        """A :class:`server.MailDelivery` which sends a SMTP
+    def test_SMTPIncomingDelivery_validateTo_badUsername_plusAddress(self):
+        """'givemebridges+zh_cn@...' should raise an SMTPBadRcpt exception."""
+        self._setUpRCPTTO('givemebridges+zh_cn')
+        self.assertRaises(SMTPBadRcpt, self.delivery.validateTo, self.user)
+
+    def test_SMTPIncomingDelivery_validateTo_badUsername(self):
+        """A :class:`server.SMTPIncomingDelivery` which sends a SMTP
         ``RCPT TO: yo.mama@localhost`` should raise a
         ``twisted.mail.smtp.SMTPBadRcpt`` exception.
         """
         self._setUpRCPTTO('yo.mama')
         self.assertRaises(SMTPBadRcpt, self.delivery.validateTo, self.user)
 
+    def test_SMTPIncomingDelivery_validateTo_notOurDomain(self):
+        """An SMTP ``RCPT TO: bridges@xxxxxxxxxxx`` should raise an SMTPBadRcpt
+        exception.
+        """
+        self._setUpRCPTTO('bridges', 'forealsi.es')
+        self.assertRaises(SMTPBadRcpt, self.delivery.validateTo, self.user)
+
+    def test_SMTPIncomingDelivery_validateTo_subdomain(self):
+        """An SMTP ``RCPT TO: bridges@xxxxxxxxxxxxxxxxxxx`` should be allowed.
+        """
+        self._setUpRCPTTO('bridges', 'subdomain.localhost')
+        validated = self.delivery.validateTo(self.user)
+        self.assertIsInstance(validated, types.FunctionType)
+        self.assertIsInstance(validated(), server.SMTPMessage)
+
 
 class SMTPTestCaseMixin(TestCaseMixin):
     """Utility methods for use within any subclasses of
@@ -516,7 +286,7 @@ class SMTPTestCaseMixin(TestCaseMixin):
 
         class ExampleSMTPTests(SMTPTestCaseMixin, unittest.TestCase):
             def setUp(self):
-                factory = twisted.mail.smtp.SMTPFactory()
+                factory = twisted.mail.smtp.SMTPIncomingServerFactory()
                 self.proto = self.factory.buildProtocol(('127.0.0.1', 0))
 
 
@@ -550,7 +320,7 @@ class SMTPTestCaseMixin(TestCaseMixin):
          segment. Includes the SMTP DATA EOM command ('.') at the end. If no
          keyword arguments are given, the defaults are fairly sane.
 
-        Suitable for testing a :class:`bridgedb.email.server.MailFactory`.
+        Suitable for testing a :class:`bridgedb.email.server.SMTPIncomingServerFactory`.
 
         :param str fromAddr: An email address for the 'From:' header.
         :param str toAddr: An email address for the 'To:' header.
@@ -611,14 +381,17 @@ class SMTPTestCaseMixin(TestCaseMixin):
         self.assertSubstring(expected, recv)
 
 
-class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
-    """Unittests for :class:`bridgedb.email.server.MailFactory`."""
+class SMTPIncomingServerFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
+    """Unittests for :class:`bridgedb.email.server.SMTPIncomingServerFactory`."""
 
     def setUp(self):
-        """Set up a localhost MailFactory handler incoming SMTP connections."""
+        """Set up a localhost SMTPIncomingServerFactory handler incoming SMTP
+        connections.
+        """
         config = _createConfig()
-        context = _createMailContext(config)
-        factory = server.MailFactory(context)
+        context = _createMailServerContext(config)
+        factory = server.SMTPIncomingServerFactory()
+        factory.setContext(context)
         factory.protocol.timeout = None  # Otherwise the reactor gets dirty
 
         self.smtpFromAddr = context.smtpFromAddr  # 'bridges@localhost'
@@ -629,40 +402,40 @@ class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
         self.transport.protocol = self.proto
         self.proto.makeConnection(self.transport)
 
-    def test_MailFactory_HELO_localhost(self):
+    def test_SMTPIncomingServerFactory_HELO_localhost(self):
         """Send 'HELO localhost' to the server's transport."""
         ip = self.transport.getPeer().host
         self._test(['HELO localhost'],
                    "Hello %s, nice to meet you" % ip)
 
-    def test_MailFactory_MAIL_FROM_testing_at_localhost(self):
+    def test_SMTPIncomingServerFactory_MAIL_FROM_testing_at_localhost(self):
         """Send 'MAIL FROM: human@localhost'."""
         self._test(['HELO localhost',
                     'MAIL FROM: testing@localhost'],
                    "250 Sender address accepted")
 
-    def test_MailFactory_MAIL_FROM_testing_at_gethostname(self):
+    def test_SMTPIncomingServerFactory_MAIL_FROM_testing_at_gethostname(self):
         """Send 'MAIL FROM: human@hostname' for the local hostname."""
         hostname = socket.gethostname() or "computer"
         self._test(['HELO localhost',
                     'MAIL FROM: testing@%s' % hostname],
                    "250 Sender address accepted")
 
-    def test_MailFactory_MAIL_FROM_testing_at_ipaddress(self):
+    def test_SMTPIncomingServerFactory_MAIL_FROM_testing_at_ipaddress(self):
         """Send 'MAIL FROM: human@ipaddr' for the loopback IP address."""
-        hostname = socket.gethostbyname(socket.gethostname()) or "127.0.0.1"
+        hostname = 'localhost'
         self._test(['HELO localhost',
                     'MAIL FROM: testing@%s' % hostname],
                    "250 Sender address accepted")
 
-    def test_MailFactory_RCPT_TO_config_EMAIL_SMTP_FROM_ADDR(self):
+    def test_SMTPIncomingServerFactory_RCPT_TO_context_smtpFromAddr(self):
         """Send 'RCPT TO:' with the context.smtpFromAddr."""
         self._test(['HELO localhost',
                     'MAIL FROM: testing@localhost',
                     'RCPT TO: %s' % self.smtpFromAddr],
                    "250 Recipient address accepted")
 
-    def test_MailFactory_DATA_blank(self):
+    def test_SMTPIncomingServerFactory_DATA_blank(self):
         """A DATA command with nothing after it should receive::
             '354 Continue'
         in response.
@@ -673,7 +446,7 @@ class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
                     "DATA"],
                    "354 Continue")
 
-    def test_MailFactory_DATA_get_help(self):
+    def test_SMTPIncomingServerFactory_DATA_get_help(self):
         """A DATA command with ``'get help'`` in the email body should
         receive::
             '250 Delivery in progress'
@@ -687,7 +460,7 @@ class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
                    "250 Delivery in progress",
                    noisy=True)
 
-    def test_MailFactory_DATA_get_transport_obfs3(self):
+    def test_SMTPIncomingServerFactory_DATA_get_transport_obfs3(self):
         """A DATA command with ``'get transport obfs3'`` in the email body
         should receive::
             '250 Delivery in progress'
@@ -701,7 +474,7 @@ class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
                    "250 Delivery in progress",
                    noisy=True)
 
-    def test_MailFactory_DATA_To_bridges_plus_zh_CN(self):
+    def test_SMTPIncomingServerFactory_DATA_To_bridges_plus_zh_CN(self):
         """Test sending to 'bridges+zh_CN' address for Chinese translations."""
         # TODO: Add tests which use '+' syntax in mailTo in order to test
         # email translations. Do this when some strings have been translated.
@@ -716,7 +489,7 @@ class MailFactoryTests(SMTPTestCaseMixin, unittest.TestCase):
                    "250 Delivery in progress",
                    noisy=True)
 
-    def test_MailFactory_DATA_get_bridges_QUIT(self):
+    def test_SMTPIncomingServerFactory_DATA_get_bridges_QUIT(self):
         """Test sending 'DATA' with 'get bridges', then sending 'QUIT'."""
         emailText = self._buildEmail()
         self._test(['HELO localhost',
@@ -732,9 +505,9 @@ class EmailServerServiceTests(SMTPTestCaseMixin, unittest.TestCase):
     """Unittests for :func:`bridgedb.email.server.addServer`."""
 
     def setUp(self):
-        """Create a server.MailContext and EmailBasedDistributor."""
+        """Create a server.MailServerContext and EmailBasedDistributor."""
         self.config = _createConfig()
-        self.context = _createMailContext(self.config)
+        self.context = _createMailServerContext(self.config)
         self.smtpFromAddr = self.context.smtpFromAddr  # 'bridges@localhost'
         self.sched = Unscheduled()
         self.dist = self.context.distributor



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits