chore: update async tests

Author: psegedy

tests/listener_tests/conftest.py

@@ -1,16 +1,9 @@
 # -*- coding: utf-8 -*-
 # pylint:disable=missing-docstring,redefined-outer-name
-import asyncio
-
 import psycopg2
 import pytest
 
 
-@pytest.fixture(scope="class")
-def event_loop():
-    return asyncio.new_event_loop()
-
-
 @pytest.fixture(scope="module")
 def pg_db_conn(pg_db_mod):
     """Returns connection to PostgreSQL database."""

tests/notificator_tests/conftest.py

@@ -2,6 +2,8 @@
 Fixtures for notificator tests
 """
 
+import asyncio
+
 import asyncpg
 import pytest
 import pytest_asyncio
@@ -13,14 +15,14 @@
 
 
 @pytest_asyncio.fixture(loop_scope="function", scope="function")
-async def asyncpg_pool(event_loop, pg_db_func):
+async def asyncpg_pool(pg_db_func):
     """Creates asyncpg pool fixture"""
     dsn = pg_db_func.dsn()
     dsn_str = f"postgres://{dsn['user']}@{dsn['host']}:{dsn['port']}/{dsn['database']}"
 
     pool = await asyncpg.create_pool(
         dsn=dsn_str,
-        loop=event_loop,
+        loop=asyncio.get_running_loop(),
     )
     yield pool
     await pool.close()

tests/notificator_tests/test_notificator.py

@@ -2,6 +2,7 @@
 Notificator unit tests
 """
 
+import asyncio
 import json
 
 import pytest
@@ -65,9 +66,10 @@ async def _build_notificator(pool, loop):
         return notificator
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_notificator_new(asyncpg_pool, event_loop, monkeypatch):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_notificator_new(asyncpg_pool, monkeypatch):
         """Tests new sys_vulns from evaluator to notificator"""
+        event_loop = asyncio.get_running_loop()
         # update CVE-2014-1, CVE-2017-1, CVE-2017-6 to be fresh
         # leave out CVE-2016-1 to not be fresh because it has exploits
         async with asyncpg_pool.acquire() as conn:
@@ -100,9 +102,10 @@ async def test_notificator_new(asyncpg_pool, event_loop, monkeypatch):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_notificator_mitigated(asyncpg_pool, event_loop, monkeypatch):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_notificator_mitigated(asyncpg_pool, monkeypatch):
         """Tests mitigated sys_vulns from evaluator to notificator"""
+        event_loop = asyncio.get_running_loop()
         notificator = await TestNotificator._build_notificator(asyncpg_pool, event_loop)
         monkeypatch.setattr(json, "loads", lambda _: EVALUATOR_RESULT_MIT_VULNS)
 
@@ -121,9 +124,10 @@ async def test_notificator_mitigated(asyncpg_pool, event_loop, monkeypatch):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_notificator_unmitigated(asyncpg_pool, event_loop, monkeypatch):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_notificator_unmitigated(asyncpg_pool, monkeypatch):
         """Tests unmitigated sys_vulns from evaluator to notificator"""
+        event_loop = asyncio.get_running_loop()
         # update CVE-2014-1, CVE-2017-1, CVE-2017-6, CVE-2017-8 to be fresh
         # leave out CVE-2016-1 to not be fresh because it has exploits
         async with asyncpg_pool.acquire() as conn:

tests/notificator_tests/test_notificator_queue.py

@@ -2,6 +2,8 @@
 """
 Notificator Queue unit tests
 """
+import asyncio
+
 import pytest
 
 from common.peewee_model import NotificationType
@@ -33,9 +35,10 @@ async def _notified_users_cnt(pool):
             return res[0]
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_empty(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_empty(asyncpg_pool):
         """Tests queue single run when its empty"""
+        event_loop = asyncio.get_running_loop()
         queue = await TestNotificatorQueue._build_queue(asyncpg_pool, event_loop)
         await queue._process_queue()
         # Queues should be empty
@@ -44,9 +47,10 @@ async def test_queue_empty(asyncpg_pool, event_loop):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_nonexisting(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_nonexisting(asyncpg_pool):
         """Tests queue run with non existing sys_vuln"""
+        event_loop = asyncio.get_running_loop()
         queue = await TestNotificatorQueue._build_queue(asyncpg_pool, event_loop)
         # add nonexisting sys vuln to queue
         queue.notif_cves_queue[1337] = QueueItem("CVE-NONEXISTING", 1337, 0, "0", [NotificationType.CVSS_NOTIFICATION])
@@ -60,9 +64,10 @@ async def test_queue_nonexisting(asyncpg_pool, event_loop):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_non_advisor_eval(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_non_advisor_eval(asyncpg_pool):
         """Tests queue run with not yet advisor evaluated system"""
+        event_loop = asyncio.get_running_loop()
         queue = await TestNotificatorQueue._build_queue(asyncpg_pool, event_loop)
 
         # insert into db system which is not advisor evaluated and has single CVE
@@ -88,9 +93,10 @@ async def test_queue_non_advisor_eval(asyncpg_pool, event_loop):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_mitigated(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_mitigated(asyncpg_pool):
         """Test queue run but cve gets mitigated"""
+        event_loop = asyncio.get_running_loop()
         queue = await TestNotificatorQueue._build_queue(asyncpg_pool, event_loop)
 
         # insert into db system which is not vulnerable anymore, based on the advisor listener
@@ -117,9 +123,10 @@ async def test_queue_mitigated(asyncpg_pool, event_loop):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_valid(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_valid(asyncpg_pool):
         """Test queue run with valid system vulnerabilities, which should be notified"""
+        event_loop = asyncio.get_running_loop()
         msgs = []
 
         def _send_kafka_notif_mock(self, acc_id, event_type, *_, **__):
@@ -156,9 +163,10 @@ def _send_kafka_notif_mock(self, acc_id, event_type, *_, **__):
         NotificatorQueue.delete()
 
     @staticmethod
-    @pytest.mark.asyncio
-    async def test_queue_unknown_cve(asyncpg_pool, event_loop):
+    @pytest.mark.asyncio(loop_scope="function")
+    async def test_queue_unknown_cve(asyncpg_pool):
         """Test queue run with unknown cve vulnerabilities yet"""
+        event_loop = asyncio.get_running_loop()
         queue = await TestNotificatorQueue._build_queue(asyncpg_pool, event_loop)
 
         # insert into db system which vulnerable to CVE which vulnerability does not know yet

tests/taskomatic_tests/test_taskomatic.py

@@ -4,6 +4,7 @@
 """
 import asyncio
 
+import pytest
 from psycopg2.extensions import connection
 
 import taskomatic.jobs.common as tjc
@@ -90,11 +91,13 @@ def run_forever(self, *_, **__):
 class TestTaskomaticApp:
     """Test taskomatic App handlers"""
 
+    @pytest.mark.asyncio
     async def test_run_job(self, http_client):
         """Test run job handler"""
         response = await http_client.put("/api/v1/run/stale_systems", data={})
         assert response.status == 200
 
+    @pytest.mark.asyncio
     async def test_run_job_wrong(self, http_client):
         """Test run job handler with wrong job"""
         response = await http_client.put("/api/v1/run/nonexisting_job", data={})