ftmocks-utils 1.3.2 → 1.3.3

package/package.json

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

package/src/compare-utils.js

@@ -0,0 +1,151 @@
+const { clearNulls, processURL } = require("./common-utils");
+const { FtJSON } = require("./json-utils");
+
+const isUrlAndMethodSame = (req1, req2) => {
+  const url1 = new URL(`http://domain.com${req1.url}`);
+  const url2 = new URL(`http://domain.com${req2.url}`);
+  return (
+    url1.pathname === url2.pathname &&
+    url1.method?.toLowerCase() === url2.method?.toLowerCase()
+  );
+};
+
+const isSameRequest = (req1, req2) => {
+  clearNulls(req1.postData);
+  clearNulls(req2.postData);
+  let matched = true;
+  if (req1.url !== req2.url) {
+    matched = false;
+  } else if (req1.method?.toLowerCase() !== req2.method?.toLowerCase()) {
+    matched = false;
+  } else if (
+    (!req1.postData && req2.postData) ||
+    (req1.postData && !req2.postData)
+  ) {
+    matched = FtJSON.areJsonEqual(req1.postData || {}, req2.postData || {});
+  } else if (
+    req1.postData &&
+    req2.postData &&
+    !FtJSON.areJsonEqual(req1.postData, req2.postData)
+  ) {
+    matched = false;
+  }
+  return matched;
+};
+
+const isSameResponse = (req1, req2) => {
+  try {
+    let matched = true;
+    if (req1.response.status !== req2.response.status) {
+      matched = false;
+      // console.log('not matched at url', req1.method, req2.method);
+    } else if (
+      (!req1.response.content && req2.response.content) ||
+      (req1.response.content && !req2.response.content)
+    ) {
+      matched = FtJSON.areJsonEqual(
+        FtJSON.parse(req1.response.content) || {},
+        FtJSON.parse(req2.response.content) || {}
+      );
+      // console.log('not matched at post Data 0', req1.postData, req2.postData);
+    } else if (
+      req1.response.content &&
+      req2.response.content &&
+      !FtJSON.areJsonEqual(
+        FtJSON.parse(req1.response.content) || {},
+        FtJSON.parse(req2.response.content) || {}
+      )
+    ) {
+      matched = false;
+    }
+    // if (matched) {
+    //   console.log('matched responses', req1, req2);
+    // }
+    return matched;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+};
+
+function compareMockToRequest(mock, req) {
+  const mockURL = processURL(
+    mock.fileContent.url,
+    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 }
+  );
+  if (!isSameUrlAndMethod) {
+    return false;
+  }
+  const postData = mock.fileContent.request?.postData?.text
+    ? FtJSON.parse(mock.fileContent.request?.postData?.text)
+    : mock.fileContent.request?.postData;
+  return isSameRequest(
+    { url: mockURL, method: mock.fileContent.method, postData },
+    {
+      method: req.method,
+      postData: req.body,
+      url: reqURL,
+    }
+  );
+}
+
+function compareMockToFetchRequest(mock, fetchReq) {
+  try {
+    const mockURL = processURL(
+      mock.fileContent.url,
+      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" }
+    );
+    if (!isSameUrlAndMethod) {
+      return false;
+    }
+    const postData = mock.fileContent.request?.postData?.text
+      ? FtJSON.parse(mock.fileContent.request?.postData?.text)
+      : mock.fileContent.request?.postData;
+    return isSameRequest(
+      { 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 compareMockToFetchRequest", mock, fetchReq);
+    console.error(e);
+  }
+  return false;
+}
+
+const compareMockToMock = (mock1, mock2, matchResponse) => {
+  try {
+    if (matchResponse) {
+      return isSameRequest(mock1, mock2) && isSameResponse(mock1, mock2);
+    } else {
+      return isSameRequest(mock1, mock2);
+    }
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+};
+
+module.exports = {
+  isUrlAndMethodSame,
+  isSameRequest,
+  isSameResponse,
+  compareMockToRequest,
+  compareMockToFetchRequest,
+  compareMockToMock,
+};

package/src/index.js

@@ -12,209 +12,25 @@ const {
   countFilesInDirectory,
   getTestByName,
 } = require("./common-utils");
+const {
+  getDefaultMockDataFromConfig,
+  loadMockDataFromConfig,
+  resetAllMockStats,
+} = require("./mock-utils");
+const { createTest } = require("./test-utils");
 const { FtJSON } = require("./json-utils");
-const Logger = require("./log-utils");
+const { Logger, deleteAllLogs } = require("./log-utils");
+const {
+  isSameRequest,
+  compareMockToRequest,
+  compareMockToFetchRequest,
+  compareMockToMock,
+} = require("./compare-utils");
+const { getCompareRankMockToFetchRequest } = require("./rank-compare-utils");
 
 let logger = null;
 
-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 [];
-  }
-};
-
 // src/index.js
-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 [];
-  }
-};
-
-const isSameRequest = (req1, req2) => {
-  clearNulls(req1.postData);
-  clearNulls(req2.postData);
-  let matched = true;
-  if (req1.url !== req2.url) {
-    matched = false;
-  } else if (req1.method?.toLowerCase() !== req2.method?.toLowerCase()) {
-    matched = false;
-  } else if (
-    (!req1.postData && req2.postData) ||
-    (req1.postData && !req2.postData)
-  ) {
-    matched = FtJSON.areJsonEqual(req1.postData || {}, req2.postData || {});
-  } else if (
-    req1.postData &&
-    req2.postData &&
-    !FtJSON.areJsonEqual(req1.postData, req2.postData)
-  ) {
-    matched = false;
-  }
-  return matched;
-};
-
-const getSameRequestRank = (req1, req2) => {
-  let rank = 1;
-  clearNulls(req1.postData);
-  clearNulls(req2.postData);
-  // Compare path names
-  const url1 = new URL(`http://domain.com${req1.url}`);
-  const url2 = new URL(`http://domain.com${req2.url}`);
-  if (url1.pathname !== url2.pathname) {
-    rank = 0;
-  } else if (url1.method?.toLowerCase() !== url2.method?.toLowerCase()) {
-    rank = 0;
-  } else {
-    // Compare query strings
-    const queryDiff = charDifference(url1.search || "", url2.search || "");
-    rank = rank + queryDiff;
-    // Compare post data
-    const charDiff = charDifference(
-      FtJSON.stringify(req1.postData || {}),
-      FtJSON.stringify(req2.postData || {})
-    );
-    rank = rank + charDiff;
-  }
-  return rank;
-};
-
-function compareMockToRequest(mock, req) {
-  const mockURL = processURL(
-    mock.fileContent.url,
-    mock.fileContent.ignoreParams
-  );
-  const reqURL = processURL(req.originalUrl, mock.fileContent.ignoreParams);
-  const postData = mock.fileContent.request?.postData?.text
-    ? FtJSON.parse(mock.fileContent.request?.postData?.text)
-    : mock.fileContent.request?.postData;
-  return isSameRequest(
-    { url: mockURL, method: mock.fileContent.method, postData },
-    {
-      method: req.method,
-      postData: req.body,
-      url: reqURL,
-    }
-  );
-}
-
-function compareMockToFetchRequest(mock, fetchReq) {
-  try {
-    const mockURL = processURL(
-      mock.fileContent.url,
-      mock.fileContent.ignoreParams
-    );
-    const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
-    const postData = mock.fileContent.request?.postData?.text
-      ? FtJSON.parse(mock.fileContent.request?.postData?.text)
-      : mock.fileContent.request?.postData;
-    return isSameRequest(
-      { 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 compareMockToFetchRequest", mock, fetchReq);
-    console.error(e);
-  }
-  return false;
-}
-
-function getCompareRankMockToFetchRequest(mock, fetchReq) {
-  try {
-    const mockURL = processURL(
-      mock.fileContent.url,
-      mock.fileContent.ignoreParams
-    );
-    const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
-    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;
-}
-
 function getMatchingMockData({
   testMockData,
   defaultMockData,
@@ -300,22 +116,6 @@ function getMatchingMockData({
   return foundMock ? foundMock.fileContent : null;
 }
 
-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)
-    );
-  }
-}
-
 async function initiatePlaywrightRoutes(
   page,
   ftmocksConifg,
@@ -323,7 +123,11 @@ async function initiatePlaywrightRoutes(
   mockPath = "**/*",
   excludeMockPath = null
 ) {
-  logger = new Logger({disableLogs: ftmocksConifg.DISABLE_LOGS}, ftmocksConifg, testName);
+  logger = new Logger(
+    { disableLogs: ftmocksConifg.DISABLE_LOGS },
+    ftmocksConifg,
+    testName
+  );
   const testMockData = testName
     ? loadMockDataFromConfig(ftmocksConifg, testName)
     : [];
@@ -692,15 +496,6 @@ const deleteAllSnaps = async (ftmocksConifg, testName) => {
   fs.rmSync(snapFolder, { recursive: true, force: true });
 };
 
-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 });
-};
-
 function initiateJestEventSnaps(jest, ftmocksConifg, testName) {
   const mouseEvents = ftmocksConifg.snapEvents || [
     "click",
@@ -720,95 +515,6 @@ function initiateJestEventSnaps(jest, ftmocksConifg, testName) {
   });
 }
 
-const createTest = async (ftmocksConifg, testName) => {
-  const testsPath = path.join(getMockDir(ftmocksConifg), "tests.json");
-  let tests = [];
-  try {
-    // Read existing tests
-    const testsData = fs.readFileSync(testsPath, "utf8");
-    tests = JSON.parse(testsData);
-    const etest = tests.find((tst) => tst.name === testName);
-    if (!etest) {
-      const newTest = {
-        id: uuidv4(),
-        name: testName,
-      };
-      tests.push(newTest);
-      fs.writeFileSync(testsPath, JSON.stringify(tests, null, 2));
-      const folderPath = path.join(
-        getMockDir(ftmocksConifg),
-        `test_${nameToFolder(testName)}`
-      );
-      const mockListFilePath = path.join(folderPath, "_mock_list.json");
-      fs.mkdir(folderPath, { recursive: true }, (err) => {
-        if (err) {
-          console.error("\x1b[31mError creating directory:\x1b[0m", err);
-        } else {
-          console.log("\x1b[32mDirectory created successfully!\x1b[0m");
-        }
-      });
-      await fs.appendFile(mockListFilePath, "[]", () => {
-        console.log("\x1b[32mmock list file created successfully\x1b[0m");
-      });
-
-      return newTest;
-    } else {
-      throw "Test already exists";
-    }
-  } catch (error) {
-    console.error(`\x1b[31mError reading tests.json:\x1b[0m`, error);
-    return null;
-  }
-};
-
-const isSameResponse = (req1, req2) => {
-  try {
-    let matched = true;
-    if (req1.response.status !== req2.response.status) {
-      matched = false;
-      // console.log('not matched at url', req1.method, req2.method);
-    } else if (
-      (!req1.response.content && req2.response.content) ||
-      (req1.response.content && !req2.response.content)
-    ) {
-      matched = FtJSON.areJsonEqual(
-        FtJSON.parse(req1.response.content) || {},
-        FtJSON.parse(req2.response.content) || {}
-      );
-      // console.log('not matched at post Data 0', req1.postData, req2.postData);
-    } else if (
-      req1.response.content &&
-      req2.response.content &&
-      !FtJSON.areJsonEqual(
-        FtJSON.parse(req1.response.content) || {},
-        FtJSON.parse(req2.response.content) || {}
-      )
-    ) {
-      matched = false;
-    }
-    // if (matched) {
-    //   console.log('matched responses', req1, req2);
-    // }
-    return matched;
-  } catch (error) {
-    console.error(error);
-    return false;
-  }
-};
-
-const compareMockToMock = (mock1, mock2, matchResponse) => {
-  try {
-    if (matchResponse) {
-      return isSameRequest(mock1, mock2) && isSameResponse(mock1, mock2);
-    } else {
-      return isSameRequest(mock1, mock2);
-    }
-  } catch (error) {
-    console.error(error);
-    return false;
-  }
-};
-
 const saveIfItIsFile = async (route, testName, ftmocksConifg) => {
   const urlObj = new URL(route.request().url());
 

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/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/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,
+};

package/src/recorder.js

@@ -1,288 +1,306 @@
 window.FTMOCKS_CONFIG = {
-    record_mocks_url: 'http://localhost:5000/api/v1/recordMockdata',
-    record_events_url: 'http://localhost:5000/api/v1/recordedEvents'
+  record_mocks_url: "http://localhost:5000/api/v1/recordMockdata",
+  record_events_url: "http://localhost:5000/api/v1/recordedEvents",
 };
 
-
 (function () {
-    // Intercept Fetch API
-    const originalFetch = window.fetch;
-    const recordedTracks = [];
-  
-    const addTrack = track => {
-        track.id = recordedTracks.length ? recordedTracks[recordedTracks.length - 1].id + 1 : 1;
-        track.time = new Date();
-        // track.bodyHtml = document.documentElement.outerHTML.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');;
-        
-        fetch(window.FTMOCKS_CONFIG.record_events_url, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify(track),
-                }).then(response => response.json());
-    };
-  
-  
-    window.fetch = async function (url, options = {}) {
-        const method = options.method || 'GET';
-        const body = options.body;
-        const headers = options.headers || {};
-        const queryString = url.includes('?') ? url.split('?')[1] : null;
-        const response = await originalFetch(url, options);
-        const ftMocksURL = new URL(window.FTMOCKS_CONFIG.record_mocks_url);
-        const currentURL = new URL(url.startsWith('http') ? url : `http://something/${url}`);
-        const clonedResponse = response.clone();
-        clonedResponse.text().then((text) => {
-            if (ftMocksURL.hostname !== currentURL.hostname) {
-                const mockResponse = {
-                    url: url,
-                    time: new Date().toString(),
-                    method: method,
-                    request: {
-                        headers: headers,
-                        queryString: queryString,
-                        postData: {
-                            mimeType: headers['Content-Type'] || null,
-                            text: body
-                        }
-                    },
-                    response: {
-                        status: response.status,
-                        headers: Array.from(clonedResponse.headers.entries()),
-                        content: text
-                    },
-                };
-                fetch(window.FTMOCKS_CONFIG.record_mocks_url, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify(mockResponse),
-                }).then(response => response.json());
-                addTrack({
-                    type: mockResponse.method,
-                    target: mockResponse.url, 
-                });
-            }
+  // Intercept Fetch API
+  const originalFetch = window.fetch;
+  const recordedTracks = [];
+
+  const addTrack = (track) => {
+    track.id = recordedTracks.length
+      ? recordedTracks[recordedTracks.length - 1].id + 1
+      : 1;
+    track.time = new Date();
+    // track.bodyHtml = document.documentElement.outerHTML.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');;
+
+    fetch(window.FTMOCKS_CONFIG.record_events_url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(track),
+    }).then((response) => response.json());
+  };
+
+  window.fetch = async function (url, options = {}) {
+    const method = options.method || "GET";
+    const body = options.body;
+    const headers = options.headers || {};
+    const queryString = url.includes("?") ? url.split("?")[1] : null;
+    const response = await originalFetch(url, options);
+    const ftMocksURL = new URL(window.FTMOCKS_CONFIG.record_mocks_url);
+    const currentURL = new URL(
+      url.startsWith("http") ? url : `http://something/${url}`
+    );
+    const clonedResponse = response.clone();
+    clonedResponse.text().then((text) => {
+      if (ftMocksURL.hostname !== currentURL.hostname) {
+        const mockResponse = {
+          url: url,
+          time: new Date().toString(),
+          method: method,
+          request: {
+            headers: headers,
+            queryString: queryString,
+            postData: {
+              mimeType: headers["Content-Type"] || null,
+              text: body,
+            },
+          },
+          response: {
+            status: response.status,
+            headers: Array.from(clonedResponse.headers.entries()),
+            content: text,
+          },
+        };
+        fetch(window.FTMOCKS_CONFIG.record_mocks_url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(mockResponse),
+        }).then((response) => response.json());
+        addTrack({
+          type: mockResponse.method,
+          target: mockResponse.url,
         });
-        return response;
+      }
+    });
+    return response;
+  };
+
+  // Intercept XMLHttpRequest
+  const originalXHR = window.XMLHttpRequest;
+
+  function MockXHR() {
+    const xhr = new originalXHR();
+    const originalOpen = xhr.open;
+    const originalSend = xhr.send;
+    const originalSetRequestHeader = xhr.setRequestHeader;
+    let requestDetails = {
+      headers: {},
     };
-  
-    // Intercept XMLHttpRequest
-    const originalXHR = window.XMLHttpRequest;
-  
-    function MockXHR() {
-        const xhr = new originalXHR();
-        const originalOpen = xhr.open;
-        const originalSend = xhr.send;
-        const originalSetRequestHeader = xhr.setRequestHeader;
-        let requestDetails = {
-            headers: {},
-        };
-  
-        // Override 'open' method
-        xhr.open = function (method, url, async, user, password) {
-            requestDetails.method = method;
-            requestDetails.url = url;
-            requestDetails.async = async;
-            requestDetails.user = user;
-            requestDetails.password = password;
-            requestDetails.queryString = url.includes('?') ? url.split('?')[1] : null;
-            originalOpen.apply(xhr, arguments);
-        };
-  
-        // Override 'setRequestHeader' to log headers
-        xhr.setRequestHeader = function (header, value) {
-            requestDetails.headers[header] = value;
-            originalSetRequestHeader.apply(xhr, arguments);
-        };
-  
-        // Override 'send' method
-        xhr.send = function (body) {
-            requestDetails.body = body;
-            const originalOnReadyStateChange = xhr.onreadystatechange;
-            xhr.onreadystatechange = function () {
-                if (xhr.readyState === 4) { // Complete
-                    const ftMocksURL = new URL(window.FTMOCKS_CONFIG.record_mocks_url);
-                    const currentURL = new URL(requestDetails.url.startsWith('http') ? requestDetails.url : `http://something/${requestDetails.url}`);
-                    if (ftMocksURL.hostname !== currentURL.hostname) {
-                        const mockResponse = {
-                            url: requestDetails.url,
-                            time: new Date().toString(),
-                            method: requestDetails.method,
-                            request: {
-                                headers: requestDetails.headers,
-                                queryString: requestDetails.queryString,
-                                postData: {
-                                    mimeType: requestDetails.headers['Content-Type'] || null,
-                                    text: requestDetails.body
-                                }
-                            },
-                            response: {
-                                status: xhr.status,
-                                headers: xhr.getAllResponseHeaders(),
-                                content: xhr.responseText
-                            },
-                        };
-                        fetch(window.FTMOCKS_CONFIG.record_mocks_url, {
-                            method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                            },
-                            body: JSON.stringify(mockResponse),
-                        }).then(response => response.json());
-  
-                    }
-                }
-                if (originalOnReadyStateChange) originalOnReadyStateChange.apply(xhr, arguments);
+
+    // Override 'open' method
+    xhr.open = function (method, url, async, user, password) {
+      requestDetails.method = method;
+      requestDetails.url = url;
+      requestDetails.async = async;
+      requestDetails.user = user;
+      requestDetails.password = password;
+      requestDetails.queryString = url.includes("?") ? url.split("?")[1] : null;
+      originalOpen.apply(xhr, arguments);
+    };
+
+    // Override 'setRequestHeader' to log headers
+    xhr.setRequestHeader = function (header, value) {
+      requestDetails.headers[header] = value;
+      originalSetRequestHeader.apply(xhr, arguments);
+    };
+
+    // Override 'send' method
+    xhr.send = function (body) {
+      requestDetails.body = body;
+      const originalOnReadyStateChange = xhr.onreadystatechange;
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState === 4) {
+          // Complete
+          const ftMocksURL = new URL(window.FTMOCKS_CONFIG.record_mocks_url);
+          const currentURL = new URL(
+            requestDetails.url.startsWith("http")
+              ? requestDetails.url
+              : `http://something/${requestDetails.url}`
+          );
+          if (ftMocksURL.hostname !== currentURL.hostname) {
+            const mockResponse = {
+              url: requestDetails.url,
+              time: new Date().toString(),
+              method: requestDetails.method,
+              request: {
+                headers: requestDetails.headers,
+                queryString: requestDetails.queryString,
+                postData: {
+                  mimeType: requestDetails.headers["Content-Type"] || null,
+                  text: requestDetails.body,
+                },
+              },
+              response: {
+                status: xhr.status,
+                headers: xhr.getAllResponseHeaders(),
+                content: xhr.responseText,
+              },
             };
-            originalSend.apply(xhr, arguments);
-        };
-  
-        return xhr;
-    }
-  
-    window.XMLHttpRequest = MockXHR;
-  
-  
-    const generateXPathWithNearestParentId = (element) => {
-        let path = '';
-        let nearestParentId = null;
-  
-        // Check if the current element's has an ID
-        if (element.id) {
-            nearestParentId = element.id;
+            fetch(window.FTMOCKS_CONFIG.record_mocks_url, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+              },
+              body: JSON.stringify(mockResponse),
+            }).then((response) => response.json());
+          }
         }
-  
-        while (!nearestParentId && element !== document.body && element) {
-            const tagName = element.tagName.toLowerCase();
-            let index = 1;
-            let sibling = element.previousElementSibling;
-  
-            while (sibling) {
-                if (sibling.tagName.toLowerCase() === tagName) {
-                    index += 1;
-                }
-                sibling = sibling.previousElementSibling;
-            }
-  
-            if (index === 1) {
-                path = `/${tagName}${path}`;
-            } else {
-                path = `/${tagName}[${index}]${path}`;
-            }
-  
-            // Check if the current element's parent has an ID
-            if (element.parentElement && element.parentElement.id) {
-                nearestParentId = element.parentElement.id;
-                break; // Stop searching when we find the nearest parent with an ID
-            }
-  
-            element = element.parentElement;
-        }
-  
-        if (nearestParentId) {
-            path = `//*[@id='${nearestParentId}']${path}`;
-            return path;
-        }
-        return null; // No parent with an ID found
+        if (originalOnReadyStateChange)
+          originalOnReadyStateChange.apply(xhr, arguments);
+      };
+      originalSend.apply(xhr, arguments);
     };
-  
-    const handleMouseEvent = (type, limit) => event => {
-        const target = generateXPathWithNearestParentId(event.target);
-        const track = {
-            id: recordedTracks.length ? recordedTracks[recordedTracks.length - 1].id + 1 : 1,
-            type,
-            target,
-            time: new Date(),
-        };
-        if(recordedTracks.length > limit + 1) {
-            recordedTracks.shift();
+
+    return xhr;
+  }
+
+  window.XMLHttpRequest = MockXHR;
+
+  const generateXPathWithNearestParentId = (element) => {
+    let path = "";
+    let nearestParentId = null;
+
+    // Check if the current element's has an ID
+    if (element.id) {
+      nearestParentId = element.id;
+    }
+
+    while (!nearestParentId && element !== document.body && element) {
+      const tagName = element.tagName.toLowerCase();
+      let index = 1;
+      let sibling = element.previousElementSibling;
+
+      while (sibling) {
+        if (sibling.tagName.toLowerCase() === tagName) {
+          index += 1;
         }
-        recordedTracks.push(track);
-        addTrack(track);
+        sibling = sibling.previousElementSibling;
+      }
+
+      if (index === 1) {
+        path = `/${tagName}${path}`;
+      } else {
+        path = `/${tagName}[${index}]${path}`;
+      }
+
+      // Check if the current element's parent has an ID
+      if (element.parentElement && element.parentElement.id) {
+        nearestParentId = element.parentElement.id;
+        break; // Stop searching when we find the nearest parent with an ID
+      }
+
+      element = element.parentElement;
+    }
+
+    if (nearestParentId) {
+      path = `//*[@id='${nearestParentId}']${path}`;
+      return path;
+    }
+    return null; // No parent with an ID found
+  };
+
+  const handleMouseEvent = (type, limit) => (event) => {
+    const target = generateXPathWithNearestParentId(event.target);
+    const track = {
+      id: recordedTracks.length
+        ? recordedTracks[recordedTracks.length - 1].id + 1
+        : 1,
+      type,
+      target,
+      time: new Date(),
     };
-  
-    const handleChange = limit => event => {
-        const prevCommand =
-            recordedTracks && recordedTracks.length ? recordedTracks[recordedTracks.length - 1] : null;
-        const target = generateXPathWithNearestParentId(event.target);
+    if (recordedTracks.length > limit + 1) {
+      recordedTracks.shift();
+    }
+    recordedTracks.push(track);
+    addTrack(track);
+  };
+
+  const handleChange = (limit) => (event) => {
+    const prevCommand =
+      recordedTracks && recordedTracks.length
+        ? recordedTracks[recordedTracks.length - 1]
+        : null;
+    const target = generateXPathWithNearestParentId(event.target);
+    const track = {
+      id: recordedTracks.length
+        ? recordedTracks[recordedTracks.length - 1].id + 1
+        : 1,
+      type: "change",
+      target,
+      value: event.target.value,
+      time: new Date(),
+    };
+    if (recordedTracks.length > limit + 1) {
+      recordedTracks.shift();
+    }
+    if (
+      prevCommand &&
+      prevCommand.type === "change" &&
+      prevCommand.target === target
+    ) {
+      recordedTracks.pop();
+    }
+    recordedTracks.push(track);
+    addTrack(track);
+  };
+
+  const handleDocumentLoad = (limit) => () => {
+    let oldHref = document.location.href;
+    const body = document.querySelector("body");
+    const observer = new MutationObserver((mutations) => {
+      if (oldHref !== document.location.href) {
+        oldHref = document.location.href;
         const track = {
-            id: recordedTracks.length ? recordedTracks[recordedTracks.length - 1].id + 1 : 1,
-            type: 'change',
-            target,
-            value: event.target.value,
-            time: new Date(),
+          id: recordedTracks.length
+            ? recordedTracks[recordedTracks.length - 1].id + 1
+            : 1,
+          type: "url",
+          value: oldHref,
+          time: new Date(),
         };
-        if(recordedTracks.length > limit + 1) {
-            recordedTracks.shift();
-        }
-        if (
-            prevCommand &&
-            prevCommand.type === 'change' &&
-            prevCommand.target === target
-        ) {
-            recordedTracks.pop();
+        if (recordedTracks.length > limit + 1) {
+          recordedTracks.shift();
         }
         recordedTracks.push(track);
         addTrack(track);
+      }
+    });
+    observer.observe(body, { childList: true, subtree: true });
+  };
+
+  const clearTracks = () => {
+    recordedTracks = [];
+  };
+
+  const getAllTracks = () => {
+    return recordedTracks;
+  };
+
+  const initTracks = (
+    initInfo = {
+      events: ["click", "change", "url", "dblclick", "contextmenu"],
+      limit: 100,
+    }
+  ) => {
+    const { events, limit } = initInfo;
+    const mouseEvents = {
+      click: handleMouseEvent("click", limit),
+      contextmenu: handleMouseEvent("contextmenu", limit),
+      dblclick: handleMouseEvent("dblclick", limit),
+      mousedown: handleMouseEvent("mousedown", limit),
+      mouseenter: handleMouseEvent("mouseenter", limit),
+      mouseleave: handleMouseEvent("mouseleave", limit),
+      mousemove: handleMouseEvent("mousemove", limit),
+      mouseout: handleMouseEvent("mouseout", limit),
+      mouseover: handleMouseEvent("mouseover", limit),
+      mouseup: handleMouseEvent("mouseup", limit),
     };
-  
-    const handleDocumentLoad = limit => () => {
-        let oldHref = document.location.href;
-        const body = document.querySelector('body');
-        const observer = new MutationObserver(mutations => {
-            if (oldHref !== document.location.href) {
-                oldHref = document.location.href;
-                const track = {
-                    id: recordedTracks.length ? recordedTracks[recordedTracks.length - 1].id + 1 : 1,
-                    type: 'url',
-                    value: oldHref,
-                    time: new Date(),
-                };
-                if(recordedTracks.length > limit + 1) {
-                    recordedTracks.shift();
-                }
-                recordedTracks.push(track);
-                addTrack(track);
-            }
-        });
-        observer.observe(body, { childList: true, subtree: true });
-    };
-  
-    const clearTracks = () => {
-        recordedTracks = [];
-    };
-  
-    const getAllTracks = () => {
-        return recordedTracks;
-    };
-  
-    const initTracks = (initInfo = {events: ['click', 'change', 'url', 'dblclick', 'contextmenu'], limit: 100}) => {
-        const {events, limit} = initInfo;
-        const mouseEvents = {
-            click: handleMouseEvent('click', limit),
-            contextmenu: handleMouseEvent('contextmenu', limit),
-            dblclick: handleMouseEvent('dblclick', limit),
-            mousedown: handleMouseEvent('mousedown', limit),
-            mouseenter: handleMouseEvent('mouseenter', limit),
-            mouseleave: handleMouseEvent('mouseleave', limit),
-            mousemove: handleMouseEvent('mousemove', limit),
-            mouseout: handleMouseEvent('mouseout', limit),
-            mouseover: handleMouseEvent('mouseover', limit),
-            mouseup: handleMouseEvent('mouseup', limit),
-        };
-        events.forEach(e => {
-            if(e === 'url') {
-                window.onload = handleDocumentLoad(limit);
-            } else if (e === 'change') {
-                document.addEventListener('input', handleChange(limit));
-            } else {
-                document.addEventListener(e, mouseEvents[e]);
-            }
-        });
-    };
-    initTracks();
-  
-  })();
+    events.forEach((e) => {
+      if (e === "url") {
+        window.onload = handleDocumentLoad(limit);
+      } else if (e === "change") {
+        document.addEventListener("input", handleChange(limit));
+      } else {
+        document.addEventListener(e, mouseEvents[e]);
+      }
+    });
+  };
+  initTracks();
+})();

package/src/test-utils.js

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+const { getMockDir, nameToFolder } = require("./common-utils");
+const { v4: uuidv4 } = require("uuid");
+
+const createTest = async (ftmocksConifg, testName) => {
+  const testsPath = path.join(getMockDir(ftmocksConifg), "tests.json");
+  let tests = [];
+  try {
+    // Read existing tests
+    const testsData = fs.readFileSync(testsPath, "utf8");
+    tests = JSON.parse(testsData);
+    const etest = tests.find((tst) => tst.name === testName);
+    if (!etest) {
+      const newTest = {
+        id: uuidv4(),
+        name: testName,
+      };
+      tests.push(newTest);
+      fs.writeFileSync(testsPath, JSON.stringify(tests, null, 2));
+      const folderPath = path.join(
+        getMockDir(ftmocksConifg),
+        `test_${nameToFolder(testName)}`
+      );
+      const mockListFilePath = path.join(folderPath, "_mock_list.json");
+      fs.mkdir(folderPath, { recursive: true }, (err) => {
+        if (err) {
+          console.error("\x1b[31mError creating directory:\x1b[0m", err);
+        } else {
+          console.log("\x1b[32mDirectory created successfully!\x1b[0m");
+        }
+      });
+      await fs.appendFile(mockListFilePath, "[]", () => {
+        console.log("\x1b[32mmock list file created successfully\x1b[0m");
+      });
+
+      return newTest;
+    } else {
+      throw "Test already exists";
+    }
+  } catch (error) {
+    console.error(`\x1b[31mError reading tests.json:\x1b[0m`, error);
+    return null;
+  }
+};
+
+module.exports = {
+  createTest,
+};