Fixes test failure in director by keeping same loop

Removed pytest.mark.asyncio decorators. no need with pytest-aiohttp

Author: Pedro Crespo

services/director/tests/test_handlers.py

@@ -9,11 +9,11 @@
 
 API_VERSIONS = resources.listdir(resources.RESOURCE_OPENAPI_ROOT)
 
-@pytest.mark.asyncio
+
 async def test_root_get():
     fake_request = "fake request"
     web_response = await rest.handlers.root_get(fake_request)
-    assert web_response.content_type == "application/json"    
+    assert web_response.content_type == "application/json"
     assert web_response.status == 200
     healthcheck_enveloped = json.loads(web_response.text)
     assert "data" in healthcheck_enveloped
@@ -30,29 +30,29 @@ def _check_services(created_services, services, schema_version="v1"):
     assert len(created_services) == len(services)
 
     created_service_descriptions = [x["service_description"] for x in created_services]
-    
+
     json_schema_path = resources.get_path(resources.RESOURCE_NODE_SCHEMA)
     assert json_schema_path.exists() == True
     with json_schema_path.open() as file_pt:
         service_schema = json.load(file_pt)
 
-    for service in services:        
+    for service in services:
         if schema_version == "v1":
             assert created_service_descriptions.count(service) == 1
         json_schema_validator.validate_instance_object(service, service_schema)
 
-@pytest.mark.asyncio
+
 async def test_services_get(docker_registry, push_services):
     fake_request = "fake request"
     # no registry defined
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting HTTP Internal Error as no registry URL is defined"):
         services_enveloped = await rest.handlers.services_get(fake_request)
 
     # wrong registry defined
-    config.REGISTRY_URL = "blahblah" 
+    config.REGISTRY_URL = "blahblah"
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting HTTP Internal Error as SSL is enabled by default"):
         services_enveloped = await rest.handlers.services_get(fake_request)
-    
+
     # right registry defined
     config.REGISTRY_URL = docker_registry
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting HTTP Internal Error as SSL is enabled by default"):
@@ -103,7 +103,7 @@ async def test_services_get(docker_registry, push_services):
     services = services_enveloped["data"]
     assert len(services) == 2
 
-@pytest.mark.asyncio
+
 async def test_v0_services_conversion_to_new(configure_registry_access, push_v0_schema_services): #pylint: disable=W0613, W0621
     fake_request = "fake request"
     created_services = push_v0_schema_services(3,2)
@@ -117,7 +117,7 @@ async def test_v0_services_conversion_to_new(configure_registry_access, push_v0_
     # ensure old style services are not retrieved
     assert len(services) == 0
 
-@pytest.mark.asyncio
+
 async def test_services_by_key_version_get(configure_registry_access, push_services): #pylint: disable=W0613, W0621
     fake_request = "fake request"
 
@@ -131,7 +131,7 @@ async def test_services_by_key_version_get(configure_registry_access, push_servi
         web_response = await rest.handlers.services_by_key_version_get(fake_request, "whatever", "ofwhateverversion")
 
     created_services = push_services(3,2)
-    assert len(created_services) == 5    
+    assert len(created_services) == 5
 
     retrieved_services = []
     for created_service in created_services:
@@ -151,19 +151,19 @@ async def _start_get_stop_services(push_services, user_id):
 
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting internal server error"):
         web_response = await rest.handlers.running_interactive_services_post(fake_request, None, None, None, None)
-    
+
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting internal server error"):
         web_response = await rest.handlers.running_interactive_services_post(fake_request, "None", None, None, None)
 
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting internal server error"):
         web_response = await rest.handlers.running_interactive_services_post(fake_request, "None", "None", None, None)
-    
+
     with pytest.raises(web_exceptions.HTTPNotFound, message="Expecting not found error"):
         web_response = await rest.handlers.running_interactive_services_post(fake_request, "None", "None", "None", None)
 
     with pytest.raises(web_exceptions.HTTPNotFound, message="Expecting not found error"):
         web_response = await rest.handlers.running_interactive_services_post(fake_request, "None", "None", "None", "ablah")
-    
+
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting internal server error"):
         web_response = await rest.handlers.running_interactive_services_get(fake_request, None)
 
@@ -201,11 +201,11 @@ async def _start_get_stop_services(push_services, user_id):
         assert web_response.content_type == "application/json"
         assert web_response.text is None
 
-@pytest.mark.asyncio
+
 async def test_running_services_post_and_delete_no_swarm(configure_registry_access, push_services, user_id): #pylint: disable=W0613, W0621
     with pytest.raises(web_exceptions.HTTPInternalServerError, message="Expecting internal error as there is no docker swarm"):
         await _start_get_stop_services(push_services, user_id)
 
-@pytest.mark.asyncio
+
 async def test_running_services_post_and_delete(configure_registry_access, push_services, docker_swarm, user_id): #pylint: disable=W0613, W0621
     await _start_get_stop_services(push_services, user_id)

services/director/tests/test_producer.py

@@ -8,12 +8,12 @@
 )
 
 @pytest.fixture
-async def run_services(configure_registry_access, push_services, docker_swarm, user_id): #pylint: disable=W0613, W0621
+async def run_services(loop, configure_registry_access, push_services, docker_swarm, user_id): #pylint: disable=W0613, W0621
     started_services = []
     async def push_start_services(number_comp, number_dyn):
         pushed_services = push_services(number_comp,number_dyn, 60)
         assert len(pushed_services) == (number_comp + number_dyn)
-        for pushed_service in pushed_services:    
+        for pushed_service in pushed_services:
             service_description = pushed_service["service_description"]
 
             service_key = service_description["key"]
@@ -25,26 +25,27 @@ async def push_start_services(number_comp, number_dyn):
             started_service = await producer.start_service(user_id, service_key, service_version, service_uuid)
             assert "published_port" in started_service
             assert "entry_point" in started_service
-            assert "service_uuid" in started_service    
+            assert "service_uuid" in started_service
             # should not throw
             await producer.get_service_details(service_uuid)
             started_services.append(started_service)
         return started_services
+
     yield push_start_services
 
     #teardown stop the services
-    for service in started_services:    
+    for service in started_services:
         service_uuid = service["service_uuid"]
         await producer.stop_service(service_uuid)
         with pytest.raises(exceptions.ServiceUUIDNotFoundError, message="expecting service uuid not found error"):
             await producer.get_service_details(service_uuid)
 
-@pytest.mark.asyncio
+
 async def test_start_stop_service(run_services): #pylint: disable=W0613, W0621
     # standard test
     await run_services(1,1)
 
-@pytest.mark.asyncio
+
 async def test_service_assigned_env_variables(run_services, user_id): #pylint: disable=W0621
     started_services = await run_services(1,1)
     client = docker.from_env()
@@ -70,7 +71,7 @@ async def test_service_assigned_env_variables(run_services, user_id): #pylint: d
         assert "SIMCORE_USER_ID" in envs_dict
         assert envs_dict["SIMCORE_USER_ID"] == user_id
 
-@pytest.mark.asyncio
+
 async def test_interactive_service_published_port(run_services): #pylint: disable=W0621
     running_dynamic_services = await run_services(0,1)
     assert len(running_dynamic_services) == 1
@@ -88,4 +89,4 @@ async def test_interactive_service_published_port(run_services): #pylint: disabl
     low_level_client = docker.APIClient()
     service_information = low_level_client.inspect_service(docker_service.id)
     service_published_port = service_information["Endpoint"]["Ports"][0]["PublishedPort"]
-    assert service_published_port == service_port
+    assert service_published_port == service_port