Fix async tests

Author: sfc-gh-pczajka

test/integ/aio/test_autocommit_async.py

@@ -5,8 +5,6 @@
 
 from __future__ import annotations
 
-import snowflake.connector.aio
-
 
 async def exe0(cnx, sql):
     return await cnx.cursor().execute(sql)
@@ -164,7 +162,7 @@ async def exe(cnx, sql):
             )
 
 
-async def test_autocommit_parameters(db_parameters):
+async def test_autocommit_parameters(db_parameters, conn_cnx):
     """Tests autocommit parameter.
 
     Args:
@@ -174,17 +172,7 @@ async def test_autocommit_parameters(db_parameters):
     async def exe(cnx, sql):
         return await cnx.cursor().execute(sql.format(name=db_parameters["name"]))
 
-    async with snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        protocol=db_parameters["protocol"],
-        schema=db_parameters["schema"],
-        database=db_parameters["database"],
-        autocommit=False,
-    ) as cnx:
+    async with conn_cnx(autocommit=False) as cnx:
         await exe(
             cnx,
             """
@@ -193,17 +181,7 @@ async def exe(cnx, sql):
         )
         await _run_autocommit_off(cnx, db_parameters)
 
-    async with snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        protocol=db_parameters["protocol"],
-        schema=db_parameters["schema"],
-        database=db_parameters["database"],
-        autocommit=True,
-    ) as cnx:
+    async with conn_cnx(autocommit=True) as cnx:
         await _run_autocommit_on(cnx, db_parameters)
         await exe(
             cnx,

test/integ/aio/test_converter_null_async.py

@@ -8,25 +8,16 @@
 from datetime import datetime, timedelta, timezone
 from test.integ.test_converter_null import NUMERIC_VALUES
 
-import snowflake.connector.aio
 from snowflake.connector.converter import ZERO_EPOCH
 from snowflake.connector.converter_null import SnowflakeNoConverterToPython
 
 
-async def test_converter_no_converter_to_python(db_parameters):
+async def test_converter_no_converter_to_python(conn_cnx):
     """Tests no converter.
 
     This should not translate the Snowflake internal data representation to the Python native types.
     """
-    async with snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        protocol=db_parameters["protocol"],
+    async with conn_cnx(
         timezone="UTC",
         converter_class=SnowflakeNoConverterToPython,
     ) as con:

test/integ/aio/test_cursor_async.py

@@ -188,7 +188,9 @@ async def test_insert_select(conn, db_parameters, caplog):
             assert "Number of results in first chunk: 3" in caplog.text
 
 
-async def test_insert_and_select_by_separate_connection(conn, db_parameters, caplog):
+async def test_insert_and_select_by_separate_connection(
+    conn, conn_cnx, db_parameters, caplog
+):
     """Inserts a record and select it by a separate connection."""
     caplog.set_level(logging.DEBUG)
     async with conn() as cnx:
@@ -202,20 +204,7 @@ async def test_insert_and_select_by_separate_connection(conn, db_parameters, cap
             cnt += int(rec[0])
         assert cnt == 1, "wrong number of records were inserted"
         assert result.rowcount == 1, "wrong number of records were inserted"
-
-    cnx2 = snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        protocol=db_parameters["protocol"],
-        timezone="UTC",
-    )
-    await cnx2.connect()
-    try:
+    async with conn_cnx(timezone="UTC") as cnx2:
         c = cnx2.cursor()
         await c.execute("select aa from {name}".format(name=db_parameters["name"]))
         results = []
@@ -225,8 +214,6 @@ async def test_insert_and_select_by_separate_connection(conn, db_parameters, cap
         assert results[0] == 1234, "the first result was wrong"
         assert result.rowcount == 1, "wrong number of records were selected"
         assert "Number of results in first chunk: 1" in caplog.text
-    finally:
-        await cnx2.close()
 
 
 def _total_milliseconds_from_timedelta(td):
@@ -239,7 +226,7 @@ def _total_seconds_from_timedelta(td):
     return _total_milliseconds_from_timedelta(td) // 10**3
 
 
-async def test_insert_timestamp_select(conn, db_parameters):
+async def test_insert_timestamp_select(conn, conn_cnx, db_parameters):
     """Inserts and gets timestamp, timestamp with tz, date, and time.
 
     Notes:
@@ -282,19 +269,7 @@ async def test_insert_timestamp_select(conn, db_parameters):
         finally:
             await c.close()
 
-    cnx2 = snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        protocol=db_parameters["protocol"],
-        timezone="UTC",
-    )
-    await cnx2.connect()
-    try:
+    async with conn_cnx(timezone="UTC") as cnx2:
         c = cnx2.cursor()
         await c.execute(
             "select aa, tsltz, tstz, tsntz, dt, tm from {name}".format(
@@ -374,8 +349,6 @@ async def test_insert_timestamp_select(conn, db_parameters):
             assert (
                 constants.FIELD_ID_TO_NAME[type_code(desc[5])] == "TIME"
             ), "invalid column name"
-    finally:
-        await cnx2.close()
 
 
 async def test_insert_timestamp_ltz(conn, db_parameters):
@@ -475,7 +448,7 @@ async def test_struct_time(conn, db_parameters):
                 time.tzset()
 
 
-async def test_insert_binary_select(conn, db_parameters):
+async def test_insert_binary_select(conn, conn_cnx, db_parameters):
     """Inserts and get a binary value."""
     value = b"\x00\xFF\xA1\xB2\xC3"
 
@@ -490,18 +463,7 @@ async def test_insert_binary_select(conn, db_parameters):
         finally:
             await c.close()
 
-    cnx2 = snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        protocol=db_parameters["protocol"],
-    )
-    await cnx2.connect()
-    try:
+    async with conn_cnx() as cnx2:
         c = cnx2.cursor()
         await c.execute("select b from {name}".format(name=db_parameters["name"]))
 
@@ -524,11 +486,9 @@ async def test_insert_binary_select(conn, db_parameters):
             assert (
                 constants.FIELD_ID_TO_NAME[type_code(desc[0])] == "BINARY"
             ), "invalid column name"
-    finally:
-        await cnx2.close()
 
 
-async def test_insert_binary_select_with_bytearray(conn, db_parameters):
+async def test_insert_binary_select_with_bytearray(conn, conn_cnx, db_parameters):
     """Inserts and get a binary value using the bytearray type."""
     value = bytearray(b"\x00\xFF\xA1\xB2\xC3")
 
@@ -543,18 +503,7 @@ async def test_insert_binary_select_with_bytearray(conn, db_parameters):
         finally:
             await c.close()
 
-    cnx2 = snowflake.connector.aio.SnowflakeConnection(
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        account=db_parameters["account"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        protocol=db_parameters["protocol"],
-    )
-    await cnx2.connect()
-    try:
+    async with conn_cnx() as cnx2:
         c = cnx2.cursor()
         await c.execute("select b from {name}".format(name=db_parameters["name"]))
 
@@ -577,8 +526,6 @@ async def test_insert_binary_select_with_bytearray(conn, db_parameters):
             assert (
                 constants.FIELD_ID_TO_NAME[type_code(desc[0])] == "BINARY"
             ), "invalid column name"
-    finally:
-        await cnx2.close()
 
 
 async def test_variant(conn, db_parameters):

test/integ/aio/test_dbapi_async.py

@@ -133,21 +133,10 @@ async def test_exceptions_as_connection_attributes(conn_cnx):
         assert con.NotSupportedError == errors.NotSupportedError
 
 
-async def test_commit(db_parameters):
-    con = snowflake.connector.aio.SnowflakeConnection(
-        account=db_parameters["account"],
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        protocol=db_parameters["protocol"],
-    )
-    await con.connect()
-    try:
+async def test_commit(conn_cnx):
+    async with conn_cnx() as con:
         # Commit must work, even if it doesn't do anything
         await con.commit()
-    finally:
-        await con.close()
 
 
 async def test_rollback(conn_cnx, db_parameters):
@@ -247,20 +236,9 @@ async def test_rowcount(conn_local):
         assert cur.rowcount == 1, "cursor.rowcount should the number of rows returned"
 
 
-async def test_close(db_parameters):
-    con = snowflake.connector.aio.SnowflakeConnection(
-        account=db_parameters["account"],
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        protocol=db_parameters["protocol"],
-    )
-    await con.connect()
-    try:
+async def test_close(conn_cnx):
+    async with conn_cnx() as con:
         cur = con.cursor()
-    finally:
-        await con.close()
 
     # commit is currently a nop; disabling for now
     # connection.commit should raise an Error if called after connection is

test/integ/aio/test_put_windows_path_async.py

@@ -21,11 +21,7 @@ async def test_abc(conn_cnx, tmpdir, db_parameters):
     fileURI = pathlib.Path(test_data).as_uri()
 
     subdir = db_parameters["name"]
-    async with conn_cnx(
-        user=db_parameters["user"],
-        account=db_parameters["account"],
-        password=db_parameters["password"],
-    ) as con:
+    async with conn_cnx() as con:
         rec = await (
             await con.cursor().execute(f"put {fileURI} @~/{subdir}0/")
         ).fetchall()

test/integ/aio/test_session_parameters_async.py

@@ -16,19 +16,9 @@
     CONNECTION_PARAMETERS_ADMIN = {}
 
 
-async def test_session_parameters(db_parameters):
+async def test_session_parameters(conn_cnx):
     """Sets the session parameters in connection time."""
-    async with snowflake.connector.aio.SnowflakeConnection(
-        protocol=db_parameters["protocol"],
-        account=db_parameters["account"],
-        user=db_parameters["user"],
-        password=db_parameters["password"],
-        host=db_parameters["host"],
-        port=db_parameters["port"],
-        database=db_parameters["database"],
-        schema=db_parameters["schema"],
-        session_parameters={"TIMEZONE": "UTC"},
-    ) as connection:
+    async with conn_cnx(session_parameters={"TIMEZONE": "UTC"}) as connection:
         ret = await (
             await connection.cursor().execute("show parameters like 'TIMEZONE'")
         ).fetchone()