79:T57f,// Pattern 1: Cleanup callbacks for test observation interface ResourceWithCallback { dispose(onCleanup?: () => void): void; } class FileResource implements ResourceWithCallback { private isOpen = true; private readonly handle: FileHandle; constructor(path: string) { this.handle = openFile(path); } dispose(onCleanup?: () => void): void { if (this.isOpen) { this.handle.close(); this.isOpen = false; onCleanup?.(); // Test hook: observable cleanup } } // For testing: expose internal state get isClosed(): boolean { return !this.isOpen; } } // Pattern 2: Disposal tracking registry class ResourceRegistry { private acquired = new Set(); private disposed = new Set(); trackAcquisition(resourceId: string): void { this.acquired.add(resourceId); } trackDisposal(resourceId: string): void { this.disposed.add(resourceId); } // Test assertion: all acquired resources were disposed assertAllDisposed(): void { const leaks = [...this.acquired].filter(id => !this.disposed.has(id)); if (leaks.length > 0) { throw new Error(`Resource leaks detected: ${leaks.join(', ')}`); } } reset(): void { this.acquired.clear(); this.disposed.clear(); } }7a:T746,// Pattern 1: Cleanup callbacks for test observation public interface ResourceWithCallback extends AutoCloseable { void dispose(Runnable onCleanup); @Override default void close() throws Exception { dispose(null); } } public class FileResource implements ResourceWithCallback { private boolean isOpen = true; private final RandomAccessFile handle; public FileResource(String path) throws IOException { this.handle = new RandomAccessFile(path, "rw"); } @Override public synchronized void dispose(Runnable onCleanup) { if (isOpen) { try { handle.close(); } catch (IOException e) { // Log but continue—cleanup must complete } isOpen = false; if (onCleanup != null) { onCleanup.run(); // Test hook } } } // For testing: expose internal state public boolean isClosed() { return !isOpen; } } // Pattern 2: Disposal tracking registry public class ResourceRegistry { private final Set acquired = ConcurrentHashMap.newKeySet(); private final Set disposed = ConcurrentHashMap.newKeySet(); public void trackAcquisition(String resourceId) { acquired.add(resourceId); } public void trackDisposal(String resourceId) { disposed.add(resourceId); } // Test assertion public void assertAllDisposed() { Set leaks = new HashSet<>(acquired); leaks.removeAll(disposed); if (!leaks.isEmpty()) { throw new AssertionError( "Resource leaks detected: " + String.join(", ", leaks) ); } } public void reset() { acquired.clear(); disposed.clear(); } }7b:T6ab,# Pattern 1: Cleanup callbacks for test observation from typing import Callable, Optional from abc import ABC, abstractmethod class ResourceWithCallback(ABC): @abstractmethod def dispose(self, on_cleanup: Optional[Callable[[], None]] = None) -> None: pass def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.dispose() return False class FileResource(ResourceWithCallback): def __init__(self, path: str): self._is_open = True self._handle = open(path, 'r+b') def dispose(self, on_cleanup: Optional[Callable[[], None]] = None) -> None: if self._is_open: self._handle.close() self._is_open = False if on_cleanup: on_cleanup() # Test hook: observable cleanup @property def is_closed(self) -> bool: """For testing: expose internal state""" return not self._is_open # Pattern 2: Disposal tracking registry class ResourceRegistry: def __init__(self): self._acquired: set[str] = set() self._disposed: set[str] = set() def track_acquisition(self, resource_id: str) -> None: self._acquired.add(resource_id) def track_disposal(self, resource_id: str) -> None: self._disposed.add(resource_id) def assert_all_disposed(self) -> None: """Test assertion: all acquired resources were disposed""" leaks = self._acquired - self._disposed if leaks: raise AssertionError(f"Resource leaks detected: {', '.join(leaks)}") def reset(self) -> None: self._acquired.clear() self._disposed.clear()7c:T6ca,// Injectable factory pattern for testability interface IConnectionFactory { createConnection(): IConnection; } interface IConnection { execute(query: string): Promise; dispose(): void; } // Production implementation class DatabaseConnectionFactory implements IConnectionFactory { constructor(private readonly connectionString: string) {} createConnection(): IConnection { return new RealDatabaseConnection(this.connectionString); } } // Service that uses connections class DataRepository { constructor(private readonly connectionFactory: IConnectionFactory) {} async fetchData(id: string): Promise { const connection = this.connectionFactory.createConnection(); try { return await connection.execute(`SELECT * FROM data WHERE id = '${id}'`); } finally { connection.dispose(); // Cleanup happens regardless of success/failure } } } // Test: verify cleanup with mock factory class MockConnectionFactory implements IConnectionFactory { readonly connections: MockConnection[] = []; createConnection(): IConnection { const conn = new MockConnection(); this.connections.push(conn); return conn; } assertAllConnectionsClosed(): void { const unclosed = this.connections.filter(c => !c.isClosed); if (unclosed.length > 0) { throw new Error(`${unclosed.length} connection(s) not properly closed`); } } } class MockConnection implements IConnection { isClosed = false; async execute(query: string): Promise { return { rows: [] }; } dispose(): void { this.isClosed = true; } }7d:T6e8,import { describe, it, expect, beforeEach, afterEach } from 'vitest'; describe('DataRepository resource cleanup', () => { let mockFactory: MockConnectionFactory; let repository: DataRepository; beforeEach(() => { mockFactory = new MockConnectionFactory(); repository = new DataRepository(mockFactory); }); afterEach(() => { // Verify no leaks after each test mockFactory.assertAllConnectionsClosed(); }); it('should close connection after successful query', async () => { // Arrange const id = 'test-id-123'; // Act await repository.fetchData(id); // Assert expect(mockFactory.connections).toHaveLength(1); expect(mockFactory.connections[0].isClosed).toBe(true); }); it('should close connection even when query fails', async () => { // Arrange mockFactory = new MockConnectionFactory(); mockFactory.failNextQuery = true; // Configure to throw repository = new DataRepository(mockFactory); // Act & Assert await expect(repository.fetchData('any-id')).rejects.toThrow(); // Critical: verify cleanup still happened expect(mockFactory.connections[0].isClosed).toBe(true); }); it('should handle multiple sequential operations', async () => { // Act await repository.fetchData('id-1'); await repository.fetchData('id-2'); await repository.fetchData('id-3'); // Assert: each operation should use and close its own connection expect(mockFactory.connections).toHaveLength(3); expect(mockFactory.connections.every(c => c.isClosed)).toBe(true); }); });7e:T5b0,import pytest from unittest.mock import MagicMock class TestDataRepositoryResourceCleanup: @pytest.fixture(autouse=True) def setup(self): self.mock_factory = MockConnectionFactory() self.repository = DataRepository(self.mock_factory) yield # Verify no leaks after each test self.mock_factory.assert_all_connections_closed() def test_should_close_connection_after_successful_query(self): # Arrange test_id = 'test-id-123' # Act self.repository.fetch_data(test_id) # Assert assert len(self.mock_factory.connections) == 1 assert self.mock_factory.connections[0].is_closed == True def test_should_close_connection_even_when_query_fails(self): # Arrange self.mock_factory.fail_next_query = True # Act & Assert with pytest.raises(Exception): self.repository.fetch_data('any-id') # Critical: verify cleanup still happened assert self.mock_factory.connections[0].is_closed == True def test_should_handle_multiple_sequential_operations(self): # Act self.repository.fetch_data('id-1') self.repository.fetch_data('id-2') self.repository.fetch_data('id-3') # Assert assert len(self.mock_factory.connections) == 3 assert all(c.is_closed for c in self.mock_factory.connections)7f:T67a,import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; class DataRepositoryResourceCleanupTest { private MockConnectionFactory mockFactory; private DataRepository repository; @BeforeEach void setUp() { mockFactory = new MockConnectionFactory(); repository = new DataRepository(mockFactory); } @AfterEach void tearDown() { // Verify no leaks after each test mockFactory.assertAllConnectionsClosed(); } @Test void shouldCloseConnectionAfterSuccessfulQuery() throws Exception { // Arrange String id = "test-id-123"; // Act repository.fetchData(id); // Assert assertEquals(1, mockFactory.getConnections().size()); assertTrue(mockFactory.getConnections().get(0).isClosed()); } @Test void shouldCloseConnectionEvenWhenQueryFails() { // Arrange mockFactory.setFailNextQuery(true); // Act & Assert assertThrows(Exception.class, () -> repository.fetchData("any-id")); // Critical: verify cleanup still happened assertTrue(mockFactory.getConnections().get(0).isClosed()); } @Test void shouldHandleMultipleSequentialOperations() throws Exception { // Act repository.fetchData("id-1"); repository.fetchData("id-2"); repository.fetchData("id-3"); // Assert assertEquals(3, mockFactory.getConnections().size()); assertTrue(mockFactory.getConnections().stream() .allMatch(MockConnection::isClosed)); } }80:T86c,// Testing that cleanup happens in correct order class OrderTrackingResource { private static cleanupOrder: string[] = []; constructor(private readonly name: string) {} dispose(): void { OrderTrackingResource.cleanupOrder.push(this.name); } static getCleanupOrder(): string[] { return [...OrderTrackingResource.cleanupOrder]; } static resetTracking(): void { OrderTrackingResource.cleanupOrder = []; } } describe('nested resource cleanup ordering', () => { beforeEach(() => { OrderTrackingResource.resetTracking(); }); it('should clean up inner resources before outer resources', async () => { // Simulate: connection -> transaction -> cursor // Cleanup should be: cursor -> transaction -> connection const connection = new OrderTrackingResource('connection'); const transaction = new OrderTrackingResource('transaction'); const cursor = new OrderTrackingResource('cursor'); // Business operations... // Cleanup in reverse order of acquisition cursor.dispose(); transaction.dispose(); connection.dispose(); // Verify order expect(OrderTrackingResource.getCleanupOrder()).toEqual([ 'cursor', 'transaction', 'connection' ]); }); it('should maintain cleanup order even with exceptions', async () => { const resources: OrderTrackingResource[] = []; try { resources.push(new OrderTrackingResource('outer')); resources.push(new OrderTrackingResource('middle')); resources.push(new OrderTrackingResource('inner')); throw new Error('Simulated failure'); } finally { // Cleanup in reverse order while (resources.length > 0) { resources.pop()!.dispose(); } } expect(OrderTrackingResource.getCleanupOrder()).toEqual([ 'inner', 'middle', 'outer' ]); }); });81:T877,// Resource supporting cleanup callbacks interface DisposableResource { dispose(): Promise; onDispose(callback: () => void): void; } class ManagedFileHandle implements DisposableResource { private readonly callbacks: (() => void)[] = []; private disposed = false; constructor(private readonly path: string) {} onDispose(callback: () => void): void { this.callbacks.push(callback); } async dispose(): Promise { if (this.disposed) return; // Idempotent await this.closeHandle(); this.disposed = true; // Notify all observers this.callbacks.forEach(cb => cb()); } private async closeHandle(): Promise { // Actual file closing logic } } // Test using callbacks describe('ManagedFileHandle disposal', () => { it('should invoke cleanup callbacks on dispose', async () => { const handle = new ManagedFileHandle('/tmp/test.txt'); let cleanupInvoked = false; handle.onDispose(() => { cleanupInvoked = true; }); await handle.dispose(); expect(cleanupInvoked).toBe(true); }); it('should invoke multiple callbacks in registration order', async () => { const handle = new ManagedFileHandle('/tmp/test.txt'); const invocationOrder: number[] = []; handle.onDispose(() => invocationOrder.push(1)); handle.onDispose(() => invocationOrder.push(2)); handle.onDispose(() => invocationOrder.push(3)); await handle.dispose(); expect(invocationOrder).toEqual([1, 2, 3]); }); it('should handle idempotent disposal gracefully', async () => { const handle = new ManagedFileHandle('/tmp/test.txt'); let callbackCount = 0; handle.onDispose(() => callbackCount++); // Dispose multiple times await handle.dispose(); await handle.dispose(); await handle.dispose(); // Callback should only fire once expect(callbackCount).toBe(1); }); });82:T9b9,# Resource supporting cleanup callbacks from typing import Callable, List from abc import ABC, abstractmethod class DisposableResource(ABC): @abstractmethod async def dispose(self) -> None: pass @abstractmethod def on_dispose(self, callback: Callable[[], None]) -> None: pass class ManagedFileHandle(DisposableResource): def __init__(self, path: str): self._path = path self._callbacks: List[Callable[[], None]] = [] self._disposed = False def on_dispose(self, callback: Callable[[], None]) -> None: self._callbacks.append(callback) async def dispose(self) -> None: if self._disposed: return # Idempotent await self._close_handle() self._disposed = True # Notify all observers for callback in self._callbacks: callback() async def _close_handle(self) -> None: # Actual file closing logic pass # Tests using callbacks import pytest class TestManagedFileHandleDisposal: @pytest.mark.asyncio async def test_should_invoke_cleanup_callbacks_on_dispose(self): handle = ManagedFileHandle('/tmp/test.txt') cleanup_invoked = False def on_cleanup(): nonlocal cleanup_invoked cleanup_invoked = True handle.on_dispose(on_cleanup) await handle.dispose() assert cleanup_invoked == True @pytest.mark.asyncio async def test_should_invoke_multiple_callbacks_in_order(self): handle = ManagedFileHandle('/tmp/test.txt') invocation_order = [] handle.on_dispose(lambda: invocation_order.append(1)) handle.on_dispose(lambda: invocation_order.append(2)) handle.on_dispose(lambda: invocation_order.append(3)) await handle.dispose() assert invocation_order == [1, 2, 3] @pytest.mark.asyncio async def test_should_handle_idempotent_disposal(self): handle = ManagedFileHandle('/tmp/test.txt') callback_count = 0 def increment(): nonlocal callback_count callback_count += 1 handle.on_dispose(increment) # Dispose multiple times await handle.dispose() await handle.dispose() await handle.dispose() # Callback should only fire once assert callback_count == 183:Tbb6,// Pattern: Resource with queryable disposal state enum ResourceState { Created = 'CREATED', Active = 'ACTIVE', Disposing = 'DISPOSING', Disposed = 'DISPOSED' } class StatefulResource { private _state: ResourceState = ResourceState.Created; get state(): ResourceState { return this._state; } get isActive(): boolean { return this._state === ResourceState.Active; } get isDisposed(): boolean { return this._state === ResourceState.Disposed; } async activate(): Promise { this.assertState(ResourceState.Created); // Acquisition logic... this._state = ResourceState.Active; } async dispose(): Promise { if (this._state === ResourceState.Disposed) return; if (this._state === ResourceState.Disposing) { throw new Error('Dispose already in progress'); } this._state = ResourceState.Disposing; try { await this.performCleanup(); this._state = ResourceState.Disposed; } catch (error) { // Cleanup failed - still mark as disposed to prevent reuse this._state = ResourceState.Disposed; throw error; } } private assertState(expected: ResourceState): void { if (this._state !== expected) { throw new Error( `Invalid state transition: expected ${expected}, was ${this._state}` ); } } private async performCleanup(): Promise { // Actual cleanup logic } } // State-based tests describe('StatefulResource state transitions', () => { it('should transition through correct states', async () => { const resource = new StatefulResource(); expect(resource.state).toBe(ResourceState.Created); await resource.activate(); expect(resource.state).toBe(ResourceState.Active); expect(resource.isActive).toBe(true); await resource.dispose(); expect(resource.state).toBe(ResourceState.Disposed); expect(resource.isDisposed).toBe(true); }); it('should prevent operations on disposed resource', async () => { const resource = new StatefulResource(); await resource.activate(); await resource.dispose(); // Attempting to activate disposed resource should fail await expect(resource.activate()).rejects.toThrow('Invalid state'); }); it('should mark as disposed even if cleanup fails', async () => { const resource = new StatefulResourceWithFailingCleanup(); await resource.activate(); await expect(resource.dispose()).rejects.toThrow(); // Despite failure, resource should be marked disposed // to prevent reuse of potentially corrupted resource expect(resource.isDisposed).toBe(true); }); });84:Tbca,describe('cleanup under failure conditions', () => { let resourceTracker: ResourceTracker; beforeEach(() => { resourceTracker = new ResourceTracker(); }); afterEach(() => { resourceTracker.assertNoLeaks(); }); it('should cleanup when operation throws synchronously', async () => { const service = new FailingService(resourceTracker); await expect(service.operationThatThrowsImmediately()) .rejects.toThrow('Immediate failure'); expect(resourceTracker.openResources).toBe(0); }); it('should cleanup when operation throws asynchronously', async () => { const service = new FailingService(resourceTracker); await expect(service.operationThatThrowsAsync()) .rejects.toThrow('Async failure'); expect(resourceTracker.openResources).toBe(0); }); it('should cleanup when operation times out', async () => { const service = new SlowService(resourceTracker); const timeoutPromise = withTimeout( service.verySlowOperation(), 100 // ms ); await expect(timeoutPromise).rejects.toThrow('Operation timed out'); // Critical: resource should still be cleaned up // even though the operation didn't complete normally await waitForCleanup(50); // Allow cleanup to run expect(resourceTracker.openResources).toBe(0); }); it('should cleanup when operation is cancelled', async () => { const controller = new AbortController(); const service = new CancellableService(resourceTracker); const operationPromise = service.cancellableOperation(controller.signal); // Cancel mid-operation setTimeout(() => controller.abort(), 50); await expect(operationPromise).rejects.toThrow('Operation cancelled'); expect(resourceTracker.openResources).toBe(0); }); it('should cleanup all resources when nested operation fails', async () => { const service = new NestedOperationService(resourceTracker); // This operation acquires 3 resources, then fails on the 3rd await expect(service.nestedOperationFailingOnThird()) .rejects.toThrow(); // All 3 resources should be cleaned up expect(resourceTracker.totalAcquired).toBe(3); expect(resourceTracker.totalReleased).toBe(3); expect(resourceTracker.openResources).toBe(0); }); }); // Helper: timeout wrapper function withTimeout(promise: Promise, ms: number): Promise { return Promise.race([ promise, new Promise((_, reject) => setTimeout(() => reject(new Error('Operation timed out')), ms) ) ]); } // Helper: wait for async cleanup function waitForCleanup(ms: number): Promise { return new Promise(resolve => setTimeout(resolve, ms)); }85:Tbb1,describe('idempotent disposal behavior', () => { it('should allow multiple dispose calls without error', async () => { const resource = new ManagedResource(); await resource.activate(); // Should not throw await resource.dispose(); await resource.dispose(); await resource.dispose(); expect(resource.isDisposed).toBe(true); }); it('should only perform cleanup once', async () => { const cleanupCounter = { count: 0 }; const resource = new ManagedResource({ onCleanup: () => cleanupCounter.count++ }); await resource.activate(); await resource.dispose(); await resource.dispose(); await resource.dispose(); // Cleanup logic should only run once expect(cleanupCounter.count).toBe(1); }); it('should handle concurrent dispose calls', async () => { const resource = new ManagedResource(); await resource.activate(); // Call dispose concurrently const disposePromises = [ resource.dispose(), resource.dispose(), resource.dispose(), ]; // All should resolve without error await expect(Promise.all(disposePromises)).resolves.toBeDefined(); expect(resource.isDisposed).toBe(true); }); it('should return immediately if already disposed', async () => { const resource = new SlowCleanupResource(); await resource.activate(); // First dispose is slow const firstStart = Date.now(); await resource.dispose(); const firstDuration = Date.now() - firstStart; // Second dispose should be instant const secondStart = Date.now(); await resource.dispose(); const secondDuration = Date.now() - secondStart; expect(secondDuration).toBeLessThan(firstDuration / 10); }); }); // Implementation pattern for idempotent disposal class ManagedResource { private disposed = false; private disposePromise: Promise | null = null; private options: { onCleanup?: () => void }; constructor(options: { onCleanup?: () => void } = {}) { this.options = options; } get isDisposed(): boolean { return this.disposed; } async activate(): Promise { /* ... */ } async dispose(): Promise { // Fast path: already disposed if (this.disposed) return; // Prevent concurrent cleanup if (this.disposePromise) { return this.disposePromise; } // Perform cleanup once this.disposePromise = this.performCleanup(); await this.disposePromise; this.disposed = true; } private async performCleanup(): Promise { // Actual cleanup work this.options.onCleanup?.(); } }71:{"json":{"id":"seed_e7f60a2e69c0f0b1761b9d2c37de56c0","slug":"testing-resource-management","category":"System Design (LLD)","topic":"Testing Resource Management","title":"Testing Resource Management","description":"Master the art of testing resource management code—from verifying cleanup to detecting leaks, mocking external resources, and integration testing. Learn the techniques that ensure your resource-handling code is robust, reliable, and production-ready.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_569ff07ae153d3cff8af9cb17ff1d986","title":"Verifying Resource Cleanup","order":0,"content":[{"id":"opening-hook","title":"The Hidden Danger of Untested Resource Management","content":[{"data":{"content":"Resource management code is uniquely treacherous. Unlike typical application logic where bugs manifest as incorrect outputs or visible errors, resource management failures are often **silent**. A file handle left open doesn't crash your application—it quietly consumes system resources until, hours or days later, the operating system refuses to open any more files. A database connection that isn't returned to the pool doesn't throw an exception—it silently depletes your connection pool until your application grinds to a halt under load.\n\nThis silence makes testing resource management not just important, but **critical**. Without deliberate verification that resources are being properly acquired and released, you're building on a foundation of hope rather than engineering certainty. The question isn't whether your untested resource management code will fail—it's when, and how catastrophically."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand how to design testable resource management code, implement verification strategies for cleanup operations, write tests that catch resource leaks before production, and apply patterns that make resource lifecycle assertions straightforward and reliable.","variant":"info"},"type":"callout"}]},{"id":"challenge-of-testing-cleanup","title":"The Challenge of Testing Resource Cleanup","content":[{"data":{"content":"Testing resource cleanup presents unique challenges that standard unit testing approaches don't address. Understanding these challenges is the first step toward developing effective testing strategies.\n\n**Why resource cleanup is hard to test:**\n\nResource cleanup operates at the intersection of your application code and external systems—operating systems, databases, network stacks, and memory managers. This boundary crossing creates several problems:"},"type":"text"},{"data":{"items":["**Side Effects Are Invisible** — When you call `file.close()`, there's no return value indicating success. The operation's effect—releasing the OS file handle—is a side effect on an external system that your test can't directly observe.","**Timing Dependencies** — Resource cleanup often uses finalizers, garbage collection, or deferred execution. Testing these time-dependent mechanisms requires special techniques.","**Non-Deterministic Behavior** — Garbage collectors run unpredictably, socket timeouts vary, and file system operations may be buffered. Tests must account for this non-determinism.","**State Pollution** — Resources acquired in one test can pollute subsequent tests. A connection leak in test A may cause test B to fail with 'connection pool exhausted'—making failures hard to diagnose.","**Production vs Test Environments** — Your tests run in a controlled environment, but production faces memory pressure, concurrent access, and partial failures that are hard to simulate."],"title":{"icon":"AlertCircle","text":"Core Testing Challenges","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"icon":"AlertCircle","title":"The Deceptive Green Bar","content":"A passing test suite doesn't guarantee correct resource management. Tests typically run with fresh processes, minimal load, and generous timeouts. Resource leaks may only manifest after hundreds of operations or under concurrent access—conditions your test suite might never create.","variant":"warning"},"type":"callout"},{"data":{"content":"**The fundamental insight:**\n\nTo test resource cleanup effectively, we must transform the invisible into the visible. We need to structure our code so that cleanup operations produce observable evidence—evidence our tests can verify."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"designing-testable-resource-management","title":"Designing for Testability","content":[{"data":{"content":"The key to effective resource cleanup testing is designing your resource management code with testability as a first-class concern. This doesn't mean compromising production code quality—rather, it means structuring code so that its correctness can be verified.\n\n**Principle 1: Make cleanup observable**\n\nThe most fundamental principle is transforming silent cleanup into observable behavior. There are several techniques to achieve this:"},"type":"text"},{"data":{"fileName":"observable-cleanup-pattern.ts","languages":[{"code":"$79","label":"TypeScript","value":"typescript"},{"code":"$7a","label":"Java","value":"java"},{"code":"$7b","label":"Python","value":"python"}]},"type":"code"},{"data":{"content":"**Principle 2: Inject resource factories**\n\nDirect resource acquisition (`new FileStream(path)`, `DriverManager.getConnection()`) creates hard dependencies that resist testing. Instead, inject factories that can be replaced with test doubles:"},"type":"text"},{"data":{"fileName":"injectable-resource-factory.ts","languages":[{"code":"$7c","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"The Inversion of Control Principle","content":"Testable resource management follows the same principle as other testable code: invert control. Instead of classes creating their own resources, they receive factories they can use to request resources. This allows tests to substitute observable implementations that track and verify cleanup behavior.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"writing-cleanup-verification-tests","title":"Writing Cleanup Verification Tests","content":[{"data":{"content":"With testable patterns in place, we can write tests that verify resource cleanup actually occurs. Let's explore the key testing scenarios and techniques.\n\n**Scenario 1: Happy path cleanup verification**\n\nThe simplest case: verify that normal operation properly releases resources."},"type":"text"},{"data":{"fileName":"cleanup-verification-tests.ts","languages":[{"code":"$7d","label":"TypeScript","value":"typescript"},{"code":"$7e","label":"Python","value":"python"},{"code":"$7f","label":"Java","value":"java"}]},"type":"code"},{"data":{"content":"**Scenario 2: Testing cleanup ordering**\n\nWhen multiple resources must be cleaned up, the order often matters. For example, you must close a transaction before closing the connection that owns it:"},"type":"text"},{"data":{"fileName":"cleanup-ordering-tests.ts","languages":[{"code":"$80","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"Info","title":"LIFO Cleanup Pattern","content":"Resources should typically be cleaned up in Last-In-First-Out (LIFO) order—the reverse of their acquisition order. This ensures that resources don't try to use their dependencies after those dependencies have been disposed. Your tests should verify this ordering is maintained.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"testing-cleanup-callbacks","title":"Testing with Cleanup Callbacks","content":[{"data":{"content":"Cleanup callbacks are a powerful pattern for verifying resource disposal in tests. They allow you to inject observation points into the cleanup process without modifying the core resource logic.\n\n**Pattern: Verified disposal with callbacks**"},"type":"text"},{"data":{"fileName":"cleanup-callback-testing.ts","languages":[{"code":"$81","label":"TypeScript","value":"typescript"},{"code":"$82","label":"Python","value":"python"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"Testing Async Cleanup","content":"Modern resources often involve asynchronous cleanup—flushing buffers, closing network connections, or waiting for pending operations. Your test framework must support async assertions. Use async/await in tests and ensure cleanup callbacks are awaited before making assertions.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"state-based-verification","title":"State-Based Cleanup Verification","content":[{"data":{"content":"Some resource cleanup is best verified by examining state changes. This approach is particularly useful when cleanup has observable effects on the resource's internal state or on external systems.\n\n**Pattern: Exposing disposal state**"},"type":"text"},{"data":{"fileName":"state-based-verification.ts","languages":[{"code":"$83","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"left":[{"data":{"items":["**Deterministic** — State queries return immediate, consistent results","**Self-documenting** — State enums make lifecycle clear","**Debuggable** — Current state visible in logs/debugger","**Race-safe** — State transitions can be atomic"],"title":{"icon":"CheckCircle","text":"State-Based Testing Advantages","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["**Added complexity** — Extra state management code","**Test-only exposure** — May expose internals unnecessarily","**State vs action** — State being 'Disposed' doesn't prove cleanup ran correctly","**Memory overhead** — Small, but exists for each resource"],"title":{"icon":"AlertCircle","text":"Considerations","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"}],"titleType":"number","titleNumber":5},{"id":"testing-cleanup-exceptions","title":"Testing Cleanup in Exception Scenarios","content":[{"data":{"content":"The most critical cleanup verification tests are those that verify resources are released even when operations fail. This is where most resource leaks originate—developers test the happy path but forget about exception flows.\n\n**The cleanup guarantee principle:**\n\nResources must be released regardless of how the operation using them terminates. This includes normal completion, exceptions, timeouts, and cancellation."},"type":"text"},{"data":{"fileName":"exception-cleanup-tests.ts","languages":[{"code":"$84","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Timeout Trap","content":"Timeouts are particularly dangerous for resource management. When you abort an operation due to timeout, the underlying operation may still be running asynchronously—with resources allocated. Your cleanup logic must account for this: either the operation must be truly cancellable, or you must track and clean up 'orphaned' resources from timed-out operations.","variant":"error"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"testing-idempotent-disposal","title":"Testing Idempotent Disposal","content":[{"data":{"content":"A well-designed dispose method should be **idempotent**—calling it multiple times should have the same effect as calling it once, and should not throw errors. This is critical for robust error handling, where cleanup code may run multiple times through different paths.\n\n**Why idempotency matters:**"},"type":"text"},{"data":{"items":["**Exception handlers may double-dispose** — A finally block might dispose a resource that was already disposed in a catch block","**Framework cleanup uncertainty** — You may not know if a framework has already called dispose on your behalf","**Defensive programming** — Callers may dispose 'just to be safe' without tracking whether disposal already occurred","**Nested using/try-with-resources** — Automatic disposal mechanisms may overlap with manual cleanup"],"variant":"glass"},"type":"list"},{"data":{"fileName":"idempotent-disposal-tests.ts","languages":[{"code":"$85","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"Double-Checked Locking for Disposal","content":"The pattern shown uses a cached promise to handle concurrent dispose calls. The first caller creates the promise and stores it; subsequent callers simply await the existing promise. This ensures cleanup runs exactly once, even with concurrent calls.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: Verifying Resource Cleanup","content":[{"data":{"content":"Verifying resource cleanup is one of the most important—and often neglected—aspects of testing resource management code. Let's consolidate the key principles and techniques we've covered:"},"type":"text"},{"data":{"type":"ordered","items":["**Make cleanup observable** — Transform silent cleanup into verifiable behavior through callbacks, state exposure, or tracking registries","**Design for testability** — Use dependency injection for resource factories so tests can substitute tracking implementations","**Test the unhappy paths** — Exception scenarios, timeouts, and cancellations are where cleanup bugs hide—test them explicitly","**Verify cleanup ordering** — When resources have dependencies, ensure LIFO cleanup order is maintained","**Ensure idempotency** — Dispose methods should be safe to call multiple times without error or duplicate cleanup","**Use cleanup assertions in teardown** — Run leak detection after every test to catch issues immediately"],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nVerifying cleanup is half the battle—the other half is detecting when cleanup *doesn't* happen. In the next page, we'll explore techniques for detecting resource leaks, including memory profiling, handle tracking, and automated leak detection in test suites."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand how to design testable resource management code and write tests that verify cleanup occurs correctly. These patterns form the foundation for building robust, leak-free systems. Next, we'll explore how to detect resource leaks when prevention fails.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_0860c7364d0b6a9b0e9408238e9aa077","title":"Detecting Resource Leaks","order":1,"content":null,"isLocked":true},{"id":"seed_90082a9a12fcbc25e0ef794c831aca8f","title":"Mocking External Resources","order":2,"content":null,"isLocked":true},{"id":"seed_a92ad54898adf9c21c3b0bfc7927ab7a","title":"Integration Testing with Resources","order":3,"content":null,"isLocked":true}]}}