fix a failure in 3.14t test run , closes #9

Author: egorsmkv

justfile

@@ -2,3 +2,6 @@ set shell := ["bash", "-euo", "pipefail", "-c"]
 
 tls-test-certs outdir="tests/fixtures/tls":
     ./scripts/generate-test-tls-certs.sh {{outdir}}
+
+test:
+    uv run python -m unittest discover -s tests

src/stream_transport.rs

@@ -734,6 +734,19 @@ impl WorkerThread {
 }
 
 impl StreamTransportCore {
+    fn close_extra_socket_with_py(&self, py: Python<'_>) {
+        let socket = self
+            .state
+            .lock()
+            .expect("poisoned transport state")
+            .extra
+            .get("socket")
+            .map(|value| value.clone_ref(py));
+        if let Some(socket) = socket {
+            let _ = socket.bind(py).call_method0("close");
+        }
+    }
+
     fn register_worker(&self, worker: WorkerThread) {
         self.workers
             .lock()
@@ -1089,6 +1102,8 @@ impl StreamTransportCore {
             self.call_protocol_method1(py, &callback, &context, context_needs_run, arg)?;
         }
 
+        self.close_extra_socket_with_py(py);
+
         if let Some(server) = server.and_then(|weak| weak.upgrade()) {
             server.connection_lost();
         }
@@ -1133,7 +1148,8 @@ impl StreamTransportCore {
         }
     }
 
-    fn detach_underlying_stream(&self) {
+    fn detach_underlying_stream(&self, py: Python<'_>) {
+        self.close_extra_socket_with_py(py);
         let mut state = self.state.lock().expect("poisoned transport state");
         state.detached = true;
         state.closing = true;
@@ -1387,7 +1403,7 @@ impl StreamTransportCore {
         let fd = fd_ops::dup_raw_fd(socket.bind(py).call_method0("fileno")?.extract()?)
             .map_err(|err| PyRuntimeError::new_err(err.to_string()))?;
 
-        self.detach_underlying_stream();
+        self.detach_underlying_stream(py);
         let _ = self.writer_tx.send(WriterCommand::Stop);
         if let Some(fd) = self.runtime_socket_fd() {
             let _ = self
@@ -1529,6 +1545,15 @@ impl StreamTransportCore {
 }
 
 impl ServerCore {
+    fn close_python_sockets(&self) {
+        let _ = Python::try_attach(|py| -> PyResult<()> {
+            for socket in &self.sockets {
+                let _ = socket.bind(py).call_method0("close");
+            }
+            Ok(())
+        });
+    }
+
     fn report_error(&self, err: PyErr, message: &str) {
         let _ = Python::try_attach(|py| -> PyResult<()> {
             let context = PyDict::new(py);
@@ -1582,6 +1607,8 @@ impl ServerCore {
             state.listeners.clear();
         }
 
+        self.close_python_sockets();
+
         for task in self
             .accept_tasks
             .lock()
@@ -1997,16 +2024,7 @@ fn socket_from_owned_raw(fd: fd_ops::RawFd) -> PyResult<Socket> {
 }
 
 fn detached_socket_handle(py: Python<'_>, socket_obj: &Py<PyAny>) -> PyResult<fd_ops::RawFd> {
-    #[cfg(windows)]
-    {
-        return socket_obj.call_method0(py, "fileno")?.extract(py);
-    }
-
-    #[cfg(not(windows))]
-    {
-        let dup = socket_obj.call_method0(py, "dup")?;
-        dup.call_method0(py, "detach")?.extract(py)
-    }
+    socket_obj.call_method0(py, "detach")?.extract(py)
 }
 
 fn tcp_family(stream: &StdTcpStream) -> c_int {

tests/test_compat.py

@@ -80,7 +80,7 @@ async def fake_sock_connect(self, sock, address):
         self.assertEqual(rsloop.run(main()), [42001, 42003, 42002, 42004])
 
     def test_create_connection_happy_eyeballs_staggers_attempts(self) -> None:
-        async def main() -> float:
+        async def main() -> tuple[float, int]:
             loop = asyncio.get_running_loop()
             done = loop.create_future()
 
@@ -139,12 +139,16 @@ async def fake_sock_connect(self, sock, address):
                         )
                         await asyncio.wait_for(done, 1.0)
                         transport.close()
-                return time.monotonic() - started
+                        await asyncio.sleep(0)
+                        socket_fileno = transport.get_extra_info("socket").fileno()
+                return time.monotonic() - started, socket_fileno
             finally:
                 server.close()
                 await server.wait_closed()
 
-        self.assertLess(rsloop.run(main()), 0.15)
+        elapsed, socket_fileno = rsloop.run(main())
+        self.assertLess(elapsed, 0.15)
+        self.assertEqual(socket_fileno, -1)
 
     def test_shutdown_default_executor_timeout_warns_and_falls_back_to_nowait(
         self,
@@ -161,6 +165,7 @@ def shutdown(self, wait):
                         time.sleep(0.2)
 
             loop.set_default_executor(DummyExecutor())
+
             def capture_warning(message, category=None, stacklevel=1, source=None):
                 messages.append(str(message))
                 return None

tests/test_tls.py

@@ -50,9 +50,11 @@ def test_create_default_context_marks_default_verify_paths(self) -> None:
         self.assertTrue(context.__dict__.get("_rsloop_use_default_verify_paths"))
 
     def test_create_connection_and_server_tls_round_trip(self) -> None:
-        async def main() -> str:
+        async def main() -> tuple[str, tuple[int, ...]]:
             loop = asyncio.get_running_loop()
             done: asyncio.Future[str] = loop.create_future()
+            result = ""
+            server_fds: tuple[int, ...] = ()
 
             class ServerProtocol(asyncio.Protocol):
                 def connection_made(self, transport: asyncio.BaseTransport) -> None:
@@ -104,17 +106,24 @@ def connection_lost(self, exc: Exception | None) -> None:
                         await asyncio.wait_for(client_protocol.result, 5.0), "TLS-OK"
                     )
                     self.assertEqual(await asyncio.wait_for(done, 5.0), "server-closed")
-                    return "ok"
+                    result = "ok"
                 finally:
                     server.close()
                     await server.wait_closed()
+                    server_fds = tuple(sock.fileno() for sock in server.sockets)
+
+            return result, server_fds
 
-        self.assertEqual(rsloop.run(main()), "ok")
+        result, server_fds = rsloop.run(main())
+        self.assertEqual(result, "ok")
+        self.assertEqual(server_fds, (-1,))
 
     @unittest.skipIf(os.name == "nt", "Unix sockets are Unix-only")
     def test_create_unix_connection_and_server_tls_round_trip(self) -> None:
-        async def main() -> str:
+        async def main() -> tuple[str, tuple[int, ...]]:
             loop = asyncio.get_running_loop()
+            result = ""
+            server_fds: tuple[int, ...] = ()
 
             class ServerProtocol(asyncio.Protocol):
                 def connection_made(self, transport: asyncio.BaseTransport) -> None:
@@ -155,12 +164,17 @@ def connection_lost(self, exc: Exception | None) -> None:
                         ssl=client_ctx,
                         server_hostname="localhost",
                     )
-                    return await asyncio.wait_for(client_protocol.done, 5.0)
+                    result = await asyncio.wait_for(client_protocol.done, 5.0)
                 finally:
                     server.close()
                     await server.wait_closed()
+                    server_fds = tuple(sock.fileno() for sock in server.sockets)
+
+            return result, server_fds
 
-        self.assertEqual(rsloop.run(main()), "unix:tls")
+        result, server_fds = rsloop.run(main())
+        self.assertEqual(result, "unix:tls")
+        self.assertEqual(server_fds, (-1,))
 
     def test_connect_accepted_socket_tls_round_trip(self) -> None:
         async def main() -> str: