Merge pull request #13509 from rgacogne/ddist-teeaction-proxyprotocol

[thirdparty/pdns.git] / regression-tests.recursor-dnssec / test_DNS64.py

diff --git a/regression-tests.recursor-dnssec/test_DNS64.py b/regression-tests.recursor-dnssec/test_DNS64.py
index 7038fe48f6396fcf503dde66d6b9e164f8b7606e..abf6fdb23ac20f726ab1a04693af5514869bbadc 100644 (file)
--- a/regression-tests.recursor-dnssec/test_DNS64.py
+++ b/regression-tests.recursor-dnssec/test_DNS64.py
@@ -14,22 +14,15 @@ class DNS64RecursorTest(RecursorTest):
     dns64-prefix=64:ff9b::/96
     """ % (_confdir, _confdir, _confdir)
 
-    @classmethod
-    def setUpClass(cls):
-
-        # we don't need all the auth stuff
-        cls.setUpSockets()
-        cls.startResponders()
-
-        confdir = os.path.join('configs', cls._confdir)
-        cls.createConfigDir(confdir)
-
-        cls.generateRecursorConfig(confdir)
-        cls.startRecursor(confdir, cls._recursorPort)
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.tearDownRecursor()
+    _lua_dns_script_file = """
+      function nodata(dq)
+        if dq.qtype == pdns.AAAA and dq.qname:equal("formerr.example.dns64") then
+          dq.rcode = pdns.FORMERR
+          return true
+        end
+        return false
+       end
+    """
 
     @classmethod
     def generateRecursorConfig(cls, confdir):
@@ -40,6 +33,9 @@ class DNS64RecursorTest(RecursorTest):
 www 3600 IN A 192.0.2.42
 www 3600 IN TXT "does exist"
 aaaa 3600 IN AAAA 2001:db8::1
+cname 3600 IN CNAME cname2.example.dns64.
+cname2 3600 IN CNAME www.example.dns64.
+formerr 3600 IN A 192.0.2.43
 """.format(soa=cls._SOA))
 
         authzonepath = os.path.join(confdir, 'in-addr.arpa.zone')
@@ -79,7 +75,7 @@ aaaa 3600 IN AAAA 2001:db8::1
             sender = getattr(self, method)
             res = sender(query)
             self.assertRcodeEqual(res, dns.rcode.NOERROR)
-            self.assertEquals(len(res.answer), 0)
+            self.assertEqual(len(res.answer), 0)
 
     # this type (AAAA) does not exist for this name but there is an A record, we should get a DNS64-wrapped AAAA
     def testNonExistingAAAA(self):
@@ -93,8 +89,26 @@ aaaa 3600 IN AAAA 2001:db8::1
             self.assertRcodeEqual(res, dns.rcode.NOERROR)
             self.assertRRsetInAnswer(res, expected)
 
+    # there is a CNAME from that name to a second one, then to a name for which this type (AAAA)
+    # does not exist, but an A record does, so we should get a DNS64-wrapped AAAA
+    def testCNAMEToA(self):
+        qname = 'cname.example.dns64.'
+        expectedResults = [
+            dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'CNAME', 'cname2.example.dns64.'),
+            dns.rrset.from_text('cname2.example.dns64.', 0, dns.rdataclass.IN, 'CNAME', 'www.example.dns64.'),
+            dns.rrset.from_text('www.example.dns64.', 0, dns.rdataclass.IN, 'AAAA', '64:ff9b::c000:22a')
+        ]
+
+        query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            res = sender(query)
+            self.assertRcodeEqual(res, dns.rcode.NOERROR)
+            for expected in expectedResults:
+                self.assertRRsetInAnswer(res, expected)
+
     # this type (AAAA) does not exist for this name and there is no A record either, we should get a NXDomain
-    def testNonExistingAAAA(self):
+    def testNXD(self):
         qname = 'nxd.example.dns64.'
 
         query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
@@ -115,6 +129,28 @@ aaaa 3600 IN AAAA 2001:db8::1
             self.assertRcodeEqual(res, dns.rcode.NOERROR)
             self.assertRRsetInAnswer(res, expected)
 
+    # If the AAAA is handled by Lua code, we should not get a dns64 result
+    def testFormerr(self):
+        qname = 'formerr.example.dns64'
+
+        query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            res = sender(query)
+            self.assertRcodeEqual(res, dns.rcode.FORMERR)
+
+    # If the AAAA times out, we still should get a dns64 result
+    def testTimeout(self):
+        qname = '8.delay1.example.'
+        expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'AAAA', '64:ff9b::c000:264')
+
+        query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            res = sender(query)
+            self.assertRcodeEqual(res, dns.rcode.NOERROR)
+            self.assertRRsetInAnswer(res, expected)
+
     # there is a TXT record, we should get it
     def testExistingTXT(self):
         qname = 'www.example.dns64.'