formatting (black)

Author: varun-edachali-dbx

tests/e2e/test_driver.py

@@ -856,7 +856,9 @@ def test_closing_a_closed_connection_doesnt_fail(self, caplog):
                     raise KeyboardInterrupt("Simulated interrupt")
         finally:
             if conn is not None:
-                assert not conn.open, "Connection should be closed after KeyboardInterrupt"
+                assert (
+                    not conn.open
+                ), "Connection should be closed after KeyboardInterrupt"
 
     def test_cursor_close_properly_closes_operation(self):
         """Test that Cursor.close() properly closes the active operation handle on the server."""
@@ -883,7 +885,9 @@ def test_cursor_close_properly_closes_operation(self):
                         raise KeyboardInterrupt("Simulated interrupt")
         finally:
             if cursor is not None:
-                assert not cursor.open, "Cursor should be closed after KeyboardInterrupt"
+                assert (
+                    not cursor.open
+                ), "Cursor should be closed after KeyboardInterrupt"
 
     def test_nested_cursor_context_managers(self):
         """Test that nested cursor context managers properly close operations on the server."""

tests/unit/test_client.py

@@ -528,7 +528,7 @@ def test_cursor_close_handles_exception(self):
         mock_backend = Mock()
         mock_connection = Mock()
         mock_op_handle = Mock()
-        
+
         mock_backend.close_command.side_effect = Exception("Test error")
 
         cursor = client.Cursor(mock_connection, mock_backend)
@@ -537,78 +537,80 @@ def test_cursor_close_handles_exception(self):
         cursor.close()
 
         mock_backend.close_command.assert_called_once_with(mock_op_handle)
-        
+
         self.assertIsNone(cursor.active_op_handle)
-        
+
         self.assertFalse(cursor.open)
 
     def test_cursor_context_manager_handles_exit_exception(self):
         """Test that cursor's context manager handles exceptions during __exit__."""
         mock_backend = Mock()
         mock_connection = Mock()
-        
+
         cursor = client.Cursor(mock_connection, mock_backend)
         original_close = cursor.close
         cursor.close = Mock(side_effect=Exception("Test error during close"))
-        
+
         try:
             with cursor:
                 raise ValueError("Test error inside context")
         except ValueError:
             pass
-        
+
         cursor.close.assert_called_once()
 
     def test_connection_close_handles_cursor_close_exception(self):
         """Test that _close handles exceptions from cursor.close() properly."""
         cursors_closed = []
-        
+
         def mock_close_with_exception():
             cursors_closed.append(1)
             raise Exception("Test error during close")
-        
+
         cursor1 = Mock()
         cursor1.close = mock_close_with_exception
-        
+
         def mock_close_normal():
             cursors_closed.append(2)
-        
+
         cursor2 = Mock()
         cursor2.close = mock_close_normal
-        
+
         mock_backend = Mock()
         mock_session_handle = Mock()
-        
+
         try:
             for cursor in [cursor1, cursor2]:
                 try:
                     cursor.close()
                 except Exception:
                     pass
-                    
+
             mock_backend.close_session(mock_session_handle)
         except Exception as e:
             self.fail(f"Connection close should handle exceptions: {e}")
-        
-        self.assertEqual(cursors_closed, [1, 2], "Both cursors should have close called")
+
+        self.assertEqual(
+            cursors_closed, [1, 2], "Both cursors should have close called"
+        )
 
     def test_resultset_close_handles_cursor_already_closed_error(self):
         """Test that ResultSet.close() handles CursorAlreadyClosedError properly."""
         result_set = client.ResultSet.__new__(client.ResultSet)
         result_set.thrift_backend = Mock()
-        result_set.thrift_backend.CLOSED_OP_STATE = 'CLOSED'
+        result_set.thrift_backend.CLOSED_OP_STATE = "CLOSED"
         result_set.connection = Mock()
         result_set.connection.open = True
-        result_set.op_state = 'RUNNING'
+        result_set.op_state = "RUNNING"
         result_set.has_been_closed_server_side = False
         result_set.command_id = Mock()
 
         class MockRequestError(Exception):
             def __init__(self):
                 self.args = ["Error message", CursorAlreadyClosedError()]
-        
+
         result_set.thrift_backend.close_command.side_effect = MockRequestError()
-        
+
         original_close = client.ResultSet.close
         try:
             try:
@@ -624,11 +626,13 @@ def __init__(self):
             finally:
                 result_set.has_been_closed_server_side = True
                 result_set.op_state = result_set.thrift_backend.CLOSED_OP_STATE
-                
-            result_set.thrift_backend.close_command.assert_called_once_with(result_set.command_id)
-            
+
+            result_set.thrift_backend.close_command.assert_called_once_with(
+                result_set.command_id
+            )
+
             assert result_set.has_been_closed_server_side is True
-            
+
             assert result_set.op_state == result_set.thrift_backend.CLOSED_OP_STATE
         finally:
             pass