ftmocks-utils 1.2.2 → 1.2.5

package/package.json

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

package/src/common-utils.js

@@ -0,0 +1,171 @@
+const path = require("path");
+const fs = require("fs");
+
+const charDifference = (str1, str2) => {
+  let count1 = {},
+    count2 = {};
+
+  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)]);
+
+  for (let ch of chars) {
+    diff += Math.abs((count1[ch] || 0) - (count2[ch] || 0));
+  }
+
+  return diff;
+};
+
+const nameToFolder = (name) => {
+  return name.replaceAll(" ", "_");
+};
+
+const getMockDir = (config) => {
+  if (!path.isAbsolute(config.MOCK_DIR)) {
+    return path.resolve(process.cwd(), config.MOCK_DIR);
+  }
+  return config.MOCK_DIR;
+};
+
+const getFallbackDir = (config) => {
+  if (config.FALLBACK_DIR && !path.isAbsolute(config.FALLBACK_DIR)) {
+    return path.resolve(process.cwd(), config.FALLBACK_DIR);
+  }
+  return config.FALLBACK_DIR;
+};
+
+const capitalizeHeader = (header) => {
+  return header
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("-");
+};
+
+const capitalizeHeaders = (headers) => {
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      capitalizeHeader(key),
+      value,
+    ])
+  );
+};
+
+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) {
+      delete postData[key];
+    }
+  });
+};
+
+const processURL = (url, ignoreParams = []) => {
+  // Remove the hostname from the URL
+  const urlWithoutHost = url.replace(/^(https?:\/\/)?[^\/]+/, "");
+  const processedURL = new URL(`http://domain.com${urlWithoutHost}`);
+  const params = new URLSearchParams(processedURL.search);
+  if (ignoreParams?.length > 0) {
+    ignoreParams.forEach((ip) => {
+      params.delete(ip);
+    });
+  }
+  params.sort();
+  return decodeURIComponent(`${processedURL.pathname}?${params}`);
+};
+
+const getHeaders = (headers) => {
+  let res = null;
+  try {
+    res = new Map([
+      ...Object.entries(headers),
+      ...Object.entries(capitalizeHeaders(headers)),
+    ]);
+  } catch (e) {
+    console.error("error at getHeaders", e);
+    res = new Map([
+      ["Content-Type", "application/json"],
+      ["content-type", "application/json"],
+    ]);
+  }
+  return Object.fromEntries(res);
+};
+
+function countFilesInDirectory(directoryPath) {
+  return new Promise((resolve, reject) => {
+    fs.readdir(directoryPath, (err, files) => {
+      if (err) {
+        return reject(err); // Handle error
+      }
+
+      // Filter out directories and only count files
+      const fileCount = files.filter((file) => {
+        const filePath = path.join(directoryPath, file);
+        return fs.statSync(filePath).isFile();
+      }).length;
+
+      resolve(fileCount);
+    });
+  });
+}
+
+const getTestByName = 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);
+    return etest;
+  } catch (error) {
+    console.error(`\x1b[31mError reading tests.json:\x1b[0m`, error);
+    return null;
+  }
+};
+
+module.exports = {
+  charDifference,
+  nameToFolder,
+  getMockDir,
+  getFallbackDir,
+  capitalizeHeader,
+  capitalizeHeaders,
+  areJsonEqual,
+  clearNulls,
+  processURL,
+  getHeaders,
+  countFilesInDirectory,
+  getTestByName,
+};

package/src/index.js

@@ -1,105 +1,18 @@
 const fs = require("fs");
 const path = require("path");
 const { v4: uuidv4 } = require("uuid");
-
-function charDifference(str1, str2) {
-  let count1 = {},
-    count2 = {};
-
-  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)]);
-
-  for (let ch of chars) {
-    diff += Math.abs((count1[ch] || 0) - (count2[ch] || 0));
-  }
-
-  return diff;
-}
-
-const nameToFolder = (name) => {
-  return name.replaceAll(" ", "_");
-};
-
-const getMockDir = (config) => {
-  if (!path.isAbsolute(config.MOCK_DIR)) {
-    return path.resolve(process.cwd(), config.MOCK_DIR);
-  }
-  return config.MOCK_DIR;
-};
-
-const getFallbackDir = (config) => {
-  if (config.FALLBACK_DIR && !path.isAbsolute(config.FALLBACK_DIR)) {
-    return path.resolve(process.cwd(), config.FALLBACK_DIR);
-  }
-  return config.FALLBACK_DIR;
-};
-
-const capitalizeHeader = (header) => {
-  return header
-    .split("-")
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join("-");
-};
-
-const capitalizeHeaders = (headers) => {
-  return Object.fromEntries(
-    Object.entries(headers).map(([key, value]) => [
-      capitalizeHeader(key),
-      value,
-    ])
-  );
-};
-
-const getHeaders = (headers) => {
-  let res = null;
-  try {
-    res = new Map([
-      ...Object.entries(headers),
-      ...Object.entries(capitalizeHeaders(headers)),
-    ]);
-  } catch (e) {
-    console.error("error at getHeaders", e);
-    res = new Map([
-      ["Content-Type", "application/json"],
-      ["content-type", "application/json"],
-    ]);
-  }
-  return Object.fromEntries(res);
-};
-
-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 {
+  charDifference,
+  nameToFolder,
+  getMockDir,
+  getFallbackDir,
+  areJsonEqual,
+  clearNulls,
+  processURL,
+  getHeaders,
+  countFilesInDirectory,
+  getTestByName,
+} = require("./common-utils");
 
 const getDefaultMockDataFromConfig = (testConfig) => {
   const defaultPath = path.join(getMockDir(testConfig), "default.json");
@@ -174,14 +87,6 @@ const loadMockDataFromConfig = (testConfig, _testName) => {
   }
 };
 
-const clearNulls = (postData) => {
-  Object.keys(postData || {}).forEach((key) => {
-    if (postData[key] === null) {
-      delete postData[key];
-    }
-  });
-};
-
 const isSameRequest = (req1, req2) => {
   clearNulls(req1.postData);
   clearNulls(req2.postData);
@@ -230,20 +135,6 @@ const getSameRequestRank = (req1, req2) => {
   return rank;
 };
 
-const processURL = (url, ignoreParams = []) => {
-  // Remove the hostname from the URL
-  const urlWithoutHost = url.replace(/^(https?:\/\/)?[^\/]+/, "");
-  const processedURL = new URL(`http://domain.com${urlWithoutHost}`);
-  const params = new URLSearchParams(processedURL.search);
-  if (ignoreParams?.length > 0) {
-    ignoreParams.forEach((ip) => {
-      params.delete(ip);
-    });
-  }
-  params.sort();
-  return decodeURIComponent(`${processedURL.pathname}?${params}`);
-};
-
 function compareMockToRequest(mock, req) {
   const mockURL = processURL(
     mock.fileContent.url,
@@ -424,9 +315,13 @@ async function initiatePlaywrightRoutes(
   resetAllMockStats({ testMockData, testConfig: ftmocksConifg, testName });
   const test = await getTestByName(ftmocksConifg, testName);
   const defaultMockData = getDefaultMockDataFromConfig(ftmocksConifg);
-  console.debug("calling initiatePlaywrightRoutes fetch");
+  console.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(),
@@ -436,12 +331,6 @@ async function initiatePlaywrightRoutes(
       await route.fallback();
       return;
     }
-    console.debug(
-      "got fetch request",
-      request.method(),
-      request.url(),
-      request.postData()
-    );
     let mockData = getMatchingMockData({
       testMockData,
       defaultMockData,
@@ -451,53 +340,140 @@ async function initiatePlaywrightRoutes(
       testName,
       mode: test.mode || "loose",
     });
-    if (mockData) {
-      console.debug("mocked", url, options);
-      const { content, headers, status } = mockData.response;
-
-      const json = {
-        status,
-        headers: getHeaders(headers),
-        body: content,
-      };
+    try {
+      if (mockData) {
+        const { content, headers, status, file } = mockData.response;
 
-      await route.fulfill(json);
-    } else {
-      console.debug("missing mock data", url, options);
-      const fallbackDir = getFallbackDir(ftmocksConifg);
-      if (!fallbackDir) {
-        await route.fallback();
-        return;
-      }
-      const urlObj = new URL(route.request().url());
-      const filePath = path.join(
-        fallbackDir,
-        urlObj.pathname === "/" || urlObj.pathname === ""
-          ? ftmocksConifg.FALLBACK_DIR_INDEX_FILE || "index.html"
-          : urlObj.pathname
-      );
-      console.debug("serving file ", filePath);
-      if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
-        const fileContent = fs.readFileSync(filePath);
-        const ext = path.extname(filePath);
-        const contentType =
-          {
-            ".html": "text/html",
-            ".css": "text/css",
-            ".js": "application/javascript",
-            ".json": "application/json",
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-          }[ext] || "application/octet-stream";
+        const json = {
+          status,
+          headers: getHeaders(headers),
+          body: content,
+        };
 
-        console.debug("serving file", filePath);
-        await route.fulfill({
-          body: fileContent,
-          headers: { "Content-Type": contentType },
-        });
+        if (file) {
+          const filePath = path.join(
+            getMockDir(ftmocksConifg),
+            `test_${nameToFolder(testName)}`,
+            "_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 {
-        await route.fallback();
+        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"
+          );
+          console.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";
+
+          console.debug("\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);
+          await route.fallback();
+        }
       }
+    } catch (e) {
+      console.error(e);
+      console.error(
+        "\x1b[31merror at initiatePlaywrightRoutes\x1b[0m",
+        url,
+        options
+      );
     }
   });
 }
@@ -657,24 +633,6 @@ function initiateConsoleLogs(jest, ftmocksConifg, testName) {
   };
 }
 
-function countFilesInDirectory(directoryPath) {
-  return new Promise((resolve, reject) => {
-    fs.readdir(directoryPath, (err, files) => {
-      if (err) {
-        return reject(err); // Handle error
-      }
-
-      // Filter out directories and only count files
-      const fileCount = files.filter((file) => {
-        const filePath = path.join(directoryPath, file);
-        return fs.statSync(filePath).isFile();
-      }).length;
-
-      resolve(fileCount);
-    });
-  });
-}
-
 const saveSnap = async (html, ftmocksConifg, testName) => {
   const snapFolder = path.join(
     getMockDir(ftmocksConifg),
@@ -739,21 +697,6 @@ function initiateJestEventSnaps(jest, ftmocksConifg, testName) {
   });
 }
 
-const getTestByName = 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);
-    return etest;
-  } catch (error) {
-    console.error(`Error reading tests.json:`, error);
-    return null;
-  }
-};
-
 const createTest = async (ftmocksConifg, testName) => {
   const testsPath = path.join(getMockDir(ftmocksConifg), "tests.json");
   let tests = [];
@@ -776,13 +719,13 @@ const createTest = async (ftmocksConifg, testName) => {
       const mockListFilePath = path.join(folderPath, "_mock_list.json");
       fs.mkdir(folderPath, { recursive: true }, (err) => {
         if (err) {
-          console.error("Error creating directory:", err);
+          console.error("\x1b[31mError creating directory:\x1b[0m", err);
         } else {
-          console.log("Directory created successfully!");
+          console.log("\x1b[32mDirectory created successfully!\x1b[0m");
         }
       });
       await fs.appendFile(mockListFilePath, "[]", () => {
-        console.log("mock list file created successfully");
+        console.log("\x1b[32mmock list file created successfully\x1b[0m");
       });
 
       return newTest;
@@ -790,7 +733,7 @@ const createTest = async (ftmocksConifg, testName) => {
       throw "Test already exists";
     }
   } catch (error) {
-    console.error(`Error reading tests.json:`, error);
+    console.error(`\x1b[31mError reading tests.json:\x1b[0m`, error);
     return null;
   }
 };