Formatting tests files using black formatter

Author: jahnvi480

tests/test_003_connection.py

@@ -992,14 +992,16 @@ def test_execute_with_large_parameters(db_connection, conn_str):
         pytest.skip("Skipping for Azure SQL - large parameter tests may cause timeouts")
 
     # Test with a temporary table for large data
-    cursor = db_connection.execute("""
+    cursor = db_connection.execute(
+        """
     DROP TABLE IF EXISTS #large_params_test;
     CREATE TABLE #large_params_test (
         id INT,
         large_text NVARCHAR(MAX),
         large_binary VARBINARY(MAX)
     )
-    """)
+    """
+    )
     cursor.close()
 
     try:
@@ -2124,10 +2126,12 @@ def test_timeout_long_query(db_connection):
                     while retry_count < max_retries:
                         start_time = time.perf_counter()
                         try:
-                            cursor.execute("""
+                            cursor.execute(
+                                """
                             SELECT COUNT(*) FROM sys.objects a, sys.objects b, sys.objects c
                             WHERE a.object_id = b.object_id * c.object_id
-                            """)
+                            """
+                            )
                             cursor.fetchall()
                             elapsed_time = time.perf_counter() - start_time
                             break  # Success, exit retry loop

tests/test_004_cursor.py

@@ -15406,7 +15406,9 @@ def test_native_uuid_false_returns_strings(db_connection):
         cursor.execute("SELECT id, name FROM #test_native_uuid_false")
         row = cursor.fetchone()
         assert isinstance(row[0], str), f"With native_uuid=False, expected str, got {type(row[0])}"
-        assert row[0] == str(test_uuid).upper(), f"UUID string mismatch: {row[0]} != {str(test_uuid).upper()}"
+        assert (
+            row[0] == str(test_uuid).upper()
+        ), f"UUID string mismatch: {row[0]} != {str(test_uuid).upper()}"
 
         # fetchall
         cursor.execute("SELECT id, name FROM #test_native_uuid_false")
@@ -15845,7 +15847,9 @@ def test_two_connections_different_native_uuid(conn_str):
 
         assert isinstance(row_uuid[0], uuid.UUID), f"Expected uuid.UUID, got {type(row_uuid[0])}"
         assert isinstance(row_string[0], str), f"Expected str, got {type(row_string[0])}"
-        assert str(row_uuid[0]).upper() == row_string[0], "Values should be equal as uppercase strings"
+        assert (
+            str(row_uuid[0]).upper() == row_string[0]
+        ), "Values should be equal as uppercase strings"
 
         drop_table_if_exists(cursor_uuid, "#test_dual_conn")
         drop_table_if_exists(cursor_string, "##test_dual_conn_shared")

tests/test_011_performance_stress.py

@@ -53,13 +53,15 @@ def test_exception_mid_batch_no_corrupt_data(cursor, db_connection):
         drop_table_if_exists(cursor, "#pytest_mid_batch_exception")
 
         # Create simple table to test batch processing integrity
-        cursor.execute("""
+        cursor.execute(
+            """
             CREATE TABLE #pytest_mid_batch_exception (
                 id INT,
                 value NVARCHAR(50),
                 amount FLOAT
             )
-        """)
+        """
+        )
         db_connection.commit()
 
         # Insert 1000 rows using individual inserts to avoid executemany complications
@@ -119,14 +121,16 @@ def test_python_c_api_null_handling_memory_pressure(cursor, db_connection):
         drop_table_if_exists(cursor, "#pytest_memory_pressure")
 
         # Create table with various string types
-        cursor.execute("""
+        cursor.execute(
+            """
             CREATE TABLE #pytest_memory_pressure (
                 id INT,
                 varchar_col VARCHAR(1000),
                 nvarchar_col NVARCHAR(1000),
                 varbinary_col VARBINARY(1000)
             )
-        """)
+        """
+        )
         db_connection.commit()
 
         # Insert test data
@@ -188,14 +192,16 @@ def test_thousands_of_empty_strings_allocation_stress(cursor, db_connection):
     try:
         drop_table_if_exists(cursor, "#pytest_empty_stress")
 
-        cursor.execute("""
+        cursor.execute(
+            """
             CREATE TABLE #pytest_empty_stress (
                 id INT,
                 empty_varchar VARCHAR(100),
                 empty_nvarchar NVARCHAR(100),
                 empty_varbinary VARBINARY(100)
             )
-        """)
+        """
+        )
         db_connection.commit()
 
         # Insert 10,000 rows with empty strings
@@ -271,14 +277,16 @@ def test_large_result_set_100k_rows_no_overflow(cursor, db_connection):
     try:
         drop_table_if_exists(cursor, "#pytest_100k_rows")
 
-        cursor.execute("""
+        cursor.execute(
+            """
             CREATE TABLE #pytest_100k_rows (
                 id INT,
                 varchar_col VARCHAR(50),
                 nvarchar_col NVARCHAR(50),
                 int_col INT
             )
-        """)
+        """
+        )
         db_connection.commit()
 
         # Insert 100,000 rows with sequential IDs and predictable data
@@ -367,14 +375,16 @@ def test_very_large_lob_10mb_data_integrity(cursor, db_connection):
     try:
         drop_table_if_exists(cursor, "#pytest_10mb_lob")
 
-        cursor.execute("""
+        cursor.execute(
+            """
             CREATE TABLE #pytest_10mb_lob (
                 id INT,
                 varchar_lob VARCHAR(MAX),
                 nvarchar_lob NVARCHAR(MAX),
                 varbinary_lob VARBINARY(MAX)
             )
-        """)
+        """
+        )
         db_connection.commit()
 
         # Create 10MB+ data
@@ -484,13 +494,15 @@ def worker_thread(thread_id: int, conn_str: str, results_list: List, errors_list
             table_name = f"#pytest_concurrent_t{thread_id}"
             drop_table_if_exists(cursor, table_name)
 
-            cursor.execute(f"""
+            cursor.execute(
+                f"""
                 CREATE TABLE {table_name} (
                     id INT,
                     thread_id INT,
                     data VARCHAR(100)
                 )
-            """)
+            """
+            )
             conn.commit()
 
             # Insert thread-specific data