tests(asyncio): adapt tests to OTel usage.

Signed-off-by: Paulo Vital <[email protected]>

Author: pvital

tests/conftest.py

@@ -45,7 +45,6 @@
 collect_ignore_glob.append("*clients/test_sql*")
 
 collect_ignore_glob.append("*frameworks/test_aiohttp*")
-collect_ignore_glob.append("*frameworks/test_asyncio*")
 collect_ignore_glob.append("*frameworks/test_celery*")
 collect_ignore_glob.append("*frameworks/test_gevent*")
 collect_ignore_glob.append("*frameworks/test_grpcio*")

tests/frameworks/test_asyncio.py

@@ -2,140 +2,149 @@
 # (c) Copyright Instana Inc. 2020
 
 import asyncio
+from typing import Any, Dict, Generator, Optional
+
 import aiohttp
-import unittest
+import pytest
 
-import tests.apps.flask_app
-from ..helpers import testenv
+import tests.apps.flask_app  # noqa: F401
 from instana.configurator import config
-from instana.singletons import async_tracer
-
+from instana.singletons import tracer
+from tests.helpers import testenv
+
+
+class TestAsyncio:
+    async def fetch(
+        self,
+        session: aiohttp.ClientSession,
+        url: str,
+        headers: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ):
+        try:
+            async with session.get(url, headers=headers, params=params) as response:
+                return response
+        except aiohttp.web_exceptions.HTTPException:
+            pass
 
-class TestAsyncio(unittest.TestCase):
-    def setUp(self):
-        """ Clear all spans before a test run """
-        self.recorder = async_tracer.recorder
+    @pytest.fixture(autouse=True)
+    def _resource(self) -> Generator[None, None, None]:
+        """SetUp and TearDown"""
+        # setup
+        # Clear all spans before a test run
+        self.recorder = tracer.span_processor
         self.recorder.clear_spans()
 
         # New event loop for every test
         self.loop = asyncio.new_event_loop()
         asyncio.set_event_loop(None)
 
         # Restore default
-        config['asyncio_task_context_propagation']['enabled'] = False
-
-    def tearDown(self):
-        """ Purge the queue """
-        pass
-
-    async def fetch(self, session, url, headers=None):
-        try:
-            async with session.get(url, headers=headers) as response:
-                return response
-        except aiohttp.web_exceptions.HTTPException:
-            pass
-
-    def test_ensure_future_with_context(self):
+        config["asyncio_task_context_propagation"]["enabled"] = False
+        yield
+        # teardown
+        # Close the loop if running
+        if self.loop.is_running():
+            self.loop.close()
+
+    def test_ensure_future_with_context(self) -> None:
         async def run_later(msg="Hello"):
-            # print("run_later: %s" % async_tracer.active_span.operation_name)
             async with aiohttp.ClientSession() as session:
                 return await self.fetch(session, testenv["flask_server"] + "/")
 
         async def test():
-            with async_tracer.start_active_span('test'):
-                asyncio.ensure_future(run_later("Hello"))
+            with tracer.start_as_current_span("test"):
+                asyncio.ensure_future(run_later("Hello OTel"))
             await asyncio.sleep(0.5)
 
         # Override default task context propagation
-        config['asyncio_task_context_propagation']['enabled'] = True
+        config["asyncio_task_context_propagation"]["enabled"] = True
 
         self.loop.run_until_complete(test())
 
         spans = self.recorder.queued_spans()
-        self.assertEqual(3, len(spans))
+        assert len(spans) == 3
 
         test_span = spans[0]
         wsgi_span = spans[1]
         aioclient_span = spans[2]
 
-        self.assertEqual(test_span.t, wsgi_span.t)
-        self.assertEqual(test_span.t, aioclient_span.t)
+        assert test_span.t == wsgi_span.t
+        assert aioclient_span.t == test_span.t
 
-        self.assertEqual(test_span.p, None)
-        self.assertEqual(wsgi_span.p, aioclient_span.s)
-        self.assertEqual(aioclient_span.p, test_span.s)
+        assert not test_span.p
+        assert wsgi_span.p == aioclient_span.s
+        assert aioclient_span.p == test_span.s
 
-    def test_ensure_future_without_context(self):
+    def test_ensure_future_without_context(self) -> None:
         async def run_later(msg="Hello"):
-            # print("run_later: %s" % async_tracer.active_span.operation_name)
             async with aiohttp.ClientSession() as session:
                 return await self.fetch(session, testenv["flask_server"] + "/")
 
         async def test():
-            with async_tracer.start_active_span('test'):
-                asyncio.ensure_future(run_later("Hello"))
+            with tracer.start_as_current_span("test"):
+                asyncio.ensure_future(run_later("Hello OTel"))
             await asyncio.sleep(0.5)
 
         self.loop.run_until_complete(test())
 
         spans = self.recorder.queued_spans()
 
-        self.assertEqual(2, len(spans))
-        self.assertEqual("sdk", spans[0].n)
-        self.assertEqual("wsgi", spans[1].n)
+        assert len(spans) == 2
+        assert spans[0].n == "sdk"
+        assert spans[1].n == "wsgi"
 
         # Without the context propagated, we should get two separate traces
-        self.assertNotEqual(spans[0].t, spans[1].t)
+        assert spans[0].t != spans[1].t
 
     if hasattr(asyncio, "create_task"):
-        def test_create_task_with_context(self):
+
+        def test_create_task_with_context(self) -> None:
             async def run_later(msg="Hello"):
-                # print("run_later: %s" % async_tracer.active_span.operation_name)
                 async with aiohttp.ClientSession() as session:
                     return await self.fetch(session, testenv["flask_server"] + "/")
 
             async def test():
-                with async_tracer.start_active_span('test'):
-                    asyncio.create_task(run_later("Hello"))
+                with tracer.start_as_current_span("test"):
+                    asyncio.create_task(run_later("Hello OTel"))
                 await asyncio.sleep(0.5)
 
             # Override default task context propagation
-            config['asyncio_task_context_propagation']['enabled'] = True
+            config["asyncio_task_context_propagation"]["enabled"] = True
 
             self.loop.run_until_complete(test())
 
             spans = self.recorder.queued_spans()
-            self.assertEqual(3, len(spans))
+            assert len(spans) == 3
 
             test_span = spans[0]
             wsgi_span = spans[1]
             aioclient_span = spans[2]
 
-            self.assertEqual(test_span.t, wsgi_span.t)
-            self.assertEqual(test_span.t, aioclient_span.t)
+            assert wsgi_span.t == test_span.t
+            assert aioclient_span.t == test_span.t
 
-            self.assertEqual(test_span.p, None)
-            self.assertEqual(wsgi_span.p, aioclient_span.s)
-            self.assertEqual(aioclient_span.p, test_span.s)
+            assert not test_span.p
+            assert wsgi_span.p == aioclient_span.s
+            assert aioclient_span.p == test_span.s
 
-        def test_create_task_without_context(self):
+        def test_create_task_without_context(self) -> None:
             async def run_later(msg="Hello"):
-                # print("run_later: %s" % async_tracer.active_span.operation_name)
                 async with aiohttp.ClientSession() as session:
                     return await self.fetch(session, testenv["flask_server"] + "/")
 
             async def test():
-                with async_tracer.start_active_span('test'):
-                    asyncio.create_task(run_later("Hello"))
+                with tracer.start_as_current_span("test"):
+                    asyncio.create_task(run_later("Hello OTel"))
                 await asyncio.sleep(0.5)
 
             self.loop.run_until_complete(test())
 
             spans = self.recorder.queued_spans()
 
-            self.assertEqual(2, len(spans))
-            self.assertEqual("sdk", spans[0].n)
-            self.assertEqual("wsgi", spans[1].n)
+            assert len(spans) == 2
+            assert spans[0].n == "sdk"
+            assert spans[1].n == "wsgi"
 
             # Without the context propagated, we should get two separate traces
-            self.assertNotEqual(spans[0].t, spans[1].t)
+            assert spans[0].t != spans[1].t