test-proxy-recorder 0.1.11 → 0.2.0

package/README.md

@@ -99,10 +99,10 @@ This marks recording files as binary, which causes long mock files to be collaps
 Create `e2e/global-teardown.ts`:
 
 ```typescript
-import { setProxyMode } from 'test-proxy-recorder';
+import { playwrightProxy } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent').catch(err => { console.error(err) });
+  await playwrightProxy.teardown();
 }
 
 export default globalTeardown;
@@ -128,15 +128,17 @@ Create `e2e/example.spec.ts`:
 import { test, expect } from '@playwright/test';
 import { playwrightProxy } from 'test-proxy-recorder';
 
+// Setup afterEach hook to reset proxy after each test
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 test('example test with proxy', async ({ page }, testInfo) => {
   // Set proxy mode: 'record' to capture, 'replay' to use recordings
   await playwrightProxy.before(testInfo, 'replay');
 
   await page.goto('/');
   await expect(page.getByText('Welcome')).toBeVisible();
-
-  // Always cleanup after test
-  await playwrightProxy.after(testInfo);
 });
 ```
 
@@ -186,27 +188,38 @@ test-proxy-recorder http://localhost:8000 http://localhost:9000 --port 8100
 
 ### Basic Test Structure
 
-Every test using the proxy should follow this pattern:
+Every test file using the proxy should follow this pattern:
 
 ```typescript
 import { test } from '@playwright/test';
 import { playwrightProxy } from 'test-proxy-recorder';
 
+// Setup afterEach hook once per test file
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 test('test name', async ({ page }, testInfo) => {
   // 1. Set mode BEFORE test actions
   await playwrightProxy.before(testInfo, 'replay');
 
   // 2. Test code
   await page.goto('/page');
-
-  // 3. Reset mode AFTER test completes
-  await playwrightProxy.after(testInfo);
+  // Test assertions...
 });
 ```
 
 ### Recording vs Replay
 
 ```typescript
+import { test } from '@playwright/test';
+import { playwrightProxy } from 'test-proxy-recorder';
+
+// Setup afterEach hook to automatically cleanup after each test
+test.afterEach(async ({ page: _page }, testInfo) => {
+  await playwrightProxy.after(testInfo);
+});
+
 // Recording mode - captures API responses
 test('create user', async ({ page }, testInfo) => {
   await playwrightProxy.before(testInfo, 'record');
@@ -214,8 +227,6 @@ test('create user', async ({ page }, testInfo) => {
   await page.goto('/users/new');
   await page.fill('[name="username"]', 'testuser');
   await page.click('button[type="submit"]');
-
-  await playwrightProxy.after(testInfo);
 });
 
 // Replay mode - uses recorded responses
@@ -225,8 +236,6 @@ test('create user', async ({ page }, testInfo) => {
   await page.goto('/users/new');
   await page.fill('[name="username"]', 'testuser');
   await page.click('button[type="submit"]');
-
-  await playwrightProxy.after(testInfo);
 });
 ```
 
@@ -244,10 +253,10 @@ Recording files are auto-generated from test names:
 Create `e2e/global-teardown.ts`:
 
 ```typescript
-import { setProxyMode } from 'test-proxy-recorder';
+import { playwrightProxy } from 'test-proxy-recorder';
 
 async function globalTeardown() {
-  await setProxyMode('transparent').catch(err => { console.error(err) });
+  await playwrightProxy.teardown();
 }
 
 export default globalTeardown;
@@ -412,8 +421,13 @@ const playwrightProxy = {
     timeout?: number
   ): Promise<void>;
 
-  // Reset to transparent mode after test
+  // Reset replay session and return to transparent mode after test
+  // Resets sequence counters to ensure next replay starts fresh
   async after(testInfo: TestInfo): Promise<void>;
+
+  // Global teardown - switches proxy to transparent mode
+  // Use in Playwright's globalTeardown configuration
+  async teardown(): Promise<void>;
 };
 
 // Direct mode control
@@ -438,6 +452,8 @@ async function setProxyMode(
 }
 ```
 
+**Note**: Switching to replay mode automatically resets session counters (clears served recordings tracker), allowing replay from the beginning.
+
 **Response**:
 
 ```typescript

package/dist/{index-Cx_Kflfl.d.cts → index-nmNRt1WE.d.cts}

@@ -89,13 +89,20 @@ declare const playwrightProxy: {
      * Setup before test - sets the proxy mode
      * @param testInfo - Playwright test info object
      * @param mode - The proxy mode to use for this test
+     * @param timeout - Optional timeout in milliseconds
      */
-    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    before(testInfo: PlaywrightTestInfo, mode: Mode, timeout?: number): Promise<void>;
     /**
-     * Cleanup after test - returns to transparent mode
+     * Cleanup after test - resets replay session by re-entering replay mode
+     * switchToReplayMode automatically clears sequence counters
      * @param testInfo - Playwright test info object
      */
     after(testInfo: PlaywrightTestInfo): Promise<void>;
+    /**
+     * Global teardown - switches proxy to transparent mode
+     * Use this in Playwright's globalTeardown to ensure clean state
+     */
+    teardown(): Promise<void>;
 };
 
 export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

package/dist/{index-Cx_Kflfl.d.ts → index-nmNRt1WE.d.ts}

@@ -89,13 +89,20 @@ declare const playwrightProxy: {
      * Setup before test - sets the proxy mode
      * @param testInfo - Playwright test info object
      * @param mode - The proxy mode to use for this test
+     * @param timeout - Optional timeout in milliseconds
      */
-    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    before(testInfo: PlaywrightTestInfo, mode: Mode, timeout?: number): Promise<void>;
     /**
-     * Cleanup after test - returns to transparent mode
+     * Cleanup after test - resets replay session by re-entering replay mode
+     * switchToReplayMode automatically clears sequence counters
      * @param testInfo - Playwright test info object
      */
     after(testInfo: PlaywrightTestInfo): Promise<void>;
+    /**
+     * Global teardown - switches proxy to transparent mode
+     * Use this in Playwright's globalTeardown to ensure clean state
+     */
+    teardown(): Promise<void>;
 };
 
 export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

package/dist/index.cjs

@@ -529,7 +529,11 @@ var ProxyServer = class {
       }
       const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
+        const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
+        const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
+        return aSeq - bSeq;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -552,7 +556,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -569,7 +573,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(
@@ -953,19 +957,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-Cx_Kflfl.cjs';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-nmNRt1WE.cjs';
 import '@playwright/test';
 
 declare class ProxyServer {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-Cx_Kflfl.js';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-nmNRt1WE.js';
 import '@playwright/test';
 
 declare class ProxyServer {

package/dist/index.mjs

@@ -517,7 +517,11 @@ var ProxyServer = class {
       }
       const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
+        const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
+        const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
+        return aSeq - bSeq;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -540,7 +544,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -557,7 +561,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(
@@ -941,19 +945,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/playwright/index.cjs

@@ -89,19 +89,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/playwright/index.d.cts

@@ -1,3 +1,3 @@
 import '@playwright/test';
-export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-Cx_Kflfl.cjs';
+export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-nmNRt1WE.cjs';
 import 'node:http';

package/dist/playwright/index.d.ts

@@ -1,3 +1,3 @@
 import '@playwright/test';
-export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-Cx_Kflfl.js';
+export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-nmNRt1WE.js';
 import 'node:http';

package/dist/playwright/index.mjs

@@ -87,19 +87,27 @@ var playwrightProxy = {
    * Setup before test - sets the proxy mode
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
+   * @param timeout - Optional timeout in milliseconds
    */
-  async before(testInfo, mode) {
+  async before(testInfo, mode, timeout) {
     const sessionId = generateSessionId(testInfo);
-    console.log("Proxy setup:", { mode, sessionId });
-    await setProxyMode(mode, sessionId);
+    await setProxyMode(mode, sessionId, timeout);
   },
   /**
-   * Cleanup after test - returns to transparent mode
+   * Cleanup after test - resets replay session by re-entering replay mode
+   * switchToReplayMode automatically clears sequence counters
    * @param testInfo - Playwright test info object
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode(Modes.transparent, sessionId);
+    await setProxyMode(Modes.replay, sessionId);
+  },
+  /**
+   * Global teardown - switches proxy to transparent mode
+   * Use this in Playwright's globalTeardown to ensure clean state
+   */
+  async teardown() {
+    await setProxyMode(Modes.transparent);
   }
 };
 

package/dist/proxy.js

@@ -551,7 +551,11 @@ var ProxyServer = class {
       }
       const servedForThisKey = sessionState.servedRecordingIdsByKey.get(key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => a.recordingId - b.recordingId);
+      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
+        const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
+        const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
+        return aSeq - bSeq;
+      });
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -574,7 +578,7 @@ var ProxyServer = class {
       }
       const requestCount = servedForThisKey.size + 1;
       console.log(
-        `[REPLAY REQUEST #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
+        `[replay request #${requestCount}] ${req.method} ${req.url} (session: ${recordingId}, total: ${recordsWithKey.length}, served: ${servedForThisKey.size})`
       );
       let record;
       for (const rec of recordsWithKey) {
@@ -591,7 +595,7 @@ var ProxyServer = class {
       }
       servedForThisKey.add(record.recordingId);
       console.log(
-        `[REPLAY SERVING] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
+        `[replay serving] recordingId: ${record.recordingId}, session: ${recordingId}, body_len: ${record.response?.body?.length || 0}`
       );
       if (!record.response) {
         throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "description": "HTTP proxy server for recording and replaying network requests in testing. Works seamlessly with Playwright testing framework.",
   "type": "module",
   "main": "dist/index.mjs",