Merge pull request #8110 from zeha/urls-https

[thirdparty/pdns.git] / regression-tests.dnsdist / test_EDNSSelfGenerated.py

diff --git a/regression-tests.dnsdist/test_EDNSSelfGenerated.py b/regression-tests.dnsdist/test_EDNSSelfGenerated.py
index 7704641319a7e08531bb775f5896d105b50dd05b..fdaeec32a0d368db5718b387d9bff6752bf2d559 100644 (file)
--- a/regression-tests.dnsdist/test_EDNSSelfGenerated.py
+++ b/regression-tests.dnsdist/test_EDNSSelfGenerated.py
@@ -11,14 +11,14 @@ class TestEDNSSelfGenerated(DNSDistTest):
     """
 
     _config_template = """
-    addAction("rcode.edns-self.tests.powerdns.com.", RCodeAction(dnsdist.REFUSED))
+    addAction("rcode.edns-self.tests.powerdns.com.", RCodeAction(DNSRCode.REFUSED))
     addAction("tc.edns-self.tests.powerdns.com.", TCAction())
 
     function luarule(dq)
       return DNSAction.Nxdomain, ""
     end
 
-    addLuaAction("lua.edns-self.tests.powerdns.com.", luarule)
+    addAction("lua.edns-self.tests.powerdns.com.", LuaAction(luarule))
 
     addAction("spoof.edns-self.tests.powerdns.com.", SpoofAction({'192.0.2.1', '192.0.2.2'}))
 
@@ -36,50 +36,46 @@ class TestEDNSSelfGenerated(DNSDistTest):
         expectedResponse = dns.message.make_response(query)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'no-edns.tc.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN')
         expectedResponse = dns.message.make_response(query)
         expectedResponse.flags |= dns.flags.TC
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'no-edns.lua.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN')
         expectedResponse = dns.message.make_response(query)
         expectedResponse.set_rcode(dns.rcode.NXDOMAIN)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'no-edns.spoof.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN')
         # dnsdist set RA = RD for spoofed responses
         query.flags &= ~dns.flags.RD
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.answer.append(dns.rrset.from_text(name,
                                                            60,
                                                            dns.rdataclass.IN,
                                                            dns.rdatatype.A,
                                                            '192.0.2.1', '192.0.2.2'))
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
     def testWithEDNSNoDO(self):
         """
@@ -87,69 +83,57 @@ class TestEDNSSelfGenerated(DNSDistTest):
         """
         name = 'edns-no-do.rcode.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-no-do.tc.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.flags |= dns.flags.TC
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-no-do.lua.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.NXDOMAIN)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-no-do.spoof.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
         # dnsdist set RA = RD for spoofed responses
         query.flags &= ~dns.flags.RD
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.answer.append(dns.rrset.from_text(name,
                                                            60,
                                                            dns.rdataclass.IN,
                                                            dns.rdatatype.A,
                                                            '192.0.2.1', '192.0.2.2'))
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
     def testWithEDNSWithDO(self):
         """
@@ -157,69 +141,57 @@ class TestEDNSSelfGenerated(DNSDistTest):
         """
         name = 'edns-do.rcode.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-do.tc.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.flags |= dns.flags.TC
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-do.lua.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.NXDOMAIN)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-do.spoof.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=True)
         # dnsdist set RA = RD for spoofed responses
         query.flags &= ~dns.flags.RD
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.answer.append(dns.rrset.from_text(name,
                                                            60,
                                                            dns.rdataclass.IN,
                                                            dns.rdatatype.A,
                                                            '192.0.2.1', '192.0.2.2'))
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
     def testWithEDNSNoOptions(self):
         """
@@ -228,69 +200,57 @@ class TestEDNSSelfGenerated(DNSDistTest):
         name = 'edns-options.rcode.edns-self.tests.powerdns.com.'
         ecso = clientsubnetoption.ClientSubnetOption('127.0.0.1', 24)
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, options=[ecso], payload=512, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-options.tc.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, options=[ecso], payload=512, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.flags |= dns.flags.TC
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-options.lua.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, options=[ecso], payload=512, want_dnssec=True)
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.set_rcode(dns.rcode.NXDOMAIN)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
         name = 'edns-options.spoof.edns-self.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, options=[ecso], payload=512, want_dnssec=True)
         # dnsdist set RA = RD for spoofed responses
         query.flags &= ~dns.flags.RD
-        expectedResponse = dns.message.make_response(query)
+        expectedResponse = dns.message.make_response(query, our_payload=1042)
         expectedResponse.answer.append(dns.rrset.from_text(name,
                                                            60,
                                                            dns.rdataclass.IN,
                                                            dns.rdatatype.A,
                                                            '192.0.2.1', '192.0.2.2'))
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
-        self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
-        self.assertEquals(receivedResponse.payload, 1042)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
+            self.assertTrue(receivedResponse.ednsflags & dns.flags.DO)
+            self.assertEquals(receivedResponse.payload, 1042)
 
 
 class TestEDNSSelfGeneratedDisabled(DNSDistTest):
@@ -302,14 +262,14 @@ class TestEDNSSelfGeneratedDisabled(DNSDistTest):
     _config_template = """
     setAddEDNSToSelfGeneratedResponses(false)
 
-    addAction("rcode.edns-self-disabled.tests.powerdns.com.", RCodeAction(dnsdist.REFUSED))
+    addAction("rcode.edns-self-disabled.tests.powerdns.com.", RCodeAction(DNSRCode.REFUSED))
     addAction("tc.edns-self-disabled.tests.powerdns.com.", TCAction())
 
     function luarule(dq)
       return DNSAction.Nxdomain, ""
     end
 
-    addLuaAction("lua.edns-self-disabled.tests.powerdns.com.", luarule)
+    addAction("lua.edns-self-disabled.tests.powerdns.com.", LuaAction(luarule))
 
     addAction("spoof.edns-self-disabled.tests.powerdns.com.", SpoofAction({'192.0.2.1', '192.0.2.2'}))
 
@@ -327,33 +287,30 @@ class TestEDNSSelfGeneratedDisabled(DNSDistTest):
         expectedResponse = dns.message.make_response(query)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'edns-no-do.tc.edns-self-disabled.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
         expectedResponse = dns.message.make_response(query)
         expectedResponse.flags |= dns.flags.TC
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'edns-no-do.lua.edns-self-disabled.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
         expectedResponse = dns.message.make_response(query)
         expectedResponse.set_rcode(dns.rcode.NXDOMAIN)
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)
 
         name = 'edns-no-do.spoof.edns-self-disabled.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096, want_dnssec=False)
@@ -366,8 +323,7 @@ class TestEDNSSelfGeneratedDisabled(DNSDistTest):
                                                            dns.rdatatype.A,
                                                            '192.0.2.1', '192.0.2.2'))
 
-        (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
-
-        (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.checkMessageNoEDNS(expectedResponse, receivedResponse)
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            self.checkMessageNoEDNS(expectedResponse, receivedResponse)