def test_finish(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndReturn(['example.com'])
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     ptr.start()
     self.assertEqual('example.com', ptr.finish(runtime=1.0))
 def test_run_dnsexception(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(DNSException)
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     self.assertIsInstance(ptr, gevent.Greenlet)
     self.assertIsNone(ptr._run())
Exemple #3
0
 def test_run_nxdomain(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     assert_is_instance(ptr, gevent.Greenlet)
     assert_is_none(ptr._run())
 def test_run_nxdomain(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     assert_is_instance(ptr, gevent.Greenlet)
     assert_is_none(ptr._run())
Exemple #5
0
 def test_run_dnsexception(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(DNSException)
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     self.assertIsInstance(ptr, gevent.Greenlet)
     self.assertIsNone(ptr._run())
Exemple #6
0
 def test_finish(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndReturn(['example.com'])
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     ptr.start()
     self.assertEqual('example.com', ptr.finish(runtime=1.0))
 def test_finish_timeout(self):
     self.mox.StubOutWithMock(dns_resolver, 'query')
     def long_sleep(*args):
         gevent.sleep(1.0)
     dns_resolver.query(IgnoreArg(), 'PTR').WithSideEffects(long_sleep)
     self.mox.ReplayAll()
     ptr = PtrLookup('127.0.0.1')
     ptr.start()
     self.assertIsNone(ptr.finish(runtime=0.0))
 def test_attempt_no_answer(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx = MxSmtpRelay()
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(DNSTimeout)
     self.mox.ReplayAll()
     with self.assertRaises(TransientRelayError):
         mx.attempt(env, 0)
 def test_attempt_no_answer(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx = MxSmtpRelay()
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(DNSTimeout)
     self.mox.ReplayAll()
     with assert_raises(TransientRelayError):
         mx.attempt(env, 0)
 def test_attempt_no_answer(self):
     env = Envelope("*****@*****.**", ["*****@*****.**"])
     mx = MxSmtpRelay()
     self.mox.StubOutWithMock(mx, "new_static_relay")
     self.mox.StubOutWithMock(dns_resolver, "query")
     dns_resolver.query("example.com", "MX").AndRaise(DNSTimeout)
     self.mox.ReplayAll()
     with assert_raises(TransientRelayError):
         mx.attempt(env, 0)
 def test_dnsblocklistgroup_get_reasons(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl('test1.example.com')
     group.add_dnsbl('test2.example.com')
     group.add_dnsbl('test3.example.com')
     dns_resolver.query('4.3.2.1.test1.example.com', 'TXT').InAnyOrder().AndReturn(['reason one'])
     dns_resolver.query('4.3.2.1.test3.example.com', 'TXT').InAnyOrder()
     self.mox.ReplayAll()
     assert_equal({'test1.example.com': 'reason one', 'test3.example.com': None},
                      group.get_reasons(set(['test1.example.com', 'test3.example.com']), '1.2.3.4'))
 def test_dnsblocklistgroup_get_reasons(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl('test1.example.com')
     group.add_dnsbl('test2.example.com')
     group.add_dnsbl('test3.example.com')
     dns_resolver.query('4.3.2.1.test1.example.com', 'TXT').InAnyOrder().AndReturn(['reason one'])
     dns_resolver.query('4.3.2.1.test3.example.com', 'TXT').InAnyOrder()
     self.mox.ReplayAll()
     self.assertEqual({'test1.example.com': 'reason one', 'test3.example.com': None},
                      group.get_reasons(set(['test1.example.com', 'test3.example.com']), '1.2.3.4'))
 def test_attempt_no_records(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query('example.com', 'A').AndRaise(dns.resolver.NXDOMAIN)
     self.mox.ReplayAll()
     with assert_raises(PermanentRelayError):
         mx.attempt(env, 0)
 def test_attempt_no_records(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query('example.com', 'A').AndRaise(dns.resolver.NXDOMAIN)
     self.mox.ReplayAll()
     with self.assertRaises(PermanentRelayError):
         mx.attempt(env, 0)
Exemple #15
0
    def test_finish_timeout(self):
        self.mox.StubOutWithMock(dns_resolver, 'query')

        def long_sleep(*args):
            gevent.sleep(1.0)

        dns_resolver.query(IgnoreArg(), 'PTR').WithSideEffects(long_sleep)
        self.mox.ReplayAll()
        ptr = PtrLookup('127.0.0.1')
        ptr.start()
        assert_is_none(ptr.finish(runtime=0.0))
 def test_attempt_no_records(self):
     env = Envelope("*****@*****.**", ["*****@*****.**"])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, "new_static_relay")
     self.mox.StubOutWithMock(dns_resolver, "query")
     dns_resolver.query("example.com", "MX").AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query("example.com", "A").AndRaise(dns.resolver.NXDOMAIN)
     self.mox.ReplayAll()
     with assert_raises(PermanentRelayError):
         mx.attempt(env, 0)
 def test_dnsblocklistgroup_get_reasons(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl("test1.example.com")
     group.add_dnsbl("test2.example.com")
     group.add_dnsbl("test3.example.com")
     dns_resolver.query("4.3.2.1.test1.example.com", "TXT").InAnyOrder().AndReturn(["reason one"])
     dns_resolver.query("4.3.2.1.test3.example.com", "TXT").InAnyOrder()
     self.mox.ReplayAll()
     self.assertEqual(
         {"test1.example.com": "reason one", "test3.example.com": None},
         group.get_reasons(set(["test1.example.com", "test3.example.com"]), "1.2.3.4"),
     )
 def test_ptr_lookup(self):
     environ = self.environ.copy()
     environ['REMOTE_ADDR'] = '1.2.3.4'
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(DNSException)
     dns_resolver.query(IgnoreArg(), 'PTR').AndReturn(['example.com'])
     self.mox.ReplayAll()
     w = WsgiEdge(None)
     w._ptr_lookup(environ)
     self.assertNotIn('slimta.reverse_address', environ)
     w._ptr_lookup(environ)
     self.assertEqual('example.com', environ['slimta.reverse_address'])
 def test_ptr_lookup(self):
     environ = self.environ.copy()
     environ['REMOTE_ADDR'] = '1.2.3.4'
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query(IgnoreArg(), 'PTR').AndRaise(DNSException)
     dns_resolver.query(IgnoreArg(), 'PTR').AndReturn(['example.com'])
     self.mox.ReplayAll()
     w = WsgiEdge(None)
     w._ptr_lookup(environ)
     self.assertNotIn('slimta.reverse_address', environ)
     w._ptr_lookup(environ)
     self.assertEqual('example.com', environ['slimta.reverse_address'])
 def test_attempt_no_mx(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     a_ret = FakeAAnswer(False, [('1.2.3.4', )])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query('example.com', 'A').AndReturn(a_ret)
     mx.new_static_relay('1.2.3.4', 25).AndReturn(static)
     static.attempt(env, 0)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
 def test_attempt_no_mx(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     a_ret = FakeAAnswer(False, [('1.2.3.4', )])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query('example.com', 'A').AndReturn(a_ret)
     mx.new_static_relay('1.2.3.4', 25).AndReturn(static)
     static.attempt(env, 0)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
 def test_attempt_no_mx(self):
     env = Envelope("*****@*****.**", ["*****@*****.**"])
     a_ret = FakeAAnswer(False, [("1.2.3.4",)])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, "new_static_relay")
     self.mox.StubOutWithMock(dns_resolver, "query")
     dns_resolver.query("example.com", "MX").AndRaise(dns.resolver.NXDOMAIN)
     dns_resolver.query("example.com", "A").AndReturn(a_ret)
     mx.new_static_relay("1.2.3.4", 25).AndReturn(static)
     static.attempt(env, 0)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
 def test_attempt(self):
     env = Envelope("*****@*****.**", ["*****@*****.**"])
     mx_ret = FakeMxAnswer(False, [(5, "mx1.example.com"), (10, "mx2.example.com")])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, "new_static_relay")
     self.mox.StubOutWithMock(dns_resolver, "query")
     dns_resolver.query("example.com", "MX").AndReturn(mx_ret)
     mx.new_static_relay("mx1.example.com", 25).AndReturn(static)
     static.attempt(env, 0)
     mx.new_static_relay("mx2.example.com", 25).AndReturn(static)
     static.attempt(env, 1)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
     mx.attempt(env, 1)
Exemple #24
0
    def get(self, ip, timeout=None, strict=False):
        """Checks this DNSBL for the given IP address. This method does not
        check the answer, only that the response was not ``NXDOMAIN``.

        :param ip: The IP address string to check.
        :param timeout: A timeout in seconds before ``False`` is returned.
        :param strict: If ``True``, DNS exceptions that are not ``NXDOMAIN``
                       (including timeouts) will also  result in a ``True``
                       return value.
        :returns: ``True`` if the DNSBL had an entry for the given IP address,
                  ``False`` otherwise.

        """
        with gevent.Timeout(timeout, None):
            query = self._build_query(ip)
            try:
                answers = dns_resolver.query(query, 'A')
            except NXDOMAIN:
                return False
            except DNSException:
                logging.log_exception(__name__, query=query)
                return not strict
            else:
                return True
        return strict
Exemple #25
0
 def _resolve_a(self):
     answer = dns_resolver.query(self.domain, 'A')
     ret = []
     for rdata in answer:
         ret.append((0, str(rdata.address)))
         break
     return ret, answer.expiration
 def test_attempt(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx_ret = FakeMxAnswer(False, [(5, 'mx1.example.com'),
                                   (10, 'mx2.example.com')])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndReturn(mx_ret)
     mx.new_static_relay('mx1.example.com', 25).AndReturn(static)
     static.attempt(env, 0)
     mx.new_static_relay('mx2.example.com', 25).AndReturn(static)
     static.attempt(env, 1)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
     mx.attempt(env, 1)
Exemple #27
0
    def get(self, ip, timeout=None, strict=False):
        """Checks this DNSBL for the given IP address. This method does not
        check the answer, only that the response was not ``NXDOMAIN``.

        :param ip: The IP address string to check.
        :param timeout: A timeout in seconds before ``False`` is returned.
        :param strict: If ``True``, DNS exceptions that are not ``NXDOMAIN``
                       (including timeouts) will also  result in a ``True``
                       return value.
        :returns: ``True`` if the DNSBL had an entry for the given IP address,
                  ``False`` otherwise.

        """
        with gevent.Timeout(timeout, None):
            query = self._build_query(ip)
            try:
                answers = dns_resolver.query(query, 'A')
            except NXDOMAIN:
                return False
            except DNSException:
                logging.log_exception(__name__, query=query)
                return not strict
            else:
                return True
        return strict
 def test_attempt(self):
     env = Envelope('*****@*****.**', ['*****@*****.**'])
     mx_ret = FakeMxAnswer(False, [(5, 'mx1.example.com'),
                                   (10, 'mx2.example.com')])
     mx = MxSmtpRelay()
     static = self.mox.CreateMock(StaticSmtpRelay)
     self.mox.StubOutWithMock(mx, 'new_static_relay')
     self.mox.StubOutWithMock(dns_resolver, 'query')
     dns_resolver.query('example.com', 'MX').AndReturn(mx_ret)
     mx.new_static_relay('mx1.example.com', 25).AndReturn(static)
     static.attempt(env, 0)
     mx.new_static_relay('mx2.example.com', 25).AndReturn(static)
     static.attempt(env, 1)
     self.mox.ReplayAll()
     mx.attempt(env, 0)
     mx.attempt(env, 1)
Exemple #29
0
 def _resolve_a(self):
     answer = dns_resolver.query(self.domain, 'A')
     ret = []
     for rdata in answer:
         ret.append((0, str(rdata.address)))
         break
     return ret, answer.expiration
Exemple #30
0
 def _resolve_mx(self):
     answer = dns_resolver.query(self.domain, 'MX')
     ret = []
     for rdata in answer:
         for i, rec in enumerate(ret):
             if rec[0] > rdata.preference:
                 ret.insert(i, (rdata.preference, str(rdata.exchange)))
                 break
         else:
             ret.append((rdata.preference, str(rdata.exchange)))
     return ret, answer.expiration
Exemple #31
0
 def _resolve_mx(self):
     answer = dns_resolver.query(self.domain, 'MX')
     ret = []
     for rdata in answer:
         for i, rec in enumerate(ret):
             if rec[0] > rdata.preference:
                 ret.insert(i, (rdata.preference, str(rdata.exchange)))
                 break
         else:
             ret.append((rdata.preference, str(rdata.exchange)))
     return ret, answer.expiration
    def test_check_dnsrbl(self):
        class TestSession(object):
            address = ('1.2.3.4', 56789)
        class TestValidators(object):
            def __init__(self):
                self.session = TestSession()
            @check_dnsbl('test.example.com')
            def validate_mail(self, reply, sender):
                assert False

        dns_resolver.query('4.3.2.1.test.example.com', 'A').AndRaise(NXDOMAIN)
        dns_resolver.query('4.3.2.1.test.example.com', 'A')
        self.mox.ReplayAll()
        validators = TestValidators()
        reply = Reply('250', '2.0.0 Ok')
        assert_raises(AssertionError, validators.validate_mail, reply, 'asdf')
        assert_equal('250', reply.code)
        assert_equal('2.0.0 Ok', reply.message)
        validators.validate_mail(reply, 'asdf')
        assert_equal('550', reply.code)
        assert_equal('5.7.1 Access denied', reply.message)
    def test_check_dnsrbl(self):
        class TestSession(object):
            address = ('1.2.3.4', 56789)
        class TestValidators(object):
            def __init__(self):
                self.session = TestSession()
            @check_dnsbl('test.example.com')
            def validate_mail(self, reply, sender):
                assert False

        dns_resolver.query('4.3.2.1.test.example.com', 'A').AndRaise(NXDOMAIN)
        dns_resolver.query('4.3.2.1.test.example.com', 'A')
        self.mox.ReplayAll()
        validators = TestValidators()
        reply = Reply('250', '2.0.0 Ok')
        self.assertRaises(AssertionError, validators.validate_mail, reply, 'asdf')
        self.assertEqual('250', reply.code)
        self.assertEqual('2.0.0 Ok', reply.message)
        validators.validate_mail(reply, 'asdf')
        self.assertEqual('550', reply.code)
        self.assertEqual('5.7.1 Access denied', reply.message)
 def test_dnsblocklist_get_reason(self):
     dns_resolver.query('4.3.2.1.test.example.com', 'TXT')
     dns_resolver.query('4.3.2.1.test.example.com', 'TXT').AndReturn(['good reason'])
     dns_resolver.query('8.7.6.5.test.example.com', 'TXT').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     assert_equal(None, self.dnsbl.get_reason('1.2.3.4'))
     assert_equal('good reason', self.dnsbl.get_reason('1.2.3.4'))
     assert_equal(None, self.dnsbl['5.6.7.8'])
 def test_dnsblocklist_get_reason(self):
     dns_resolver.query("4.3.2.1.test.example.com", "TXT")
     dns_resolver.query("4.3.2.1.test.example.com", "TXT").AndReturn(["good reason"])
     dns_resolver.query("8.7.6.5.test.example.com", "TXT").AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertEqual(None, self.dnsbl.get_reason("1.2.3.4"))
     self.assertEqual("good reason", self.dnsbl.get_reason("1.2.3.4"))
     self.assertEqual(None, self.dnsbl["5.6.7.8"])
 def test_dnsblocklist_get_reason(self):
     dns_resolver.query('4.3.2.1.test.example.com', 'TXT')
     dns_resolver.query('4.3.2.1.test.example.com', 'TXT').AndReturn(['good reason'])
     dns_resolver.query('8.7.6.5.test.example.com', 'TXT').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertEqual(None, self.dnsbl.get_reason('1.2.3.4'))
     self.assertEqual('good reason', self.dnsbl.get_reason('1.2.3.4'))
     self.assertEqual(None, self.dnsbl['5.6.7.8'])
    def test_check_dnsrbl(self):
        class TestSession(object):
            address = ("1.2.3.4", 56789)

        class TestValidators(object):
            def __init__(self):
                self.session = TestSession()

            @check_dnsbl("test.example.com")
            def validate_mail(self, reply, sender):
                assert False

        dns_resolver.query("4.3.2.1.test.example.com", "A").AndRaise(NXDOMAIN)
        dns_resolver.query("4.3.2.1.test.example.com", "A")
        self.mox.ReplayAll()
        validators = TestValidators()
        reply = Reply("250", "2.0.0 Ok")
        self.assertRaises(AssertionError, validators.validate_mail, reply, "asdf")
        self.assertEqual("250", reply.code)
        self.assertEqual("2.0.0 Ok", reply.message)
        validators.validate_mail(reply, "asdf")
        self.assertEqual("550", reply.code)
        self.assertEqual("5.7.1 Access denied", reply.message)
Exemple #38
0
 def _ptr_lookup(self, environ):
     ip = environ.get('REMOTE_ADDR', '0.0.0.0')
     try:
         ptraddr = reversename.from_address(ip)
         try:
             answers = dns_resolver.query(ptraddr, 'PTR')
         except NXDOMAIN:
             answers = []
         try:
             environ['slimta.reverse_address'] = str(answers[0])
         except IndexError:
             pass
     except Exception:
         log_exception(__name__, query=ip)
Exemple #39
0
 def _ptr_lookup(self, environ):
     ip = environ.get('REMOTE_ADDR', '0.0.0.0')
     try:
         ptraddr = reversename.from_address(ip)
         try:
             answers = dns_resolver.query(ptraddr, 'PTR')
         except NXDOMAIN:
             answers = []
         try:
             environ['slimta.reverse_address'] = str(answers[0])
         except IndexError:
             pass
     except Exception:
         log_exception(__name__, query=ip)
 def _run(self):
     try:
         ptraddr = reversename.from_address(self.ip)
         try:
             answers = dns_resolver.query(ptraddr, 'PTR')
         except NXDOMAIN:
             answers = []
         try:
             return str(answers[0])
         except IndexError:
             pass
     except (DnsSyntaxError, gevent.GreenletExit):
         pass
     except Exception:
         logging.log_exception(__name__, query=self.ip)
 def _run(self):
     try:
         ptraddr = reversename.from_address(self.ip)
         try:
             answers = dns_resolver.query(ptraddr, 'PTR')
         except NXDOMAIN:
             answers = []
         try:
             return str(answers[0])
         except IndexError:
             pass
     except (DnsSyntaxError, gevent.GreenletExit):
         pass
     except Exception:
         logging.log_exception(__name__, query=self.ip)
Exemple #42
0
    def get_reason(self, ip, timeout=None):
        """Gets the TXT record for the IP address on this DNSBL. This is
        usually a reason for why the IP address matched. As such, this function
        should only be called after :meth:`.get()` returns ``True``.

        :param ip: The IP address to get a match reason for.
        :param timeout: A timeout in seconds before giving up.
        :returns: A string with the reason, or ``None``.

        """
        with gevent.Timeout(timeout, None):
            query = self._build_query(ip)
            try:
                answers = dns_resolver.query(query, 'TXT')
            except DNSException:
                pass
            else:
                if answers:
                    for txt in answers:
                        return str(txt)
Exemple #43
0
    def get_reason(self, ip, timeout=None):
        """Gets the TXT record for the IP address on this DNSBL. This is
        usually a reason for why the IP address matched. As such, this function
        should only be called after :meth:`.get()` returns ``True``.

        :param ip: The IP address to get a match reason for.
        :param timeout: A timeout in seconds before giving up.
        :returns: A string with the reason, or ``None``.

        """
        with gevent.Timeout(timeout, None):
            query = self._build_query(ip)
            try:
                answers = dns_resolver.query(query, 'TXT')
            except DNSException:
                pass
            else:
                if answers:
                    for txt in answers:
                        return str(txt)
 def test_dnsblocklistgroup_get(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl('test1.example.com')
     group.add_dnsbl('test2.example.com')
     group.add_dnsbl('test3.example.com')
     dns_resolver.query('4.3.2.1.test1.example.com', 'A').InAnyOrder('one')
     dns_resolver.query('4.3.2.1.test2.example.com', 'A').InAnyOrder('one').AndRaise(NXDOMAIN)
     dns_resolver.query('4.3.2.1.test3.example.com', 'A').InAnyOrder('one')
     dns_resolver.query('8.7.6.5.test1.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     dns_resolver.query('8.7.6.5.test2.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     dns_resolver.query('8.7.6.5.test3.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertEqual(set(['test1.example.com', 'test3.example.com']), group.get('1.2.3.4'))
     self.assertNotIn('5.6.7.8', group)
 def test_dnsblocklist_get(self):
     dns_resolver.query("4.3.2.1.test.example.com", "A")
     dns_resolver.query("8.7.6.5.test.example.com", "A").AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertTrue(self.dnsbl.get("1.2.3.4"))
     self.assertNotIn("5.6.7.8", self.dnsbl)
 def test_dnsblocklist_get(self):
     dns_resolver.query('4.3.2.1.test.example.com', 'A')
     dns_resolver.query('8.7.6.5.test.example.com', 'A').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     assert_true(self.dnsbl.get('1.2.3.4'))
     assert_not_in('5.6.7.8', self.dnsbl)
 def test_dnsblocklistgroup_get(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl("test1.example.com")
     group.add_dnsbl("test2.example.com")
     group.add_dnsbl("test3.example.com")
     dns_resolver.query("4.3.2.1.test1.example.com", "A").InAnyOrder("one")
     dns_resolver.query("4.3.2.1.test2.example.com", "A").InAnyOrder("one").AndRaise(NXDOMAIN)
     dns_resolver.query("4.3.2.1.test3.example.com", "A").InAnyOrder("one")
     dns_resolver.query("8.7.6.5.test1.example.com", "A").InAnyOrder("two").AndRaise(NXDOMAIN)
     dns_resolver.query("8.7.6.5.test2.example.com", "A").InAnyOrder("two").AndRaise(NXDOMAIN)
     dns_resolver.query("8.7.6.5.test3.example.com", "A").InAnyOrder("two").AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertEqual(set(["test1.example.com", "test3.example.com"]), group.get("1.2.3.4"))
     self.assertNotIn("5.6.7.8", group)
 def test_dnsblocklistgroup_get(self):
     group = DnsBlocklistGroup()
     group.add_dnsbl('test1.example.com')
     group.add_dnsbl('test2.example.com')
     group.add_dnsbl('test3.example.com')
     dns_resolver.query('4.3.2.1.test1.example.com', 'A').InAnyOrder('one')
     dns_resolver.query('4.3.2.1.test2.example.com', 'A').InAnyOrder('one').AndRaise(NXDOMAIN)
     dns_resolver.query('4.3.2.1.test3.example.com', 'A').InAnyOrder('one')
     dns_resolver.query('8.7.6.5.test1.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     dns_resolver.query('8.7.6.5.test2.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     dns_resolver.query('8.7.6.5.test3.example.com', 'A').InAnyOrder('two').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     assert_equal(set(['test1.example.com', 'test3.example.com']), group.get('1.2.3.4'))
     assert_not_in('5.6.7.8', group)
 def test_dnsblocklist_get(self):
     dns_resolver.query('4.3.2.1.test.example.com', 'A')
     dns_resolver.query('8.7.6.5.test.example.com', 'A').AndRaise(NXDOMAIN)
     self.mox.ReplayAll()
     self.assertTrue(self.dnsbl.get('1.2.3.4'))
     self.assertNotIn('5.6.7.8', self.dnsbl)