Refactor tests

* Use pytest-aiohttp
* Use the async def / await syntax.
* Fix tests to run with Python 3.8

tests/utils/test_asyncio.py

@@ -25,53 +25,33 @@ from gns3server.utils.asyncio import wait_run_in_executor, subprocess_check_outp
 from tests.utils import AsyncioMagicMock
 
 
-def test_wait_run_in_executor(loop):
+async def test_wait_run_in_executor():
 
     def change_var(param):
         return param
 
-    exec = wait_run_in_executor(change_var, "test")
-    result = loop.run_until_complete(asyncio.ensure_future(exec))
+    result = await wait_run_in_executor(change_var, "test")
     assert result == "test"
 
 
-def test_exception_wait_run_in_executor(loop):
+async def test_exception_wait_run_in_executor():
 
     def raise_exception():
         raise Exception("test")
 
-    exec = wait_run_in_executor(raise_exception)
     with pytest.raises(Exception):
-        result = loop.run_until_complete(asyncio.ensure_future(exec))
+        await wait_run_in_executor(raise_exception)
 
 
 @pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
-def test_subprocess_check_output(loop, tmpdir, restore_original_path):
+async def test_subprocess_check_output(loop, tmpdir):
 
     path = str(tmpdir / "test")
-    exec = subprocess_check_output("echo", "-n", path)
-    result = loop.run_until_complete(asyncio.ensure_future(exec))
+    result = await subprocess_check_output("echo", "-n", path)
     assert result == path
 
 
-def test_wait_for_process_termination(loop):
-
-    if sys.version_info >= (3, 5):
-        # No need for test we use native version
-        return
-    process = MagicMock()
-    process.returncode = 0
-    exec = wait_for_process_termination(process)
-    loop.run_until_complete(asyncio.ensure_future(exec))
-
-    process = MagicMock()
-    process.returncode = None
-    exec = wait_for_process_termination(process, timeout=0.5)
-    with pytest.raises(asyncio.TimeoutError):
-        loop.run_until_complete(asyncio.ensure_future(exec))
-
-
-def test_lock_decorator(loop):
+async def test_lock_decorator():
     """
     The test check if the the second call to method_to_lock wait for the
     first call to finish
@@ -84,11 +64,11 @@ def test_lock_decorator(loop):
 
         @locking
         async def method_to_lock(self):
-            res = self._test_val
+            result = self._test_val
             await asyncio.sleep(0.1)
             self._test_val += 1
-            return res
+            return result
 
     i = TestLock()
-    res = set(loop.run_until_complete(asyncio.gather(i.method_to_lock(), i.method_to_lock())))
+    res = set(await asyncio.gather(i.method_to_lock(), i.method_to_lock()))
     assert res == set((0, 1,))  # We use a set to test this to avoid order issue