stopping wrapping of driver exceptions as is maintenance issue

Author: millerjp

tests/unit/test_auth_failures.py

@@ -121,8 +121,8 @@ async def test_auth_failure_during_operation(self):
         ---------------
         1. Unauthorized error during query
         2. Permission failures on tables
-        3. Wrapped in QueryError
-        4. Original Unauthorized accessible
+        3. Passed through directly
+        4. Native exception handling
 
         Why this matters:
         ----------------
@@ -131,7 +131,7 @@ async def test_auth_failure_during_operation(self):
         - Role changes after connection
         - Fine-grained access control
 
-        Applications need to:
+        Applications need direct access to:
         - Handle permission errors gracefully
         - Potentially retry with different user
         - Log security violations
@@ -232,7 +232,7 @@ async def test_authorization_failure_different_operations(self):
         1. Different permission types (SELECT, MODIFY, CREATE, etc.)
         2. Each permission failure handled correctly
         3. Error messages indicate specific permission
-        4. Consistent wrapping in QueryError
+        4. Exceptions passed through directly
 
         Why this matters:
         ----------------

tests/unit/test_connection_pool_exhaustion.py

@@ -111,7 +111,7 @@ async def test_pool_exhaustion_under_load(self, mock_session):
         ---------------
         1. Pool has finite connection limit
         2. Excess queries fail with NoConnectionsAvailable
-        3. Failures are wrapped in QueryError
+        3. Exceptions passed through directly
         4. Success/failure count matches pool size
 
         Why this matters:
@@ -121,8 +121,8 @@ async def test_pool_exhaustion_under_load(self, mock_session):
         - Database has connection limits
         - Pool size must be tuned
 
-        Applications must handle pool exhaustion
-        gracefully with retries or backoff.
+        Applications need direct access to
+        handle pool exhaustion with retries.
         """
         async_session = AsyncCassandraSession(mock_session)
 
@@ -152,14 +152,8 @@ def execute_async_side_effect(*args, **kwargs):
 
         # First pool_size queries should succeed
         successful = [r for r in results if not isinstance(r, Exception)]
-        # NoConnectionsAvailable is wrapped in QueryError
-        from async_cassandra.exceptions import QueryError
-
-        failed = [
-            r
-            for r in results
-            if isinstance(r, QueryError) and isinstance(r.cause, NoConnectionsAvailable)
-        ]
+        # NoConnectionsAvailable is now passed through directly
+        failed = [r for r in results if isinstance(r, NoConnectionsAvailable)]
 
         assert len(successful) == pool_size
         assert len(failed) == 3
@@ -240,12 +234,9 @@ def execute_async_side_effect(*args, **kwargs):
         mock_session.execute_async.side_effect = execute_async_side_effect
 
         # First attempts fail
-        from async_cassandra.exceptions import QueryError
-
         for i in range(3):
-            with pytest.raises(QueryError) as exc_info:
+            with pytest.raises(NoConnectionsAvailable):
                 await async_session.execute("SELECT * FROM test")
-            assert isinstance(exc_info.value.cause, NoConnectionsAvailable)
 
         # Wait a bit (simulating pool recovery)
         await asyncio.sleep(0.1)
@@ -301,7 +292,7 @@ def execute_async_side_effect(*args, **kwargs):
             try:
                 result = await async_session.execute(f"SELECT {i}")
                 results.append(result)
-            except Exception:  # QueryError wrapping NoConnectionsAvailable
+            except NoConnectionsAvailable:  # NoConnectionsAvailable is now passed through directly
                 results.append(None)
 
         # Should have 1 failure (3rd query)
@@ -381,14 +372,8 @@ def execute_async_side_effect(*args, **kwargs):
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
         # Should have mix of successes and failures
-        from async_cassandra.exceptions import QueryError
-
         successes = sum(1 for r in results if not isinstance(r, Exception))
-        failures = sum(
-            1
-            for r in results
-            if isinstance(r, QueryError) and isinstance(r.cause, NoConnectionsAvailable)
-        )
+        failures = sum(1 for r in results if isinstance(r, NoConnectionsAvailable))
 
         assert successes >= max_concurrent
         assert failures > 0
@@ -629,11 +614,8 @@ def execute_async_side_effect(*args, **kwargs):
         degradation_active = True
 
         # Non-critical query should fail
-        from async_cassandra.exceptions import QueryError
-
-        with pytest.raises(QueryError) as exc_info:
+        with pytest.raises(NoConnectionsAvailable):
             await async_session.execute("SELECT * FROM test")
-        assert isinstance(exc_info.value.cause, NoConnectionsAvailable)
 
         # Critical query should still work
         result = await async_session.execute("CRITICAL: SELECT * FROM system.local")

tests/unit/test_network_failures.py

@@ -32,7 +32,6 @@
 from cassandra.cluster import ConnectionException, Host, NoHostAvailable
 
 from async_cassandra import AsyncCassandraSession, AsyncCluster
-from async_cassandra.exceptions import QueryError
 
 
 class TestNetworkFailures:
@@ -107,8 +106,8 @@ async def test_partial_network_failure(self, mock_session):
         ---------------
         1. Connection established but queries fail
         2. ConnectionException during execution
-        3. Wrapped in QueryError for context
-        4. Original exception preserved
+        3. Exception passed through directly
+        4. Native error handling preserved
 
         Why this matters:
         ----------------
@@ -117,8 +116,8 @@ async def test_partial_network_failure(self, mock_session):
         - Network degradation after connect
         - Load balancer issues
 
-        Applications need to detect and handle
-        these "connected but broken" states.
+        Applications need direct access to
+        handle these "connected but broken" states.
         """
         async_session = AsyncCassandraSession(mock_session)
 
@@ -127,12 +126,11 @@ async def test_partial_network_failure(self, mock_session):
             ConnectionException("Connection closed by remote host")
         )
 
-        # ConnectionException is wrapped in QueryError
-        with pytest.raises(QueryError) as exc_info:
+        # ConnectionException is now passed through directly
+        with pytest.raises(ConnectionException) as exc_info:
             await async_session.execute("SELECT * FROM test")
 
         assert "Connection closed by remote host" in str(exc_info.value)
-        assert isinstance(exc_info.value.cause, ConnectionException)
 
     @pytest.mark.asyncio
     async def test_connection_timeout_during_query(self, mock_session):
@@ -323,9 +321,8 @@ def execute_async_side_effect(*args, **kwargs):
             try:
                 result = await async_session.execute(f"SELECT {i}")
                 results.append(result.rows[0]["flap_count"])
-            except QueryError as e:
-                if isinstance(e.cause, ConnectionException):
-                    errors.append(str(e))
+            except ConnectionException as e:
+                errors.append(str(e))
 
         # Should have mix of successes and failures
         assert len(results) == 3  # Even numbered attempts succeed

tests/unit/test_protocol_edge_cases.py

@@ -32,7 +32,7 @@
 from cassandra.connection import ProtocolError
 
 from async_cassandra import AsyncCassandraSession
-from async_cassandra.exceptions import ConnectionError, QueryError
+from async_cassandra.exceptions import ConnectionError
 
 
 class TestProtocolEdgeCases:
@@ -298,7 +298,7 @@ async def test_protocol_error_recovery(self, mock_session):
         ---------------
         1. Protocol errors can be transient
         2. Recovery possible after errors
-        3. Multiple attempts tracked
+        3. Direct exception handling
         4. Eventually succeeds
 
         Why this matters:
@@ -308,8 +308,8 @@ async def test_protocol_error_recovery(self, mock_session):
         - Temporary corruption
         - Race conditions
 
-        Retry with new connection often
-        resolves transient issues.
+        Users can implement retry logic
+        with new connections as needed.
         """
         async_session = AsyncCassandraSession(mock_session)
 
@@ -331,9 +331,8 @@ def execute_async_side_effect(*args, **kwargs):
 
         # First two attempts should fail
         for i in range(2):
-            with pytest.raises(QueryError) as exc_info:
+            with pytest.raises(ProtocolError):
                 await async_session.execute("SELECT * FROM test")
-            assert isinstance(exc_info.value.__cause__, ProtocolError)
 
         # Third attempt should succeed
         result = await async_session.execute("SELECT * FROM test")