♻️ Remove overloaded loops in tests (ITISFoundation#2674)

* remove module scoped loop
* removed pytest-lazy-fixture
* removed nest-asyncio
* create xml report for vscode extension

Author: sanderegg

.env-devel

@@ -63,8 +63,12 @@ SCICRUNCH_API_KEY=REPLACE_ME_with_valid_api_key
 SMTP_HOST=mail.speag.com
 SMTP_PORT=25
 
+SIMCORE_SERVICES_NETWORK_NAME=interactive_services_subnet
+
 STORAGE_ENDPOINT=storage:8080
 
+SWARM_STACK_NAME=master-simcore
+
 TRACING_ENABLED=1
 TRACING_ZIPKIN_ENDPOINT=http://jaeger:9411
 TRACING_THRIFT_COMPACT_ENDPOINT=http://jaeger:5775

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

@@ -1,11 +1,13 @@
 # pylint:disable=unused-variable
 # pylint:disable=unused-argument
 # pylint:disable=redefined-outer-name
+# pylint: disable=too-many-branches
 
-
+import asyncio
 import json
 import logging
 import subprocess
+import sys
 from contextlib import suppress
 from pathlib import Path
 from typing import Any, Dict, Iterator
@@ -136,10 +138,10 @@ def _fetch_and_print_services(
                         "Slot": ...,
                     },
                 )
-                for task in service_obj.tasks()
+                for task in service_obj.tasks()  # type: ignore
             ]
 
-        print(HEADER_STR.format(service_obj.name))
+        print(HEADER_STR.format(service_obj.name))  # type: ignore
         print(json.dumps({"service": service, "tasks": tasks}, indent=1))
 
 
@@ -216,8 +218,9 @@ def docker_stack(
     stacks_deployed: Dict[str, Dict] = {}
     for key, stack_name, compose_file in stacks:
         subprocess.run(
-            f"docker stack deploy --with-registry-auth -c {compose_file.name} {stack_name}",
-            shell=True,
+            f"docker stack deploy --with-registry-auth -c {compose_file.name} {stack_name}".split(
+                " "
+            ),
             check=True,
             cwd=compose_file.parent,
         )
@@ -230,22 +233,45 @@ def docker_stack(
     # - notice that the timeout is set for all services in both stacks
     # - TODO: the time to deploy will depend on the number of services selected
     try:
-        for attempt in Retrying(
-            wait=wait_fixed(5),
-            stop=stop_after_delay(8 * MINUTE),
-            before_sleep=before_sleep_log(log, logging.INFO),
-            reraise=True,
-        ):
-            with attempt:
-                for service in docker_client.services.list():
-                    assert_service_is_running(service)
+        if sys.version_info >= (3, 7):
+            from tenacity._asyncio import AsyncRetrying
+
+            async def _check_all_services_are_running():
+                async for attempt in AsyncRetrying(
+                    wait=wait_fixed(5),
+                    stop=stop_after_delay(8 * MINUTE),
+                    before_sleep=before_sleep_log(log, logging.INFO),
+                    reraise=True,
+                ):
+                    with attempt:
+                        await asyncio.gather(
+                            *[
+                                asyncio.get_event_loop().run_in_executor(
+                                    None, assert_service_is_running, service
+                                )
+                                for service in docker_client.services.list()
+                            ]
+                        )
+
+            asyncio.run(_check_all_services_are_running())
+
+        else:
+            for attempt in Retrying(
+                wait=wait_fixed(5),
+                stop=stop_after_delay(8 * MINUTE),
+                before_sleep=before_sleep_log(log, logging.INFO),
+                reraise=True,
+            ):
+                with attempt:
+                    for service in docker_client.services.list():
+                        assert_service_is_running(service)
 
     finally:
         _fetch_and_print_services(docker_client, "[BEFORE TEST]")
 
     yield {
         "stacks": stacks_deployed,
-        "services": [service.name for service in docker_client.services.list()],
+        "services": [service.name for service in docker_client.services.list()],  # type: ignore
     }
 
     ## TEAR DOWN ----------------------
@@ -276,8 +302,7 @@ def docker_stack(
 
         try:
             subprocess.run(
-                f"docker stack remove {stack}",
-                shell=True,
+                f"docker stack remove {stack}".split(" "),
                 check=True,
                 capture_output=True,
             )

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

@@ -1,6 +1,6 @@
-# pylint:disable=unused-variable
-# pylint:disable=unused-argument
 # pylint:disable=redefined-outer-name
+# pylint:disable=unused-argument
+# pylint:disable=unused-variable
 import asyncio
 import logging
 from typing import AsyncIterator, Dict, Iterator, List
@@ -72,13 +72,6 @@ def drop_template_db(postgres_engine: sa.engine.Engine) -> None:
     execute_queries(postgres_engine, queries)
 
 
-@pytest.fixture(scope="module")
-def loop(request):
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-
 @pytest.fixture(scope="module")
 def postgres_with_template_db(
     postgres_db: sa.engine.Engine, postgres_dsn: Dict, postgres_engine: sa.engine.Engine
@@ -173,9 +166,10 @@ def postgres_db(
         yield postgres_engine
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture(scope="function")
 async def aiopg_engine(
-    postgres_db: sa.engine.Engine, loop
+    loop: asyncio.AbstractEventLoop,
+    postgres_db: sa.engine.Engine,
 ) -> AsyncIterator[aiopg.sa.engine.Engine]:
     """An aiopg engine connected to an initialized database"""
     from aiopg.sa import create_engine

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

@@ -2,13 +2,12 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 
-import asyncio
 import json
 import logging
 import os
 import socket
 from dataclasses import dataclass
-from typing import Any, AsyncIterator, Dict, Iterator, Optional
+from typing import Any, AsyncIterator, Dict, Optional
 
 import aio_pika
 import pytest
@@ -39,17 +38,8 @@ async def wait_till_rabbit_responsive(url: str) -> None:
 # FIXTURES ------------------------------------------------------------------------------------
 
 
-@pytest.fixture(scope="module")
-def loop(request) -> Iterator[asyncio.AbstractEventLoop]:
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture(scope="module")
-async def rabbit_config(
-    loop: asyncio.AbstractEventLoop, docker_stack: Dict, testing_environ_vars: Dict
-) -> RabbitConfig:
+@pytest.fixture(scope="function")
+async def rabbit_config(docker_stack: Dict, testing_environ_vars: Dict) -> RabbitConfig:
     prefix = testing_environ_vars["SWARM_STACK_NAME"]
     assert f"{prefix}_rabbit" in docker_stack["services"]
     rabbit_config = RabbitConfig(

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

@@ -2,32 +2,25 @@
 # pylint:disable=unused-argument
 # pylint:disable=redefined-outer-name
 
-import asyncio
 import logging
-from typing import Dict, Iterator, Union
+from typing import AsyncIterator, Dict, Union
 
 import aioredis
 import pytest
 import tenacity
 from models_library.settings.redis import RedisConfig
+from tenacity.before_sleep import before_sleep_log
+from tenacity.stop import stop_after_delay
+from tenacity.wait import wait_fixed
 from yarl import URL
 
 from .helpers.utils_docker import get_service_published_port
 
 log = logging.getLogger(__name__)
 
 
-@pytest.fixture(scope="module")
-def loop(request) -> Iterator[asyncio.AbstractEventLoop]:
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture(scope="module")
-async def redis_config(
-    loop, docker_stack: Dict, testing_environ_vars: Dict
-) -> RedisConfig:
+@pytest.fixture(scope="function")
+async def redis_config(docker_stack: Dict, testing_environ_vars: Dict) -> RedisConfig:
     prefix = testing_environ_vars["SWARM_STACK_NAME"]
     assert f"{prefix}_redis" in docker_stack["services"]
 
@@ -43,14 +36,14 @@ async def redis_config(
 
 
 @pytest.fixture(scope="function")
-async def redis_service(redis_config: RedisConfig, monkeypatch) -> RedisConfig:
+def redis_service(redis_config: RedisConfig, monkeypatch) -> RedisConfig:
     monkeypatch.setenv("REDIS_HOST", redis_config.host)
     monkeypatch.setenv("REDIS_PORT", str(redis_config.port))
     return redis_config
 
 
 @pytest.fixture(scope="function")
-async def redis_client(loop, redis_config: RedisConfig) -> Iterator[aioredis.Redis]:
+async def redis_client(redis_config: RedisConfig) -> AsyncIterator[aioredis.Redis]:
     client = await aioredis.create_redis_pool(redis_config.dsn, encoding="utf-8")
 
     yield client
@@ -64,9 +57,9 @@ async def redis_client(loop, redis_config: RedisConfig) -> Iterator[aioredis.Red
 
 
 @tenacity.retry(
-    wait=tenacity.wait_fixed(5),
-    stop=tenacity.stop_after_attempt(60),
-    before_sleep=tenacity.before_sleep_log(log, logging.INFO),
+    wait=wait_fixed(5),
+    stop=stop_after_delay(60),
+    before_sleep=before_sleep_log(log, logging.INFO),
     reraise=True,
 )
 async def wait_till_redis_responsive(redis_url: Union[URL, str]) -> None:

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

@@ -135,7 +135,7 @@ def services_endpoint(
 
 
 @pytest.fixture(scope="module")
-async def simcore_services_ready(
+def simcore_services_ready(
     services_endpoint: Dict[str, URL], monkeypatch_module: MonkeyPatch
 ) -> None:
     """
@@ -155,11 +155,14 @@ async def simcore_services_ready(
     for h in health_endpoints:
         print(f" - {h.name} -> {h.url}")
 
+    async def _check_all_services_are_healthy():
+        await asyncio.gather(
+            *[wait_till_service_healthy(h.name, h.url) for h in health_endpoints],
+            return_exceptions=False,
+        )
+
     # check ready
-    await asyncio.gather(
-        *[wait_till_service_healthy(h.name, h.url) for h in health_endpoints],
-        return_exceptions=False,
-    )
+    asyncio.run(_check_all_services_are_healthy())
 
     # patches environment variables with right host/port per service
     for service, endpoint in services_endpoint.items():

scripts/common-service.Makefile

@@ -105,6 +105,7 @@ _run-test-dev: _check_venv_active
 		--color=yes \
 		--cov-config=.coveragerc \
 		--cov-report=term-missing \
+		--cov-report=xml \
 		--cov=$(APP_PACKAGE_NAME) \
 		--durations=10 \
 		--exitfirst \

services/api-server/tests/unit/conftest.py

@@ -1,6 +1,7 @@
-# pylint:disable=unused-variable
-# pylint:disable=unused-argument
+# pylint:disable=no-name-in-module
 # pylint:disable=redefined-outer-name
+# pylint:disable=unused-argument
+# pylint:disable=unused-variable
 
 import os
 import shutil

services/catalog/tests/unit/with_dbs/conftest.py

@@ -3,6 +3,7 @@
 # pylint:disable=redefined-outer-name
 
 
+import asyncio
 import itertools
 import random
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Tuple
@@ -41,7 +42,7 @@ def app(
 
 
 @pytest.fixture
-def client(app: FastAPI) -> Iterable[TestClient]:
+def client(loop: asyncio.AbstractEventLoop, app: FastAPI) -> Iterable[TestClient]:
     with TestClient(app) as cli:
         # Note: this way we ensure the events are run in the application
         yield cli

services/catalog/tests/unit/with_dbs/test_db_repositories.py

@@ -232,6 +232,7 @@ async def test_list_service_releases_version_filtered(
     latest = await services_repo.get_latest_release(
         "simcore/services/dynamic/jupyterlab"
     )
+    assert latest
     assert latest.version == fake_catalog_with_jupyterlab.expected_latest
 
     releases_1_1_x: List[