test-proxy-recorder 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -24,7 +24,7 @@ var Modes = {
 };
 var JSON_INDENT_SPACES = 2;
 function getRecordingPath(recordingsDir, id) {
-  return path.join(recordingsDir, `${id}.json`);
+  return path.join(recordingsDir, `${id}.mock.json`);
 }
 async function loadRecordingSession(filePath) {
   const fileContent = await fs.readFile(filePath, "utf8");
@@ -32,6 +32,8 @@ async function loadRecordingSession(filePath) {
 }
 async function saveRecordingSession(recordingsDir, session) {
   const filePath = getRecordingPath(recordingsDir, session.id);
+  const dirPath = path.dirname(filePath);
+  await fs.mkdir(dirPath, { recursive: true });
   await fs.writeFile(
     filePath,
     JSON.stringify(session, null, JSON_INDENT_SPACES)
@@ -116,6 +118,7 @@ var ProxyServer = class {
       this.handleUpgrade(req, socket, head);
     });
     server.listen(port, () => {
+      process.env.TEST_PROXY_RECORDER_PORT = String(port);
       this.logServerStartup(port);
     });
     return server;
@@ -124,14 +127,17 @@ var ProxyServer = class {
     this.proxy.on("error", this.handleProxyError.bind(this));
     this.proxy.on("proxyRes", this.handleProxyResponse.bind(this));
   }
-  handleProxyError(err, _req, res) {
+  handleProxyError(err, req, res) {
     console.error("Proxy error:", err);
     if (!(res instanceof http.ServerResponse)) {
       return;
     }
     if (!res.headersSent) {
+      const origin = req.headers.origin;
       res.writeHead(HTTP_STATUS_BAD_GATEWAY, {
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": origin || "*",
+        "Access-Control-Allow-Credentials": "true"
       });
     }
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
@@ -187,7 +193,7 @@ var ProxyServer = class {
   async switchMode(mode, id) {
     if (this.currentSession) {
       console.log("Switching mode, saving current session first");
-      await this.saveCurrentSession();
+      await this.saveCurrentSession(true);
       console.log("Session saved, continuing with mode switch");
     }
     switch (mode) {
@@ -242,13 +248,13 @@ var ProxyServer = class {
     if (timeout && timeout > 0) {
       this.modeTimeout = setTimeout(async () => {
         console.log("Timeout reached, switching back to transparent mode");
-        await this.saveCurrentSession();
+        await this.saveCurrentSession(true);
         this.switchToTransparentMode();
         this.modeTimeout = null;
       }, timeout);
     }
   }
-  async saveCurrentSession() {
+  async saveCurrentSession(filterIncomplete = false) {
     if (!this.currentSession) {
       console.log("No current session to save");
       return;
@@ -257,13 +263,27 @@ var ProxyServer = class {
       console.log("Session has no recordings, skipping save");
       return;
     }
+    if (filterIncomplete) {
+      const incompleteCount = this.currentSession.recordings.filter(
+        (r) => !r.response
+      ).length;
+      if (incompleteCount > 0) {
+        console.log(
+          `Removing ${incompleteCount} incomplete recording(s) without responses`
+        );
+        this.currentSession.recordings = this.currentSession.recordings.filter(
+          (r) => r.response
+        );
+      }
+    }
     console.log(
       `Saving session with ${this.currentSession.recordings.length} HTTP and ${this.currentSession.websocketRecordings.length} WebSocket recordings`
     );
     await saveRecordingSession(this.recordingsDir, this.currentSession);
   }
-  async saveRequestRecord(req, body) {
+  saveRequestRecordSync(req, body) {
     if (!this.currentSession) {
+      console.log("saveRequestRecordSync: No current session");
       return;
     }
     const key = getReqID(req);
@@ -281,6 +301,30 @@ var ProxyServer = class {
       sequence: currentSequence
     };
     this.currentSession.recordings.push(record);
+    console.log(
+      // eslint-disable-next-line sonarjs/no-nested-template-literals
+      `saveRequestRecordSync: Saved ${req.method} ${req.url} (key: ${key}, seq: ${currentSequence}, body: ${body ? `${body.length} chars` : "null"}, total: ${this.currentSession.recordings.length}, sessionId: ${this.currentSession.id})`
+    );
+  }
+  updateRequestBodySync(req, body) {
+    if (!this.currentSession) {
+      console.log("updateRequestBodySync: No current session");
+      return;
+    }
+    const key = getReqID(req);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
+    if (!record) {
+      console.error(
+        `updateRequestBodySync: Could not find request record for ${req.method} ${req.url}`
+      );
+      return;
+    }
+    record.request.body = body || null;
+    console.log(
+      `updateRequestBodySync: Updated body for ${req.method} ${req.url} (${body.length} chars)`
+    );
   }
   async recordResponse(req, proxyRes) {
     if (!this.currentSession) {
@@ -309,49 +353,105 @@ var ProxyServer = class {
       console.log(`Recorded: ${req.method} ${req.url}`);
     });
   }
+  async recordResponseData(req, proxyRes, body) {
+    if (!this.currentSession) {
+      console.log("recordResponseData: No current session");
+      return false;
+    }
+    const key = getReqID(req);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
+    if (!record) {
+      const host = req.headers.host || "unknown";
+      const recordsWithKey = this.currentSession.recordings.filter(
+        (r) => r.key === key
+      );
+      console.error(
+        `Request record not found for response: ${key} at ${req.method} ${host}${req.url}`
+      );
+      console.error(
+        `  Total recordings: ${this.currentSession.recordings.length}, with this key: ${recordsWithKey.length}`
+      );
+      console.error(
+        `  Records with key:`,
+        recordsWithKey.map((r) => ({
+          seq: r.sequence,
+          hasResponse: !!r.response
+        }))
+      );
+      return false;
+    }
+    record.response = {
+      statusCode: proxyRes.statusCode,
+      headers: proxyRes.headers,
+      body: body || null
+    };
+    await this.saveCurrentSession();
+    console.log(
+      `recordResponseData: Recorded response for ${req.method} ${req.url}`
+    );
+    return true;
+  }
   async handleReplayRequest(req, res) {
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
     try {
       const session = await loadRecordingSession(filePath);
-      const currentSequence = this.replaySequenceMap.get(key) || 0;
-      const record = session.recordings.find(
-        (r) => r.key === key && r.sequence === currentSequence
+      const host = req.headers.host || "unknown";
+      const recordsWithKey = session.recordings.filter(
+        (r) => r.key === key && r.response
       );
-      if (!record) {
+      if (recordsWithKey.length === 0) {
         throw new Error(
-          `No recording found for ${key} with sequence ${currentSequence}`
+          `No recording found for ${key} at ${req.method} ${host}${req.url}`
         );
       }
+      const usageCount = this.replaySequenceMap.get(key) || 0;
+      const recordIndex = usageCount % recordsWithKey.length;
+      const record = recordsWithKey[recordIndex];
+      console.log(
+        `Replaying ${req.method} ${req.url} (usage: ${usageCount}, using recording ${recordIndex}/${recordsWithKey.length})`
+      );
+      this.replaySequenceMap.set(key, usageCount + 1);
       if (!record.response) {
-        throw new Error("No response recorded for this request");
+        throw new Error(
+          `No response recorded for this request: ${req.method} ${host}${req.url}`
+        );
       }
-      this.replaySequenceMap.set(key, currentSequence + 1);
       const { statusCode, headers, body } = record.response;
       const origin = req.headers.origin;
       const responseHeaders = {
         ...headers,
         "access-control-allow-origin": origin || "*",
-        "access-control-allow-credentials": "true"
+        "access-control-allow-credentials": "true",
+        "access-control-allow-headers": req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization",
+        "access-control-allow-methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+        "access-control-expose-headers": "*"
       };
       res.writeHead(statusCode, responseHeaders);
       res.end(body);
-      console.log(
-        `Replayed: ${req.method} ${req.url} (sequence: ${currentSequence})`
-      );
     } catch (error) {
-      this.handleReplayError(res, error, key, filePath);
+      this.handleReplayError(req, res, error, key, filePath);
     }
   }
-  handleReplayError(res, err, key, filePath) {
+  handleReplayError(req, res, err, key, filePath) {
     const isFileNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
     console.error("Replay error:", err);
-    sendJsonResponse(res, HTTP_STATUS_NOT_FOUND, {
-      error: isFileNotFound ? "Recording file not found" : "Recording not found",
-      message: err instanceof Error ? err.message : "Unknown error",
-      key,
-      filePath
+    const origin = req.headers.origin;
+    res.writeHead(HTTP_STATUS_NOT_FOUND, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": origin || "*",
+      "Access-Control-Allow-Credentials": "true"
     });
+    res.end(
+      JSON.stringify({
+        error: isFileNotFound ? "Recording file not found" : "Recording not found",
+        message: err instanceof Error ? err.message : "Unknown error",
+        key,
+        filePath
+      })
+    );
   }
   async handleRequest(req, res) {
     if (req.method === "OPTIONS") {
@@ -381,6 +481,7 @@ var ProxyServer = class {
     const target = this.getTarget();
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
+      this.saveRequestRecordSync(req, null);
       await this.bufferAndProxyRequest(req, res, target);
     } else {
       this.proxy.web(req, res, { target });
@@ -391,11 +492,20 @@ var ProxyServer = class {
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
-    await new Promise((resolve) => {
-      req.on("end", () => resolve());
-    });
+    try {
+      await new Promise((resolve, reject) => {
+        req.on("end", () => resolve());
+        req.on("error", (err) => reject(err));
+        setTimeout(
+          () => reject(new Error("Request buffering timeout")),
+          3e4
+        );
+      });
+    } catch (error) {
+      console.error("Error buffering request:", error);
+    }
     const body = Buffer.concat(chunks).toString("utf8");
-    await this.saveRequestRecord(req, body);
+    this.updateRequestBodySync(req, body);
     const targetUrl = new URL(target);
     const isHttps = targetUrl.protocol === "https:";
     const requestModule = isHttps ? https : http;
@@ -410,9 +520,38 @@ var ProxyServer = class {
       },
       (proxyRes) => {
         this.addCorsHeaders(proxyRes, req);
-        this.recordResponse(req, proxyRes);
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
+        const responseChunks = [];
+        proxyRes.on("data", (chunk) => {
+          responseChunks.push(chunk);
+        });
+        proxyRes.on("end", async () => {
+          const responseBody = Buffer.concat(responseChunks);
+          const recorded = await this.recordResponseData(
+            req,
+            proxyRes,
+            responseBody.toString("utf8")
+          );
+          const origin = req.headers.origin;
+          const responseHeaders = {
+            ...proxyRes.headers,
+            "access-control-allow-origin": origin || "*",
+            "access-control-allow-credentials": "true",
+            "access-control-allow-headers": req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization",
+            "access-control-allow-methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "access-control-expose-headers": "*"
+          };
+          res.writeHead(proxyRes.statusCode || 200, responseHeaders);
+          res.end(responseBody);
+          if (recorded) {
+            console.log(`Recorded: ${req.method} ${req.url}`);
+          }
+        });
+        proxyRes.on("error", (err) => {
+          console.error("Proxy response error:", err);
+          if (!res.headersSent) {
+            this.handleProxyError(err, req, res);
+          }
+        });
       }
     );
     proxyReq.on("error", (err) => {
@@ -594,15 +733,25 @@ var ProxyServer = class {
 };
 
 // src/playwright/index.ts
-var INTERNAL_API_URL = process.env.INTERNAL_API_URL || "http://localhost:8100";
+function getProxyPort() {
+  const envPort = process.env.TEST_PROXY_RECORDER_PORT;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return 8100;
+}
 async function setProxyMode(mode, sessionId, timeout) {
+  const proxyPort = getProxyPort();
   try {
     const body = {
       mode,
       id: sessionId,
       ...timeout && { timeout }
     };
-    const response = await fetch(`${INTERNAL_API_URL}/__control`, {
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/__control`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -619,8 +768,34 @@ async function setProxyMode(mode, sessionId, timeout) {
     throw error;
   }
 }
+function parseSpecFilePath(specPath) {
+  const folderMatch = specPath.match(/^(.+?)\/([^/]+)\.(spec|test)\.ts$/);
+  if (folderMatch) {
+    return { folder: folderMatch[1], fileName: folderMatch[2] };
+  }
+  const fileMatch = specPath.match(/^([^/]+)\.(spec|test)\.ts$/);
+  if (fileMatch) {
+    return { folder: null, fileName: fileMatch[1] };
+  }
+  return { folder: null, fileName: null };
+}
+function buildSessionPath(folder, fileName, testName) {
+  if (folder && fileName) {
+    return `${folder}/${fileName}__${testName}`;
+  }
+  if (fileName) {
+    return `${fileName}__${testName}`;
+  }
+  return testName;
+}
 function generateSessionId(testInfo) {
-  return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  const { titlePath } = testInfo;
+  if (!titlePath || titlePath.length === 0) {
+    return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  }
+  const { folder, fileName } = parseSpecFilePath(titlePath[0]);
+  const testName = titlePath.at(-1).toLowerCase().replaceAll(/\s+/g, "-");
+  return buildSessionPath(folder, fileName, testName);
 }
 async function startRecording(testInfo) {
   const sessionId = generateSessionId(testInfo);

package/dist/playwright/index.cjs

@@ -8,15 +8,25 @@ var Modes = {
 };
 
 // src/playwright/index.ts
-var INTERNAL_API_URL = process.env.INTERNAL_API_URL || "http://localhost:8100";
+function getProxyPort() {
+  const envPort = process.env.TEST_PROXY_RECORDER_PORT;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return 8100;
+}
 async function setProxyMode(mode, sessionId, timeout) {
+  const proxyPort = getProxyPort();
   try {
     const body = {
       mode,
       id: sessionId,
       ...timeout && { timeout }
     };
-    const response = await fetch(`${INTERNAL_API_URL}/__control`, {
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/__control`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -33,8 +43,34 @@ async function setProxyMode(mode, sessionId, timeout) {
     throw error;
   }
 }
+function parseSpecFilePath(specPath) {
+  const folderMatch = specPath.match(/^(.+?)\/([^/]+)\.(spec|test)\.ts$/);
+  if (folderMatch) {
+    return { folder: folderMatch[1], fileName: folderMatch[2] };
+  }
+  const fileMatch = specPath.match(/^([^/]+)\.(spec|test)\.ts$/);
+  if (fileMatch) {
+    return { folder: null, fileName: fileMatch[1] };
+  }
+  return { folder: null, fileName: null };
+}
+function buildSessionPath(folder, fileName, testName) {
+  if (folder && fileName) {
+    return `${folder}/${fileName}__${testName}`;
+  }
+  if (fileName) {
+    return `${fileName}__${testName}`;
+  }
+  return testName;
+}
 function generateSessionId(testInfo) {
-  return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  const { titlePath } = testInfo;
+  if (!titlePath || titlePath.length === 0) {
+    return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  }
+  const { folder, fileName } = parseSpecFilePath(titlePath[0]);
+  const testName = titlePath.at(-1).toLowerCase().replaceAll(/\s+/g, "-");
+  return buildSessionPath(folder, fileName, testName);
 }
 async function startRecording(testInfo) {
   const sessionId = generateSessionId(testInfo);

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-De4mgziH.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-CBjvm5rb.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-De4mgziH.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-CBjvm5rb.js';
 import 'node:http';

package/dist/playwright/index.mjs

@@ -6,15 +6,25 @@ var Modes = {
 };
 
 // src/playwright/index.ts
-var INTERNAL_API_URL = process.env.INTERNAL_API_URL || "http://localhost:8100";
+function getProxyPort() {
+  const envPort = process.env.TEST_PROXY_RECORDER_PORT;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return 8100;
+}
 async function setProxyMode(mode, sessionId, timeout) {
+  const proxyPort = getProxyPort();
   try {
     const body = {
       mode,
       id: sessionId,
       ...timeout && { timeout }
     };
-    const response = await fetch(`${INTERNAL_API_URL}/__control`, {
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/__control`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -31,8 +41,34 @@ async function setProxyMode(mode, sessionId, timeout) {
     throw error;
   }
 }
+function parseSpecFilePath(specPath) {
+  const folderMatch = specPath.match(/^(.+?)\/([^/]+)\.(spec|test)\.ts$/);
+  if (folderMatch) {
+    return { folder: folderMatch[1], fileName: folderMatch[2] };
+  }
+  const fileMatch = specPath.match(/^([^/]+)\.(spec|test)\.ts$/);
+  if (fileMatch) {
+    return { folder: null, fileName: fileMatch[1] };
+  }
+  return { folder: null, fileName: null };
+}
+function buildSessionPath(folder, fileName, testName) {
+  if (folder && fileName) {
+    return `${folder}/${fileName}__${testName}`;
+  }
+  if (fileName) {
+    return `${fileName}__${testName}`;
+  }
+  return testName;
+}
 function generateSessionId(testInfo) {
-  return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  const { titlePath } = testInfo;
+  if (!titlePath || titlePath.length === 0) {
+    return testInfo.title.toLowerCase().replaceAll(/\s+/g, "-");
+  }
+  const { folder, fileName } = parseSpecFilePath(titlePath[0]);
+  const testName = titlePath.at(-1).toLowerCase().replaceAll(/\s+/g, "-");
+  return buildSessionPath(folder, fileName, testName);
 }
 async function startRecording(testInfo) {
   const sessionId = generateSessionId(testInfo);