Testing Resource Management

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// WRONG: Mock that doesn't track disposal
class BadMockConnection {
    execute(query: string): Promise<Result> {
        return Promise.resolve({ rows: [] });
    }
    // No dispose method - can't verify cleanup!
}
 
// CORRECT: Mock with full lifecycle tracking
class MockConnection implements IConnection {
    private _isOpen = true;
    private _disposed = false;
    private _disposeCount = 0;
    readonly queries: string[] = [];
    
    get isOpen(): boolean { return this._isOpen; }
    get isDisposed(): boolean { return this._disposed; }
    get disposeCallCount(): number { return this._disposeCount; }
    
    async execute(query: string): Promise<Result> {
        if (this._disposed) {
            throw new Error('Cannot execute on disposed connection');
        }
        this.queries.push(query);
        return { rows: [] };
    }
    
    dispose(): void {
        this._disposeCount++;
        if (!this._disposed) {
            this._isOpen = false;
            this._disposed = true;
        }
    }
    
    // Test helper: verify proper usage
    assertProperlyManaged(): void {
        if (!this._disposed) {
            throw new Error('Connection was not disposed');
        }
        if (this._disposeCount > 1) {
            // This might be okay (idempotent) or might indicate a bug
            console.warn(`dispose() called ${this._disposeCount} times`);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// Comprehensive in-memory file system mock for testing
interface IFileHandle {
    read(): Promise<Buffer>;
    write(data: Buffer): Promise<void>;
    close(): Promise<void>;
    readonly path: string;
    readonly isOpen: boolean;
}
 
interface IFileSystem {
    open(path: string, mode: 'r' | 'w' | 'rw'): Promise<IFileHandle>;
    exists(path: string): Promise<boolean>;
    delete(path: string): Promise<void>;
    readdir(path: string): Promise<string[]>;
}
 
class MockFileHandle implements IFileHandle {
    private _isOpen = true;
    private _closeCount = 0;
    
    constructor(
        readonly path: string,
        private readonly fs: MockFileSystem,
        private readonly mode: 'r' | 'w' | 'rw'
    ) {
        fs.trackHandleOpened(this);
    }
    
    get isOpen(): boolean { return this._isOpen; }
    get closeCount(): number { return this._closeCount; }
    
    async read(): Promise<Buffer> {
        this.ensureOpen('read');
        if (this.mode === 'w') {
            throw new Error('Cannot read from write-only handle');
        }
        return this.fs.getFileContent(this.path);
    }
    
    async write(data: Buffer): Promise<void> {
        this.ensureOpen('write');
        if (this.mode === 'r') {
            throw new Error('Cannot write to read-only handle');
        }
        this.fs.setFileContent(this.path, data);
    }
    
    async close(): Promise<void> {
        this._closeCount++;
        if (this._isOpen) {
            this._isOpen = false;
            this.fs.trackHandleClosed(this);
        }
    }
    
    private ensureOpen(operation: string): void {
        if (!this._isOpen) {
            throw new Error(`Cannot ${operation} closed file handle: ${this.path}`);
        }
    }
}
 
class MockFileSystem implements IFileSystem {
    private files = new Map<string, Buffer>();
    private openHandles = new Set<MockFileHandle>();
    private allHandlesEverOpened: MockFileHandle[] = [];
    
    // Configure initial file state
    setFile(path: string, content: string | Buffer): void {
        this.files.set(path, typeof content === 'string' 
            ? Buffer.from(content) 
            : content
        );
    }
    
    getFileContent(path: string): Buffer {
        const content = this.files.get(path);
        if (!content) throw new Error(`File not found: ${path}`);
        return content;
    }
    
    setFileContent(path: string, content: Buffer): void {
        this.files.set(path, content);
    }
    
    async open(path: string, mode: 'r' | 'w' | 'rw'): Promise<IFileHandle> {
        if (mode === 'r' && !this.files.has(path)) {
            throw new Error(`ENOENT: File not found: ${path}`);
        }
        return new MockFileHandle(path, this, mode);
    }
    
    async exists(path: string): Promise<boolean> {
        return this.files.has(path);
    }
    
    async delete(path: string): Promise<void> {
        this.files.delete(path);
    }
    
    async readdir(path: string): Promise<string[]> {
        const prefix = path.endsWith('/') ? path : path + '/';
        return Array.from(this.files.keys())
            .filter(p => p.startsWith(prefix))
            .map(p => p.substring(prefix.length).split('/')[0]);
    }
    
    // Internal tracking for handles
    trackHandleOpened(handle: MockFileHandle): void {
        this.openHandles.add(handle);
        this.allHandlesEverOpened.push(handle);
    }
    
    trackHandleClosed(handle: MockFileHandle): void {
        this.openHandles.delete(handle);
    }
    
    // ===== TEST VERIFICATION METHODS =====
    
    getOpenHandleCount(): number {
        return this.openHandles.size;
    }
    
    getOpenHandles(): MockFileHandle[] {
        return Array.from(this.openHandles);
    }
    
    assertAllHandlesClosed(): void {
        if (this.openHandles.size > 0) {
            const leaked = Array.from(this.openHandles)
                .map(h => h.path)
                .join(', ');
            throw new Error(`File handle leak: ${this.openHandles.size} handles still open: ${leaked}`);
        }
    }
    
    assertHandleWasClosed(path: string): void {
        const handle = this.allHandlesEverOpened.find(h => h.path === path);
        if (!handle) {
            throw new Error(`No handle was ever opened for: ${path}`);
        }
        if (handle.isOpen) {
            throw new Error(`Handle for ${path} was opened but never closed`);
        }
    }
    
    reset(): void {
        this.files.clear();
        this.openHandles.clear();
        this.allHandlesEverOpened = [];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

describe('FileProcessor with mock file system', () => {
    let mockFs: MockFileSystem;
    let processor: FileProcessor;
    
    beforeEach(() => {
        mockFs = new MockFileSystem();
        processor = new FileProcessor(mockFs);
    });
    
    afterEach(() => {
        // Verify no handle leaks after every test
        mockFs.assertAllHandlesClosed();
    });
    
    it('should close file handle after successful processing', async () => {
        mockFs.setFile('/input/data.txt', 'test content');
        
        await processor.processFile('/input/data.txt');
        
        expect(mockFs.getOpenHandleCount()).toBe(0);
        mockFs.assertHandleWasClosed('/input/data.txt');
    });
    
    it('should close file handle even when processing throws', async () => {
        mockFs.setFile('/input/bad.txt', 'invalid content');
        
        await expect(processor.processFile('/input/bad.txt'))
            .rejects.toThrow('Processing failed');
        
        // Critical: handle must still be closed
        expect(mockFs.getOpenHandleCount()).toBe(0);
    });
    
    it('should handle multiple files without leaking handles', async () => {
        mockFs.setFile('/a.txt', 'a');
        mockFs.setFile('/b.txt', 'b');
        mockFs.setFile('/c.txt', 'c');
        
        await processor.processFiles(['/a.txt', '/b.txt', '/c.txt']);
        
        expect(mockFs.getOpenHandleCount()).toBe(0);
    });
    
    it('should prevent operations on closed handles', async () => {
        mockFs.setFile('/test.txt', 'content');
        
        const handle = await mockFs.open('/test.txt', 'r');
        await handle.close();
        
        await expect(handle.read())
            .rejects.toThrow('Cannot read closed file handle');
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

// Behavior configuration for mock connection
interface MockConnectionBehavior {
    executeDelay?: number;          // Simulate network latency
    failOnExecute?: boolean;        // Simulate query failure
    failOnOpen?: boolean;           // Simulate connection failure
    failOnClose?: boolean;          // Simulate cleanup failure
    throwAfterQueries?: number;     // Fail after N queries
}
 
class MockDatabaseConnection implements IConnection {
    private _isOpen = true;
    private _isDisposed = false;
    private _queryCount = 0;
    private _inTransaction = false;
    private readonly _executedQueries: string[] = [];
    
    constructor(
        readonly id: string,
        private readonly behavior: MockConnectionBehavior = {}
    ) {}
    
    get isOpen(): boolean { return this._isOpen; }
    get isDisposed(): boolean { return this._isDisposed; }
    get queryCount(): number { return this._queryCount; }
    get executedQueries(): string[] { return [...this._executedQueries]; }
    get inTransaction(): boolean { return this._inTransaction; }
    
    async execute(query: string): Promise<QueryResult> {
        this.ensureOpen();
        
        if (this.behavior.executeDelay) {
            await sleep(this.behavior.executeDelay);
        }
        
        this._queryCount++;
        this._executedQueries.push(query);
        
        if (this.behavior.throwAfterQueries && 
            this._queryCount >= this.behavior.throwAfterQueries) {
            throw new Error(`Mock failure after ${this._queryCount} queries`);
        }
        
        if (this.behavior.failOnExecute) {
            throw new Error('Mock execute failure');
        }
        
        return { rows: [], affectedRows: 0 };
    }
    
    async beginTransaction(): Promise<void> {
        this.ensureOpen();
        if (this._inTransaction) {
            throw new Error('Transaction already in progress');
        }
        this._inTransaction = true;
        this._executedQueries.push('BEGIN TRANSACTION');
    }
    
    async commit(): Promise<void> {
        this.ensureOpen();
        if (!this._inTransaction) {
            throw new Error('No transaction to commit');
        }
        this._inTransaction = false;
        this._executedQueries.push('COMMIT');
    }
    
    async rollback(): Promise<void> {
        this.ensureOpen();
        if (!this._inTransaction) {
            throw new Error('No transaction to rollback');
        }
        this._inTransaction = false;
        this._executedQueries.push('ROLLBACK');
    }
    
    dispose(): void {
        if (this.behavior.failOnClose) {
            throw new Error('Mock dispose failure');
        }
        
        if (!this._isDisposed) {
            // Auto-rollback uncommitted transaction (like real DBs)
            if (this._inTransaction) {
                this._executedQueries.push('ROLLBACK (auto on dispose)');
                this._inTransaction = false;
            }
            this._isOpen = false;
            this._isDisposed = true;
        }
    }
    
    private ensureOpen(): void {
        if (!this._isOpen || this._isDisposed) {
            throw new Error('Connection is closed');
        }
    }
    
    // Verification helpers
    assertDisposed(): void {
        if (!this._isDisposed) {
            throw new Error(`Connection ${this.id} was not disposed`);
        }
    }
    
    assertNoUncommittedTransaction(): void {
        if (this._inTransaction) {
            throw new Error(`Connection ${this.id} has uncommitted transaction`);
        }
    }
    
    assertQueryExecuted(pattern: string | RegExp): void {
        const found = this._executedQueries.some(q => 
            typeof pattern === 'string' ? q.includes(pattern) : pattern.test(q)
        );
        if (!found) {
            throw new Error(
                `Expected query matching "${pattern}" not found. Executed: ${this._executedQueries.join('; ')}`
            );
        }
    }
}
 
// Mock connection pool
class MockConnectionPool implements IConnectionPool {
    private connections: MockDatabaseConnection[] = [];
    private _borrowCount = 0;
    private _returnCount = 0;
    private nextBehavior: MockConnectionBehavior = {};
    
    borrow(): MockDatabaseConnection {
        this._borrowCount++;
        const conn = new MockDatabaseConnection(
            `conn-${this._borrowCount}`,
            this.nextBehavior
        );
        this.connections.push(conn);
        return conn;
    }
    
    return(conn: IConnection): void {
        this._returnCount++;
        (conn as MockDatabaseConnection).dispose();
    }
    
    // Test configuration
    setNextBehavior(behavior: MockConnectionBehavior): void {
        this.nextBehavior = behavior;
    }
    
    // Verification
    get borrowCount(): number { return this._borrowCount; }
    get returnCount(): number { return this._returnCount; }
    get allConnections(): MockDatabaseConnection[] { return [...this.connections]; }
    
    assertAllReturned(): void {
        if (this._borrowCount !== this._returnCount) {
            throw new Error(
                `Connection leak: ${this._borrowCount} borrowed, ${this._returnCount} returned`
            );
        }
    }
    
    assertAllDisposed(): void {
        const undisposed = this.connections.filter(c => !c.isDisposed);
        if (undisposed.length > 0) {
            throw new Error(
                `${undisposed.length} connection(s) not disposed: ${undisposed.map(c => c.id).join(', ')}`
            );
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

describe('TransactionManager cleanup behavior', () => {
    let mockPool: MockConnectionPool;
    let txManager: TransactionManager;
    
    beforeEach(() => {
        mockPool = new MockConnectionPool();
        txManager = new TransactionManager(mockPool);
    });
    
    afterEach(() => {
        mockPool.assertAllReturned();
        mockPool.assertAllDisposed();
    });
    
    it('should commit and return connection on success', async () => {
        await txManager.executeInTransaction(async (conn) => {
            await conn.execute('INSERT INTO users ...');
        });
        
        const conn = mockPool.allConnections[0];
        expect(conn.executedQueries).toContain('COMMIT');
        expect(conn.isDisposed).toBe(true);
    });
    
    it('should rollback and return connection on failure', async () => {
        await expect(txManager.executeInTransaction(async (conn) => {
            await conn.execute('INSERT INTO users ...');
            throw new Error('Business logic failed');
        })).rejects.toThrow('Business logic failed');
        
        const conn = mockPool.allConnections[0];
        expect(conn.executedQueries).toContain('ROLLBACK');
        expect(conn.isDisposed).toBe(true);
    });
    
    it('should handle query failure mid-transaction', async () => {
        mockPool.setNextBehavior({ throwAfterQueries: 2 });
        
        await expect(txManager.executeInTransaction(async (conn) => {
            await conn.execute('INSERT 1'); // OK
            await conn.execute('INSERT 2'); // Throws
        })).rejects.toThrow('Mock failure');
        
        const conn = mockPool.allConnections[0];
        expect(conn.executedQueries).toContain('ROLLBACK');
    });
    
    it('should cleanup even if close fails', async () => {
        mockPool.setNextBehavior({ failOnClose: true });
        
        // Should not throw despite close failure
        await expect(txManager.executeInTransaction(async (conn) => {
            await conn.execute('SELECT 1');
        })).rejects.toThrow(); // Or resolves, depending on your error policy
        
        // Connection was at least attempted to be cleaned up
        expect(mockPool.returnCount).toBe(1);
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

// Mock HTTP client with connection and stream management
interface HttpResponse {
    status: number;
    headers: Record<string, string>;
    body: () => Promise<Buffer>;
    bodyStream: () => ReadableStream<Uint8Array>;
}
 
interface IHttpClient {
    request(options: RequestOptions): Promise<HttpResponse>;
    close(): Promise<void>;
}
 
class MockHttpClient implements IHttpClient {
    private _isClosed = false;
    private _requestCount = 0;
    private _activeStreams = new Set<MockBodyStream>();
    private readonly _requestLog: RequestOptions[] = [];
    private responseHandlers = new Map<string, () => HttpResponse>();
    
    // Configure responses
    onRequest(urlPattern: string, handler: () => HttpResponse): void {
        this.responseHandlers.set(urlPattern, handler);
    }
    
    async request(options: RequestOptions): Promise<HttpResponse> {
        if (this._isClosed) {
            throw new Error('Cannot use closed HTTP client');
        }
        
        this._requestCount++;
        this._requestLog.push(options);
        
        // Find matching handler
        const handler = Array.from(this.responseHandlers.entries())
            .find(([pattern]) => options.url.includes(pattern))?.[1];
        
        if (handler) {
            const response = handler();
            // Wrap body stream to track it
            return this.wrapResponseWithTracking(response);
        }
        
        // Default response
        return this.wrapResponseWithTracking({
            status: 200,
            headers: {},
            body: async () => Buffer.from(''),
            bodyStream: () => new ReadableStream(),
        });
    }
    
    private wrapResponseWithTracking(response: HttpResponse): HttpResponse {
        const self = this;
        
        return {
            ...response,
            bodyStream: () => {
                const stream = new MockBodyStream(response, self);
                self._activeStreams.add(stream);
                return stream;
            },
        };
    }
    
    streamClosed(stream: MockBodyStream): void {
        this._activeStreams.delete(stream);
    }
    
    async close(): Promise<void> {
        // Abort any active streams
        for (const stream of this._activeStreams) {
            stream.abort();
        }
        this._activeStreams.clear();
        this._isClosed = true;
    }
    
    // Verification
    get isClosed(): boolean { return this._isClosed; }
    get requestCount(): number { return this._requestCount; }
    get requestLog(): RequestOptions[] { return [...this._requestLog]; }
    get activeStreamCount(): number { return this._activeStreams.size; }
    
    assertClosed(): void {
        if (!this._isClosed) {
            throw new Error('HTTP client was not closed');
        }
    }
    
    assertNoActiveStreams(): void {
        if (this._activeStreams.size > 0) {
            throw new Error(`${this._activeStreams.size} response stream(s) still active`);
        }
    }
    
    assertRequestMade(urlPattern: string | RegExp): void {
        const found = this._requestLog.some(r => 
            typeof urlPattern === 'string' 
                ? r.url.includes(urlPattern)
                : urlPattern.test(r.url)
        );
        if (!found) {
            throw new Error(`No request matching "${urlPattern}" was made`);
        }
    }
}
 
class MockBodyStream extends ReadableStream<Uint8Array> {
    private _aborted = false;
    private _closed = false;
    
    constructor(
        private readonly response: HttpResponse,
        private readonly client: MockHttpClient
    ) {
        super({
            start(controller) {
                // Simulate some data
                response.body().then(data => {
                    controller.enqueue(new Uint8Array(data));
                    controller.close();
                });
            },
        });
    }
    
    abort(): void {
        this._aborted = true;
        this.cancel();
    }
    
    // Override to track closure
    async cancel(reason?: any): Promise<void> {
        this._closed = true;
        this.client.streamClosed(this);
        return super.cancel(reason);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

describe('ApiClient stream management', () => {
    let mockHttp: MockHttpClient;
    let apiClient: ApiClient;
    
    beforeEach(() => {
        mockHttp = new MockHttpClient();
        apiClient = new ApiClient(mockHttp);
        
        mockHttp.onRequest('/stream', () => ({
            status: 200,
            headers: { 'content-type': 'application/octet-stream' },
            body: async () => Buffer.from('chunk1chunk2chunk3'),
            bodyStream: () => new ReadableStream(),
        }));
    });
    
    afterEach(async () => {
        await apiClient.close();
        mockHttp.assertClosed();
        mockHttp.assertNoActiveStreams();
    });
    
    it('should close stream after successful read', async () => {
        const data = await apiClient.downloadFile('/stream/file.dat');
        
        expect(mockHttp.activeStreamCount).toBe(0);
    });
    
    it('should close stream if processing fails mid-stream', async () => {
        // Configure to throw during processing
        apiClient.setProcessChunk(() => { throw new Error('Process failure'); });
        
        await expect(apiClient.downloadFile('/stream/file.dat'))
            .rejects.toThrow('Process failure');
        
        // Stream must still be closed
        expect(mockHttp.activeStreamCount).toBe(0);
    });
    
    it('should close underlying client on shutdown', async () => {
        await apiClient.downloadFile('/stream/file1.dat');
        await apiClient.downloadFile('/stream/file2.dat');
        
        await apiClient.close();
        
        mockHttp.assertClosed();
    });
    
    it('should abort active streams on forced close', async () => {
        // Start a download but don't wait for it
        const downloadPromise = apiClient.downloadLargeFile('/stream/huge.dat');
        
        // Immediately close
        await apiClient.close();
        
        // Download should fail gracefully
        await expect(downloadPromise).rejects.toThrow();
        expect(mockHttp.activeStreamCount).toBe(0);
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// DUMMY: Just satisfies the interface, no behavior
class DummyConnection implements IConnection {
    execute(_: string): Promise<Result> { throw new Error('Not implemented'); }
    dispose(): void { /* nothing */ }
}
 
// STUB: Returns predefined values
class StubConnection implements IConnection {
    private results: Result[] = [];
    
    setResults(...results: Result[]): void {
        this.results = results;
    }
    
    async execute(_: string): Promise<Result> {
        return this.results.shift() ?? { rows: [] };
    }
    
    dispose(): void { /* nothing */ }
}
 
// SPY: Records what happened
class SpyConnection implements IConnection {
    readonly executedQueries: string[] = [];
    disposeCallCount = 0;
    
    async execute(query: string): Promise<Result> {
        this.executedQueries.push(query);
        return { rows: [] };
    }
    
    dispose(): void {
        this.disposeCallCount++;
    }
}
 
// MOCK: Has expectations that can fail
class MockConnection implements IConnection {
    private expectDispose = false;
    private disposeCalledCount = 0;
    
    expectDisposeCall(): void {
        this.expectDispose = true;
    }
    
    async execute(_: string): Promise<Result> {
        return { rows: [] };
    }
    
    dispose(): void {
        this.disposeCalledCount++;
    }
    
    verify(): void {
        if (this.expectDispose && this.disposeCalledCount === 0) {
            throw new Error('Expected dispose() to be called, but it was not');
        }
    }
}
 
// FAKE: Working simplified implementation
class FakeInMemoryDatabase implements IDatabase {
    private tables = new Map<string, any[]>();
    private connectionPool: FakeConnection[] = [];
    
    createTable(name: string): void {
        this.tables.set(name, []);
    }
    
    createConnection(): IConnection {
        const conn = new FakeConnection(this.tables);
        this.connectionPool.push(conn);
        return conn;
    }
    
    // Can verify actual state of fake
    getTableData(name: string): any[] {
        return this.tables.get(name) ?? [];
    }
    
    assertAllConnectionsClosed(): void {
        const open = this.connectionPool.filter(c => !c.isClosed);
        if (open.length > 0) {
            throw new Error(`${open.length} connections not closed`);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 
describe('resource cleanup with vitest mocks', () => {
    // Create mock factory that returns mocks with spy capabilities
    const mockConnectionFactory = {
        createConnection: vi.fn(() => ({
            execute: vi.fn().mockResolvedValue({ rows: [] }),
            dispose: vi.fn(),
            // Track state for verification
            _isOpen: true,
        })),
    };
    
    beforeEach(() => {
        vi.clearAllMocks();
    });
    
    it('should call dispose on connections', async () => {
        const repository = new UserRepository(mockConnectionFactory);
        
        await repository.findById('123');
        
        // Get the mock connection that was created
        const mockConnection = mockConnectionFactory.createConnection.mock.results[0].value;
        
        // Verify dispose was called
        expect(mockConnection.dispose).toHaveBeenCalledTimes(1);
    });
    
    it('should dispose in correct order for nested resources', async () => {
        const callOrder: string[] = [];
        
        const mockInnerResource = {
            use: vi.fn(),
            dispose: vi.fn(() => callOrder.push('inner')),
        };
        
        const mockOuterResource = {
            inner: mockInnerResource,
            dispose: vi.fn(() => callOrder.push('outer')),
        };
        
        // Simulate using nested resources
        await useNestedResources(mockOuterResource);
        
        // Verify LIFO order
        expect(callOrder).toEqual(['inner', 'outer']);
    });
    
    it('should handle async dispose', async () => {
        const mockAsyncResource = {
            use: vi.fn(),
            dispose: vi.fn().mockImplementation(async () => {
                await new Promise(r => setTimeout(r, 10));
            }),
        };
        
        await withResource(mockAsyncResource, async (r) => {
            r.use();
        });
        
        // Verify async dispose was awaited
        expect(mockAsyncResource.dispose).toHaveBeenCalledTimes(1);
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// Template for well-designed resource mock
abstract class BaseMockResource<TConfig = {}> {
    protected _disposed = false;
    protected _disposeCount = 0;
    protected _operationLog: string[] = [];
    
    constructor(protected config: TConfig = {} as TConfig) {}
    
    // State accessors
    get isDisposed(): boolean { return this._disposed; }
    get disposeCount(): number { return this._disposeCount; }
    get operationLog(): string[] { return [...this._operationLog]; }
    
    // Lifecycle
    dispose(): void {
        this._disposeCount++;
        if (!this._disposed) {
            this._disposed = true;
            this._operationLog.push('dispose');
            this.onDispose();
        }
    }
    
    protected abstract onDispose(): void;
    
    // Verification helpers - call these in tests
    assertDisposed(): void {
        if (!this._disposed) {
            throw new Error(`${this.constructor.name} was not disposed`);
        }
    }
    
    assertDisposeCalledOnce(): void {
        if (this._disposeCount !== 1) {
            throw new Error(
                `Expected dispose() once, called ${this._disposeCount} times`
            );
        }
    }
    
    assertOperationSequence(expected: string[]): void {
        const actual = this._operationLog;
        if (JSON.stringify(actual) !== JSON.stringify(expected)) {
            throw new Error(
                `Operation sequence mismatch.\nExpected: ${expected.join(' → ')}\nActual: ${actual.join(' → ')}`
            );
        }
    }
    
    // For test reset
    reset(): void {
        this._disposed = false;
        this._disposeCount = 0;
        this._operationLog = [];
    }
}
 
// Example concrete mock using the template
class MockFileResource extends BaseMockResource<{ failOnRead?: boolean }> {
    async read(): Promise<string> {
        if (this._disposed) throw new Error('Cannot read disposed file');
        this._operationLog.push('read');
        if (this.config.failOnRead) throw new Error('Mock read failure');
        return 'mock content';
    }
    
    protected onDispose(): void {
        // Custom cleanup logic for this resource type
    }
}