assert_quiescent_pool_state: Use plain asserts

Author: Lorak-mmk

tests/integration/simulacron/test_connection.py

@@ -185,7 +185,7 @@ def test_callbacks_and_pool_when_oto(self):
         with pytest.raises(OperationTimedOut):
             future.result()
 
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
 
         time.sleep(server_delay + 1)
         # PYTHON-630 -- only the errback should be called
@@ -358,11 +358,11 @@ def test_retry_after_defunct(self):
 
         # Might take some time to close the previous connections and reconnect
         time.sleep(10)
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
         clear_queries()
 
         time.sleep(10)
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
 
     def test_idle_connection_is_not_closed(self):
         """
@@ -425,7 +425,7 @@ def test_host_is_not_set_to_down_after_query_oto(self):
             assert isinstance(f._final_exception, OperationTimedOut)
 
         assert listener.hosts_marked_down == []
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
 
     def test_can_shutdown_connection_subclass(self):
         start_and_prime_singledc()

tests/integration/standard/test_authentication.py

@@ -107,7 +107,7 @@ def test_auth_connect(self):
             session = cluster.connect(wait_for_all_pools=True)
             try:
                 assert session.execute("SELECT release_version FROM system.local WHERE key='local'")
-                assert_quiescent_pool_state(self, cluster, wait=1)
+                assert_quiescent_pool_state(cluster, wait=1)
                 for pool in session.get_pools():
                     connection, _ = pool.borrow_connection(timeout=0)
                     assert connection.authenticator.server_authenticator_class == 'org.apache.cassandra.auth.PasswordAuthenticator'
@@ -116,15 +116,15 @@ def test_auth_connect(self):
                 cluster.shutdown()
         finally:
             root_session.execute('DROP USER %s', user)
-            assert_quiescent_pool_state(self, root_session.cluster, wait=1)
+            assert_quiescent_pool_state(root_session.cluster, wait=1)
             root_session.cluster.shutdown()
 
     def test_connect_wrong_pwd(self):
         cluster = self.cluster_as('cassandra', 'wrong_pass')
         try:
             with pytest.raises(NoHostAvailable, match='.*AuthenticationFailed.'):
                 cluster.connect()
-            assert_quiescent_pool_state(self, cluster)
+            assert_quiescent_pool_state(cluster)
         finally:
             cluster.shutdown()
 
@@ -133,7 +133,7 @@ def test_connect_wrong_username(self):
         try:
             with pytest.raises(NoHostAvailable, match='.*AuthenticationFailed.*'):
                 cluster.connect()
-            assert_quiescent_pool_state(self, cluster)
+            assert_quiescent_pool_state(cluster)
         finally:
             cluster.shutdown()
 
@@ -142,7 +142,7 @@ def test_connect_empty_pwd(self):
         try:
             with pytest.raises(NoHostAvailable, match='.*AuthenticationFailed.*'):
                 cluster.connect()
-            assert_quiescent_pool_state(self, cluster)
+            assert_quiescent_pool_state(cluster)
         finally:
             cluster.shutdown()
 
@@ -151,7 +151,7 @@ def test_connect_no_auth_provider(self):
         try:
             with pytest.raises(NoHostAvailable, match='.*AuthenticationFailed.*'):
                 cluster.connect()
-            assert_quiescent_pool_state(self, cluster)
+            assert_quiescent_pool_state(cluster)
         finally:
             cluster.shutdown()
 

tests/integration/standard/test_cluster.py

@@ -781,7 +781,7 @@ def test_idle_heartbeat(self):
 
         cluster._idle_heartbeat.stop()
         cluster._idle_heartbeat.join()
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
 
         cluster.shutdown()
 
@@ -829,7 +829,7 @@ def test_pool_management(self):
         cluster.refresh_schema_metadata()
         cluster.refresh_schema_metadata(max_schema_agreement_wait=0)
 
-        assert_quiescent_pool_state(self, cluster)
+        assert_quiescent_pool_state(cluster)
 
         cluster.shutdown()
 

tests/integration/util.py

@@ -18,14 +18,14 @@
 import time
 
 
-def assert_quiescent_pool_state(test_case, cluster, wait=None):
+def assert_quiescent_pool_state(cluster, wait=None):
     """
     Checking the quiescent pool state checks that none of the requests ids have
     been lost. However, the callback corresponding to a request_id is called
     before the request_id is returned back to the pool, therefore
 
     session.execute("SELECT * from system.local")
-    assert_quiescent_pool_state(self, session.cluster)
+    assert_quiescent_pool_state(session.cluster)
 
     (with no wait) might fail because when execute comes back the request_id
     hasn't yet been returned to the pool, therefore the wait.
@@ -35,23 +35,23 @@ def assert_quiescent_pool_state(test_case, cluster, wait=None):
 
     for session in cluster.sessions:
         pool_states = session.get_pool_state().values()
-        test_case.assertTrue(pool_states)
+        assert pool_states
 
         for state in pool_states:
-            test_case.assertFalse(state['shutdown'])
-            test_case.assertGreater(state['open_count'], 0)
+            assert not state['shutdown']
+            assert state['open_count'] > 0
             no_in_flight = all((i == 0 for i in state['in_flights']))
             orphans_and_inflights = zip(state['orphan_requests'],state['in_flights'])
             all_orphaned = all((len(orphans) == inflight for (orphans,inflight) in orphans_and_inflights))
-            test_case.assertTrue(no_in_flight or all_orphaned)
+            assert no_in_flight or all_orphaned
 
     for holder in cluster.get_connection_holders():
         for connection in holder.get_connections():
             # all ids are unique
             req_ids = connection.request_ids
             orphan_ids = connection.orphaned_request_ids
-            test_case.assertEqual(len(req_ids), len(set(req_ids)))
-            test_case.assertEqual(connection.highest_request_id, len(req_ids) + len(orphan_ids) - 1)
-            test_case.assertEqual(connection.highest_request_id, max(chain(req_ids, orphan_ids)))
+            assert len(req_ids) == len(set(req_ids))
+            assert connection.highest_request_id == len(req_ids) + len(orphan_ids) - 1
+            assert connection.highest_request_id == max(chain(req_ids, orphan_ids))
             if PROTOCOL_VERSION < 3:
-                test_case.assertEqual(connection.highest_request_id, connection.max_request_id)
+                assert connection.highest_request_id == connection.max_request_id