Fix scoped resource leak on cancellation in exit-stack cleanup (#142)

clean_exit_stack and async_clean_exit_stack caught only `except Exception`
while iterating the exit stack. asyncio.CancelledError (and KeyboardInterrupt
/ SystemExit) are BaseException, not Exception, so when a generator's teardown
re-raised the exception being unwound it escaped the loop early, skipping the
remaining generators and exit_stack.clear(). On a cancelled `async with
container.enter_scope()` block (asyncio.wait_for timeout, task cancellation)
every earlier-registered scoped resource leaked, matching neither the
documented behaviour nor contextlib.AsyncExitStack.

Add an `except BaseException` branch to both loops: swallow the re-raised
exc_val so cleanup of the remaining generators continues (and the stack is
cleared), while propagating any genuinely new BaseException. New BaseExceptions
are not appended to the errors list since ContainerCloseError subclasses
ExceptionGroup on 3.11+, which rejects non-Exception members.

Fixes #141

Co-authored-by: glitch-ux <glitch-ux@users.noreply.github.com>

Author: glitch-ux

test/unit/test_exit_stack.py

@@ -1,9 +1,18 @@
+import asyncio
 import re
 from collections.abc import AsyncGenerator, Generator
 
 import pytest
 from wireup.errors import WireupError
-from wireup.ioc._exit_stack import clean_exit_stack
+from wireup.ioc._exit_stack import async_clean_exit_stack, clean_exit_stack
+
+
+class _Cancelled(BaseException):
+    """Stand-in for a BaseException (not Exception) re-raised during teardown.
+
+    Mirrors asyncio.CancelledError / KeyboardInterrupt / SystemExit without
+    tripping pytest's session-level handling of the latter two.
+    """
 
 
 def test_clean_exit_stack_with_sync_generators() -> None:
@@ -46,3 +55,66 @@ async def gen_1() -> AsyncGenerator[None, None]:
         ),
     ):
         clean_exit_stack([(g1, True)])
+
+
+def test_clean_exit_stack_continues_teardown_when_unwinding_base_exception() -> None:
+    # KeyboardInterrupt / SystemExit are BaseException, not Exception. When one is
+    # being unwound, every generator must still be torn down and the stack cleared.
+    teardowns: list[str] = []
+
+    def make(name: str) -> Generator[None, None, None]:
+        try:
+            yield
+        finally:
+            teardowns.append(name)
+
+    g1 = make("first")
+    next(g1)
+    g2 = make("second")
+    next(g2)
+
+    exit_stack = [(g1, False), (g2, False)]
+    clean_exit_stack(exit_stack, exc_val=_Cancelled())
+
+    assert teardowns == ["second", "first"]
+    assert exit_stack == []
+
+
+async def test_async_clean_exit_stack_continues_teardown_on_cancellation() -> None:
+    # Regression: when an `async with container.enter_scope()` block is cancelled
+    # (asyncio.wait_for timeout, task.cancel()), the CancelledError is re-raised by
+    # each generator's teardown. Cleanup must not abort early and leak the rest.
+    teardowns: list[str] = []
+
+    async def make(name: str) -> AsyncGenerator[None, None]:
+        try:
+            yield
+        finally:
+            teardowns.append(name)
+
+    g1 = make("first")
+    await g1.__anext__()
+    g2 = make("second")
+    await g2.__anext__()
+
+    exit_stack = [(g1, True), (g2, True)]
+    await async_clean_exit_stack(exit_stack, exc_val=asyncio.CancelledError())
+
+    assert teardowns == ["second", "first"]
+    assert exit_stack == []
+
+
+async def test_async_clean_exit_stack_propagates_new_base_exception_from_teardown() -> None:
+    # A brand-new BaseException raised during teardown (not the one being unwound)
+    # must still propagate rather than be silently swallowed.
+    async def gen() -> AsyncGenerator[None, None]:
+        try:
+            yield
+        finally:
+            raise KeyboardInterrupt
+
+    g = gen()
+    await g.__anext__()
+
+    with pytest.raises(KeyboardInterrupt):
+        await async_clean_exit_stack([(g, True)])

wireup/ioc/_exit_stack.py

@@ -33,12 +33,20 @@ def clean_exit_stack(
         except Exception as e:  # noqa: BLE001
             if e is not exc_val:
                 errors.append(e)
+        except BaseException as e:
+            # CancelledError / KeyboardInterrupt / SystemExit are BaseException, not
+            # Exception. When the exception being unwound (exc_val) re-emerges from a
+            # generator's teardown, keep closing the remaining generators instead of
+            # letting it abort cleanup, which would skip exit_stack.clear() and leak
+            # every earlier-registered resource. A genuinely new one is propagated.
+            if e is not exc_val:
+                raise
 
     exit_stack.clear()
     maybe_raise_exc(exc_val=exc_val, exc_tb=exc_tb, container_close_errors=errors)
 
 
-async def async_clean_exit_stack(
+async def async_clean_exit_stack(  # noqa: C901
     exit_stack: ExitStack,
     exc_val: BaseException | None = None,
     exc_tb: TracebackType | None = None,
@@ -64,6 +72,14 @@ async def async_clean_exit_stack(
         except Exception as e:  # noqa: BLE001
             if e is not exc_val:
                 errors.append(e)
+        except BaseException as e:
+            # CancelledError / KeyboardInterrupt / SystemExit are BaseException, not
+            # Exception. When the exception being unwound (exc_val) re-emerges from a
+            # generator's teardown, keep closing the remaining generators instead of
+            # letting it abort cleanup, which would skip exit_stack.clear() and leak
+            # every earlier-registered resource. A genuinely new one is propagated.
+            if e is not exc_val:
+                raise
 
     exit_stack.clear()
     maybe_raise_exc(exc_val=exc_val, exc_tb=exc_tb, container_close_errors=errors)