Add await to fetch calls in aio cursor tests

laughingman7743 · claude · laughingman7743 · commit c8f536224aed · 2026-02-21T14:34:03.000+09:00
Tests were calling fetchone(), fetchmany(), fetchall() without await,
producing "coroutine was never awaited" warnings and incorrect
assertions (comparing coroutine objects instead of results).

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/tests/pyathena/aio/arrow/test_cursor.py b/tests/pyathena/aio/arrow/test_cursor.py
@@ -11,20 +11,20 @@ class TestAioArrowCursor:
     async def test_fetchone(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT * FROM one_row")
         assert aio_arrow_cursor.rownumber == 0
-        assert aio_arrow_cursor.fetchone() == (1,)
+        assert await aio_arrow_cursor.fetchone() == (1,)
         assert aio_arrow_cursor.rownumber == 1
-        assert aio_arrow_cursor.fetchone() is None
+        assert await aio_arrow_cursor.fetchone() is None
 
     async def test_fetchmany(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT * FROM many_rows LIMIT 15")
-        assert len(aio_arrow_cursor.fetchmany(10)) == 10
-        assert len(aio_arrow_cursor.fetchmany(10)) == 5
+        assert len(await aio_arrow_cursor.fetchmany(10)) == 10
+        assert len(await aio_arrow_cursor.fetchmany(10)) == 5
 
     async def test_fetchall(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT * FROM one_row")
-        assert aio_arrow_cursor.fetchall() == [(1,)]
+        assert await aio_arrow_cursor.fetchall() == [(1,)]
         await aio_arrow_cursor.execute("SELECT a FROM many_rows ORDER BY a")
-        assert aio_arrow_cursor.fetchall() == [(i,) for i in range(10000)]
+        assert await aio_arrow_cursor.fetchall() == [(i,) for i in range(10000)]
 
     async def test_as_arrow(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT * FROM one_row")
@@ -45,11 +45,11 @@ async def test_execute_returns_self(self, aio_arrow_cursor):
 
     async def test_no_result_set_raises(self, aio_arrow_cursor):
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchone()
+            await aio_arrow_cursor.fetchone()
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchmany()
+            await aio_arrow_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchall()
+            await aio_arrow_cursor.fetchall()
         with pytest.raises(ProgrammingError):
             aio_arrow_cursor.as_arrow()
         with pytest.raises(ProgrammingError):
@@ -62,7 +62,7 @@ async def test_context_manager(self):
         try:
             async with conn.cursor() as cursor:
                 await cursor.execute("SELECT * FROM one_row")
-                assert cursor.fetchone() == (1,)
+                assert await cursor.fetchone() == (1,)
         finally:
             conn.close()
 
@@ -77,7 +77,7 @@ async def test_invalid_arraysize(self, aio_arrow_cursor):
 
     async def test_description(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT CAST(1 AS INT) AS foobar FROM one_row")
-        assert aio_arrow_cursor.fetchall() == [(1,)]
+        assert await aio_arrow_cursor.fetchall() == [(1,)]
         assert aio_arrow_cursor.description == [("foobar", "integer", None, None, 10, 0, "UNKNOWN")]
 
     async def test_description_initial(self, aio_arrow_cursor):
@@ -92,11 +92,11 @@ async def test_executemany_fetch(self, aio_arrow_cursor):
             "SELECT %(x)d FROM one_row", [{"x": i} for i in range(1, 2)]
         )
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchall()
+            await aio_arrow_cursor.fetchall()
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchmany()
+            await aio_arrow_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_arrow_cursor.fetchone()
+            await aio_arrow_cursor.fetchone()
         with pytest.raises(ProgrammingError):
             aio_arrow_cursor.as_arrow()
         with pytest.raises(ProgrammingError):
@@ -109,8 +109,8 @@ async def test_executemany_fetch(self, aio_arrow_cursor):
     )
     async def test_fetchone_unload(self, aio_arrow_cursor):
         await aio_arrow_cursor.execute("SELECT * FROM one_row")
-        assert aio_arrow_cursor.fetchone() == (1,)
-        assert aio_arrow_cursor.fetchone() is None
+        assert await aio_arrow_cursor.fetchone() == (1,)
+        assert await aio_arrow_cursor.fetchone() is None
 
     @pytest.mark.parametrize(
         "aio_arrow_cursor",
diff --git a/tests/pyathena/aio/pandas/test_cursor.py b/tests/pyathena/aio/pandas/test_cursor.py
@@ -11,20 +11,20 @@ class TestAioPandasCursor:
     async def test_fetchone(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT * FROM one_row")
         assert aio_pandas_cursor.rownumber == 0
-        assert aio_pandas_cursor.fetchone() == (1,)
+        assert await aio_pandas_cursor.fetchone() == (1,)
         assert aio_pandas_cursor.rownumber == 1
-        assert aio_pandas_cursor.fetchone() is None
+        assert await aio_pandas_cursor.fetchone() is None
 
     async def test_fetchmany(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT * FROM many_rows LIMIT 15")
-        assert len(aio_pandas_cursor.fetchmany(10)) == 10
-        assert len(aio_pandas_cursor.fetchmany(10)) == 5
+        assert len(await aio_pandas_cursor.fetchmany(10)) == 10
+        assert len(await aio_pandas_cursor.fetchmany(10)) == 5
 
     async def test_fetchall(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT * FROM one_row")
-        assert aio_pandas_cursor.fetchall() == [(1,)]
+        assert await aio_pandas_cursor.fetchall() == [(1,)]
         await aio_pandas_cursor.execute("SELECT a FROM many_rows ORDER BY a")
-        assert aio_pandas_cursor.fetchall() == [(i,) for i in range(10000)]
+        assert await aio_pandas_cursor.fetchall() == [(i,) for i in range(10000)]
 
     async def test_as_pandas(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT * FROM one_row")
@@ -39,11 +39,11 @@ async def test_execute_returns_self(self, aio_pandas_cursor):
 
     async def test_no_result_set_raises(self, aio_pandas_cursor):
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchone()
+            await aio_pandas_cursor.fetchone()
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchmany()
+            await aio_pandas_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchall()
+            await aio_pandas_cursor.fetchall()
         with pytest.raises(ProgrammingError):
             aio_pandas_cursor.as_pandas()
 
@@ -54,7 +54,7 @@ async def test_context_manager(self):
         try:
             async with conn.cursor() as cursor:
                 await cursor.execute("SELECT * FROM one_row")
-                assert cursor.fetchone() == (1,)
+                assert await cursor.fetchone() == (1,)
         finally:
             conn.close()
 
@@ -69,7 +69,7 @@ async def test_invalid_arraysize(self, aio_pandas_cursor):
 
     async def test_description(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT CAST(1 AS INT) AS foobar FROM one_row")
-        assert aio_pandas_cursor.fetchall() == [(1,)]
+        assert await aio_pandas_cursor.fetchall() == [(1,)]
         assert aio_pandas_cursor.description == [
             ("foobar", "integer", None, None, 10, 0, "UNKNOWN")
         ]
@@ -86,11 +86,11 @@ async def test_executemany_fetch(self, aio_pandas_cursor):
             "SELECT %(x)d FROM one_row", [{"x": i} for i in range(1, 2)]
         )
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchall()
+            await aio_pandas_cursor.fetchall()
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchmany()
+            await aio_pandas_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_pandas_cursor.fetchone()
+            await aio_pandas_cursor.fetchone()
         with pytest.raises(ProgrammingError):
             aio_pandas_cursor.as_pandas()
 
@@ -101,8 +101,8 @@ async def test_executemany_fetch(self, aio_pandas_cursor):
     )
     async def test_fetchone_unload(self, aio_pandas_cursor):
         await aio_pandas_cursor.execute("SELECT * FROM one_row")
-        assert aio_pandas_cursor.fetchone() == (1,)
-        assert aio_pandas_cursor.fetchone() is None
+        assert await aio_pandas_cursor.fetchone() == (1,)
+        assert await aio_pandas_cursor.fetchone() is None
 
     @pytest.mark.parametrize(
         "aio_pandas_cursor",
diff --git a/tests/pyathena/aio/polars/test_cursor.py b/tests/pyathena/aio/polars/test_cursor.py
@@ -11,20 +11,20 @@ class TestAioPolarsCursor:
     async def test_fetchone(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT * FROM one_row")
         assert aio_polars_cursor.rownumber == 0
-        assert aio_polars_cursor.fetchone() == (1,)
+        assert await aio_polars_cursor.fetchone() == (1,)
         assert aio_polars_cursor.rownumber == 1
-        assert aio_polars_cursor.fetchone() is None
+        assert await aio_polars_cursor.fetchone() is None
 
     async def test_fetchmany(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT * FROM many_rows LIMIT 15")
-        assert len(aio_polars_cursor.fetchmany(10)) == 10
-        assert len(aio_polars_cursor.fetchmany(10)) == 5
+        assert len(await aio_polars_cursor.fetchmany(10)) == 10
+        assert len(await aio_polars_cursor.fetchmany(10)) == 5
 
     async def test_fetchall(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT * FROM one_row")
-        assert aio_polars_cursor.fetchall() == [(1,)]
+        assert await aio_polars_cursor.fetchall() == [(1,)]
         await aio_polars_cursor.execute("SELECT a FROM many_rows ORDER BY a")
-        assert aio_polars_cursor.fetchall() == [(i,) for i in range(10000)]
+        assert await aio_polars_cursor.fetchall() == [(i,) for i in range(10000)]
 
     async def test_as_polars(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT * FROM one_row")
@@ -44,11 +44,11 @@ async def test_execute_returns_self(self, aio_polars_cursor):
 
     async def test_no_result_set_raises(self, aio_polars_cursor):
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchone()
+            await aio_polars_cursor.fetchone()
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchmany()
+            await aio_polars_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchall()
+            await aio_polars_cursor.fetchall()
         with pytest.raises(ProgrammingError):
             aio_polars_cursor.as_polars()
         with pytest.raises(ProgrammingError):
@@ -61,7 +61,7 @@ async def test_context_manager(self):
         try:
             async with conn.cursor() as cursor:
                 await cursor.execute("SELECT * FROM one_row")
-                assert cursor.fetchone() == (1,)
+                assert await cursor.fetchone() == (1,)
         finally:
             conn.close()
 
@@ -76,7 +76,7 @@ async def test_invalid_arraysize(self, aio_polars_cursor):
 
     async def test_description(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT CAST(1 AS INT) AS foobar FROM one_row")
-        assert aio_polars_cursor.fetchall() == [(1,)]
+        assert await aio_polars_cursor.fetchall() == [(1,)]
         assert aio_polars_cursor.description == [
             ("foobar", "integer", None, None, 10, 0, "UNKNOWN")
         ]
@@ -93,11 +93,11 @@ async def test_executemany_fetch(self, aio_polars_cursor):
             "SELECT %(x)d FROM one_row", [{"x": i} for i in range(1, 2)]
         )
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchall()
+            await aio_polars_cursor.fetchall()
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchmany()
+            await aio_polars_cursor.fetchmany()
         with pytest.raises(ProgrammingError):
-            aio_polars_cursor.fetchone()
+            await aio_polars_cursor.fetchone()
         with pytest.raises(ProgrammingError):
             aio_polars_cursor.as_polars()
         with pytest.raises(ProgrammingError):
@@ -110,8 +110,8 @@ async def test_executemany_fetch(self, aio_polars_cursor):
     )
     async def test_fetchone_unload(self, aio_polars_cursor):
         await aio_polars_cursor.execute("SELECT * FROM one_row")
-        assert aio_polars_cursor.fetchone() == (1,)
-        assert aio_polars_cursor.fetchone() is None
+        assert await aio_polars_cursor.fetchone() == (1,)
+        assert await aio_polars_cursor.fetchone() is None
 
     @pytest.mark.parametrize(
         "aio_polars_cursor",
