chore(dnsdist): reformat test_Async.py

diff --git a/regression-tests.dnsdist/test_Async.py b/regression-tests.dnsdist/test_Async.py
index 454bfa03deace493781f1e18745a23432bc35b8d..6bea2cb7d4e1f7c59fc70dc38134063acb3e3c19 100644 (file)
--- a/regression-tests.dnsdist/test_Async.py
+++ b/regression-tests.dnsdist/test_Async.py
@@ -11,6 +11,7 @@ import doqclient
 
 from dnsdisttests import DNSDistTest, pickAvailablePort
 
+
 def AsyncResponder(listenPath, responsePath):
     # Make sure the socket does not already exist
     try:
@@ -32,47 +33,47 @@ def AsyncResponder(listenPath, responsePath):
             break
 
         request = dns.message.from_wire(data)
-        reply = str(request.id) + ' '
-        if str(request.question[0].name).startswith('accept-then-refuse'):
+        reply = str(request.id) + " "
+        if str(request.question[0].name).startswith("accept-then-refuse"):
             if request.flags & dns.flags.QR:
-                reply = reply + 'refuse'
+                reply = reply + "refuse"
             else:
-                reply = reply + 'accept'
-        elif str(request.question[0].name).startswith('accept-then-drop'):
+                reply = reply + "accept"
+        elif str(request.question[0].name).startswith("accept-then-drop"):
             if request.flags & dns.flags.QR:
-                reply = reply + 'drop'
+                reply = reply + "drop"
             else:
-                reply = reply + 'accept'
-        elif str(request.question[0].name).startswith('accept-then-custom'):
+                reply = reply + "accept"
+        elif str(request.question[0].name).startswith("accept-then-custom"):
             if request.flags & dns.flags.QR:
-                reply = reply + 'custom'
+                reply = reply + "custom"
             else:
-                reply = reply + 'accept'
-        elif str(request.question[0].name).startswith('timeout-then-accept'):
+                reply = reply + "accept"
+        elif str(request.question[0].name).startswith("timeout-then-accept"):
             if request.flags & dns.flags.QR:
-                reply = reply + 'accept'
+                reply = reply + "accept"
             else:
                 # no response
                 continue
-        elif str(request.question[0].name).startswith('accept-then-timeout'):
+        elif str(request.question[0].name).startswith("accept-then-timeout"):
             if request.flags & dns.flags.QR:
                 # no response
                 continue
             else:
-                reply = reply + 'accept'
-        elif str(request.question[0].name).startswith('accept'):
-            reply = reply + 'accept'
-        elif str(request.question[0].name).startswith('refuse'):
-            reply = reply + 'refuse'
-        elif str(request.question[0].name).startswith('drop'):
-            reply = reply + 'drop'
-        elif str(request.question[0].name).startswith('custom'):
-            reply = reply + 'custom'
-        elif str(request.question[0].name).startswith('timeout'):
+                reply = reply + "accept"
+        elif str(request.question[0].name).startswith("accept"):
+            reply = reply + "accept"
+        elif str(request.question[0].name).startswith("refuse"):
+            reply = reply + "refuse"
+        elif str(request.question[0].name).startswith("drop"):
+            reply = reply + "drop"
+        elif str(request.question[0].name).startswith("custom"):
+            reply = reply + "custom"
+        elif str(request.question[0].name).startswith("timeout"):
             # no response
             continue
         else:
-            reply = reply + 'invalid'
+            reply = reply + "invalid"
 
         remote = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
         remote.connect(responsePath)
@@ -81,45 +82,59 @@ def AsyncResponder(listenPath, responsePath):
 
     sock.close()
 
-asyncResponderSocketPath = '/tmp/async-responder.sock'
-dnsdistSocketPath = '/tmp/dnsdist.sock'
-asyncResponder = threading.Thread(name='Asynchronous Responder', target=AsyncResponder, args=[asyncResponderSocketPath, dnsdistSocketPath])
+
+asyncResponderSocketPath = "/tmp/async-responder.sock"
+dnsdistSocketPath = "/tmp/dnsdist.sock"
+asyncResponder = threading.Thread(
+    name="Asynchronous Responder",
+    target=AsyncResponder,
+    args=[asyncResponderSocketPath, dnsdistSocketPath],
+)
 asyncResponder.daemon = True
 asyncResponder.start()
 
+
 class AsyncTests(object):
-    _serverKey = 'server.key'
-    _serverCert = 'server.chain'
-    _serverName = 'tls.tests.dnsdist.org'
-    _caCert = 'ca.pem'
+    _serverKey = "server.key"
+    _serverCert = "server.chain"
+    _serverName = "tls.tests.dnsdist.org"
+    _caCert = "ca.pem"
     _tlsServerPort = pickAvailablePort()
     _dohWithNGHTTP2ServerPort = pickAvailablePort()
     _dohWithH2OServerPort = pickAvailablePort()
-    _dohWithNGHTTP2BaseURL = ("https://%s:%d/" % (_serverName, _dohWithNGHTTP2ServerPort))
-    _dohWithH2OBaseURL = ("https://%s:%d/" % (_serverName, _dohWithH2OServerPort))
+    _dohWithNGHTTP2BaseURL = "https://%s:%d/" % (_serverName, _dohWithNGHTTP2ServerPort)
+    _dohWithH2OBaseURL = "https://%s:%d/" % (_serverName, _dohWithH2OServerPort)
     _doqServerPort = pickAvailablePort()
 
     def testPass(self):
         """
         Async: Accept
         """
-        for name in ['accept.async.tests.powerdns.com.', 'accept.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "accept.async.tests.powerdns.com.",
+            "accept.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+            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':
+                if method == "sendDOQQueryWrapper":
                     # dnspython sets the ID to 0
                     receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
@@ -128,20 +143,29 @@ class AsyncTests(object):
         """
         Async: Accept (cached)
         """
-        name = 'accept.cache.async.tests.powerdns.com.'
-        query = dns.message.make_query(name, 'A', 'IN')
+        name = "accept.cache.async.tests.powerdns.com."
+        query = dns.message.make_query(name, "A", "IN")
 
         response = dns.message.make_response(query)
-        rrset = dns.rrset.from_text(name,
-                                    60,
-                                    dns.rdataclass.IN,
-                                    dns.rdatatype.A,
-                                    '192.0.2.1')
+        rrset = dns.rrset.from_text(
+            name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+        )
         response.answer.append(rrset)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+        for method in (
+            "sendUDPQuery",
+            "sendTCPQuery",
+            "sendDOTQueryWrapper",
+            "sendDOHWithNGHTTP2QueryWrapper",
+            "sendDOHWithH2OQueryWrapper",
+            "sendDOQQueryWrapper",
+        ):
             sender = getattr(self, method)
-            if method != 'sendDOTQueryWrapper' and method != 'sendDOHWithH2OQueryWrapper' and method != 'sendDOQQueryWrapper':
+            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)
@@ -152,7 +176,7 @@ class AsyncTests(object):
             # second time from the cache
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
-            if method == 'sendDOQQueryWrapper':
+            if method == "sendDOQQueryWrapper":
                 # dnspython sets the ID to 0
                 receivedResponse.id = response.id
             self.assertEqual(response, receivedResponse)
@@ -161,23 +185,31 @@ class AsyncTests(object):
         """
         Async: Timeout then accept
         """
-        for name in ['timeout-then-accept.async.tests.powerdns.com.', 'timeout-then-accept.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "timeout-then-accept.async.tests.powerdns.com.",
+            "timeout-then-accept.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+            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':
+                if method == "sendDOQQueryWrapper":
                     # dnspython sets the ID to 0
                     receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
@@ -186,23 +218,31 @@ class AsyncTests(object):
         """
         Async: Accept then timeout
         """
-        for name in ['accept-then-timeout.async.tests.powerdns.com.', 'accept-then-timeout.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "accept-then-timeout.async.tests.powerdns.com.",
+            "accept-then-timeout.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+            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':
+                if method == "sendDOQQueryWrapper":
                     # dnspython sets the ID to 0
                     receivedResponse.id = response.id
                 self.assertEqual(response, receivedResponse)
@@ -211,27 +251,35 @@ class AsyncTests(object):
         """
         Async: Accept then refuse
         """
-        for name in ['accept-then-refuse.async.tests.powerdns.com.', 'accept-then-refuse.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "accept-then-refuse.async.tests.powerdns.com.",
+            "accept-then-refuse.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
             expectedResponse = dns.message.make_response(query)
             expectedResponse.flags |= dns.flags.RA
             expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+            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':
+                if method == "sendDOQQueryWrapper":
                     # dnspython sets the ID to 0
                     receivedResponse.id = expectedResponse.id
                 self.assertEqual(expectedResponse, receivedResponse)
@@ -240,29 +288,37 @@ class AsyncTests(object):
         """
         Async: Accept then custom
         """
-        for name in ['accept-then-custom.async.tests.powerdns.com.', 'accept-then-custom.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "accept-then-custom.async.tests.powerdns.com.",
+            "accept-then-custom.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
-            expectedQuery = dns.message.make_query(name, '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", "sendDOQQueryWrapper"):
+            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':
+                if method == "sendDOQQueryWrapper":
                     # dnspython sets the ID to 0
                     receivedResponse.id = expectedResponse.id
                 self.assertEqual(expectedResponse, receivedResponse)
@@ -271,18 +327,26 @@ class AsyncTests(object):
         """
         Async: Accept then drop
         """
-        for name in ['accept-then-drop.async.tests.powerdns.com.', 'accept-then-drop.tcp-only.async.tests.powerdns.com.']:
-            query = dns.message.make_query(name, 'A', 'IN')
+        for name in [
+            "accept-then-drop.async.tests.powerdns.com.",
+            "accept-then-drop.tcp-only.async.tests.powerdns.com.",
+        ]:
+            query = dns.message.make_query(name, "A", "IN")
 
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        60,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '192.0.2.1')
+            rrset = dns.rrset.from_text(
+                name, 60, dns.rdataclass.IN, dns.rdatatype.A, "192.0.2.1"
+            )
             response.answer.append(rrset)
 
-            for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+            for method in (
+                "sendUDPQuery",
+                "sendTCPQuery",
+                "sendDOTQueryWrapper",
+                "sendDOHWithNGHTTP2QueryWrapper",
+                "sendDOHWithH2OQueryWrapper",
+                "sendDOQQueryWrapper",
+            ):
                 sender = getattr(self, method)
                 try:
                     if method in ['sendDOQQueryWrapper']:
@@ -301,18 +365,25 @@ class AsyncTests(object):
         """
         Async: Refused
         """
-        name = 'refused.async.tests.powerdns.com.'
-        query = dns.message.make_query(name, 'A', 'IN')
+        name = "refused.async.tests.powerdns.com."
+        query = dns.message.make_query(name, "A", "IN")
 
         expectedResponse = dns.message.make_response(query)
         expectedResponse.flags |= dns.flags.RA
         expectedResponse.set_rcode(dns.rcode.REFUSED)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+        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':
+            if method == "sendDOQQueryWrapper":
                 # dnspython sets the ID to 0
                 receivedResponse.id = expectedResponse.id
             self.assertEqual(expectedResponse, receivedResponse)
@@ -321,10 +392,17 @@ class AsyncTests(object):
         """
         Async: Drop
         """
-        name = 'drop.async.tests.powerdns.com.'
-        query = dns.message.make_query(name, 'A', 'IN')
-
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+        name = "drop.async.tests.powerdns.com."
+        query = dns.message.make_query(name, "A", "IN")
+
+        for method in (
+            "sendUDPQuery",
+            "sendTCPQuery",
+            "sendDOTQueryWrapper",
+            "sendDOHWithNGHTTP2QueryWrapper",
+            "sendDOHWithH2OQueryWrapper",
+            "sendDOQQueryWrapper",
+        ):
             sender = getattr(self, method)
             try:
                 (_, receivedResponse) = sender(query, response=None, useQueue=False)
@@ -336,18 +414,25 @@ class AsyncTests(object):
         """
         Async: Custom answer
         """
-        name = 'custom.async.tests.powerdns.com.'
-        query = dns.message.make_query(name, 'A', 'IN')
+        name = "custom.async.tests.powerdns.com."
+        query = dns.message.make_query(name, "A", "IN")
 
         expectedResponse = dns.message.make_response(query)
         expectedResponse.flags |= dns.flags.RA
         expectedResponse.set_rcode(dns.rcode.FORMERR)
 
-        for method in ("sendUDPQuery", "sendTCPQuery", "sendDOTQueryWrapper", "sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper", "sendDOQQueryWrapper"):
+        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':
+            if method == "sendDOQQueryWrapper":
                 # dnspython sets the ID to 0
                 receivedResponse.id = expectedResponse.id
             self.assertEqual(expectedResponse, receivedResponse)
@@ -361,17 +446,17 @@ class AsyncTests(object):
 
         for method in ("sendDOHWithNGHTTP2QueryWrapper", "sendDOHWithH2OQueryWrapper"):
             sender = getattr(self, method)
-            name = 'timeout-then-accept.' + method + '.tc.async.tests.powerdns.com.'
-            query = dns.message.make_query(name, 'A', 'IN')
+            name = "timeout-then-accept." + method + ".tc.async.tests.powerdns.com."
+            query = dns.message.make_query(name, "A", "IN")
             query.id = 42
-            expectedQuery = dns.message.make_query(name, 'A', 'IN', use_edns=True, payload=4096)
+            expectedQuery = dns.message.make_query(
+                name, "A", "IN", use_edns=True, payload=4096
+            )
             expectedQuery.id = 42
             response = dns.message.make_response(query)
-            rrset = dns.rrset.from_text(name,
-                                        3600,
-                                        dns.rdataclass.IN,
-                                        dns.rdatatype.A,
-                                        '127.0.0.1')
+            rrset = dns.rrset.from_text(
+                name, 3600, dns.rdataclass.IN, dns.rdatatype.A, "127.0.0.1"
+            )
             response.answer.append(rrset)
 
             # first response is a TC=1
@@ -397,7 +482,8 @@ class AsyncTests(object):
             self.assertEqual(expectedQuery, receivedQuery)
             self.checkQueryEDNSWithoutECS(expectedQuery, receivedQuery)
 
-@unittest.skipIf('SKIP_DOH_TESTS' in os.environ, 'DNS over HTTPS tests are disabled')
+
+@unittest.skipIf("SKIP_DOH_TESTS" in os.environ, "DNS over HTTPS tests are disabled")
 class TestAsyncFFI(DNSDistTest, AsyncTests):
     _config_template = """
     newServer{address="127.0.0.1:%d", pool={'', 'cache'}}
@@ -528,10 +614,28 @@ class TestAsyncFFI(DNSDistTest, AsyncTests):
     """
     _asyncResponderSocketPath = asyncResponderSocketPath
     _dnsdistSocketPath = dnsdistSocketPath
-    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_doqServerPort', '_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')
+
+@unittest.skipIf("SKIP_DOH_TESTS" in os.environ, "DNS over HTTPS tests are disabled")
 class TestAsyncLua(DNSDistTest, AsyncTests):
     _config_template = """
     newServer{address="127.0.0.1:%d", pool={'', 'cache'}}
@@ -643,5 +747,22 @@ class TestAsyncLua(DNSDistTest, AsyncTests):
     """
     _asyncResponderSocketPath = asyncResponderSocketPath
     _dnsdistSocketPath = dnsdistSocketPath
-    _config_params = ['_testServerPort', '_testServerPort', '_tlsServerPort', '_serverCert', '_serverKey', '_dohWithH2OServerPort', '_serverCert', '_serverKey', '_dohWithNGHTTP2ServerPort', '_serverCert', '_serverKey', '_doqServerPort', '_serverCert', '_serverKey', '_asyncResponderSocketPath', '_dnsdistSocketPath']
+    _config_params = [
+        "_testServerPort",
+        "_testServerPort",
+        "_tlsServerPort",
+        "_serverCert",
+        "_serverKey",
+        "_dohWithH2OServerPort",
+        "_serverCert",
+        "_serverKey",
+        "_dohWithNGHTTP2ServerPort",
+        "_serverCert",
+        "_serverKey",
+        "_doqServerPort",
+        "_serverCert",
+        "_serverKey",
+        "_asyncResponderSocketPath",
+        "_dnsdistSocketPath",
+    ]
     _verboseMode = True