shrinkray 26.2.4.0__tar.gz → 26.2.4.1__tar.gz

{shrinkray-26.2.4.0/src/shrinkray.egg-info → shrinkray-26.2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.2.4.0
+Version: 26.2.4.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "26.2.4.0"
+version = "26.2.4.1"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1}/src/shrinkray/subprocess/client.py

@@ -27,6 +27,7 @@ class SubprocessClient:
         self._progress_queue: asyncio.Queue[ProgressUpdate] = asyncio.Queue()
         self._reader_task: asyncio.Task | None = None
         self._completed = False
+        self._closed = False
         self._error_message: str | None = None
         self._debug_mode = debug_mode
         self._stderr_log_file: IO[str] | None = None
@@ -261,6 +262,17 @@ class SubprocessClient:
 
     async def close(self) -> None:
         """Close the subprocess."""
+        if self._closed:
+            return
+        self._closed = True
+
+        # Cancel all pending futures first so any code awaiting send_command
+        # responses (e.g. cancel() in action_quit) is unblocked immediately.
+        for future in self._pending_responses.values():
+            if not future.done():
+                future.cancel()
+        self._pending_responses.clear()
+
         if self._reader_task is not None:
             self._reader_task.cancel()
             try:
@@ -278,13 +290,21 @@ class SubprocessClient:
             if self._process.returncode is None:
                 try:
                     self._process.terminate()
-                    await asyncio.wait_for(self._process.wait(), timeout=5.0)
+                    await asyncio.wait_for(self._process.wait(), timeout=2.0)
                 except TimeoutError:
                     self._process.kill()
                     await self._process.wait()
                 except ProcessLookupError:
                     pass  # Process already exited
 
+            # Always await wait() to ensure the asyncio transport is fully
+            # finalized before the event loop closes. This prevents the
+            # "Event loop is closed" RuntimeError from BaseSubprocessTransport.__del__.
+            if self._process.returncode is not None:
+                await self._process.wait()
+                # Flush pending event loop callbacks (transport cleanup)
+                await asyncio.sleep(0)
+
         # Close and remove the stderr log file
         if self._stderr_log_file is not None:
             try:

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1}/src/shrinkray/tui.py

@@ -1938,11 +1938,14 @@ class ShrinkRayApp(App[None]):
 
     async def action_quit(self) -> None:
         """Quit the application with graceful cancellation."""
+        self.update_status("Shutting down...")
         if self._client and not self._completed:
             try:
-                await self._client.cancel()
+                await self._client.close()
             except Exception:
                 pass  # Process may have already exited
+            # Prevent double-close in run_reduction's finally block
+            self._client = None
         self.exit()
 
     def action_show_pass_stats(self) -> None:

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1/src/shrinkray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.2.4.0
+Version: 26.2.4.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1}/tests/test_subprocess_client.py

@@ -1120,3 +1120,123 @@ def test_subprocess_client_close_handles_stderr_log_file_exception():
         mock_file.close.assert_called_once()
 
     asyncio.run(run())
+
+
+def test_subprocess_client_close_cancels_pending_futures():
+    """Test close() cancels all pending futures so awaiting code is unblocked."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create pending futures
+        loop = asyncio.get_event_loop()
+        future1: asyncio.Future[Response] = loop.create_future()
+        future2: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-1"] = future1
+        client._pending_responses["req-2"] = future2
+
+        await client.close()
+
+        # Both futures should be cancelled
+        assert future1.cancelled()
+        assert future2.cancelled()
+        # Pending responses should be cleared
+        assert len(client._pending_responses) == 0
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_is_idempotent():
+    """Test close() is a no-op on second call due to _closed flag."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create a pending future
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-1"] = future
+
+        await client.close()
+        assert future.cancelled()
+        assert client._closed
+
+        # Add another future after close (simulating a race)
+        future2: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-2"] = future2
+
+        # Second close should be a no-op
+        await client.close()
+
+        # The second future should NOT be cancelled (close was a no-op)
+        assert not future2.cancelled()
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_awaits_wait_after_process_exit():
+    """Test close() always awaits process.wait() after process exits."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create a mock process that has already exited
+        mock_process = MagicMock()
+        mock_process.returncode = 0  # Already exited
+        mock_process.stdin = MagicMock()
+        mock_process.stdin.close = MagicMock()
+
+        wait_called = [False]
+
+        async def mock_wait():
+            wait_called[0] = True
+
+        mock_process.wait = mock_wait
+        client._process = mock_process
+        client._reader_task = None
+
+        await client.close()
+
+        # wait() should have been called even though process already exited
+        assert wait_called[0]
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_skips_done_futures():
+    """Test close() skips already-done futures when cancelling."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create one done and one pending future
+        loop = asyncio.get_event_loop()
+        done_future: asyncio.Future[Response] = loop.create_future()
+        done_future.set_result(Response(id="done", result={"status": "ok"}))
+        pending_future: asyncio.Future[Response] = loop.create_future()
+
+        client._pending_responses["done"] = done_future
+        client._pending_responses["pending"] = pending_future
+
+        await client.close()
+
+        # Done future should still have its result (not cancelled)
+        assert not done_future.cancelled()
+        assert done_future.result().result == {"status": "ok"}
+        # Pending future should be cancelled
+        assert pending_future.cancelled()
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_handles_stderr_log_unlink_exception():
+    """Test close() handles exception when unlinking stderr log file."""
+
+    async def run():
+        client = SubprocessClient()
+        client._stderr_log_path = "/nonexistent/path/that/will/fail"
+
+        # Should not raise even if unlink fails
+        await client.close()
+
+    asyncio.run(run())

{shrinkray-26.2.4.0 → shrinkray-26.2.4.1}/tests/test_tui.py

@@ -113,6 +113,7 @@ class FakeReductionClient:
 
     async def close(self) -> None:
         self._closed = True
+        self._cancelled = True
 
     async def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]:
         for update in self._updates:
@@ -5459,7 +5460,7 @@ def test_expanded_modal_output_content_without_test_id():
 
 
 def test_action_quit_with_client():
-    """Test action_quit cancels client before exiting."""
+    """Test action_quit closes client directly before exiting."""
 
     async def run():
         fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
@@ -5483,8 +5484,10 @@ def test_action_quit_with_client():
                 await pilot.press("q")
                 await pilot.pause()
 
-                # Client should have been cancelled
-                assert fake_client._cancelled
+                # Client should have been closed directly (not just cancelled)
+                assert fake_client._closed
+                # Client reference should be cleared to prevent double-close
+                assert app._client is None
         finally:
             if os.path.exists(temp_file):
                 os.unlink(temp_file)
@@ -5493,16 +5496,16 @@ def test_action_quit_with_client():
 
 
 def test_action_quit_handles_exception():
-    """Test action_quit handles exception from cancel gracefully."""
+    """Test action_quit handles exception from close gracefully."""
 
     async def run():
         fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
 
-        # Make cancel raise an exception
+        # Make close raise an exception
         async def raise_exception():
             raise RuntimeError("Process already exited")
 
-        fake_client.cancel = raise_exception
+        fake_client.close = raise_exception
 
         with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
             f.write("test")