ftmocks-utils 1.0.4 → 1.0.6

package/package.json

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

package/src/index.js

@@ -183,6 +183,144 @@ async function resetAllMockStats({testMockData, testConfig, testName}) {
   }
 }
 
+async function initiateJestFetch (jest, ftmocksConifg, testName) {
+  const testMockData = testName ? loadMockDataFromConfig(ftmocksConifg, testName) : [];
+  resetAllMockStats({testMockData, testConfig: ftmocksConifg, testName});
+  const defaultMockData = getDefaultMockDataFromConfig(ftmocksConifg);
+  global.fetch = jest.fn((url, options = {}) => {
+    let mockData = getMatchingMockData({testMockData, defaultMockData, url, options, testConfig: ftmocksConifg, testName});
+    if (mockData) {
+      console.debug('mocked', url, options);
+    } else {
+      console.debug('missing mock data', url, options);
+      return Promise.resolve({
+        status: 404,
+        headers: new Map([['content-type', 'application/json']]),
+        json: () => Promise.resolve({ error: 'Mock data not found' }),
+      });
+    }
+  
+    const { content, headers, status } = mockData.response;
+    
+    return Promise.resolve({
+      status,
+      headers,
+      json: () => Promise.resolve(JSON.parse(content)),
+    });
+  });
+
+  global.XMLHttpRequest = jest.fn(function () {
+    const xhrMock = {
+      open: jest.fn(),
+      send: jest.fn(),
+      setRequestHeader: jest.fn(),
+      getAllResponseHeaders: jest.fn(() => {
+        return '';
+      }),
+      getResponseHeader: jest.fn((header) => {
+        return null;
+      }),
+      readyState: 4,
+      status: 0,
+      response: null,
+      responseText: '',
+      onreadystatechange: null,
+      onload: null,
+      onerror: null,
+    };
+  
+    xhrMock.send.mockImplementation(function () {
+      const mockData = getMatchingMockData({
+        testMockData,
+        defaultMockData,
+        url: xhrMock._url,
+        options: xhrMock._options,
+        testConfig: ftmocksConifg,
+        testName,
+      });
+  
+      if (mockData) {
+        console.debug('mocked', xhrMock._url, xhrMock._options);
+        const { content, headers, status } = mockData.response;
+  
+        xhrMock.status = status;
+        xhrMock.responseText = content;
+        xhrMock.response = content;
+        xhrMock.headers = headers;
+  
+        if (xhrMock.onreadystatechange) {
+          xhrMock.onreadystatechange();
+        }
+        if (xhrMock.onload) {
+          xhrMock.onload();
+        }
+      } else {
+        console.debug('missing mock data', xhrMock._url, xhrMock._options);
+  
+        xhrMock.status = 404;
+        xhrMock.responseText = JSON.stringify({ error: 'Mock data not found' });
+        xhrMock.response = xhrMock.responseText;
+  
+        if (xhrMock.onreadystatechange) {
+          xhrMock.onreadystatechange();
+        }
+        if (xhrMock.onerror) {
+          xhrMock.onerror();
+        }
+      }
+    });
+  
+    xhrMock.open.mockImplementation(function (method, url) {
+      xhrMock._options = { method };
+      xhrMock._url = url;
+    });
+  
+    return xhrMock;
+  });
+  
+  return;
+};
+
+
+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(ftmocksConifg.MOCK_DIR, `test_${nameToFolder(testName)}`, '_snaps');
+  const snapTemplate = path.join(ftmocksConifg.MOCK_DIR, 'snap_template.html');
+  
+  if (!fs.existsSync(snapFolder)) {
+    fs.mkdirSync(snapFolder);
+  }
+  const fileCount =  await (countFilesInDirectory(snapFolder));
+  const snapFilePath = path.join(snapFolder, `snap_${fileCount + 1}.html`);
+  let resHtml = html;
+  if (fs.existsSync(snapFolder)) {
+    const templateHtml = fs.readFileSync(snapTemplate, 'utf8');;
+    resHtml = templateHtml.replace('<!--FtMocks-Snap-Template-To-Be-Replaced-->', html)
+  }
+  fs.writeFileSync(snapFilePath, resHtml)
+};
+
+const deleteAllSnaps = async (ftmocksConifg, testName) => {
+  const snapFolder = path.join(ftmocksConifg.MOCK_DIR, `test_${nameToFolder(testName)}`, '_snaps');
+  fs.rmSync(snapFolder, { recursive: true, force: true });
+};
 
 // Export functions as a module
 module.exports = {
@@ -194,5 +332,8 @@ module.exports = {
     nameToFolder,
     compareMockToFetchRequest,
     getMatchingMockData,
-    resetAllMockStats
+    resetAllMockStats,
+    initiateJestFetch,
+    saveSnap,
+    deleteAllSnaps
 };

package/src/recorder.js

@@ -2,10 +2,12 @@
     // 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: {
@@ -14,8 +16,8 @@
                     body: JSON.stringify(track),
                 }).then(response => response.json());
     };
-
-
+  
+  
     window.fetch = async function (url, options = {}) {
         const method = options.method || 'GET';
         const body = options.body;
@@ -60,10 +62,10 @@
         });
         return response;
     };
-
+  
     // Intercept XMLHttpRequest
     const originalXHR = window.XMLHttpRequest;
-
+  
     function MockXHR() {
         const xhr = new originalXHR();
         const originalOpen = xhr.open;
@@ -72,7 +74,7 @@
         let requestDetails = {
             headers: {},
         };
-
+  
         // Override 'open' method
         xhr.open = function (method, url, async, user, password) {
             requestDetails.method = method;
@@ -83,13 +85,13 @@
             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;
@@ -124,63 +126,63 @@
                             },
                             body: JSON.stringify(mockResponse),
                         }).then(response => response.json());
-
+  
                     }
                 }
                 if (originalOnReadyStateChange) originalOnReadyStateChange.apply(xhr, arguments);
             };
             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;
         }
-
+  
         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
     };
-
+  
     const handleMouseEvent = (type, limit) => event => {
         const target = generateXPathWithNearestParentId(event.target);
         const track = {
@@ -195,7 +197,7 @@
         recordedTracks.push(track);
         addTrack(track);
     };
-
+  
     const handleChange = limit => event => {
         const prevCommand =
             recordedTracks && recordedTracks.length ? recordedTracks[recordedTracks.length - 1] : null;
@@ -220,7 +222,7 @@
         recordedTracks.push(track);
         addTrack(track);
     };
-
+  
     const handleDocumentLoad = limit => () => {
         let oldHref = document.location.href;
         const body = document.querySelector('body');
@@ -242,15 +244,15 @@
         });
         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 = {
@@ -276,5 +278,5 @@
         });
     };
     initTracks();
-
-})();
+  
+  })();