Update tests for latest pytest-asyncio

Author: frmdstryr

tests/test_benchmark.py

@@ -1,3 +1,4 @@
+import asyncio
 from datetime import datetime
 
 import pytest
@@ -102,9 +103,10 @@ def test_serialize_flat(benchmark):
 
 
 @pytest.mark.benchmark(group="base")
-def test_restore_flat(benchmark, event_loop):
+def test_restore_flat(benchmark):
     def run():
-        event_loop.run_until_complete(Product.restore(flat_state))
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(Product.restore(flat_state))
 
     benchmark(run)
 
@@ -121,8 +123,9 @@ def test_serialize_nested(benchmark):
 
 
 @pytest.mark.benchmark(group="base")
-def test_restore_nested(benchmark, event_loop):
+def test_restore_nested(benchmark):
     def run():
-        event_loop.run_until_complete(Page.restore(nested_state))
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(Page.restore(nested_state))
 
     benchmark(run)

tests/test_sql_benchmark.py

@@ -1,12 +1,15 @@
+import asyncio
+
 import pytest
 from test_sql import Image, Page, db, reset_tables
 
 assert db  # fix flake8
 
 
 @pytest.mark.benchmark(group="sql-create")
-def test_benchmark_create(db, event_loop, benchmark):
-    event_loop.run_until_complete(reset_tables(Image))
+def test_benchmark_create(db, benchmark):
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(reset_tables(Image))
 
     async def create_images():
         for i in range(100):
@@ -20,13 +23,14 @@ async def create_images():
             )
 
     def run():
-        event_loop.run_until_complete(create_images())
+        loop.run_until_complete(create_images())
 
     benchmark(run)
 
 
-def prepare_benchmark(event_loop, n: int):
-    event_loop.run_until_complete(reset_tables(Image))
+def prepare_benchmark(n: int):
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(reset_tables(Image))
     images = []
 
     async def make():
@@ -42,41 +46,44 @@ async def make():
         )
 
     for i in range(n):
-        event_loop.run_until_complete(make())
+        loop.run_until_complete(make())
 
     return images
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get(db, event_loop, benchmark):
+def test_benchmark_get(db, benchmark):
     """Do a normal get query where the item is not in the cache"""
-    prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1)
     Image.objects.cache.clear()
 
     async def task():
         image = await Image.objects.get(name="Image 0")
         assert image.name == "Image 0"
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get_cached(db, event_loop, benchmark):
+def test_benchmark_get_cached(db, benchmark):
     """Do a normal get query where the item is in the cache"""
-    images = prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    images = prepare_benchmark(n=1)
     assert images
 
     async def task():
         image = await Image.objects.get(name="Image 0")
         assert image.name == "Image 0"
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get_raw(db, event_loop, benchmark):
+def test_benchmark_get_raw(db, benchmark):
     """Do a prebuilt get query with restoring without cache"""
-    prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1)
     q = Image.objects.filter(name="Image 0").query("select")
     Image.objects.cache.clear()
 
@@ -87,13 +94,14 @@ async def task():
             image = await Image.restore(row)
             assert image.name == "Image 0"
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get_raw_str(db, event_loop, benchmark):
+def test_benchmark_get_raw_str(db, benchmark):
     """Do a prebuilt get query with restoring without cache"""
-    images = prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    images = prepare_benchmark(n=1)
     assert images
     q = str(Image.objects.filter(name="Image 0").query("select"))
 
@@ -104,13 +112,14 @@ async def task():
             image = await Image.restore(row)
             assert image.name == "Image 0"
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get_raw_cached(db, event_loop, benchmark):
+def test_benchmark_get_raw_cached(db, benchmark):
     """Do a prebuilt get query with restoring with cache"""
-    images = prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    images = prepare_benchmark(n=1)
     assert images
     q = Image.objects.filter(name="Image 0").query("select")
     # Image.objects.cache.clear()
@@ -122,13 +131,14 @@ async def task():
             image = await Image.restore(row)
             assert image.name == "Image 0"
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-get")
-def test_benchmark_get_raw_row(db, event_loop, benchmark):
+def test_benchmark_get_raw_row(db, benchmark):
     """Do a prebuilt get query without restoring"""
-    prepare_benchmark(event_loop, n=1)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1)
     q = Image.objects.filter(name="Image 0").query("select")
 
     async def task():
@@ -138,39 +148,42 @@ async def task():
             assert row["name"] == "Image 0"
             # No restore
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-filter")
-def test_benchmark_filter(db, event_loop, benchmark):
+def test_benchmark_filter(db, benchmark):
     """Do a filter query where no items are in the cache"""
-    prepare_benchmark(event_loop, n=1000)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1000)
     Image.objects.cache.clear()
 
     async def task():
         results = await Image.objects.filter(alpha__ne=0)
         assert len(results) == 996
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-filter")
-def test_benchmark_filter_cached(db, event_loop, benchmark):
+def test_benchmark_filter_cached(db, benchmark):
     """Do a filter query where all items are in the cache"""
-    images = prepare_benchmark(event_loop, n=1000)
+    loop = asyncio.get_event_loop()
+    images = prepare_benchmark(n=1000)
     assert images
 
     async def task():
         results = await Image.objects.filter(alpha__ne=0)
         assert len(results) == 996
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-filter")
-def test_benchmark_filter_raw(db, event_loop, benchmark):
+def test_benchmark_filter_raw(db, benchmark):
     """Do a raw filter query where no items are in the cache"""
-    prepare_benchmark(event_loop, n=1000)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1000)
     Image.objects.cache.clear()
     q = Image.objects.filter(alpha__ne=0).query("select")
 
@@ -180,13 +193,14 @@ async def task():
             results = [await Image.restore(row) for row in await cursor.fetchall()]
             assert len(results) == 996
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-filter")
-def test_benchmark_filter_raw_cached(db, event_loop, benchmark):
+def test_benchmark_filter_raw_cached(db, benchmark):
     """Do a raw filter query where all items are in the cache"""
-    images = prepare_benchmark(event_loop, n=1000)
+    loop = asyncio.get_event_loop()
+    images = prepare_benchmark(n=1000)
     assert images
     # Image.objects.cache.clear()
     q = Image.objects.filter(alpha__ne=0).query("select")
@@ -197,13 +211,14 @@ async def task():
             results = [await Image.restore(row) for row in await cursor.fetchall()]
             assert len(results) == 996
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-filter")
-def test_benchmark_filter_raw_row(db, event_loop, benchmark):
+def test_benchmark_filter_raw_row(db, benchmark):
     """Do a raw filter query without restoring item from rows"""
-    prepare_benchmark(event_loop, n=1000)
+    loop = asyncio.get_event_loop()
+    prepare_benchmark(n=1000)
     # Image.objects.cache.clear()
     q = Image.objects.filter(alpha__ne=0).query("select")
 
@@ -214,7 +229,7 @@ async def task():
             results = [row for row in await cursor.fetchall()]
             assert len(results) == 996
 
-    benchmark(lambda: event_loop.run_until_complete(task()))
+    benchmark(lambda: loop.run_until_complete(task()))
 
 
 @pytest.mark.benchmark(group="sql-build-query")