@sanderegg review: rename as paused_container (last)

Author: pcrespov

packages/pytest-simcore/src/pytest_simcore/docker.py

@@ -47,7 +47,7 @@ async def _pause_docker_container(
 
 
 @pytest.fixture
-async def pause_container() -> Callable[[str], AbstractAsyncContextManager[None]]:
+async def paused_container() -> Callable[[str], AbstractAsyncContextManager[None]]:
     @contextlib.asynccontextmanager
     async def _(container_name: str) -> AsyncIterator[None]:
         async with aiodocker.Docker() as docker_client, _pause_docker_container(

packages/service-library/tests/deferred_tasks/test_deferred_tasks.py

@@ -342,17 +342,17 @@ def __init__(
         self,
         redis_client: RedisClientSDK,
         rabbit_client: RabbitMQClient,
-        pause_container_in_context: Callable[[str], AbstractAsyncContextManager[None]],
+        paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     ) -> None:
         self.redis_client = redis_client
         self.rabbit_client = rabbit_client
-        self.pause_container_in_context = pause_container_in_context
+        self.paused_container = paused_container
 
     @contextlib.asynccontextmanager
-    async def _pause_container(
+    async def _paused_container(
         self, container_name: str, client: ClientWithPingProtocol
     ) -> AsyncIterator[None]:
-        async with self.pause_container_in_context(container_name):
+        async with self.paused_container(container_name):
             async for attempt in AsyncRetrying(
                 wait=wait_fixed(0.1),
                 stop=stop_after_delay(10),
@@ -374,15 +374,15 @@ async def _pause_container(
 
     @contextlib.asynccontextmanager
     async def pause_rabbit(self) -> AsyncIterator[None]:
-        async with self._pause_container("rabbit", self.rabbit_client):
+        async with self._paused_container("rabbit", self.rabbit_client):
             yield
 
     @contextlib.asynccontextmanager
     async def pause_redis(self) -> AsyncIterator[None]:
         # save db for clean restore point
         await self.redis_client.redis.save()
 
-        async with self._pause_container("redis", self.redis_client):
+        async with self._paused_container("redis", self.redis_client):
             yield
 
 
@@ -399,7 +399,7 @@ def mock_default_socket_timeout(mocker: MockerFixture) -> None:
 @pytest.mark.parametrize("service", ["rabbit", "redis"])
 async def test_workflow_with_third_party_services_outages(
     mock_default_socket_timeout: None,
-    pause_container: Callable[[str], AbstractAsyncContextManager[None]],
+    paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     redis_client_sdk_deferred_tasks: RedisClientSDK,
     rabbit_client: RabbitMQClient,
     get_remote_process: Callable[[], Awaitable[_RemoteProcess]],
@@ -410,7 +410,7 @@ async def test_workflow_with_third_party_services_outages(
     service: str,
 ):
     service_manager = ServiceManager(
-        redis_client_sdk_deferred_tasks, rabbit_client, pause_container
+        redis_client_sdk_deferred_tasks, rabbit_client, paused_container
     )
 
     async with _RemoteProcessLifecycleManager(

packages/service-library/tests/rabbitmq/test_rabbitmq_connection.py

@@ -27,12 +27,12 @@
 
 
 async def test_rabbit_client_lose_connection(
-    pause_container: Callable[[str], AbstractAsyncContextManager[None]],
+    paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     create_rabbitmq_client: Callable[[str], RabbitMQClient],
 ):
     rabbit_client = create_rabbitmq_client("pinger")
     assert await rabbit_client.ping() is True
-    async with pause_container("rabbit"):
+    async with paused_container("rabbit"):
         # check that connection was lost
         async for attempt in AsyncRetrying(
             stop=stop_after_delay(15), wait=wait_fixed(0.5), reraise=True
@@ -69,7 +69,7 @@ def _creator(**kwargs: dict[str, Any]) -> PytestRabbitMessage:
 
 @pytest.mark.no_cleanup_check_rabbitmq_server_has_no_errors()
 async def test_rabbit_client_with_paused_container(
-    pause_container: Callable[[str], AbstractAsyncContextManager[None]],
+    paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     random_exchange_name: Callable[[], str],
     random_rabbit_message: Callable[..., PytestRabbitMessage],
     create_rabbitmq_client: Callable[[str], RabbitMQClient],
@@ -79,7 +79,7 @@ async def test_rabbit_client_with_paused_container(
     exchange_name = random_exchange_name()
     message = random_rabbit_message()
     await rabbit_client.publish(exchange_name, message)
-    async with pause_container("rabbit"):
+    async with paused_container("rabbit"):
         # check that connection was lost
         with pytest.raises(asyncio.TimeoutError):
             await rabbit_client.publish(exchange_name, message)

packages/service-library/tests/redis/test_client.py

@@ -131,12 +131,12 @@ async def test_redis_client_sdk_setup_shutdown(
 
 async def test_regression_fails_on_redis_service_outage(
     mock_redis_socket_timeout: None,
-    pause_container: Callable[[str], AbstractAsyncContextManager[None]],
+    paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     redis_client_sdk: RedisClientSDK,
 ):
     assert await redis_client_sdk.ping() is True
 
-    async with pause_container("redis"):
+    async with paused_container("redis"):
         # no connection available any longer should not hang but timeout
         assert await redis_client_sdk.ping() is False
 

services/clusters-keeper/tests/unit/test_modules_rabbitmq.py

@@ -136,7 +136,7 @@ async def test_post_message_with_disabled_rabbit_does_not_raise(
 
 
 async def test_post_message_when_rabbit_disconnected_does_not_raise(
-    pause_container: Callable[[str], AbstractAsyncContextManager[None]],
+    paused_container: Callable[[str], AbstractAsyncContextManager[None]],
     enabled_rabbitmq: RabbitSettings,
     disabled_ec2: None,
     disabled_ssm: None,
@@ -147,6 +147,6 @@ async def test_post_message_when_rabbit_disconnected_does_not_raise(
     # NOTE: if the connection is not initialized before pausing the container, then
     # this test hangs forever!!! This needs investigations!
     await post_message(initialized_app, message=rabbit_log_message)
-    async with pause_container("rabbit"):
+    async with paused_container("rabbit"):
         # now posting should not raise out
         await post_message(initialized_app, message=rabbit_log_message)