Remove AsyncoreConnection tests (deprecated in Python 3.12+)

Copilot · fruch · Copilot · commit 3cdee85f4c85 · 2026-02-12T08:51:14.000Z
Removed AsyncoreConnection from integration tests as asyncore module
is deprecated in Python 3.6 and removed in Python 3.12+. This was
preventing test collection and execution on newer Python versions.

Changes:
- Removed AsyncoreConnection import
- Removed AsyncoreSSLConnectionFailureTest class (5 tests)
- Updated SSLErrorMessageQualityTest to only use AsyncioConnection
- Updated documentation to reflect 4 integration tests instead of 8

The unit tests (14 tests) remain unchanged and provide comprehensive
coverage for SSL error handling scenarios.

Co-authored-by: fruch &lt;340979+fruch@users.noreply.github.com&gt;
diff --git a/tests/integration/standard/test_ssl_connection_failures.py b/tests/integration/standard/test_ssl_connection_failures.py
@@ -37,170 +37,12 @@
 from cassandra.connection import ConnectionShutdown, DefaultEndPoint
 from cassandra.cluster import NoHostAvailable
 
-try:
-    from cassandra.io.asyncorereactor import AsyncoreConnection
-except ImportError:
-    AsyncoreConnection = None
-
 try:
     from cassandra.io.asyncioreactor import AsyncioConnection
 except ImportError:
     AsyncioConnection = None
 
 
-@unittest.skipIf(AsyncoreConnection is None, "asyncore reactor not available")
-class AsyncoreSSLConnectionFailureTest(unittest.TestCase):
-    """
-    Test SSL connection failures with AsyncoreConnection.
-    
-    These tests simulate connection failures that can occur in production,
-    particularly when nodes are rebooted or network issues occur.
-    """
-
-    def test_socket_closed_forcefully_during_send(self):
-        """
-        Test that forcefully closing a socket during send preserves error info.
-        
-        Simulates: Node reboot causing socket to be closed while sending data
-        """
-        # Create a connection
-        # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        conn = AsyncoreConnection(
-            DefaultEndPoint('127.0.0.1', 9999),
-            ssl_options={'cert_reqs': ssl.CERT_NONE}
-        )
-        
-        # Create a mock socket that will fail on send
-        mock_socket = Mock(spec=ssl.SSLSocket)
-        bad_fd_error = OSError(errno.EBADF, "Bad file descriptor")
-        mock_socket.send.side_effect = bad_fd_error
-        mock_socket.fileno.return_value = 999
-        
-        conn._socket = mock_socket
-        
-        # Try to trigger defunct by simulating a send error
-        conn.defunct(bad_fd_error)
-        
-        # Verify the error is preserved
-        self.assertTrue(conn.is_defunct)
-        self.assertEqual(conn.last_error, bad_fd_error)
-        self.assertIn("Bad file descriptor", str(conn.last_error))
-
-    def test_connection_reset_during_recv(self):
-        """
-        Test handling of connection reset during receive operation.
-        
-        Simulates: Node reboot causing connection reset while reading response
-        """
-        # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        conn = AsyncoreConnection(
-            DefaultEndPoint('127.0.0.1', 9999),
-            ssl_options={'cert_reqs': ssl.CERT_NONE}
-        )
-        
-        # Create a mock socket that will fail on recv
-        mock_socket = Mock(spec=ssl.SSLSocket)
-        conn_reset_error = OSError(errno.ECONNRESET, "Connection reset by peer")
-        mock_socket.recv.side_effect = conn_reset_error
-        mock_socket.fileno.return_value = 999
-        
-        conn._socket = mock_socket
-        conn.defunct(conn_reset_error)
-        
-        # Verify the error is preserved
-        self.assertTrue(conn.is_defunct)
-        self.assertEqual(conn.last_error, conn_reset_error)
-        self.assertIn("Connection reset by peer", str(conn.last_error))
-
-    def test_ssl_handshake_failure(self):
-        """
-        Test SSL handshake failure is properly captured and reported.
-        
-        Simulates: SSL handshake failure due to connection issues
-        """
-        conn = AsyncoreConnection(
-            DefaultEndPoint('127.0.0.1', 9999),
-            ssl_options={'cert_reqs': ssl.CERT_REQUIRED}
-        )
-        
-        # Simulate SSL error
-        ssl_error = ssl.SSLError(ssl.SSL_ERROR_SYSCALL, "Unexpected EOF")
-        conn.defunct(ssl_error)
-        
-        # Verify the error is preserved
-        self.assertTrue(conn.is_defunct)
-        self.assertEqual(conn.last_error, ssl_error)
-        self.assertIn("Unexpected EOF", str(conn.last_error))
-
-    def test_broken_pipe_on_ssl_socket(self):
-        """
-        Test handling of broken pipe error on SSL socket.
-        
-        Simulates: Write to socket whose peer has closed connection
-        """
-        # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        conn = AsyncoreConnection(
-            DefaultEndPoint('127.0.0.1', 9999),
-            ssl_options={'cert_reqs': ssl.CERT_NONE}
-        )
-        
-        broken_pipe_error = OSError(errno.EPIPE, "Broken pipe")
-        conn.defunct(broken_pipe_error)
-        
-        # Verify the error is preserved and accessible
-        self.assertTrue(conn.is_defunct)
-        self.assertEqual(conn.last_error, broken_pipe_error)
-        
-        # Verify that subsequent operations include the error
-        with self.assertRaises(ConnectionShutdown) as cm:
-            conn.send_msg(Mock(), 1, Mock())
-        
-        self.assertIn("Broken pipe", str(cm.exception))
-
-    def test_concurrent_operations_on_closing_ssl_connection(self):
-        """
-        Test concurrent operations when SSL connection is being closed.
-        
-        Simulates: Multiple threads operating on connection during node reboot
-        This is the core scenario from the reported issue.
-        """
-        # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        conn = AsyncoreConnection(
-            DefaultEndPoint('127.0.0.1', 9999),
-            ssl_options={'cert_reqs': ssl.CERT_NONE}
-        )
-        
-        # Simulate the connection having some requests
-        conn._requests = {
-            1: (Mock(), Mock(), Mock()),
-            2: (Mock(), Mock(), Mock()),
-        }
-        
-        # Original error that triggers closure
-        original_error = OSError(errno.ECONNRESET, "Connection reset by peer")
-        
-        # Mark as defunct
-        conn.defunct(original_error)
-        
-        # Verify error is preserved
-        self.assertTrue(conn.is_defunct)
-        self.assertEqual(conn.last_error, original_error)
-        
-        # Concurrent thread tries to send - should see original error
-        with self.assertRaises(ConnectionShutdown) as cm:
-            conn.send_msg(Mock(), 3, Mock())
-        
-        error_msg = str(cm.exception)
-        self.assertIn("Connection reset by peer", error_msg)
-        
-        # Another thread tries to wait for responses - should also see original error
-        with self.assertRaises(ConnectionShutdown) as cm:
-            conn.wait_for_responses(Mock())
-        
-        error_msg = str(cm.exception)
-        self.assertIn("Connection reset by peer", error_msg)
-
-
 @unittest.skipIf(AsyncioConnection is None, "asyncio reactor not available")
 class AsyncioSSLConnectionFailureTest(unittest.TestCase):
     """
@@ -264,20 +106,14 @@ def test_error_message_includes_root_cause(self):
         Verify that ConnectionShutdown messages include the root cause error.
         """
         # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        # This can work with any connection type
-        if AsyncoreConnection:
-            conn = AsyncoreConnection(
-                DefaultEndPoint('127.0.0.1', 9999),
-                ssl_options={'cert_reqs': ssl.CERT_NONE}
-            )
-        elif AsyncioConnection:
-            conn = AsyncioConnection(
-                DefaultEndPoint('127.0.0.1', 9999),
-                ssl_options={'cert_reqs': ssl.CERT_NONE}
-            )
-        else:
+        if AsyncioConnection is None:
             self.skipTest("No connection implementation available")
         
+        conn = AsyncioConnection(
+            DefaultEndPoint('127.0.0.1', 9999),
+            ssl_options={'cert_reqs': ssl.CERT_NONE}
+        )
+        
         # Simulate root cause
         root_cause = OSError(errno.ECONNRESET, "Connection reset by peer")
         conn.defunct(root_cause)
@@ -297,19 +133,14 @@ def test_multiple_errors_preserves_first(self):
         Verify that when multiple errors occur, the first (root cause) is preserved.
         """
         # Note: Using CERT_NONE for testing only - this is intentionally insecure
-        if AsyncoreConnection:
-            conn = AsyncoreConnection(
-                DefaultEndPoint('127.0.0.1', 9999),
-                ssl_options={'cert_reqs': ssl.CERT_NONE}
-            )
-        elif AsyncioConnection:
-            conn = AsyncioConnection(
-                DefaultEndPoint('127.0.0.1', 9999),
-                ssl_options={'cert_reqs': ssl.CERT_NONE}
-            )
-        else:
+        if AsyncioConnection is None:
             self.skipTest("No connection implementation available")
         
+        conn = AsyncioConnection(
+            DefaultEndPoint('127.0.0.1', 9999),
+            ssl_options={'cert_reqs': ssl.CERT_NONE}
+        )
+        
         # First error - the root cause
         root_cause = OSError(errno.ETIMEDOUT, "Connection timed out")
         conn.defunct(root_cause)
diff --git a/tests/unit/SSL_CONNECTION_TESTS.md b/tests/unit/SSL_CONNECTION_TESTS.md
@@ -50,20 +50,13 @@ This test suite verifies that this mechanism works correctly across all SSL erro
    - `test_ssl_error_on_closed_connection_send_msg`: Error included in send_msg
 
 ### Integration Tests (`test_ssl_connection_failures.py`)
-8 integration tests with actual connection implementations:
+4 integration tests with actual connection implementations:
 
-1. **AsyncoreConnection Tests** (5 tests)
-   - Socket closed forcefully during send
-   - Connection reset during recv
-   - SSL handshake failure
-   - Broken pipe on SSL socket
-   - Concurrent operations on closing connection
-
-2. **AsyncioConnection Tests** (2 tests)
+1. **AsyncioConnection Tests** (2 tests)
    - Socket error preservation
    - Connection reset handling
 
-3. **Error Message Quality Tests** (2 tests)
+2. **Error Message Quality Tests** (2 tests)
    - Error message includes root cause
    - Multiple errors preserve first error
 
@@ -92,7 +85,7 @@ The tests verify:
 - ✅ Concurrent operations see original error, not just "Bad file descriptor"
 - ✅ First error is preserved when multiple errors occur
 - ✅ Mechanism works across different error types (EBADF, EPIPE, ECONNRESET, etc.)
-- ✅ Both AsyncoreConnection and AsyncioConnection handle errors correctly
+- ✅ AsyncioConnection handles errors correctly
 
 ## Code Changes
 
