ftmocks-utils 1.3.1 → 1.3.3

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