ftmocks-utils 1.5.4 → 1.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ftmocks-utils",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "Util functions for FtMocks",
   "main": "src/index.js",
   "scripts": {

package/src/compare-utils.js

@@ -1,6 +1,70 @@
 const { clearNulls, processURL } = require("./common-utils");
 const { FtJSON } = require("./json-utils");
 
+/** @param {Record<string, string>|undefined|null} headers */
+function getHeaderValueCaseInsensitive(headers, headerName) {
+  if (!headers || !headerName) {
+    return undefined;
+  }
+  const lower = headerName.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === lower) {
+      return headers[key];
+    }
+  }
+  return undefined;
+}
+
+function parseMatchHeadersList(testConfig) {
+  const raw = testConfig?.MATCH_HEADERS;
+  if (!raw || typeof raw !== "string") {
+    return [];
+  }
+  return raw
+    .split(",")
+    .map((h) => h.trim())
+    .filter(Boolean);
+}
+
+/** Normalize fetch `options.headers` (plain object or Headers) to a plain object. */
+function normalizeIncomingHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (typeof headers.forEach === "function") {
+    const out = {};
+    headers.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+  if (typeof headers === "object") {
+    return { ...headers };
+  }
+  return {};
+}
+
+/**
+ * When MATCH_HEADERS is set, each listed header must match between the mock
+ * recording and the incoming request (case-insensitive name, value compared as strings).
+ */
+function incomingHeadersMatchMock(mock, incomingHeaders, testConfig) {
+  const names = parseMatchHeadersList(testConfig);
+  if (names.length === 0) {
+    return true;
+  }
+  const mockHeaders = mock.fileContent.request?.headers || {};
+  const incoming = incomingHeaders || {};
+  for (const name of names) {
+    const mockVal = getHeaderValueCaseInsensitive(mockHeaders, name);
+    const reqVal = getHeaderValueCaseInsensitive(incoming, name);
+    if (String(mockVal ?? "") !== String(reqVal ?? "")) {
+      return false;
+    }
+  }
+  return true;
+}
+
 const isUrlAndMethodSame = (req1, req2) => {
   const url1 = new URL(`http://domain.com${req1.url}`);
   const url2 = new URL(`http://domain.com${req2.url}`);
@@ -45,7 +109,7 @@ const isSameResponse = (req1, req2) => {
     ) {
       matched = FtJSON.areJsonEqual(
         FtJSON.parse(req1.response.content) || {},
-        FtJSON.parse(req2.response.content) || {}
+        FtJSON.parse(req2.response.content) || {},
       );
       // console.log('not matched at post Data 0', req1.postData, req2.postData);
     } else if (
@@ -53,7 +117,7 @@ const isSameResponse = (req1, req2) => {
       req2.response.content &&
       !FtJSON.areJsonEqual(
         FtJSON.parse(req1.response.content) || {},
-        FtJSON.parse(req2.response.content) || {}
+        FtJSON.parse(req2.response.content) || {},
       )
     ) {
       matched = false;
@@ -71,12 +135,12 @@ const isSameResponse = (req1, req2) => {
 function compareMockToRequest(mock, req) {
   const mockURL = processURL(
     mock.fileContent.url,
-    mock.fileContent.ignoreParams
+    mock.fileContent.ignoreParams,
   );
   const reqURL = processURL(req.originalUrl, mock.fileContent.ignoreParams);
   const isSameUrlAndMethod = isUrlAndMethodSame(
     { url: mockURL, method: mock.fileContent.method },
-    { url: reqURL, method: req.method }
+    { url: reqURL, method: req.method },
   );
   if (!isSameUrlAndMethod) {
     return false;
@@ -90,20 +154,20 @@ function compareMockToRequest(mock, req) {
       method: req.method,
       postData: req.body,
       url: reqURL,
-    }
+    },
   );
 }
 
-function compareMockToFetchRequest(mock, fetchReq) {
+function compareMockToFetchRequest(mock, fetchReq, testConfig) {
   try {
     const mockURL = processURL(
       mock.fileContent.url,
-      mock.fileContent.ignoreParams
+      mock.fileContent.ignoreParams,
     );
     const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
     const isSameUrlAndMethod = isUrlAndMethodSame(
       { url: mockURL, method: mock.fileContent.method },
-      { url: reqURL, method: fetchReq.options.method || "GET" }
+      { url: reqURL, method: fetchReq.options.method || "GET" },
     );
     if (!isSameUrlAndMethod) {
       return false;
@@ -111,7 +175,7 @@ function compareMockToFetchRequest(mock, fetchReq) {
     const postData = mock.fileContent.request?.postData?.text
       ? FtJSON.parse(mock.fileContent.request?.postData?.text)
       : mock.fileContent.request?.postData;
-    return isSameRequest(
+    const sameBody = isSameRequest(
       { url: mockURL, method: mock.fileContent.method, postData },
       {
         method: fetchReq.options.method || "GET",
@@ -119,8 +183,13 @@ function compareMockToFetchRequest(mock, fetchReq) {
           ? FtJSON.parse(fetchReq.options.body)
           : fetchReq.options.body,
         url: reqURL,
-      }
+      },
     );
+    if (!sameBody) {
+      return false;
+    }
+    const incomingHeaders = normalizeIncomingHeaders(fetchReq.options?.headers);
+    return incomingHeadersMatchMock(mock, incomingHeaders, testConfig);
   } catch (e) {
     console.error("error at compareMockToFetchRequest", mock, fetchReq);
     console.error(e);
@@ -148,4 +217,8 @@ module.exports = {
   compareMockToRequest,
   compareMockToFetchRequest,
   compareMockToMock,
+  getHeaderValueCaseInsensitive,
+  parseMatchHeadersList,
+  normalizeIncomingHeaders,
+  incomingHeadersMatchMock,
 };

package/src/event-run-utils.js

@@ -20,7 +20,7 @@ const createDiffImage = async (img1, img2, diffPath) => {
       threshold: 0.1, // sensitivity
       diffColor: [255, 0, 0], // highlight color (red)
       diffMask: false,
-    }
+    },
   );
 
   fs.writeFileSync(diffPath, PNG.sync.write(diff));
@@ -58,7 +58,7 @@ const matchAndReplaceScreenshot = async (page, event, screenshotsDir) => {
     await createDiffImage(
       img1,
       img2,
-      path.join(screenshotsDir, `diff_${event.id}.png`)
+      path.join(screenshotsDir, `diff_${event.id}.png`),
     );
     return {
       replaced: true,
@@ -170,6 +170,8 @@ const runEvent = async ({
   screenshots = false,
   screenshotsDir = null,
   healSelectors = false,
+  eventsFile = null,
+  allEvents = null,
 }) => {
   try {
     const beforeEvent = async () => {
@@ -178,7 +180,7 @@ const runEvent = async ({
         const res = await matchAndReplaceScreenshot(
           page,
           event,
-          screenshotsDir
+          screenshotsDir,
         );
         if (res.replaced) {
           const locator = await getLocator(page, event);
@@ -200,7 +202,7 @@ const runEvent = async ({
           page,
           event,
           event.target,
-          position
+          position,
         );
         event.target = healedTarget.value;
         const selectors = [];
@@ -210,7 +212,7 @@ const runEvent = async ({
             page,
             event,
             event.selectors[i].value,
-            position
+            position,
           );
           event.selectors[i].value = healedSelector.value;
           if (healedSelector.count !== 1) {
@@ -273,6 +275,10 @@ const runEvent = async ({
       default:
         return "Unsupported event type";
     }
+    if (eventsFile && allEvents) {
+      allEvents.find((e) => e.id === event.id).executed = true;
+      fs.writeFileSync(eventsFile, JSON.stringify(allEvents, null, 2));
+    }
   } catch (error) {
     console.error("Error running event", {
       error: error.message,
@@ -321,6 +327,8 @@ const runEvents = async ({
   screenshots = false,
   screenshotsDir = null,
   healSelectors = false,
+  eventsFile = null,
+  allEvents = null,
 }) => {
   for (const event of events) {
     await runEvent({
@@ -330,6 +338,8 @@ const runEvents = async ({
       screenshots,
       screenshotsDir,
       healSelectors,
+      eventsFile,
+      allEvents,
     });
   }
 };
@@ -338,14 +348,19 @@ const runEventsForTest = async (page, ftmocksConifg, testName) => {
   const eventsFile = path.join(
     getMockDir(ftmocksConifg),
     `test_${nameToFolder(testName)}`,
-    `_events.json`
+    `_events.json`,
   );
   const events = JSON.parse(fs.readFileSync(eventsFile, "utf8"));
+  events.forEach((event) => {
+    event.executed = false;
+  });
   await runEvents({
     page,
     events,
     delay: ftmocksConifg.delay || 1000,
     screenshots: false,
+    eventsFile,
+    allEvents: events,
   });
 };
 
@@ -354,19 +369,32 @@ const runEventsInPresentationMode = async (page, ftmocksConifg, testName) => {
   const eventsFile = path.join(
     getMockDir(ftmocksConifg),
     `test_${nameToFolder(testName)}`,
-    `_events.json`
+    `_events.json`,
   );
   const events = JSON.parse(fs.readFileSync(eventsFile, "utf8"));
+  events.forEach((event) => {
+    event.executed = false;
+  });
 
   // Expose Node function
   await page.exposeFunction("nextEvent", async () => {
     if (currentEventIndex === events.length) {
       return false;
     }
-    let result = await runEvent({ page, event: events[currentEventIndex] });
+    let result = await runEvent({
+      page,
+      event: events[currentEventIndex],
+      eventsFile,
+      allEvents: events,
+    });
     while (result === "Unsupported event type") {
       currentEventIndex = currentEventIndex + 1;
-      result = await runEvent({ page, event: events[currentEventIndex] });
+      result = await runEvent({
+        page,
+        event: events[currentEventIndex],
+        eventsFile,
+        allEvents: events,
+      });
     }
     currentEventIndex = currentEventIndex + 1;
     return true;
@@ -401,7 +429,7 @@ const runEventsInPresentationMode = async (page, ftmocksConifg, testName) => {
     });
   });
 
-  await runEvent({ page, event: events[0] });
+  await runEvent({ page, event: events[0], eventsFile, allEvents: events });
 };
 
 const runEventsInTrainingMode = async (page, ftmocksConifg, testName) => {
@@ -409,15 +437,17 @@ const runEventsInTrainingMode = async (page, ftmocksConifg, testName) => {
   const eventsFile = path.join(
     getMockDir(ftmocksConifg),
     `test_${nameToFolder(testName)}`,
-    `_events.json`
+    `_events.json`,
   );
   const events = JSON.parse(fs.readFileSync(eventsFile, "utf8"));
-
+  events.forEach((event) => {
+    event.executed = false;
+  });
   // Expose Node function
   await page.exposeFunction("getNextEvent", async () => {
     let result = false;
     let nonExecutedEvents = events.filter(
-      (event) => !executedEvents.includes(event?.id)
+      (event) => !executedEvents.includes(event?.id),
     );
     let currentEventIndex = -1;
     while (!result) {
@@ -431,11 +461,11 @@ const runEventsInTrainingMode = async (page, ftmocksConifg, testName) => {
     if (nonExecutedEvents[currentEventIndex]) {
       console.log(
         "➡ Getting locator for event",
-        nonExecutedEvents[currentEventIndex]
+        nonExecutedEvents[currentEventIndex],
       );
       const selector = await getLocator(
         page,
-        nonExecutedEvents[currentEventIndex]
+        nonExecutedEvents[currentEventIndex],
       );
       const position = await getSelectorPosition(page, selector);
       const element = await page.locator(selector).elementHandle();
@@ -641,16 +671,19 @@ const runEventsInTrainingMode = async (page, ftmocksConifg, testName) => {
     });
   });
 
-  await runEvent({ page, event: events[0] });
+  await runEvent({ page, event: events[0], eventsFile, allEvents: events });
 };
 
 const runEventsForScreenshots = async (page, ftmocksConifg, testName) => {
   const eventsFile = path.join(
     getMockDir(ftmocksConifg),
     `test_${nameToFolder(testName)}`,
-    `_events.json`
+    `_events.json`,
   );
   const events = JSON.parse(fs.readFileSync(eventsFile, "utf8"));
+  events.forEach((event) => {
+    event.executed = false;
+  });
   await runEvents({
     page,
     events,
@@ -659,8 +692,10 @@ const runEventsForScreenshots = async (page, ftmocksConifg, testName) => {
     screenshotsDir: path.join(
       getMockDir(ftmocksConifg),
       `test_${nameToFolder(testName)}`,
-      `screenshots`
+      `screenshots`,
     ),
+    eventsFile,
+    allEvents: events,
   });
   fs.writeFileSync(eventsFile, JSON.stringify(events, null, 2));
   await page.waitForTimeout(1000);
@@ -671,14 +706,19 @@ const runEventsForHealingSelectors = async (page, ftmocksConifg, testName) => {
   const eventsFile = path.join(
     getMockDir(ftmocksConifg),
     `test_${nameToFolder(testName)}`,
-    `_events.json`
+    `_events.json`,
   );
   const events = JSON.parse(fs.readFileSync(eventsFile, "utf8"));
+  events.forEach((event) => {
+    event.executed = false;
+  });
   await runEvents({
     page,
     events,
     delay: ftmocksConifg.delay || 1000,
     healSelectors: true,
+    eventsFile,
+    allEvents: events,
   });
   fs.writeFileSync(eventsFile, JSON.stringify(events, null, 2));
   await page.waitForTimeout(1000);

package/src/match-utils.js

@@ -38,7 +38,7 @@ function getMatchingMockData({
         }
       }
       served = mock.fileContent.served;
-      return compareMockToFetchRequest(mock, { url, options });
+      return compareMockToFetchRequest(mock, { url, options }, testConfig);
     }) || [];
   let foundMock = matchedMocks.find((mock) => !mock.fileContent.served)
     ? matchedMocks.find((mock) => !mock.fileContent.served)
@@ -46,29 +46,41 @@ function getMatchingMockData({
 
   if (!foundMock) {
     foundMock = defaultMockData.find((tm) =>
-      compareMockToFetchRequest(tm, {
-        url,
-        options,
-      })
+      compareMockToFetchRequest(
+        tm,
+        {
+          url,
+          options,
+        },
+        testConfig
+      )
     );
   }
 
   if (!foundMock && mode !== "strict") {
     const mockRanks = {};
     testMockData.forEach((tm) => {
-      const rank = getCompareRankMockToFetchRequest(tm, {
-        url,
-        options,
-      });
+      const rank = getCompareRankMockToFetchRequest(
+        tm,
+        {
+          url,
+          options,
+        },
+        testConfig
+      );
       if (rank > 0) {
         mockRanks[tm.id] = rank;
       }
     });
     defaultMockData.forEach((tm) => {
-      const rank = getCompareRankMockToFetchRequest(tm, {
-        url,
-        options,
-      });
+      const rank = getCompareRankMockToFetchRequest(
+        tm,
+        {
+          url,
+          options,
+        },
+        testConfig
+      );
       if (rank > 0) {
         mockRanks[tm.id] = rank;
       }
@@ -157,20 +169,28 @@ function getMatchingMockDataV2({
     const mockRanks = {};
     matchedMocks.forEach((mockId) => {
       const mock = testMockIdMap[mockId];
-      const rank = getCompareRankMockToFetchRequest(mock, {
-        url,
-        options,
-      });
+      const rank = getCompareRankMockToFetchRequest(
+        mock,
+        {
+          url,
+          options,
+        },
+        testConfig
+      );
       if (rank > 0) {
         mockRanks[mock.id] = rank;
       }
     });
     defaultMatchedMocks.forEach((mockId) => {
       const mock = defaultMockIdMap[mockId];
-      const rank = getCompareRankMockToFetchRequest(mock, {
-        url,
-        options,
-      });
+      const rank = getCompareRankMockToFetchRequest(
+        mock,
+        {
+          url,
+          options,
+        },
+        testConfig
+      );
       if (rank > 0) {
         mockRanks[mock.id] = rank;
       }

package/src/playwright-utils.js

@@ -46,6 +46,7 @@ async function initiatePlaywrightRoutes(
       url,
       method: request.method(),
       body: request.postData(),
+      headers: request.headers(),
     };
     if (excludeMockPath && new RegExp(excludeMockPath).test(url)) {
       await route.fallback();

package/src/rank-compare-utils.js

@@ -1,6 +1,10 @@
 const { clearNulls, charDifference, processURL } = require("./common-utils");
 const { FtJSON } = require("./json-utils");
-const { isUrlAndMethodSame } = require("./compare-utils");
+const {
+  isUrlAndMethodSame,
+  incomingHeadersMatchMock,
+  normalizeIncomingHeaders,
+} = require("./compare-utils");
 
 const getSameRequestRank = (req1, req2) => {
   let rank = 1;
@@ -21,7 +25,7 @@ const getSameRequestRank = (req1, req2) => {
   return rank;
 };
 
-function getCompareRankMockToFetchRequest(mock, fetchReq) {
+function getCompareRankMockToFetchRequest(mock, fetchReq, testConfig) {
   try {
     const mockURL = processURL(
       mock.fileContent.url,
@@ -36,6 +40,10 @@ function getCompareRankMockToFetchRequest(mock, fetchReq) {
     ) {
       return 0;
     }
+    const incomingHeaders = normalizeIncomingHeaders(fetchReq.options?.headers);
+    if (!incomingHeadersMatchMock(mock, incomingHeaders, testConfig)) {
+      return 0;
+    }
     const postData = mock.fileContent.request?.postData?.text
       ? FtJSON.parse(mock.fileContent.request?.postData?.text)
       : mock.fileContent.request?.postData;