dnsdist: Add the DoQ transport protocol to Async tests

diff --git a/regression-tests.dnsdist/dnsdisttests.py b/regression-tests.dnsdist/dnsdisttests.py
index 7925c37cf19f4e3a46ff82e793592d1005d316d9..97f8b72dcbb63a898a68563078b61415fa8af918 100644 (file)
--- a/regression-tests.dnsdist/dnsdisttests.py
+++ b/regression-tests.dnsdist/dnsdisttests.py
@@ -1090,17 +1090,20 @@ class DNSDistTest(AssertEqualDNSMessageMixin, unittest.TestCase):
     def sendDOTQueryWrapper(self, query, response, useQueue=True):
         return self.sendDOTQuery(self._tlsServerPort, self._serverName, query, response, self._caCert, useQueue=useQueue)
 
+    def sendDOQQueryWrapper(self, query, response, useQueue=True):
+        return self.sendDOQQuery(self._doqServerPort, query, response=response, caFile=self._caCert, useQueue=useQueue, serverName=self._serverName)
+
     @classmethod
-    def getDOQConnection(cls, port, servername, caFile=None, source=None, source_port=0):
+    def getDOQConnection(cls, port, caFile=None, source=None, source_port=0):
 
         manager = dns.quic.SyncQuicManager(
             verify_mode=caFile
         )
 
-        return manager.connect(servername, port, source, source_port)
+        return manager.connect('127.0.0.1', port, source, source_port)
 
     @classmethod
-    def sendDOQQuery(cls, port, servername, query, response=None, timeout=2.0, caFile=None, useQueue=True, rawQuery=False, fromQueue=None, toQueue=None, connection=None):
+    def sendDOQQuery(cls, port, query, response=None, timeout=2.0, caFile=None, useQueue=True, rawQuery=False, fromQueue=None, toQueue=None, connection=None, serverName=None):
 
         if response:
             if toQueue:
@@ -1108,7 +1111,7 @@ class DNSDistTest(AssertEqualDNSMessageMixin, unittest.TestCase):
             else:
                 cls._toResponderQueue.put(response, True, timeout)
 
-        message = dns.query.quic(query, servername, timeout, port, verify=caFile, connection=connection)
+        message = dns.query.quic(query, '127.0.0.1', timeout, port, verify=caFile, connection=connection, server_hostname=serverName)
 
         receivedQuery = None
 

diff --git a/regression-tests.dnsdist/test_Async.py b/regression-tests.dnsdist/test_Async.py
index 8856df30f59aa3ef34ab7cdfbba172df98515f7f..e4b8e41c651e5c4ce89e15ad8d792ca1da4e9b0a 100644 (file)
--- a/regression-tests.dnsdist/test_Async.py
+++ b/regression-tests.dnsdist/test_Async.py
@@ -95,6 +95,7 @@ class AsyncTests(object):
     _dohWithH2OServerPort = pickAvailablePort()
     _dohWithNGHTTP2BaseURL = ("https://%s:%d/" % (_serverName, _dohWithNGHTTP2ServerPort))
     _dohWithH2OBaseURL = ("https://%s:%d/" % (_serverName, _dohWithH2OServerPort))
+    _doqServerPort = pickAvailablePort()
 
     def testPass(self):
         """
@@ -111,11 +112,14 @@ class AsyncTests(object):
                                         '192.0.2.1')
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
+                if method == 'sendDOQQueryWrapper':
+                    # dnspython sets the ID to 0
+                    receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
 
     def testPassCached(self):
@@ -133,9 +137,9 @@ class AsyncTests(object):
                                     '192.0.2.1')
         response.answer.append(rrset)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
             sender = getattr(self, method)
-            if method != 'sendDOTQueryWrapper' and method != 'sendDOHWithH2OQueryWrapper':
+            if method != 'sendDOTQueryWrapper' and method != 'sendDOHWithH2OQueryWrapper' and method != 'sendDOQQueryWrapper':
                 # first time to fill the cache
                 # disabled for DoT since it was already filled via TCP
                 (receivedQuery, receivedResponse) = sender(query, response)
@@ -146,6 +150,9 @@ class AsyncTests(object):
             # second time from the cache
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            if method == 'sendDOQQueryWrapper':
+                # dnspython sets the ID to 0
+                receivedResponse.id = response.id
             self.assertEqual(response, receivedResponse)
 
     def testTimeoutThenAccept(self):
@@ -163,11 +170,14 @@ class AsyncTests(object):
                                         '192.0.2.1')
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
+                if method == 'sendDOQQueryWrapper':
+                    # dnspython sets the ID to 0
+                    receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
 
     def testAcceptThenTimeout(self):
@@ -185,11 +195,14 @@ class AsyncTests(object):
                                         '192.0.2.1')
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
+                if method == 'sendDOQQueryWrapper':
+                    # dnspython sets the ID to 0
+                    receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
 
     def testAcceptThenRefuse(self):
@@ -211,11 +224,14 @@ class AsyncTests(object):
             expectedResponse.flags |= dns.flags.RA
             expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
+                if method == 'sendDOQQueryWrapper':
+                    # dnspython sets the ID to 0
+                    receivedResponse.id = expectedResponse.id
                 self.assertEqual(expectedResponse, receivedResponse)
 
     def testAcceptThenCustom(self):
@@ -233,18 +249,20 @@ class AsyncTests(object):
                                         '192.0.2.1')
             response.answer.append(rrset)
 
-            # easier to get the same custom response to everyone, sorry!
-            expectedQuery = dns.message.make_query('custom.async.tests.powerdns.com.', 'A', 'IN')
+            expectedQuery = dns.message.make_query(name, 'A', 'IN')
             expectedQuery.id = query.id
             expectedResponse = dns.message.make_response(expectedQuery)
             expectedResponse.flags |= dns.flags.RA
             expectedResponse.set_rcode(dns.rcode.FORMERR)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
+                if method == 'sendDOQQueryWrapper':
+                    # dnspython sets the ID to 0
+                    receivedResponse.id = expectedResponse.id
                 self.assertEqual(expectedResponse, receivedResponse)
 
     def testAcceptThenDrop(self):
@@ -262,9 +280,14 @@ class AsyncTests(object):
                                         '192.0.2.1')
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
                 sender = getattr(self, method)
-                (receivedQuery, receivedResponse) = sender(query, response)
+                try:
+                    (receivedQuery, receivedResponse) = sender(query, response)
+                except dns.exception.Timeout:
+                    if not self._fromResponderQueue.empty():
+                        receivedQuery = self._fromResponderQueue.get(True, 1.0)
+                    receivedResponse = None
                 receivedQuery.id = query.id
                 self.assertEqual(query, receivedQuery)
                 self.assertEqual(receivedResponse, None)
@@ -280,10 +303,13 @@ class AsyncTests(object):
         expectedResponse.flags |= dns.flags.RA
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
             self.assertTrue(receivedResponse)
+            if method == 'sendDOQQueryWrapper':
+                # dnspython sets the ID to 0
+                receivedResponse.id = expectedResponse.id
             self.assertEqual(expectedResponse, receivedResponse)
 
     def testDrop(self):
@@ -293,9 +319,12 @@ class AsyncTests(object):
         name = 'drop.async.tests.powerdns.com.'
         query = dns.message.make_query(name, 'A', 'IN')
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
             sender = getattr(self, method)
-            (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            try:
+                (_, receivedResponse) = sender(query, response=None, useQueue=False)
+            except dns.exception.Timeout:
+                receivedResponse = None
             self.assertEqual(receivedResponse, None)
 
     def testCustom(self):
@@ -309,10 +338,13 @@ class AsyncTests(object):
         expectedResponse.flags |= dns.flags.RA
         expectedResponse.set_rcode(dns.rcode.FORMERR)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
+        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
             self.assertTrue(receivedResponse)
+            if method == 'sendDOQQueryWrapper':
+                # dnspython sets the ID to 0
+                receivedResponse.id = expectedResponse.id
             self.assertEqual(expectedResponse, receivedResponse)
 
     def testTruncation(self):
@@ -369,6 +401,7 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
     addTLSLocal("127.0.0.1:%d", "%s", "%s", { provider="openssl" })
     addDOHLocal("127.0.0.1:%d", "%s", "%s", {"/"}, {library="h2o"})
     addDOHLocal("127.0.0.1:%d", "%s", "%s", {"/"}, {library="nghttp2"})
+    addDOQLocal("127.0.0.1:%d", "%s", "%s")
 
     local ffi = require("ffi")
     local C = ffi.C
@@ -380,6 +413,8 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
     pc = newPacketCache(100)
     getPool('cache'):setCache(pc)
 
+    local asyncObjectsMap = {}
+
     function gotAsyncResponse(endpointID, message, from)
 
       print('Got async response '..message)
@@ -390,6 +425,7 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
         return
       end
       local queryID = tonumber(parts[1])
+      local qname = asyncObjectsMap[queryID]
       if parts[2] == 'accept' then
         print('accepting')
         C.dnsdist_ffi_resume_from_async(asyncID, queryID, filteringTagName, #filteringTagName, filteringTagValue, #filteringTagValue, true)
@@ -407,7 +443,15 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
       end
       if parts[2] == 'custom' then
         print('sending a custom response')
-        local raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\006custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        local raw = nil
+        if qname == string.char(6)..'custom'..string.char(5)..'async'..string.char(5)..'tests'..string.char(8)..'powerdns'..string.char(3)..'com' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\006custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        elseif qname == string.char(18)..'accept-then-custom'..string.char(5)..'async'..string.char(5)..'tests'..string.char(8)..'powerdns'..string.char(3)..'com' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\018accept-then-custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        elseif qname == string.char(18)..'accept-then-custom'..string.char(8)..'tcp-only'..string.char(5)..'async'..string.char(5)..'tests'..string.char(8)..'powerdns'..string.char(3)..'com' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\018accept-then-custom\\008tcp-only\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        end
+
         C.dnsdist_ffi_set_answer_from_async(asyncID, queryID, raw, #raw)
         return
       end
@@ -418,6 +462,15 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
     listener:addUnixListeningEndpoint('%s', 0, gotAsyncResponse)
     listener:start()
 
+    function getQNameRaw(dq)
+      local ret_ptr = ffi.new("char *[1]")
+      local ret_ptr_param = ffi.cast("const char **", ret_ptr)
+      local ret_size = ffi.new("size_t[1]")
+      local ret_size_param = ffi.cast("size_t*", ret_size)
+      C.dnsdist_ffi_dnsquestion_get_qname_raw(dq, ret_ptr_param, ret_size_param)
+      return ffi.string(ret_ptr[0])
+    end
+
     function passQueryToAsyncFilter(dq)
       print('in passQueryToAsyncFilter')
       local timeout = 500 -- 500 ms
@@ -428,7 +481,9 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
       -- we need to take a copy, as we can no longer touch that data after calling set_async
       local buffer = ffi.string(queryPtr, querySize)
 
-      print(C.dnsdist_ffi_dnsquestion_set_async(dq, asyncID, C.dnsdist_ffi_dnsquestion_get_id(dq), timeout))
+      asyncObjectsMap[C.dnsdist_ffi_dnsquestion_get_id(dq)] = getQNameRaw(dq)
+
+      C.dnsdist_ffi_dnsquestion_set_async(dq, asyncID, C.dnsdist_ffi_dnsquestion_get_id(dq), timeout)
       asyncResponderEndpoint:send(buffer)
 
       return DNSAction.Allow
@@ -444,7 +499,9 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
       -- we need to take a copy, as we can no longer touch that data after calling set_async
       local buffer = ffi.string(responsePtr, responseSize)
 
-      print(C.dnsdist_ffi_dnsresponse_set_async(dr, asyncID, C.dnsdist_ffi_dnsquestion_get_id(dr), timeout))
+      asyncObjectsMap[C.dnsdist_ffi_dnsquestion_get_id(dr)] = getQNameRaw(dr)
+
+      C.dnsdist_ffi_dnsresponse_set_async(dr, asyncID, C.dnsdist_ffi_dnsquestion_get_id(dr), timeout)
       asyncResponderEndpoint:send(buffer)
 
       return DNSResponseAction.Allow
@@ -459,7 +516,7 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
     """
     _asyncResponderSocketPath = asyncResponderSocketPath
     _dnsdistSocketPath = dnsdistSocketPath
-    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_asyncResponderSocketPath', '_dnsdistSocketPath']
+    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_doqServerPort', '_serverCert', '_serverKey', '_asyncResponderSocketPath', '_dnsdistSocketPath']
     _verboseMode = True
 
 @unittest.skipIf('SKIP_DOH_TESTS' in os.environ, 'DNS over HTTPS tests are disabled')
@@ -471,6 +528,7 @@ class TestAsyncLua(DNSDistTest, AsyncTests):
     addTLSLocal("127.0.0.1:%d", "%s", "%s", { provider="openssl" })
     addDOHLocal("127.0.0.1:%d", "%s", "%s", {"/"}, {library="h2o"})
     addDOHLocal("127.0.0.1:%d", "%s", "%s", {"/"}, {library="nghttp2"})
+    addDOQLocal("127.0.0.1:%d", "%s", "%s")
 
     local filteringTagName = 'filtering'
     local filteringTagValue = 'pass'
@@ -513,8 +571,15 @@ class TestAsyncLua(DNSDistTest, AsyncTests):
       end
       if parts[2] == 'custom' then
         print('sending a custom response')
-        local raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\006custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
         local dq = asyncObject:getDQ()
+        local raw
+        if tostring(dq.qname) == 'custom.async.tests.powerdns.com.' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\006custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        elseif tostring(dq.qname) == 'accept-then-custom.async.tests.powerdns.com.' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\018accept-then-custom\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        elseif tostring(dq.qname) == 'accept-then-custom.tcp-only.async.tests.powerdns.com.' then
+          raw = '\\000\\000\\128\\129\\000\\001\\000\\000\\000\\000\\000\\001\\018accept-then-custom\\008tcp-only\\005async\\005tests\\008powerdns\\003com\\000\\000\\001\\000\\001\\000\\000\\041\\002\\000\\000\\000\\128\\000\\000\\000'
+        end
         dq:setContent(raw)
         asyncObject:resume()
         return
@@ -559,5 +624,5 @@ class TestAsyncLua(DNSDistTest, AsyncTests):
     """
     _asyncResponderSocketPath = asyncResponderSocketPath
     _dnsdistSocketPath = dnsdistSocketPath
-    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_asyncResponderSocketPath', '_dnsdistSocketPath']
+    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_doqServerPort', '_serverCert', '_serverKey', '_asyncResponderSocketPath', '_dnsdistSocketPath']
     _verboseMode = True

diff --git a/regression-tests.dnsdist/test_DOQ.py b/regression-tests.dnsdist/test_DOQ.py
index 6f1635905fe352e39c204f804f3311ad79696fd4..5c5aaae1b64161cd144e5d047d6bd98ab47584c1 100644 (file)
--- a/regression-tests.dnsdist/test_DOQ.py
+++ b/regression-tests.dnsdist/test_DOQ.py
@@ -8,7 +8,7 @@ from dnsdisttests import pickAvailablePort
 class TestDOQ(DNSDistTest):
     _serverKey = 'server.key'
     _serverCert = 'server.chain'
-    _serverName = '127.0.0.1'
+    _serverName = 'tls.tests.dnsdist.org'
     _caCert = 'ca.pem'
     _doqServerPort = pickAvailablePort()
     _config_template = """
@@ -40,7 +40,7 @@ class TestDOQ(DNSDistTest):
                                     dns.rdatatype.A,
                                     '127.0.0.1')
         response.answer.append(rrset)
-        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=response, caFile=self._caCert)
+        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=response, caFile=self._caCert, serverName=self._serverName)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = expectedQuery.id
@@ -64,15 +64,15 @@ class TestDOQ(DNSDistTest):
                                     '127.0.0.1')
         response.answer.append(rrset)
 
-        connection = self.getDOQConnection(self._doqServerPort, self._serverName, self._caCert)
+        connection = self.getDOQConnection(self._doqServerPort, self._caCert)
 
-        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=response, connection=connection)
+        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=response, caFile=self._caCert, serverName=self._serverName, connection=connection)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = expectedQuery.id
         self.assertEqual(expectedQuery, receivedQuery)
 
-        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=response, connection=connection)
+        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=response, caFile=self._caCert, serverName=self._serverName, connection=connection)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = expectedQuery.id
@@ -86,7 +86,7 @@ class TestDOQ(DNSDistTest):
         query = dns.message.make_query(name, 'A', 'IN')
         dropped = False
         try:
-            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=None, caFile=self._caCert, useQueue=False)
+            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=None, caFile=self._caCert, useQueue=False, serverName=self._serverName)
             # dns.quic doesn't seem to report correctly the quic error so the connection timeout
         except dns.exception.Timeout :
             dropped = True
@@ -103,7 +103,7 @@ class TestDOQ(DNSDistTest):
         expectedResponse = dns.message.make_response(query)
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=None, caFile=self._caCert, useQueue=False)
+        (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=None, caFile=self._caCert, useQueue=False, serverName=self._serverName)
         self.assertEqual(receivedResponse, expectedResponse)
 
     def testSpoof(self):
@@ -122,7 +122,7 @@ class TestDOQ(DNSDistTest):
                                     '1.2.3.4')
         expectedResponse.answer.append(rrset)
 
-        (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=None, caFile=self._caCert, useQueue=False)
+        (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=None, caFile=self._caCert, useQueue=False, serverName=self._serverName)
         self.assertEqual(receivedResponse, expectedResponse)
 
     def testDOQNoBackend(self):
@@ -133,7 +133,7 @@ class TestDOQ(DNSDistTest):
         query = dns.message.make_query(name, 'A', 'IN', use_edns=False)
         dropped = False
         try:
-            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=None, caFile=self._caCert, useQueue=False)
+            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=None, caFile=self._caCert, useQueue=False, serverName=self._serverName)
         except dns.exception.Timeout :
             dropped = True
         self.assertTrue(dropped)
@@ -142,7 +142,7 @@ class TestDOQ(DNSDistTest):
 class TestDOQWithCache(DNSDistTest):
     _serverKey = 'server.key'
     _serverCert = 'server.chain'
-    _serverName = '127.0.0.1'
+    _serverName = 'tls.tests.dnsdist.org'
     _caCert = 'ca.pem'
     _doqServerPort = 8853
     _config_template = """
@@ -177,7 +177,7 @@ class TestDOQWithCache(DNSDistTest):
         response.answer.append(rrset)
 
         # first query to fill the cache
-        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=response, caFile=self._caCert)
+        (receivedQuery, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=response, caFile=self._caCert, serverName=self._serverName)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = query.id
@@ -185,7 +185,7 @@ class TestDOQWithCache(DNSDistTest):
         self.assertEqual(receivedResponse, response)
 
         for _ in range(numberOfQueries):
-            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, self._serverName, query, response=None, caFile=self._caCert, useQueue=False)
+            (_, receivedResponse) = self.sendDOQQuery(self._doqServerPort, query, response=None, caFile=self._caCert, useQueue=False, serverName=self._serverName)
             self.assertEqual(receivedResponse, response)
 
         total = 0