dnsdist: Preserve 'LLVM_PROFILE_FILE' in sudo-enabled regression tests

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

diff --git a/regression-tests.dnsdist/test_Routing.py b/regression-tests.dnsdist/test_Routing.py
index 8c5e337b58e15dfd8a1589c859f7a0a1d7ee00db..d0ceeafd979c092a98da0505380307580062fda6 100644 (file)
--- a/regression-tests.dnsdist/test_Routing.py
+++ b/regression-tests.dnsdist/test_Routing.py
@@ -3,13 +3,20 @@ import base64
 import threading
 import time
 import dns
-from dnsdisttests import DNSDistTest
+from dnsdisttests import DNSDistTest, pickAvailablePort
 
 class TestRoutingPoolRouting(DNSDistTest):
 
     _config_template = """
     newServer{address="127.0.0.1:%s", pool="real"}
-    addAction(makeRule("poolaction.routing.tests.powerdns.com"), PoolAction("real"))
+    addAction(SuffixMatchNodeRule("poolaction.routing.tests.powerdns.com"), PoolAction("real"))
+    -- by default PoolAction stops the processing so the second rule should not be executed
+    addAction(SuffixMatchNodeRule("poolaction.routing.tests.powerdns.com"), PoolAction("not-real"))
+
+    -- this time we configure PoolAction to not stop the processing
+    addAction(SuffixMatchNodeRule("poolaction-nostop.routing.tests.powerdns.com"), PoolAction("no-real", false))
+    -- so the second rule should be executed
+    addAction(SuffixMatchNodeRule("poolaction-nostop.routing.tests.powerdns.com"), PoolAction("real"))
     """
 
     def testPolicyPoolAction(self):
@@ -33,8 +40,29 @@ class TestRoutingPoolRouting(DNSDistTest):
             sender = getattr(self, method)
             (receivedQuery, receivedResponse) = sender(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
+
+    def testPolicyPoolActionNoStop(self):
+        """
+        Routing: Set pool by qname via PoolAction (no stop)
+        """
+        name = 'poolaction-nostop.routing.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')
+        response.answer.append(rrset)
+
+        for method in ("sendUDPQuery", "sendTCPQuery"):
+            sender = getattr(self, method)
+            (receivedQuery, receivedResponse) = sender(query, response)
+            receivedQuery.id = query.id
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
     def testDefaultPool(self):
         """
@@ -50,12 +78,12 @@ class TestRoutingPoolRouting(DNSDistTest):
         for method in ("sendUDPQuery", "sendTCPQuery"):
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
-            self.assertEquals(receivedResponse, None)
+            self.assertEqual(receivedResponse, None)
 
 class TestRoutingQPSPoolRouting(DNSDistTest):
     _config_template = """
     newServer{address="127.0.0.1:%s", pool="regular"}
-    addAction(makeRule("qpspoolaction.routing.tests.powerdns.com"), QPSPoolAction(10, "regular"))
+    addAction(SuffixMatchNodeRule("qpspoolaction.routing.tests.powerdns.com"), QPSPoolAction(10, "regular"))
     """
 
     def testQPSPoolAction(self):
@@ -80,13 +108,13 @@ class TestRoutingQPSPoolRouting(DNSDistTest):
         for _ in range(maxQPS):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         # we should now be sent to the "abuse" pool which is empty,
         # so the queries should be dropped
         (_, receivedResponse) = self.sendUDPQuery(query, response=None, useQueue=False)
-        self.assertEquals(receivedResponse, None)
+        self.assertEqual(receivedResponse, None)
 
         time.sleep(1)
 
@@ -94,17 +122,17 @@ class TestRoutingQPSPoolRouting(DNSDistTest):
         for _ in range(maxQPS):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
 
         (_, receivedResponse) = self.sendTCPQuery(query, response=None, useQueue=False)
-        self.assertEquals(receivedResponse, None)
+        self.assertEqual(receivedResponse, None)
 
 
 class TestRoutingRoundRobinLB(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(roundrobin)
@@ -118,18 +146,18 @@ class TestRoutingRoundRobinLB(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testRR(self):
@@ -155,22 +183,22 @@ class TestRoutingRoundRobinLB(DNSDistTest):
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for key in self._responsesCounter:
             value = self._responsesCounter[key]
-            self.assertEquals(value, numberOfQueries / 2)
+            self.assertEqual(value, numberOfQueries / 2)
 
 class TestRoutingRoundRobinLBOneDown(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(roundrobin)
@@ -203,14 +231,14 @@ class TestRoutingRoundRobinLBOneDown(DNSDistTest):
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         total = 0
         for key in self._responsesCounter:
@@ -218,11 +246,11 @@ class TestRoutingRoundRobinLBOneDown(DNSDistTest):
             self.assertTrue(value == numberOfQueries or value == 0)
             total += value
 
-        self.assertEquals(total, numberOfQueries * 2)
+        self.assertEqual(total, numberOfQueries * 2)
 
 class TestRoutingRoundRobinLBAllDown(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(roundrobin)
@@ -251,11 +279,11 @@ class TestRoutingRoundRobinLBAllDown(DNSDistTest):
         for method in ("sendUDPQuery", "sendTCPQuery"):
             sender = getattr(self, method)
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
-            self.assertEquals(receivedResponse, None)
+            self.assertEqual(receivedResponse, None)
 
 class TestRoutingLuaFFIPerThreadRoundRobinLB(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     -- otherwise we start too many TCP workers, and as each thread
@@ -282,18 +310,18 @@ class TestRoutingLuaFFIPerThreadRoundRobinLB(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testRR(self):
@@ -319,22 +347,22 @@ class TestRoutingLuaFFIPerThreadRoundRobinLB(DNSDistTest):
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for key in self._responsesCounter:
             value = self._responsesCounter[key]
-            self.assertEquals(value, numberOfQueries / 2)
+            self.assertEqual(value, numberOfQueries / 2)
 
 class TestRoutingOrder(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(firstAvailable)
@@ -348,18 +376,18 @@ class TestRoutingOrder(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testOrder(self):
@@ -386,21 +414,21 @@ class TestRoutingOrder(DNSDistTest):
                 sender = getattr(self, method)
                 (receivedQuery, receivedResponse) = sender(query, response)
                 receivedQuery.id = query.id
-                self.assertEquals(query, receivedQuery)
-                self.assertEquals(response, receivedResponse)
+                self.assertEqual(query, receivedQuery)
+                self.assertEqual(response, receivedResponse)
 
         total = 0
         if 'UDP Responder' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['UDP Responder'], 0)
-        self.assertEquals(self._responsesCounter['UDP Responder 2'], numberOfQueries)
+            self.assertEqual(self._responsesCounter['UDP Responder'], 0)
+        self.assertEqual(self._responsesCounter['UDP Responder 2'], numberOfQueries)
         if 'TCP Responder' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['TCP Responder'], 0)
-        self.assertEquals(self._responsesCounter['TCP Responder 2'], numberOfQueries)
+            self.assertEqual(self._responsesCounter['TCP Responder'], 0)
+        self.assertEqual(self._responsesCounter['TCP Responder 2'], numberOfQueries)
 
 class TestFirstAvailableQPSPacketCacheHits(DNSDistTest):
 
     _verboseMode = True
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(firstAvailable)
@@ -416,18 +444,18 @@ class TestFirstAvailableQPSPacketCacheHits(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testOrderQPSCacheHits(self):
@@ -455,20 +483,20 @@ class TestFirstAvailableQPSPacketCacheHits(DNSDistTest):
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = query.id
-        self.assertEquals(query, receivedQuery)
-        self.assertEquals(receivedResponse, response)
+        self.assertEqual(query, receivedQuery)
+        self.assertEqual(receivedResponse, response)
         (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = query.id
-        self.assertEquals(query, receivedQuery)
-        self.assertEquals(receivedResponse, response)
+        self.assertEqual(query, receivedQuery)
+        self.assertEqual(receivedResponse, response)
 
         for _ in range(numberOfQueries):
             for method in ("sendUDPQuery", "sendTCPQuery"):
                 sender = getattr(self, method)
                 (_, receivedResponse) = sender(query, response=None, useQueue=False)
-                self.assertEquals(receivedResponse, response)
+                self.assertEqual(receivedResponse, response)
 
         numberOfQueries = 10
         name = 'order-qps-cache-2.routing.tests.powerdns.com.'
@@ -486,20 +514,20 @@ class TestFirstAvailableQPSPacketCacheHits(DNSDistTest):
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = query.id
-        self.assertEquals(query, receivedQuery)
-        self.assertEquals(receivedResponse, response)
+        self.assertEqual(query, receivedQuery)
+        self.assertEqual(receivedResponse, response)
         (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
         self.assertTrue(receivedQuery)
         self.assertTrue(receivedResponse)
         receivedQuery.id = query.id
-        self.assertEquals(query, receivedQuery)
-        self.assertEquals(receivedResponse, response)
+        self.assertEqual(query, receivedQuery)
+        self.assertEqual(receivedResponse, response)
 
         for _ in range(numberOfQueries):
             for method in ("sendUDPQuery", "sendTCPQuery"):
                 sender = getattr(self, method)
                 (_, receivedResponse) = sender(query, response=None, useQueue=False)
-                self.assertEquals(receivedResponse, response)
+                self.assertEqual(receivedResponse, response)
 
         # 4 queries should made it through, 2 UDP and 2 TCP
         for k,v in self._responsesCounter.items():
@@ -507,11 +535,11 @@ class TestFirstAvailableQPSPacketCacheHits(DNSDistTest):
             print(v)
 
         if 'UDP Responder' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['UDP Responder'], 0)
-        self.assertEquals(self._responsesCounter['UDP Responder 2'], 2)
+            self.assertEqual(self._responsesCounter['UDP Responder'], 0)
+        self.assertEqual(self._responsesCounter['UDP Responder 2'], 2)
         if 'TCP Responder' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['TCP Responder'], 0)
-        self.assertEquals(self._responsesCounter['TCP Responder 2'], 2)
+            self.assertEqual(self._responsesCounter['TCP Responder'], 0)
+        self.assertEqual(self._responsesCounter['TCP Responder 2'], 2)
 
 class TestRoutingNoServer(DNSDistTest):
 
@@ -545,11 +573,11 @@ class TestRoutingNoServer(DNSDistTest):
             (_, receivedResponse) = sender(query, response=None, useQueue=False)
             self.checkMessageEDNSWithoutOptions(expectedResponse, receivedResponse)
             self.assertFalse(receivedResponse.ednsflags & dns.flags.DO)
-            self.assertEquals(receivedResponse.payload, 1232)
+            self.assertEqual(receivedResponse.payload, 1232)
 
 class TestRoutingWRandom(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _config_params = ['_testServerPort', '_testServer2Port']
     _config_template = """
     setServerPolicy(wrandom)
@@ -563,18 +591,18 @@ class TestRoutingWRandom(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testWRandom(self):
@@ -600,14 +628,14 @@ class TestRoutingWRandom(DNSDistTest):
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         # The lower weight downstream should receive less than half the queries
         self.assertLess(self._responsesCounter['UDP Responder'], numberOfQueries * 0.50)
@@ -620,7 +648,7 @@ class TestRoutingWRandom(DNSDistTest):
 
 class TestRoutingHighValueWRandom(DNSDistTest):
 
-    _testServer2Port = 5351
+    _testServer2Port = pickAvailablePort()
     _consoleKey = DNSDistTest.generateConsoleKey()
     _consoleKeyB64 = base64.b64encode(_consoleKey).decode('ascii')
     _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort', '_testServer2Port']
@@ -638,18 +666,18 @@ class TestRoutingHighValueWRandom(DNSDistTest):
     def startResponders(cls):
         print("Launching responders..")
         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder.setDaemon(True)
+        cls._UDPResponder.daemon = True
         cls._UDPResponder.start()
         cls._UDPResponder2 = threading.Thread(name='UDP Responder 2', target=cls.UDPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._UDPResponder2.setDaemon(True)
+        cls._UDPResponder2.daemon = True
         cls._UDPResponder2.start()
 
         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder.setDaemon(True)
+        cls._TCPResponder.daemon = True
         cls._TCPResponder.start()
 
         cls._TCPResponder2 = threading.Thread(name='TCP Responder 2', target=cls.TCPResponder, args=[cls._testServer2Port, cls._toResponderQueue, cls._fromResponderQueue])
-        cls._TCPResponder2.setDaemon(True)
+        cls._TCPResponder2.daemon = True
         cls._TCPResponder2.start()
 
     def testHighValueWRandom(self):
@@ -676,14 +704,14 @@ class TestRoutingHighValueWRandom(DNSDistTest):
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         for _ in range(numberOfQueries):
             (receivedQuery, receivedResponse) = self.sendTCPQuery(query, response)
             receivedQuery.id = query.id
-            self.assertEquals(query, receivedQuery)
-            self.assertEquals(response, receivedResponse)
+            self.assertEqual(query, receivedQuery)
+            self.assertEqual(response, receivedResponse)
 
         stats = self.sendConsoleCommand("dumpStats()").split()
         stats_dict = {}
@@ -694,7 +722,7 @@ class TestRoutingHighValueWRandom(DNSDistTest):
                 stats_dict[x] = stats[i+1]
 
         # There should be no queries getting "no-policy" responses
-        self.assertEquals(stats_dict['no-policy'], '0')
+        self.assertEqual(stats_dict['no-policy'], '0')
 
         # Each downstream should receive some queries, but it will be unbalanced
         # because the sum of the weights is higher than INT_MAX.
@@ -704,33 +732,6 @@ class TestRoutingHighValueWRandom(DNSDistTest):
 
         # The second downstream will receive the remainder of the queries, but it might very well be 0
         if 'UDP Responder 2' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['UDP Responder 2'], numberOfQueries - self._responsesCounter['UDP Responder'])
+            self.assertEqual(self._responsesCounter['UDP Responder 2'], numberOfQueries - self._responsesCounter['UDP Responder'])
         if 'TCP Responder 2' in self._responsesCounter:
-            self.assertEquals(self._responsesCounter['TCP Responder 2'], numberOfQueries - self._responsesCounter['TCP Responder'])
-
-class TestRoutingBadWeightWRandom(DNSDistTest):
-
-    _testServer2Port = 5351
-    _consoleKey = DNSDistTest.generateConsoleKey()
-    _consoleKeyB64 = base64.b64encode(_consoleKey).decode('ascii')
-    _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort', '_testServer2Port']
-    _config_template = """
-    setKey("%s")
-    controlSocket("127.0.0.1:%s")
-    setServerPolicy(wrandom)
-    s1 = newServer{address="127.0.0.1:%s", weight=-1}
-    s2 = newServer{address="127.0.0.1:%s", weight=2147483648}
-    """
-    _checkConfigExpectedOutput = b"""Error creating new server: downstream weight value must be greater than 0.
-Error creating new server: downstream weight value must be between 1 and 2147483647
-Configuration 'configs/dnsdist_TestRoutingBadWeightWRandom.conf' OK!
-"""
-
-    def testBadWeightWRandom(self):
-        """
-        Routing: WRandom
-
-        Test that downstreams cannot be added with invalid weights.
-        """
-        # There should be no downstreams
-        self.assertTrue(self.sendConsoleCommand("getServer(0)").startswith("Error"))
+            self.assertEqual(self._responsesCounter['TCP Responder 2'], numberOfQueries - self._responsesCounter['TCP Responder'])