@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/modules/monitor/NetworkMonitor.impl.additional.test.js

@@ -0,0 +1,668 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+    buildXHRInterceptorCode: vi.fn().mockReturnValue('xhr-interceptor-code'),
+    buildFetchInterceptorCode: vi.fn().mockReturnValue('fetch-interceptor-code'),
+    CLEAR_INJECTED_BUFFERS_EXPRESSION: 'clear-buffers-expression',
+    RESET_INJECTED_INTERCEPTORS_EXPRESSION: 'reset-interceptors-expression',
+}));
+vi.mock('@utils/logger', () => ({
+    logger: mocks.logger,
+}));
+vi.mock('@modules/monitor/NetworkMonitor.interceptors', () => ({
+    buildXHRInterceptorCode: mocks.buildXHRInterceptorCode,
+    buildFetchInterceptorCode: mocks.buildFetchInterceptorCode,
+    CLEAR_INJECTED_BUFFERS_EXPRESSION: mocks.CLEAR_INJECTED_BUFFERS_EXPRESSION,
+    RESET_INJECTED_INTERCEPTORS_EXPRESSION: mocks.RESET_INJECTED_INTERCEPTORS_EXPRESSION,
+}));
+import { NetworkMonitor } from '../../../src/modules/monitor/NetworkMonitor.impl.js';
+function createMockSession() {
+    const listeners = new Map();
+    const send = vi.fn(async (..._args) => ({}));
+    const on = vi.fn((event, handler) => {
+        const group = listeners.get(event) ?? new Set();
+        group.add(handler);
+        listeners.set(event, group);
+    });
+    const off = vi.fn((event, handler) => {
+        listeners.get(event)?.delete(handler);
+    });
+    const emit = (event, payload) => {
+        listeners.get(event)?.forEach((handler) => handler(payload));
+    };
+    return {
+        session: { send, on, off },
+        send,
+        emit,
+    };
+}
+describe('NetworkMonitor.impl – additional coverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.buildXHRInterceptorCode.mockReturnValue('xhr-interceptor-code');
+        mocks.buildFetchInterceptorCode.mockReturnValue('fetch-interceptor-code');
+    });
+    describe('enable', () => {
+        it('sends Network.enable with buffer sizes', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            expect(send).toHaveBeenCalledWith('Network.enable', expect.objectContaining({
+                maxTotalBufferSize: 10000000,
+                maxResourceBufferSize: 5000000,
+            }));
+            expect(monitor.isEnabled()).toBe(true);
+        });
+        it('skips enabling when already enabled', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockClear();
+            await monitor.enable();
+            expect(send).not.toHaveBeenCalledWith('Network.enable', expect.anything());
+        });
+        it('throws and marks disabled when Network.enable fails', async () => {
+            const { session, send } = createMockSession();
+            send.mockRejectedValueOnce(new Error('CDP error'));
+            const monitor = new NetworkMonitor(session);
+            await expect(monitor.enable()).rejects.toThrow('CDP error');
+            expect(monitor.isEnabled()).toBe(false);
+        });
+    });
+    describe('disable', () => {
+        it('removes listeners and sends Network.disable', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            await monitor.disable();
+            expect(send).toHaveBeenCalledWith('Network.disable');
+            expect(monitor.isEnabled()).toBe(false);
+        });
+        it('skips when not enabled', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.disable();
+            expect(send).not.toHaveBeenCalledWith('Network.disable');
+        });
+        it('handles Network.disable failure gracefully', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockRejectedValueOnce(new Error('already detached'));
+            await expect(monitor.disable()).resolves.toBeUndefined();
+        });
+    });
+    describe('disconnected event', () => {
+        it('marks network as disabled on CDP session disconnect', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('disconnected');
+            expect(monitor.isEnabled()).toBe(false);
+        });
+    });
+    describe('request/response capture', () => {
+        it('skips malformed requestWillBeSent payloads', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', { invalid: true });
+            expect(monitor.getRequests()).toHaveLength(0);
+        });
+        it('skips malformed responseReceived payloads', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.responseReceived', { bad: 'data' });
+            expect(monitor.getResponses()).toHaveLength(0);
+        });
+        it('skips malformed loadingFinished payloads', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.loadingFinished', { noRequestId: true });
+        });
+        it('captures request with postData', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: {
+                    url: 'https://api.example.com/submit',
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    postData: '{"key":"value"}',
+                },
+                timestamp: 1,
+                type: 'Fetch',
+                initiator: { type: 'script' },
+            });
+            const reqs = monitor.getRequests();
+            expect(reqs).toHaveLength(1);
+            expect(reqs[0]).toMatchObject({
+                method: 'POST',
+                postData: '{"key":"value"}',
+                type: 'Fetch',
+            });
+        });
+        it('captures response with cache/timing metadata', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: {
+                    url: 'https://cdn.example.com/lib.js',
+                    status: 304,
+                    statusText: 'Not Modified',
+                    headers: {},
+                    mimeType: 'application/javascript',
+                    fromDiskCache: true,
+                    fromServiceWorker: false,
+                    timing: { sendStart: 10 },
+                },
+                timestamp: 2,
+            });
+            const responses = monitor.getResponses();
+            expect(responses).toHaveLength(1);
+            expect(responses[0]).toMatchObject({
+                status: 304,
+                fromCache: true,
+            });
+        });
+        it('evicts oldest request when exceeding MAX_NETWORK_RECORDS', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            const MAX = monitor.MAX_NETWORK_RECORDS;
+            for (let i = 0; i <= MAX; i++) {
+                emit('Network.requestWillBeSent', {
+                    requestId: `r-${i}`,
+                    request: { url: `https://site.com/${i}`, method: 'GET' },
+                    timestamp: i,
+                });
+            }
+            expect(monitor.getRequests().length).toBeLessThanOrEqual(MAX);
+        });
+        it('evicts oldest response when exceeding MAX_NETWORK_RECORDS', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            const MAX = monitor.MAX_NETWORK_RECORDS;
+            for (let i = 0; i <= MAX; i++) {
+                emit('Network.responseReceived', {
+                    requestId: `r-${i}`,
+                    response: {
+                        url: `https://site.com/${i}`,
+                        status: 200,
+                        statusText: 'OK',
+                        mimeType: 'text/html',
+                    },
+                    timestamp: i,
+                });
+            }
+            expect(monitor.getResponses().length).toBeLessThanOrEqual(MAX);
+        });
+    });
+    describe('getRequests filtering', () => {
+        it('filters by url substring', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://api.example.com/users', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.requestWillBeSent', {
+                requestId: 'r2',
+                request: { url: 'https://cdn.example.com/lib.js', method: 'GET' },
+                timestamp: 2,
+            });
+            const filtered = monitor.getRequests({ url: 'api.example' });
+            expect(filtered).toHaveLength(1);
+            expect(filtered[0]?.url).toContain('api.example');
+        });
+        it('filters by method', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.requestWillBeSent', {
+                requestId: 'r2',
+                request: { url: 'https://site.com/b', method: 'POST' },
+                timestamp: 2,
+            });
+            const filtered = monitor.getRequests({ method: 'POST' });
+            expect(filtered).toHaveLength(1);
+        });
+        it('applies limit', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            for (let i = 0; i < 5; i++) {
+                emit('Network.requestWillBeSent', {
+                    requestId: `r-${i}`,
+                    request: { url: `https://site.com/${i}`, method: 'GET' },
+                    timestamp: i,
+                });
+            }
+            const filtered = monitor.getRequests({ limit: 2 });
+            expect(filtered).toHaveLength(2);
+        });
+    });
+    describe('getResponses filtering', () => {
+        it('filters by status code', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/ok', status: 200, statusText: 'OK', mimeType: 'text/html' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r2',
+                response: { url: 'https://site.com/err', status: 500, statusText: 'Error', mimeType: 'text/html' },
+                timestamp: 2,
+            });
+            const filtered = monitor.getResponses({ status: 500 });
+            expect(filtered).toHaveLength(1);
+            expect(filtered[0]?.status).toBe(500);
+        });
+        it('filters by url and applies limit', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            for (let i = 0; i < 5; i++) {
+                emit('Network.responseReceived', {
+                    requestId: `r-${i}`,
+                    response: { url: `https://api.site.com/${i}`, status: 200, statusText: 'OK', mimeType: 'application/json' },
+                    timestamp: i,
+                });
+            }
+            const filtered = monitor.getResponses({ url: 'api.site', limit: 2 });
+            expect(filtered).toHaveLength(2);
+        });
+    });
+    describe('getActivity', () => {
+        it('returns both request and response for a requestId', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/api', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/api', status: 200, statusText: 'OK', mimeType: 'application/json' },
+                timestamp: 2,
+            });
+            const activity = monitor.getActivity('r1');
+            expect(activity.request?.url).toBe('https://site.com/api');
+            expect(activity.response?.status).toBe(200);
+        });
+        it('returns undefined for unknown requestId', async () => {
+            const { session } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            const activity = monitor.getActivity('nonexistent');
+            expect(activity.request).toBeUndefined();
+            expect(activity.response).toBeUndefined();
+        });
+    });
+    describe('getStatus', () => {
+        it('reports enabled status with correct counts', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            const status = monitor.getStatus();
+            expect(status.enabled).toBe(true);
+            expect(status.requestCount).toBe(1);
+            expect(status.responseCount).toBe(0);
+            expect(status.listenerCount).toBe(3);
+            expect(status.cdpSessionActive).toBe(true);
+        });
+    });
+    describe('getStats', () => {
+        it('aggregates stats by method, status, and type', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+                type: 'Document',
+            });
+            emit('Network.requestWillBeSent', {
+                requestId: 'r2',
+                request: { url: 'https://site.com/b', method: 'POST' },
+                timestamp: 2,
+                type: 'XHR',
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/a', status: 200, statusText: 'OK', mimeType: 'text/html' },
+                timestamp: 3,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r2',
+                response: { url: 'https://site.com/b', status: 404, statusText: 'Not Found', mimeType: 'text/html' },
+                timestamp: 4,
+            });
+            const stats = monitor.getStats();
+            expect(stats.totalRequests).toBe(2);
+            expect(stats.totalResponses).toBe(2);
+            expect(stats.byMethod.GET).toBe(1);
+            expect(stats.byMethod.POST).toBe(1);
+            expect(stats.byStatus[200]).toBe(1);
+            expect(stats.byStatus[404]).toBe(1);
+            expect(stats.byType.Document).toBe(1);
+            expect(stats.byType.XHR).toBe(1);
+        });
+    });
+    describe('clearRecords', () => {
+        it('clears all stored records', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            monitor.clearRecords();
+            expect(monitor.getRequests()).toHaveLength(0);
+            expect(monitor.getResponses()).toHaveLength(0);
+        });
+    });
+    describe('getResponseBody', () => {
+        it('returns null when network is not enabled', async () => {
+            const { session } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            const body = await monitor.getResponseBody('r1');
+            expect(body).toBeNull();
+        });
+        it('returns null when request not found', async () => {
+            const { session } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            const body = await monitor.getResponseBody('nonexistent');
+            expect(body).toBeNull();
+        });
+        it('returns null when response not yet received', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            const body = await monitor.getResponseBody('r1');
+            expect(body).toBeNull();
+        });
+        it('retrieves body from CDP when not in cache', async () => {
+            const { session, send, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/script.js', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/script.js', status: 200, statusText: 'OK', mimeType: 'application/javascript' },
+                timestamp: 2,
+            });
+            send.mockResolvedValueOnce({ body: 'console.log("hello")', base64Encoded: false });
+            const body = await monitor.getResponseBody('r1');
+            expect(body).toMatchObject({
+                body: 'console.log("hello")',
+                base64Encoded: false,
+            });
+        });
+        it('returns null on unexpected response body format', async () => {
+            const { session, send, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/a', status: 200, statusText: 'OK', mimeType: 'text/html' },
+                timestamp: 2,
+            });
+            send.mockResolvedValueOnce({ unexpected: 'format' });
+            const body = await monitor.getResponseBody('r1');
+            expect(body).toBeNull();
+        });
+        it('returns null when CDP throws', async () => {
+            const { session, send, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/a', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/a', status: 200, statusText: 'OK', mimeType: 'text/html' },
+                timestamp: 2,
+            });
+            send.mockRejectedValueOnce(new Error('No resource with given identifier found'));
+            const body = await monitor.getResponseBody('r1');
+            expect(body).toBeNull();
+        });
+    });
+    describe('getAllJavaScriptResponses', () => {
+        it('collects JS responses based on mimeType and URL', async () => {
+            const { session, send, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/app.js', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/app.js', status: 200, statusText: 'OK', mimeType: 'application/javascript' },
+                timestamp: 2,
+            });
+            send.mockResolvedValueOnce({ body: 'var x = 1;', base64Encoded: false });
+            const jsResponses = await monitor.getAllJavaScriptResponses();
+            expect(jsResponses).toHaveLength(1);
+            expect(jsResponses[0]).toMatchObject({
+                url: 'https://site.com/app.js',
+                content: 'var x = 1;',
+                size: 10,
+            });
+        });
+        it('skips non-JS responses', async () => {
+            const { session, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: { url: 'https://site.com/style.css', status: 200, statusText: 'OK', mimeType: 'text/css' },
+                timestamp: 1,
+            });
+            const jsResponses = await monitor.getAllJavaScriptResponses();
+            expect(jsResponses).toHaveLength(0);
+        });
+        it('detects JS by .js extension in URL', async () => {
+            const { session, send, emit } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            emit('Network.requestWillBeSent', {
+                requestId: 'r1',
+                request: { url: 'https://site.com/bundle.js?v=123', method: 'GET' },
+                timestamp: 1,
+            });
+            emit('Network.responseReceived', {
+                requestId: 'r1',
+                response: {
+                    url: 'https://site.com/bundle.js?v=123',
+                    status: 200,
+                    statusText: 'OK',
+                    mimeType: 'text/plain',
+                },
+                timestamp: 2,
+            });
+            send.mockResolvedValueOnce({ body: 'function(){}', base64Encoded: false });
+            const jsResponses = await monitor.getAllJavaScriptResponses();
+            expect(jsResponses).toHaveLength(1);
+        });
+    });
+    describe('injectXHRInterceptor', () => {
+        it('sends XHR interceptor code via Runtime.evaluate', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            await monitor.injectXHRInterceptor();
+            expect(send).toHaveBeenCalledWith('Runtime.evaluate', {
+                expression: 'xhr-interceptor-code',
+            });
+        });
+    });
+    describe('injectFetchInterceptor', () => {
+        it('sends Fetch interceptor code via Runtime.evaluate', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            await monitor.injectFetchInterceptor();
+            expect(send).toHaveBeenCalledWith('Runtime.evaluate', {
+                expression: 'fetch-interceptor-code',
+            });
+        });
+    });
+    describe('getXHRRequests', () => {
+        it('returns parsed XHR requests from Runtime.evaluate', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({
+                result: { value: [{ url: 'https://api.com/data', method: 'GET' }] },
+            });
+            const reqs = await monitor.getXHRRequests();
+            expect(reqs).toHaveLength(1);
+            expect(reqs[0]).toMatchObject({ url: 'https://api.com/data' });
+        });
+        it('returns empty array when value is not an array', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({ result: { value: null } });
+            const reqs = await monitor.getXHRRequests();
+            expect(reqs).toEqual([]);
+        });
+        it('returns empty array on evaluation error', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockRejectedValueOnce(new Error('eval failed'));
+            const reqs = await monitor.getXHRRequests();
+            expect(reqs).toEqual([]);
+        });
+    });
+    describe('getFetchRequests', () => {
+        it('returns parsed Fetch requests', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({
+                result: { value: [{ url: 'https://api.com/fetch', method: 'POST' }] },
+            });
+            const reqs = await monitor.getFetchRequests();
+            expect(reqs).toHaveLength(1);
+        });
+        it('returns empty array on error', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockRejectedValueOnce(new Error('eval failed'));
+            const reqs = await monitor.getFetchRequests();
+            expect(reqs).toEqual([]);
+        });
+    });
+    describe('clearInjectedBuffers', () => {
+        it('returns counts from Runtime.evaluate', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({
+                result: { value: { xhrCleared: 3, fetchCleared: 5 } },
+            });
+            const result = await monitor.clearInjectedBuffers();
+            expect(result).toEqual({ xhrCleared: 3, fetchCleared: 5 });
+        });
+        it('returns zeros on unexpected format', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({ result: { value: null } });
+            const result = await monitor.clearInjectedBuffers();
+            expect(result).toEqual({ xhrCleared: 0, fetchCleared: 0 });
+        });
+        it('returns zeros on error', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockRejectedValueOnce(new Error('failed'));
+            const result = await monitor.clearInjectedBuffers();
+            expect(result).toEqual({ xhrCleared: 0, fetchCleared: 0 });
+        });
+    });
+    describe('resetInjectedInterceptors', () => {
+        it('returns reset results from Runtime.evaluate', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({
+                result: { value: { xhrReset: true, fetchReset: true } },
+            });
+            const result = await monitor.resetInjectedInterceptors();
+            expect(result).toEqual({ xhrReset: true, fetchReset: true });
+        });
+        it('returns false on unexpected format', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockResolvedValueOnce({ result: { value: 'not-object' } });
+            const result = await monitor.resetInjectedInterceptors();
+            expect(result).toEqual({ xhrReset: false, fetchReset: false });
+        });
+        it('returns false on error', async () => {
+            const { session, send } = createMockSession();
+            const monitor = new NetworkMonitor(session);
+            await monitor.enable();
+            send.mockRejectedValueOnce(new Error('failed'));
+            const result = await monitor.resetInjectedInterceptors();
+            expect(result).toEqual({ xhrReset: false, fetchReset: false });
+        });
+    });
+});

package/dist/tests/modules/monitor/NetworkMonitor.impl.test.d.ts

@@ -0,0 +1 @@
+export {};