ftmocks-utils 1.3.0 → 1.3.2

package/package.json

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

package/src/common-utils.js

@@ -1,21 +1,31 @@
 const path = require("path");
 const fs = require("fs");
+const { FtJSON } = require("./json-utils");
 
 const charDifference = (str1, str2) => {
-  let count1 = {},
-    count2 = {};
+  if (str1 && str2) {
+    let count1 = {};
+    let count2 = {};
 
-  for (let ch of str1) count1[ch] = (count1[ch] || 0) + 1;
-  for (let ch of str2) count2[ch] = (count2[ch] || 0) + 1;
+    for (let ch of str1) count1[ch] = (count1[ch] || 0) + 1;
+    for (let ch of str2) count2[ch] = (count2[ch] || 0) + 1;
 
-  let diff = 0;
-  let chars = new Set([...Object.keys(count1), ...Object.keys(count2)]);
+    let diff = 0;
+    let chars = new Set([...Object.keys(count1), ...Object.keys(count2)]);
 
-  for (let ch of chars) {
-    diff += Math.abs((count1[ch] || 0) - (count2[ch] || 0));
-  }
+    for (let ch of chars) {
+      diff += Math.abs((count1[ch] || 0) - (count2[ch] || 0));
+    }
 
-  return diff;
+    return diff;
+  } else {
+    if (!str1 && str2) {
+      return str2.length;
+    } else if (str1 && !str2) {
+      return str1.length;
+    }
+    return 0;
+  }
 };
 
 const nameToFolder = (name) => {
@@ -52,37 +62,6 @@ const capitalizeHeaders = (headers) => {
   );
 };
 
-const areJsonEqual = (jsonObj1, jsonObj2) => {
-  // Check if both are objects and not null
-  if (
-    typeof jsonObj1 === "object" &&
-    jsonObj1 !== null &&
-    typeof jsonObj2 === "object" &&
-    jsonObj2 !== null
-  ) {
-    // Get the keys of both objects
-    const keys1 = Object.keys(jsonObj1);
-    const keys2 = Object.keys(jsonObj2);
-
-    // Check if the number of keys is different
-    if (keys1.length !== keys2.length) {
-      return false;
-    }
-
-    // Recursively check each key-value pair
-    for (let key of keys1) {
-      if (!keys2.includes(key) || !areJsonEqual(jsonObj1[key], jsonObj2[key])) {
-        return false;
-      }
-    }
-
-    return true;
-  } else {
-    // For non-object types, use strict equality comparison
-    return jsonObj1 === jsonObj2;
-  }
-};
-
 const clearNulls = (postData) => {
   Object.keys(postData || {}).forEach((key) => {
     if (postData[key] === null) {
@@ -162,7 +141,6 @@ module.exports = {
   getFallbackDir,
   capitalizeHeader,
   capitalizeHeaders,
-  areJsonEqual,
   clearNulls,
   processURL,
   getHeaders,

package/src/index.js

@@ -6,13 +6,16 @@ const {
   nameToFolder,
   getMockDir,
   getFallbackDir,
-  areJsonEqual,
   clearNulls,
   processURL,
   getHeaders,
   countFilesInDirectory,
   getTestByName,
 } = require("./common-utils");
+const { FtJSON } = require("./json-utils");
+const Logger = require("./log-utils");
+
+let logger = null;
 
 const getDefaultMockDataFromConfig = (testConfig) => {
   const defaultPath = path.join(
@@ -103,11 +106,11 @@ const isSameRequest = (req1, req2) => {
     (!req1.postData && req2.postData) ||
     (req1.postData && !req2.postData)
   ) {
-    matched = areJsonEqual(req1.postData || {}, req2.postData || {});
+    matched = FtJSON.areJsonEqual(req1.postData || {}, req2.postData || {});
   } else if (
     req1.postData &&
     req2.postData &&
-    !areJsonEqual(req1.postData, req2.postData)
+    !FtJSON.areJsonEqual(req1.postData, req2.postData)
   ) {
     matched = false;
   }
@@ -131,8 +134,8 @@ const getSameRequestRank = (req1, req2) => {
     rank = rank + queryDiff;
     // Compare post data
     const charDiff = charDifference(
-      JSON.stringify(req1.postData || {}),
-      JSON.stringify(req2.postData || {})
+      FtJSON.stringify(req1.postData || {}),
+      FtJSON.stringify(req2.postData || {})
     );
     rank = rank + charDiff;
   }
@@ -146,7 +149,7 @@ function compareMockToRequest(mock, req) {
   );
   const reqURL = processURL(req.originalUrl, mock.fileContent.ignoreParams);
   const postData = mock.fileContent.request?.postData?.text
-    ? JSON.parse(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 },
@@ -166,14 +169,14 @@ function compareMockToFetchRequest(mock, fetchReq) {
     );
     const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
     const postData = mock.fileContent.request?.postData?.text
-      ? JSON.parse(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
-          ? JSON.parse(fetchReq.options.body)
+          ? FtJSON.parse(fetchReq.options.body)
           : fetchReq.options.body,
         url: reqURL,
       }
@@ -193,14 +196,14 @@ function getCompareRankMockToFetchRequest(mock, fetchReq) {
     );
     const reqURL = processURL(fetchReq.url, mock.fileContent.ignoreParams);
     const postData = mock.fileContent.request?.postData?.text
-      ? JSON.parse(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
-          ? JSON.parse(fetchReq.options.body)
+          ? FtJSON.parse(fetchReq.options.body)
           : fetchReq.options.body,
         url: reqURL,
       }
@@ -320,13 +323,14 @@ async function initiatePlaywrightRoutes(
   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);
-  console.debug("\x1b[32mcalling initiatePlaywrightRoutes fetch\x1b[0m");
+  logger.debug("\x1b[32mcalling initiatePlaywrightRoutes fetch\x1b[0m");
   let firstUrl = null;
   await page.route(mockPath, async (route, request) => {
     const url = request.url();
@@ -413,7 +417,7 @@ async function initiatePlaywrightRoutes(
             fallbackDir,
             ftmocksConifg.FALLBACK_DIR_INDEX_FILE_FOR_STATUS_404 || "index.html"
           );
-          console.debug(
+          logger.debug(
             "\x1b[32mserving file for status 404\x1b[0m",
             filePath,
             url
@@ -476,19 +480,19 @@ async function initiatePlaywrightRoutes(
               ".php": "application/x-httpd-php",
             }[ext] || "application/octet-stream";
 
-          console.debug("\x1b[32mserving file\x1b[0m", filePath);
+          logger.info("\x1b[32mserving file\x1b[0m", filePath);
           await route.fulfill({
             body: fileContent,
             headers: { "Content-Type": contentType },
           });
         } else {
-          console.debug("\x1b[31mmissing mock data, falling back\x1b[0m", url);
+          logger.debug("\x1b[31mmissing mock data, falling back\x1b[0m", url);
           await route.fallback();
         }
       }
     } catch (e) {
-      console.error(e);
-      console.error(
+      logger.error(e);
+      logger.error(
         "\x1b[31merror at initiatePlaywrightRoutes\x1b[0m",
         url,
         options
@@ -530,7 +534,7 @@ async function initiateJestFetch(jest, ftmocksConifg, testName) {
     return Promise.resolve({
       status,
       headers: new Map(Object.entries(headers)),
-      json: () => Promise.resolve(JSON.parse(content)),
+      json: () => Promise.resolve(FtJSON.parse(content)),
     });
   });
 
@@ -767,17 +771,17 @@ const isSameResponse = (req1, req2) => {
       (!req1.response.content && req2.response.content) ||
       (req1.response.content && !req2.response.content)
     ) {
-      matched = areJsonEqual(
-        JSON.parse(req1.response.content) || {},
-        JSON.parse(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 &&
-      !areJsonEqual(
-        JSON.parse(req1.response.content) || {},
-        JSON.parse(req2.response.content) || {}
+      !FtJSON.areJsonEqual(
+        FtJSON.parse(req1.response.content) || {},
+        FtJSON.parse(req2.response.content) || {}
       )
     ) {
       matched = false;

package/src/json-utils.js

@@ -0,0 +1,55 @@
+class FtJSON {
+  static parse(text, reviver, reference) {
+    try {
+      return JSON.parse(text, reviver);
+    } catch (error) {
+      console.error("FtJSON parse error:", error, reference);
+      return text;
+    }
+  }
+
+  static stringify(value, replacer, space, reference) {
+    try {
+      return JSON.stringify(value, replacer, space);
+    } catch (error) {
+      console.error("FtJSON stringify error:", error, reference);
+      return value;
+    }
+  }
+
+  static areJsonEqual(jsonObj1, jsonObj2) {
+    // Check if both are objects and not null
+    if (
+      typeof jsonObj1 === "object" &&
+      jsonObj1 !== null &&
+      typeof jsonObj2 === "object" &&
+      jsonObj2 !== null
+    ) {
+      // Get the keys of both objects
+      const keys1 = Object.keys(jsonObj1);
+      const keys2 = Object.keys(jsonObj2);
+
+      // Check if the number of keys is different
+      if (keys1.length !== keys2.length) {
+        return false;
+      }
+
+      // Recursively check each key-value pair
+      for (let key of keys1) {
+        if (
+          !keys2.includes(key) ||
+          !FtJSON.areJsonEqual(jsonObj1[key], jsonObj2[key])
+        ) {
+          return false;
+        }
+      }
+
+      return true;
+    } else {
+      // For non-object types, use strict equality comparison
+      return jsonObj1 === jsonObj2;
+    }
+  }
+}
+
+module.exports = { FtJSON };

package/src/log-utils.js

@@ -0,0 +1,90 @@
+const path = require("path");
+const fs = require("fs");
+const { getMockDir, nameToFolder } = require("./common-utils");
+
+class Logger {
+  constructor(options = {}, ftmocksConifg, testName) {
+    this.levels = ["error", "warn", "info", "debug"];
+    this.level = options.level || "info";
+    this.disableLogs = options.disableLogs || false;
+    this.logsFile = path.join(
+      getMockDir(ftmocksConifg),
+      `test_${nameToFolder(testName)}`,
+      "_logs.json"
+    );
+    this.logs = [];
+  }
+
+  setLevel(level) {
+    if (this.levels.includes(level)) {
+      this.level = level;
+    }
+  }
+
+  writeToFile(type, params) {
+    try {
+      const logMessage = params.join(" ") + "\n"; // Combine params into a string with spaces
+      this.logs.push({
+        type,
+        message: logMessage,
+        time: Date.now(),
+        source: "ftmocks-utils",
+      });
+      fs.writeFileSync(this.logsFile, JSON.stringify(this.logs, null, 2), "utf8"); // Append the log message to the file
+    } catch (error) {
+      // Ignore error
+    }
+  }
+
+  log(level, ...args) {
+    if (this.disableLogs) return;
+    const levelIdx = this.levels.indexOf(level);
+    const currentLevelIdx = this.levels.indexOf(this.level);
+    if (levelIdx <= currentLevelIdx) {
+      const color = this._getColor(level);
+      const prefix = `[${level.toUpperCase()}]`;
+      if (typeof args[0] === "string") {
+        // Color only the prefix
+        console.log(`${color}${prefix}\x1b[0m`, ...args);
+      } else {
+        // Non-string first arg, just print
+        console.log(`${color}${prefix}\x1b[0m`, ...args);
+      }
+    }
+    this.writeToFile(level, args);
+  }
+
+  error(...args) {
+    this.log("error", ...args);
+  }
+
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+
+  info(...args) {
+    this.log("info", ...args);
+  }
+
+  debug(...args) {
+    this.log("debug", ...args);
+    console.debug(...args);
+  }
+
+  _getColor(level) {
+    switch (level) {
+      case "error":
+        return "\x1b[31m"; // Red
+      case "warn":
+        return "\x1b[33m"; // Yellow
+      case "info":
+        return "\x1b[36m"; // Cyan
+      case "debug":
+        return "\x1b[90m"; // Gray
+      default:
+        return "";
+    }
+  }
+}
+
+module.exports = Logger;