http-snapshotter 0.5.3 → 0.6.0-beta.1

package/README.md

@@ -20,24 +20,25 @@ Example (test.js):
 
 ```js
 import test from "tape";
-import { fileURLToPath } from "node:url";
-import { resolve, dirname } from "node:path";
 import { start, startTestCase, endTestCase } from "http-snapshotter";
+import { resolve } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
 // if you are using an isolated test runner, then use a different directory per test (e.g. http-snapshots/test-case-1)
-start({ snapshotDirectory: resolve(__dirname, "http-snapshots") });
+// you can run this only once per process
+start({ snapshotDirectory: resolve(import.meta.dirname, "http-snapshots") });
 
 test("Latest XKCD comic (ESM)", async (t) => {
   // if you are *not* using an isolated test runner (e.g. tape), then `startTestCase` adds snapshots to separate directory
   // Remove this line if it doesn't apply to your test runner
   startTestCase('test-case-1');
 
-  const res = await fetch("https://xkcd.com/info.0.json");
-  const json = await res.json();
-
-  t.deepEquals(json.title, "Iceberg Efficiency", "must be equal");
-  endTestCase();
+  try {
+    const res = await fetch("https://xkcd.com/info.0.json");
+    const json = await res.json();
+    t.deepEquals(json.title, "Iceberg Efficiency", "must be equal");
+  } finally {
+    endTestCase();
+  }
 });
 ```
 
@@ -68,6 +69,8 @@ The tests of this library uses this library itself, check the `tests/` directory
 
 2. Stripe SDK uses node http module in a way MSW interceptor cannot mock - [reference](https://github.com/mswjs/msw/issues/2259#issuecomment-2379379566). Solution mentioned in a comment there is to use Stripe SDK with `fetch` client - [reference](https://github.com/mswjs/msw/issues/2259#issuecomment-2422672039). Another workaround is to mock Stripe SDK's methods with your testing library of choice.
 
+3. You can't use MSW along with this library, because there can only be one MSW interceptor running.
+
 ## About snapshot files and its names
 
 A snapshot file name uniquely identifies a request. By default it is a combination of HTTP method + URL + body that makes a request unique (headers are ignored).

package/index.js

@@ -98,6 +98,19 @@ let snapshotDirectory = null;
 
 const dynamodbHostNameRegex = /^(?:dynamodb|\d+\.ddb)\.([^.]+)\.amazonaws\.com$/;
 
+/**
+ * Stable JSON stringify with sorted keys for deterministic hashing
+ * @param {any} val
+ * @returns {string}
+ */
+function stableStringify(val) {
+  if (typeof val !== 'object' || val === null) return JSON.stringify(val);
+  if (Array.isArray(val)) return '[' + val.map(stableStringify).join(',') + ']';
+  return '{' + Object.keys(val).sort().map(k =>
+    JSON.stringify(k) + ':' + stableStringify(val[k])
+  ).join(',') + '}';
+}
+
 const defaultKeyDerivationProps = ['method', 'url', 'body'];
 /**
  * @param {Request} request 
@@ -124,8 +137,16 @@ async function defaultSnapshotFileNameGenerator(request) {
 
   // Input data
   const dataList = await Promise.all(
-    defaultKeyDerivationProps.map((key) => {
+    defaultKeyDerivationProps.map(async (key) => {
       if (key === 'body') {
+        const contentType = request.headers.get('content-type') || '';
+        if (contentType.includes('application/json') || contentType.includes('application/x-amz-json')) {
+          try {
+            return stableStringify(await request.clone().json());
+          } catch (e) {
+            // Not valid JSON, fall back to text
+          }
+        }
         return request.clone().text();
       }
       //@ts-ignore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-snapshotter",
-  "version": "0.5.3",
+  "version": "0.6.0-beta.1",
   "description": "Snapshot HTTP requests for tests (node.js)",
   "main": "index.js",
   "types": "index.d.ts",
@@ -12,6 +12,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts"
+  ],
   "scripts": {
     "test": "tape tests/**/*.test.* | tap-arc",
     "tsc": "tsc"

package/intercept.js

@@ -1,78 +0,0 @@
-/*
- * This function was created with a realization that once you override a method for mocking
- * and run a test, you can't undo the override, because shared code (test runner without
- * test isolation) will hold on to closures to the overridden function.
- *
- * So a solution it to intercept once before all tests, mock for a test and "undoMock()" at
- * end of a test will cause the intercept to "proxy" future calls to the original method.
- */
-
-const mocked = new Set();
-
-/**
- * Extracts the keys of an object where the values of the keys are functions.
- * @template T The object type.
- * @typedef {Extract<
- *   keyof T,
- *   { [K in keyof T]: T[K] extends Function ? K : never }[keyof T]
- * >} FunctionKeys
- */
-
-/**
- * @template T
- * @template {FunctionKeys<T>} K
- * @param {T} object
- * @param {K} methodName
- */
-function intercept(object, methodName) {
-  let mockHandler = null;
-  const originalMethod = object[methodName];
-  // @ts-ignore
-  const boundedMethod = object[methodName].bind(object);
-
-  // @ts-ignore
-  // eslint-disable-next-line no-param-reassign
-  object[methodName] = function interceptedFunction(...args) {
-    return mockHandler
-      ? mockHandler(boundedMethod, ...args)
-      // @ts-ignore
-      : originalMethod.apply(object, args);
-  };
-
-  return {
-    /**
-     * @param {(originalMethod: T[K], ...args: Parameters<T[K]>) => any} mockFunction
-     */
-    mock(mockFunction) {
-      mockHandler = mockFunction;
-      mocked.add(this);
-    },
-    undoMock() {
-      mockHandler = null;
-      mocked.delete(this);
-    },
-    /**
-     * Un-intercepting will not get rid of closures to interceptedFunction
-     */
-    destroy() {
-      mockHandler = null;
-      // eslint-disable-next-line no-param-reassign
-      object[methodName] = originalMethod;
-    },
-  };
-}
-
-function undoAllMocks() {
-  [...mocked].forEach((methods) => methods.undoMock());
-}
-
-const interceptAllMethods = (object) => Object.fromEntries(
-  Object
-    .keys(object)
-    .filter((key) => typeof object[key] === 'function')
-    .map(
-      (key) => [key, intercept(object, key)],
-    ),
-);
-
-module.exports = { intercept, undoAllMocks, interceptAllMethods };

package/playground.js

@@ -1,41 +0,0 @@
-const { diffChars } = require('diff');
-
-function findMostSimilar(target, candidates) {
-    // Function to calculate similarity score based on diff
-    function getSimilarityScore(str1, str2) {
-        const changes = diffChars(str1, str2);
-        let totalChanges = 0;
-        let totalLength = 0;
-
-        changes.forEach(change => {
-            if (change.added || change.removed) {
-                totalChanges += change.value.length;
-            }
-            totalLength += change.value.length;
-        });
-
-        // Return similarity as a percentage (100 = identical, 0 = completely different)
-        return 100 * (1 - totalChanges / totalLength);
-    }
-
-    // Calculate scores for all candidates
-    const scores = candidates.map(candidate => ({
-        string: candidate,
-        score: getSimilarityScore(target, candidate)
-    }));
-
-    // Sort by score descending and return the highest scoring match
-    return scores.sort((a, b) => b.score - a.score)[0];
-}
-
-// Example usage
-const target = "hello world";
-const candidates = [
-    "hello word",
-    "hello there",
-    "hi world",
-    "completely different"
-];
-
-const result = findMostSimilar(target, candidates);
-console.log(`Most similar to "${target}" is "${result.string}" with score ${result.score.toFixed(2)}%`);