Fixed a number of test failures

Author: agronholm

tests/test_asyncio/test_connection_pool.py

@@ -13,6 +13,8 @@
 from .conftest import asynccontextmanager
 from .test_pubsub import wait_for_message
 
+pytestmark = pytest.mark.asyncio
+
 
 @pytest.mark.onlynoncluster
 class TestRedisAutoReleaseConnectionPool:
@@ -40,15 +42,13 @@ def has_no_connected_connections(pool: redis.ConnectionPool):
             for x in pool._available_connections + list(pool._in_use_connections)
         )
 
-    @pytest.mark.asyncio
     async def test_auto_disconnect_redis_created_pool(self, r: redis.Redis):
         new_conn = await self.create_two_conn(r)
         assert new_conn != r.connection
         assert self.get_total_connected_connections(r.connection_pool) == 2
         await r.aclose()
         assert self.has_no_connected_connections(r.connection_pool)
 
-    @pytest.mark.asyncio
     async def test_do_not_auto_disconnect_redis_created_pool(self, r2: redis.Redis):
         assert r2.auto_close_connection_pool is False, (
             "The connection pool should not be disconnected as a manually created "
@@ -62,7 +62,6 @@ async def test_do_not_auto_disconnect_redis_created_pool(self, r2: redis.Redis):
         assert len(r2.connection_pool._available_connections) == 1
         assert r2.connection_pool._available_connections[0].is_connected
 
-    @pytest.mark.asyncio
     async def test_auto_release_override_true_manual_created_pool(self, r: redis.Redis):
         assert r.auto_close_connection_pool is True, "This is from the class fixture"
         await self.create_two_conn(r)
@@ -74,15 +73,13 @@ async def test_auto_release_override_true_manual_created_pool(self, r: redis.Red
         assert self.has_no_connected_connections(r.connection_pool)
 
     @pytest.mark.parametrize("auto_close_conn_pool", [True, False])
-    @pytest.mark.asyncio
     async def test_close_override(self, r: redis.Redis, auto_close_conn_pool):
         r.auto_close_connection_pool = auto_close_conn_pool
         await self.create_two_conn(r)
         await r.aclose(close_connection_pool=True)
         assert self.has_no_connected_connections(r.connection_pool)
 
     @pytest.mark.parametrize("auto_close_conn_pool", [True, False])
-    @pytest.mark.asyncio
     async def test_negate_auto_close_client_pool(
         self, r: redis.Redis, auto_close_conn_pool
     ):
@@ -139,7 +136,6 @@ async def get_pool(
         finally:
             await pool.disconnect(inuse_connections=True)
 
-    @pytest.mark.asyncio
     async def test_connection_creation(self):
         connection_kwargs = {"foo": "bar", "biz": "baz"}
         async with self.get_pool(
@@ -149,7 +145,6 @@ async def test_connection_creation(self):
             assert isinstance(connection, DummyConnection)
             assert connection.kwargs == connection_kwargs
 
-    @pytest.mark.asyncio
     async def test_aclosing(self):
         connection_kwargs = {"foo": "bar", "biz": "baz"}
         pool = redis.ConnectionPool(
@@ -160,15 +155,13 @@ async def test_aclosing(self):
         async with aclosing(pool):
             pass
 
-    @pytest.mark.asyncio
     async def test_multiple_connections(self, master_host):
         connection_kwargs = {"host": master_host[0]}
         async with self.get_pool(connection_kwargs=connection_kwargs) as pool:
             c1 = await pool.get_connection()
             c2 = await pool.get_connection()
             assert c1 != c2
 
-    @pytest.mark.asyncio
     async def test_max_connections(self, master_host):
         connection_kwargs = {"host": master_host[0]}
         async with self.get_pool(
@@ -179,7 +172,6 @@ async def test_max_connections(self, master_host):
             with pytest.raises(redis.ConnectionError):
                 await pool.get_connection()
 
-    @pytest.mark.asyncio
     async def test_reuse_previously_released_connection(self, master_host):
         connection_kwargs = {"host": master_host[0]}
         async with self.get_pool(connection_kwargs=connection_kwargs) as pool:
@@ -188,7 +180,6 @@ async def test_reuse_previously_released_connection(self, master_host):
             c2 = await pool.get_connection()
             assert c1 == c2
 
-    @pytest.mark.asyncio
     async def test_repr_contains_db_info_tcp(self):
         connection_kwargs = {
             "host": "localhost",
@@ -202,7 +193,6 @@ async def test_repr_contains_db_info_tcp(self):
             expected = "host=localhost,port=6379,db=1,client_name=test-client"
             assert expected in repr(pool)
 
-    @pytest.mark.asyncio
     async def test_repr_contains_db_info_unix(self):
         connection_kwargs = {"path": "/abc", "db": 1, "client_name": "test-client"}
         async with self.get_pool(
@@ -228,7 +218,6 @@ async def get_pool(self, connection_kwargs=None, max_connections=10, timeout=20)
         finally:
             await pool.disconnect(inuse_connections=True)
 
-    @pytest.mark.asyncio
     async def test_connection_creation(self, master_host):
         connection_kwargs = {
             "foo": "bar",
@@ -241,7 +230,6 @@ async def test_connection_creation(self, master_host):
             assert isinstance(connection, DummyConnection)
             assert connection.kwargs == connection_kwargs
 
-    @pytest.mark.asyncio
     async def test_disconnect(self, master_host):
         """A regression test for #1047"""
         connection_kwargs = {
@@ -254,15 +242,13 @@ async def test_disconnect(self, master_host):
             await pool.get_connection()
             await pool.disconnect()
 
-    @pytest.mark.asyncio
     async def test_multiple_connections(self, master_host):
         connection_kwargs = {"host": master_host[0], "port": master_host[1]}
         async with self.get_pool(connection_kwargs=connection_kwargs) as pool:
             c1 = await pool.get_connection()
             c2 = await pool.get_connection()
             assert c1 != c2
 
-    @pytest.mark.asyncio
     async def test_connection_pool_blocks_until_timeout(self, master_host):
         """When out of connections, block for timeout seconds, then raise"""
         connection_kwargs = {"host": master_host[0]}
@@ -279,7 +265,6 @@ async def test_connection_pool_blocks_until_timeout(self, master_host):
             assert asyncio.get_running_loop().time() - start >= 0.05
             await c1.disconnect()
 
-    @pytest.mark.asyncio
     async def test_connection_pool_blocks_until_conn_available(self, master_host):
         """
         When out of connections, block until another connection is released
@@ -300,7 +285,6 @@ async def target():
             stop = asyncio.get_running_loop().time()
             assert (stop - start) <= 0.2
 
-    @pytest.mark.asyncio
     async def test_reuse_previously_released_connection(self, master_host):
         connection_kwargs = {"host": master_host[0]}
         async with self.get_pool(connection_kwargs=connection_kwargs) as pool:
@@ -592,7 +576,6 @@ def get_connection(self):
 
 
 class TestConnection:
-    @pytest.mark.asyncio
     async def test_on_connect_error(self):
         """
         An error in Connection.on_connect should disconnect from the server
@@ -611,7 +594,6 @@ async def test_on_connect_error(self):
     @pytest.mark.onlynoncluster
     @skip_if_server_version_lt("2.8.8")
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_busy_loading_disconnects_socket(self, r):
         """
         If Redis raises a LOADING error, the connection should be
@@ -625,7 +607,6 @@ async def test_busy_loading_disconnects_socket(self, r):
     @pytest.mark.onlynoncluster
     @skip_if_server_version_lt("2.8.8")
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_busy_loading_from_pipeline_immediate_command(self, r):
         """
         BusyLoadingErrors should raise from Pipelines that execute a
@@ -644,7 +625,6 @@ async def test_busy_loading_from_pipeline_immediate_command(self, r):
     @pytest.mark.onlynoncluster
     @skip_if_server_version_lt("2.8.8")
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_busy_loading_from_pipeline(self, r):
         """
         BusyLoadingErrors should be raised from a pipeline execution
@@ -661,14 +641,12 @@ async def test_busy_loading_from_pipeline(self, r):
 
     @skip_if_server_version_lt("2.8.8")
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_read_only_error(self, r):
         """READONLY errors get turned into ReadOnlyError exceptions"""
         with pytest.raises(redis.ReadOnlyError):
             await r.execute_command("DEBUG", "ERROR", "READONLY blah blah")
 
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_oom_error(self, r):
         """OOM errors get turned into OutOfMemoryError exceptions"""
         with pytest.raises(redis.OutOfMemoryError):
@@ -701,7 +679,6 @@ def test_connect_from_url_unix(self):
         )
 
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_connect_no_auth_supplied_when_required(self, r):
         """
         AuthenticationError should be raised when the server requires a
@@ -713,7 +690,6 @@ async def test_connect_no_auth_supplied_when_required(self, r):
             )
 
     @skip_if_redis_enterprise()
-    @pytest.mark.asyncio
     async def test_connect_invalid_password_supplied(self, r):
         """AuthenticationError should be raised when sending the wrong password"""
         with pytest.raises(redis.AuthenticationError):
@@ -744,14 +720,12 @@ def assert_interval_advanced(self, connection):
         diff = connection.next_health_check - asyncio.get_running_loop().time()
         assert self.interval >= diff > (self.interval - 1)
 
-    @pytest.mark.asyncio
     async def test_health_check_runs(self, r):
         if r.connection:
             r.connection.next_health_check = asyncio.get_running_loop().time() - 1
             await r.connection.check_health()
             self.assert_interval_advanced(r.connection)
 
-    @pytest.mark.asyncio
     async def test_arbitrary_command_invokes_health_check(self, r):
         # invoke a command to make sure the connection is entirely setup
         if r.connection:
@@ -765,7 +739,6 @@ async def test_arbitrary_command_invokes_health_check(self, r):
 
             self.assert_interval_advanced(r.connection)
 
-    @pytest.mark.asyncio
     async def test_arbitrary_command_advances_next_health_check(self, r):
         if r.connection:
             await r.get("foo")
@@ -775,7 +748,6 @@ async def test_arbitrary_command_advances_next_health_check(self, r):
             await r.get("foo")
             assert next_health_check < r.connection.next_health_check
 
-    @pytest.mark.asyncio
     async def test_health_check_not_invoked_within_interval(self, r):
         if r.connection:
             await r.get("foo")
@@ -786,7 +758,6 @@ async def test_health_check_not_invoked_within_interval(self, r):
                 ping_call_spec = (("PING",), {"check_health": False})
                 assert ping_call_spec not in m.call_args_list
 
-    @pytest.mark.asyncio
     async def test_health_check_in_pipeline(self, r):
         async with r.pipeline(transaction=False) as pipe:
             pipe.connection = await pipe.connection_pool.get_connection()
@@ -798,7 +769,6 @@ async def test_health_check_in_pipeline(self, r):
                 m.assert_any_call("PING", check_health=False)
                 assert responses == [True, b"bar"]
 
-    @pytest.mark.asyncio
     async def test_health_check_in_transaction(self, r):
         async with r.pipeline(transaction=True) as pipe:
             pipe.connection = await pipe.connection_pool.get_connection()
@@ -810,7 +780,6 @@ async def test_health_check_in_transaction(self, r):
                 m.assert_any_call("PING", check_health=False)
                 assert responses == [True, b"bar"]
 
-    @pytest.mark.asyncio
     async def test_health_check_in_watched_pipeline(self, r):
         await r.set("foo", "bar")
         async with r.pipeline(transaction=False) as pipe:
@@ -835,7 +804,6 @@ async def test_health_check_in_watched_pipeline(self, r):
                 assert responses == [True, b"not-bar"]
                 m.assert_any_call("PING", check_health=False)
 
-    @pytest.mark.asyncio
     async def test_health_check_in_pubsub_before_subscribe(self, r):
         """A health check happens before the first [p]subscribe"""
         p = r.pubsub()
@@ -855,7 +823,6 @@ async def test_health_check_in_pubsub_before_subscribe(self, r):
             subscribe_message = await wait_for_message(p)
             assert subscribe_message["type"] == "subscribe"
 
-    @pytest.mark.asyncio
     async def test_health_check_in_pubsub_after_subscribed(self, r):
         """
         Pubsub can handle a new subscribe when it's time to check the
@@ -896,7 +863,6 @@ async def test_health_check_in_pubsub_after_subscribed(self, r):
             m.assert_any_call("PING", p.HEALTH_CHECK_MESSAGE, check_health=False)
             self.assert_interval_advanced(p.connection)
 
-    @pytest.mark.asyncio
     async def test_health_check_in_pubsub_poll(self, r):
         """
         Polling a pubsub connection that's subscribed will regularly