ftmocks-utils 1.3.2 → 1.3.4

package/src/log-utils.js

@@ -30,7 +30,11 @@ class Logger {
         time: Date.now(),
         source: "ftmocks-utils",
       });
-      fs.writeFileSync(this.logsFile, JSON.stringify(this.logs, null, 2), "utf8"); // Append the log message to the file
+      fs.writeFileSync(
+        this.logsFile,
+        JSON.stringify(this.logs, null, 2),
+        "utf8"
+      ); // Append the log message to the file
     } catch (error) {
       // Ignore error
     }
@@ -87,4 +91,13 @@ class Logger {
   }
 }
 
-module.exports = Logger;
+const deleteAllLogs = async (ftmocksConifg, testName) => {
+  const mockDir = path.join(
+    getMockDir(ftmocksConifg),
+    `test_${nameToFolder(testName)}`
+  );
+  const logFilePath = path.join(mockDir, `_logs.json`);
+  fs.rmSync(logFilePath, { recursive: true, force: true });
+};
+
+module.exports = { Logger, deleteAllLogs };

package/src/match-utils.js

@@ -0,0 +1,94 @@
+const { compareMockToFetchRequest } = require("./compare-utils");
+const { getCompareRankMockToFetchRequest } = require("./rank-compare-utils");
+const { getMockDir, nameToFolder } = require("./common-utils");
+const path = require("path");
+const fs = require("fs");
+
+function getMatchingMockData({
+  testMockData,
+  defaultMockData,
+  url,
+  options,
+  testConfig,
+  testName,
+  mode,
+}) {
+  let served = false;
+  let matchedMocks =
+    testMockData?.filter((mock) => {
+      if (mock.fileContent.waitForPrevious && !served) {
+        return false;
+      }
+      served = mock.fileContent.served;
+      return compareMockToFetchRequest(mock, { url, options });
+    }) || [];
+  let foundMock = matchedMocks.find((mock) => !mock.fileContent.served)
+    ? matchedMocks.find((mock) => !mock.fileContent.served)
+    : matchedMocks[matchedMocks.length - 1];
+
+  if (!foundMock) {
+    foundMock = defaultMockData.find((tm) =>
+      compareMockToFetchRequest(tm, {
+        url,
+        options,
+      })
+    );
+  }
+
+  if (!foundMock && mode !== "strict") {
+    const mockRanks = {};
+    testMockData.forEach((tm) => {
+      const rank = getCompareRankMockToFetchRequest(tm, {
+        url,
+        options,
+      });
+      if (rank > 0) {
+        mockRanks[tm.id] = rank;
+      }
+    });
+    defaultMockData.forEach((tm) => {
+      const rank = getCompareRankMockToFetchRequest(tm, {
+        url,
+        options,
+      });
+      if (rank > 0) {
+        mockRanks[tm.id] = rank;
+      }
+    });
+    // Sort by rank to find the best match
+    const sortedRanks = Object.entries(mockRanks).sort((a, b) => a[1] - b[1]);
+    if (sortedRanks.length > 0) {
+      const bestMockId = sortedRanks?.[0]?.[0];
+      if (bestMockId) {
+        foundMock = [...testMockData, ...defaultMockData].find(
+          (mock) => mock.id === bestMockId
+        );
+      }
+    }
+  }
+  // updating stats to mock file
+  if (foundMock) {
+    let mockFilePath = path.join(
+      getMockDir(testConfig),
+      `test_${nameToFolder(testName)}`,
+      `mock_${foundMock.id}.json`
+    );
+    if (!fs.existsSync(mockFilePath)) {
+      mockFilePath = path.join(
+        getMockDir(testConfig),
+        "defaultMocks",
+        `mock_${foundMock.id}.json`
+      );
+    }
+    foundMock.fileContent.served = true;
+    fs.writeFileSync(
+      mockFilePath,
+      JSON.stringify(foundMock.fileContent, null, 2)
+    );
+  }
+  return foundMock ? foundMock.fileContent : null;
+}
+
+module.exports = {
+  getMatchingMockData,
+};

package/src/mock-utils.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+const { getMockDir, nameToFolder } = require("./common-utils");
+
+const getDefaultMockDataFromConfig = (testConfig) => {
+  const defaultPath = path.join(
+    getMockDir(testConfig),
+    "defaultMocks",
+    "_mock_list.json"
+  );
+
+  try {
+    const defaultData = fs.readFileSync(defaultPath, "utf8");
+    let parsedData = JSON.parse(defaultData);
+
+    // Read and attach mock data for each entry in parsedData
+    parsedData.forEach((entry) => {
+      const mockFilePath = path.join(
+        getMockDir(testConfig),
+        "defaultMocks",
+        `mock_${entry.id}.json`
+      );
+      try {
+        const mockData = fs.readFileSync(mockFilePath, "utf8");
+        entry.fileContent = JSON.parse(mockData);
+      } catch (error) {
+        console.error(`Error reading mock data for ${entry.id}:`, error);
+        return entry; // Return the original entry if there's an error
+      }
+    });
+    return parsedData;
+  } catch (error) {
+    console.error(`Error reading or parsing default mocks:`, error);
+    return [];
+  }
+};
+
+const loadMockDataFromConfig = (testConfig, _testName) => {
+  try {
+    let testName = _testName;
+    if (!testName) {
+      // Read the test ID from mockServer.config.json
+      const configPath = path.join(
+        getMockDir(testConfig),
+        "mockServer.config.json"
+      );
+      const configData = fs.readFileSync(configPath, "utf8");
+      const config = JSON.parse(configData);
+      testName = config.testName;
+    }
+    // Read the tests from testConfig
+    const mocksPath = path.join(
+      getMockDir(testConfig),
+      `test_${nameToFolder(testName)}`,
+      "_mock_list.json"
+    );
+    const mocksData = fs.readFileSync(mocksPath, "utf8");
+    const mocks = JSON.parse(mocksData);
+
+    mocks.forEach((mock) => {
+      const fileContent = JSON.parse(
+        fs.readFileSync(
+          path.join(
+            getMockDir(testConfig),
+            `test_${nameToFolder(testName)}`,
+            `mock_${mock.id}.json`
+          ),
+          "utf8"
+        )
+      );
+      mock.fileContent = fileContent;
+    });
+
+    return mocks;
+  } catch (error) {
+    console.error("Error loading test data:", error.message);
+    return [];
+  }
+};
+
+async function resetAllMockStats({ testMockData, testConfig, testName }) {
+  for (let i = 0; i < testMockData.length; i++) {
+    const tmd = testMockData[i];
+    const mockFilePath = path.join(
+      getMockDir(testConfig),
+      `test_${nameToFolder(testName)}`,
+      `mock_${tmd.id}.json`
+    );
+    tmd.fileContent.served = false;
+    await fs.writeFileSync(
+      mockFilePath,
+      JSON.stringify(tmd.fileContent, null, 2)
+    );
+  }
+}
+
+module.exports = {
+  getDefaultMockDataFromConfig,
+  loadMockDataFromConfig,
+  resetAllMockStats,
+};

package/src/playwright-utils.js

@@ -0,0 +1,340 @@
+const { getMatchingMockData } = require("./match-utils");
+const { getMockDir, nameToFolder, getHeaders } = require("./common-utils");
+const { getFallbackDir } = require("./common-utils");
+const { getTestByName } = require("./common-utils");
+const { compareMockToMock } = require("./compare-utils");
+const { loadMockDataFromConfig } = require("./mock-utils");
+const { resetAllMockStats } = require("./mock-utils");
+const { getDefaultMockDataFromConfig } = require("./mock-utils");
+const { Logger } = require("./log-utils");
+const { saveIfItIsFile } = require("./file-utils");
+const { createTest } = require("./test-utils");
+const path = require("path");
+const crypto = require("crypto");
+const fs = require("fs");
+
+let logger = null;
+
+async function initiatePlaywrightRoutes(
+  page,
+  ftmocksConifg,
+  testName,
+  mockPath = "**/*",
+  excludeMockPath = null
+) {
+  logger = new Logger(
+    { disableLogs: ftmocksConifg.DISABLE_LOGS },
+    ftmocksConifg,
+    testName
+  );
+  const testMockData = testName
+    ? loadMockDataFromConfig(ftmocksConifg, testName)
+    : [];
+  resetAllMockStats({ testMockData, testConfig: ftmocksConifg, testName });
+  const test = await getTestByName(ftmocksConifg, testName);
+  const defaultMockData = getDefaultMockDataFromConfig(ftmocksConifg);
+  logger.debug("\x1b[32mcalling initiatePlaywrightRoutes fetch\x1b[0m");
+  let firstUrl = null;
+  await page.route(mockPath, async (route, request) => {
+    const url = request.url();
+    if (!firstUrl) {
+      firstUrl = url;
+    }
+    const options = {
+      url,
+      method: request.method(),
+      body: request.postData(),
+    };
+    if (excludeMockPath && new RegExp(excludeMockPath).test(url)) {
+      await route.fallback();
+      return;
+    }
+    let mockData = getMatchingMockData({
+      testMockData,
+      defaultMockData,
+      url,
+      options,
+      testConfig: ftmocksConifg,
+      testName,
+      mode: test.mode || "loose",
+    });
+    try {
+      if (mockData) {
+        const { content, headers, status, file } = mockData.response;
+
+        const json = {
+          status,
+          headers: getHeaders(headers),
+          body: content,
+        };
+
+        if (file) {
+          let filePath = path.join(
+            getMockDir(ftmocksConifg),
+            `test_${nameToFolder(testName)}`,
+            "_files",
+            file
+          );
+          if (!fs.existsSync(filePath)) {
+            filePath = path.join(
+              getMockDir(ftmocksConifg),
+              "defaultMocks",
+              "_files",
+              file
+            );
+          }
+          if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
+            const fileContent = fs.readFileSync(filePath);
+            json.body = fileContent;
+
+            console.debug(
+              "\x1b[32mresponse is a file, serving file\x1b[0m",
+              filePath,
+              url
+            );
+            await route.fulfill(json);
+          }
+        } else {
+          await route.fulfill(json);
+        }
+      } else {
+        const fallbackDir = getFallbackDir(ftmocksConifg);
+        if (!fallbackDir) {
+          await route.fallback();
+          return;
+        }
+        const urlObj = new URL(route.request().url());
+        let filePath = path.join(
+          fallbackDir,
+          urlObj.pathname === "/" || urlObj.pathname === ""
+            ? ftmocksConifg.FALLBACK_DIR_INDEX_FILE || "index.html"
+            : urlObj.pathname
+        );
+
+        if (
+          !fs.existsSync(filePath) &&
+          !path.extname(filePath) &&
+          url === firstUrl
+        ) {
+          filePath = path.join(
+            fallbackDir,
+            ftmocksConifg.FALLBACK_DIR_INDEX_FILE_FOR_STATUS_404 || "index.html"
+          );
+          logger.debug(
+            "\x1b[32mserving file for status 404\x1b[0m",
+            filePath,
+            url
+          );
+        }
+        if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
+          const fileContent = fs.readFileSync(filePath);
+          const ext = path.extname(filePath);
+          const contentType =
+            {
+              ".html": "text/html",
+              ".htm": "text/html",
+              ".xhtml": "application/xhtml+xml",
+              ".css": "text/css",
+              ".js": "application/javascript",
+              ".json": "application/json",
+              ".png": "image/png",
+              ".jpg": "image/jpeg",
+              ".svg": "image/svg+xml",
+              ".ico": "image/x-icon",
+              ".webp": "image/webp",
+              ".mp4": "video/mp4",
+              ".mp3": "audio/mpeg",
+              ".wav": "audio/wav",
+              ".ogg": "audio/ogg",
+              ".pdf": "application/pdf",
+              ".doc": "application/msword",
+              ".docx":
+                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+              ".xls": "application/vnd.ms-excel",
+              ".xlsx":
+                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+              ".ppt": "application/vnd.ms-powerpoint",
+              ".pptx":
+                "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+              ".zip": "application/zip",
+              ".rar": "application/x-rar-compressed",
+              ".7z": "application/x-7z-compressed",
+              ".tar": "application/x-tar",
+              ".gz": "application/gzip",
+              ".bz2": "application/x-bzip2",
+              ".xz": "application/x-xz",
+              ".exe": "application/x-msdownload",
+              ".dll": "application/x-msdownload",
+              ".so": "application/x-sharedlib",
+              ".dylib": "application/x-dynamiclib",
+              ".bin": "application/octet-stream",
+              ".txt": "text/plain",
+              ".csv": "text/csv",
+              ".tsv": "text/tab-separated-values",
+              ".xml": "application/xml",
+              ".xsl": "application/xml",
+              ".xslt": "application/xml",
+              ".xlt": "application/xml",
+              ".xltx": "application/xml",
+              ".xltm": "application/xml",
+              ".yaml": "text/yaml",
+              ".yml": "text/yaml",
+              ".toml": "text/toml",
+              ".php": "application/x-httpd-php",
+            }[ext] || "application/octet-stream";
+
+          logger.info("\x1b[32mserving file\x1b[0m", filePath);
+          await route.fulfill({
+            body: fileContent,
+            headers: { "Content-Type": contentType },
+          });
+        } else {
+          logger.debug("\x1b[31mmissing mock data, falling back\x1b[0m", url);
+          await route.fallback();
+        }
+      }
+    } catch (e) {
+      logger.error(e);
+      logger.error(
+        "\x1b[31merror at initiatePlaywrightRoutes\x1b[0m",
+        url,
+        options
+      );
+    }
+  });
+}
+
+async function recordPlaywrightRoutes(
+  page,
+  ftmocksConifg,
+  config = {
+    testName,
+    mockPath: "**/*",
+    pattern: "^/api/.*",
+    avoidDuplicatesInTheTest: false,
+    avoidDuplicatesWithDefaultMocks: false,
+  }
+) {
+  await page.route(config.mockPath, async (route) => {
+    try {
+      const urlObj = new URL(route.request().url());
+      if (config.pattern && config.pattern.length > 0) {
+        const patternRegex = new RegExp(config.pattern);
+        if (!patternRegex.test(urlObj.pathname)) {
+          await route.continue();
+          return;
+        }
+      }
+
+      const test = await getTestByName(ftmocksConifg, config.testName);
+      if (!test) {
+        await createTest(ftmocksConifg, config.testName);
+      }
+
+      if (await saveIfItIsFile(route, config.testName, ftmocksConifg)) {
+        return;
+      }
+
+      const mockData = {
+        url: urlObj.pathname + urlObj.search,
+        time: new Date().toString(),
+        method: route.request().method(),
+        request: {
+          headers: await route.request().headers(),
+          queryString: Array.from(urlObj.searchParams.entries()).map(
+            ([name, value]) => ({
+              name,
+              value,
+            })
+          ),
+          postData: route.request().postData()
+            ? {
+                mimeType: "application/json",
+                text: route.request().postData(),
+              }
+            : null,
+        },
+        response: {
+          status: (await route.fetch()).status(),
+          headers: (await route.fetch()).headers(),
+          content: await (await route.fetch()).text(),
+        },
+        id: crypto.randomUUID(),
+        served: false,
+        ignoreParams: ftmocksConifg.ignoreParams || [],
+      };
+
+      await createTest(ftmocksConifg, config.testName);
+      if (config.avoidDuplicatesInTheTest) {
+        // Check if the mock data is a duplicate of a mock data in the test
+        const testMockList = loadMockDataFromConfig(
+          ftmocksConifg,
+          config.testName
+        );
+        const matchResponse = testMockList.find((mock) =>
+          compareMockToMock(mock.fileContent, mockData, true)
+        );
+        if (matchResponse) {
+          console.log("Aborting duplicate mock data in the test");
+          await route.continue();
+          return;
+        }
+      }
+
+      if (config.avoidDuplicatesWithDefaultMocks) {
+        // Check if the mock data is a duplicate of a mock data in the test
+        const defaultMockList = getDefaultMockDataFromConfig(ftmocksConifg);
+        const matchResponse = defaultMockList.find((mock) =>
+          compareMockToMock(mock.fileContent, mockData, true)
+        );
+        if (matchResponse) {
+          console.log("Aborting duplicate mock data with default mocks");
+          await route.continue();
+          return;
+        }
+      }
+
+      // Save the mock data to the test
+      const mockListPath = path.join(
+        getMockDir(ftmocksConifg),
+        `test_${nameToFolder(config.testName)}`,
+        "_mock_list.json"
+      );
+      let mockList = [];
+      if (fs.existsSync(mockListPath)) {
+        mockList = JSON.parse(fs.readFileSync(mockListPath, "utf8"));
+      }
+      mockList.push({
+        id: mockData.id,
+        url: mockData.url,
+        method: mockData.method,
+        time: mockData.time,
+      });
+
+      // Create test directory if it doesn't exist
+      const testDir = path.join(
+        getMockDir(ftmocksConifg),
+        `test_${nameToFolder(config.testName)}`
+      );
+      if (!fs.existsSync(testDir)) {
+        fs.mkdirSync(testDir, { recursive: true });
+      }
+      fs.writeFileSync(mockListPath, JSON.stringify(mockList, null, 2));
+      const mocDataPath = path.join(
+        getMockDir(ftmocksConifg),
+        `test_${nameToFolder(config.testName)}`,
+        `mock_${mockData.id}.json`
+      );
+      fs.writeFileSync(mocDataPath, JSON.stringify(mockData, null, 2));
+      await route.continue();
+    } catch (error) {
+      console.error(error);
+      await route.continue();
+    }
+  });
+}
+
+module.exports = {
+  initiatePlaywrightRoutes,
+  recordPlaywrightRoutes,
+};

package/src/rank-compare-utils.js

@@ -0,0 +1,62 @@
+const { clearNulls, charDifference, processURL } = require("./common-utils");
+const { FtJSON } = require("./json-utils");
+const { isUrlAndMethodSame } = require("./compare-utils");
+
+const getSameRequestRank = (req1, req2) => {
+  let rank = 1;
+  clearNulls(req1.postData);
+  clearNulls(req2.postData);
+  // Compare query strings
+  const queryDiff = charDifference(
+    req1.url.split("?")[1] || "",
+    req2.url.split("?")[1] || ""
+  );
+  rank = rank + queryDiff;
+  // Compare post data
+  const postDataDiff = charDifference(
+    FtJSON.stringify(req1.postData || {}),
+    FtJSON.stringify(req2.postData || {})
+  );
+  rank = rank + postDataDiff;
+  return rank;
+};
+
+function getCompareRankMockToFetchRequest(mock, fetchReq) {
+  try {
+    const mockURL = processURL(
+      mock.fileContent.url,
+      mock.fileContent.ignoreParams
+    );
+    const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
+    if (
+      !isUrlAndMethodSame(
+        { url: mockURL, method: mock.fileContent.method },
+        { url: reqURL, method: fetchReq.options.method || "GET" }
+      )
+    ) {
+      return 0;
+    }
+    const postData = mock.fileContent.request?.postData?.text
+      ? FtJSON.parse(mock.fileContent.request?.postData?.text)
+      : mock.fileContent.request?.postData;
+    return getSameRequestRank(
+      { url: mockURL, method: mock.fileContent.method, postData },
+      {
+        method: fetchReq.options.method || "GET",
+        postData: fetchReq.options.body?.length
+          ? FtJSON.parse(fetchReq.options.body)
+          : fetchReq.options.body,
+        url: reqURL,
+      }
+    );
+  } catch (e) {
+    console.error("error at getCompareRankMockToFetchRequest", mock, fetchReq);
+    console.error(e);
+  }
+  return false;
+}
+
+module.exports = {
+  getSameRequestRank,
+  getCompareRankMockToFetchRequest,
+};