@vitest/snapshot 2.2.0-beta.1 → 3.0.0-beta.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot-CGKRMgF8.js';
-export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot-CGKRMgF8.js';
+import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot-BWAfsPv1.js';
+export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot-BWAfsPv1.js';
 import { S as SnapshotEnvironment } from './environment-Ddx0EDtY.js';
 import { Plugin, Plugins } from '@vitest/pretty-format';
 
@@ -38,35 +38,41 @@ declare class SnapshotState {
     private _initialData;
     private _inlineSnapshots;
     private _inlineSnapshotStacks;
+    private _testIdToKeys;
     private _rawSnapshots;
     private _uncheckedKeys;
     private _snapshotFormat;
     private _environment;
     private _fileExists;
-    added: number;
+    private added;
+    private matched;
+    private unmatched;
+    private updated;
     expand: boolean;
-    matched: number;
-    unmatched: number;
-    updated: number;
     private constructor();
     static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
     get environment(): SnapshotEnvironment;
     markSnapshotsAsCheckedForTest(testName: string): void;
+    clearTest(testId: string): void;
     protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
     private _addSnapshot;
-    clear(): void;
     save(): Promise<SaveStatus>;
     getUncheckedCount(): number;
     getUncheckedKeys(): Array<string>;
     removeUncheckedKeys(): void;
-    match({ testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, }: SnapshotMatchOptions): SnapshotReturnOptions;
+    match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, }: SnapshotMatchOptions): SnapshotReturnOptions;
     pack(): Promise<SnapshotResult>;
 }
 
 interface AssertOptions {
     received: unknown;
-    filepath?: string;
-    name?: string;
+    filepath: string;
+    name: string;
+    /**
+     * Not required but needed for `SnapshotClient.clearTest` to implement test-retry behavior.
+     * @default name
+     */
+    testId?: string;
     message?: string;
     isInline?: boolean;
     properties?: object;
@@ -80,18 +86,15 @@ interface SnapshotClientOptions {
 }
 declare class SnapshotClient {
     private options;
-    filepath?: string;
-    name?: string;
-    snapshotState: SnapshotState | undefined;
     snapshotStateMap: Map<string, SnapshotState>;
     constructor(options?: SnapshotClientOptions);
-    startCurrentRun(filepath: string, name: string, options: SnapshotStateOptions): Promise<void>;
+    setup(filepath: string, options: SnapshotStateOptions): Promise<void>;
+    finish(filepath: string): Promise<SnapshotResult>;
+    skipTest(filepath: string, testName: string): void;
+    clearTest(filepath: string, testId: string): void;
     getSnapshotState(filepath: string): SnapshotState;
-    clearTest(): void;
-    skipTestSnapshots(name: string): void;
     assert(options: AssertOptions): void;
     assertRaw(options: AssertOptions): Promise<void>;
-    finishCurrentRun(): Promise<SnapshotResult | null>;
     clear(): void;
 }
 

package/dist/index.js

@@ -1783,6 +1783,33 @@ function deepMergeSnapshot(target, source) {
   }
   return target;
 }
+class DefaultMap extends Map {
+  constructor(defaultFn, entries) {
+    super(entries);
+    this.defaultFn = defaultFn;
+  }
+  get(key) {
+    if (!this.has(key)) {
+      this.set(key, this.defaultFn(key));
+    }
+    return super.get(key);
+  }
+}
+class CounterMap extends DefaultMap {
+  constructor() {
+    super(() => 0);
+  }
+  increment(key) {
+    this.set(key, this.get(key) + 1);
+  }
+  total() {
+    let total = 0;
+    for (const x of this.values()) {
+      total += x;
+    }
+    return total;
+  }
+}
 
 class SnapshotState {
   constructor(testFilePath, snapshotPath, snapshotContent, options) {
@@ -1790,20 +1817,15 @@ class SnapshotState {
     this.snapshotPath = snapshotPath;
     const { data, dirty } = getSnapshotData(snapshotContent, options);
     this._fileExists = snapshotContent != null;
-    this._initialData = data;
-    this._snapshotData = data;
+    this._initialData = { ...data };
+    this._snapshotData = { ...data };
     this._dirty = dirty;
     this._inlineSnapshots = [];
     this._inlineSnapshotStacks = [];
     this._rawSnapshots = [];
     this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
-    this._counters = /* @__PURE__ */ new Map();
     this.expand = options.expand || false;
-    this.added = 0;
-    this.matched = 0;
-    this.unmatched = 0;
     this._updateSnapshot = options.updateSnapshot;
-    this.updated = 0;
     this._snapshotFormat = {
       printBasicPrototype: false,
       escapeString: false,
@@ -1811,23 +1833,24 @@ class SnapshotState {
     };
     this._environment = options.snapshotEnvironment;
   }
-  _counters;
+  _counters = new CounterMap();
   _dirty;
   _updateSnapshot;
   _snapshotData;
   _initialData;
   _inlineSnapshots;
   _inlineSnapshotStacks;
+  _testIdToKeys = new DefaultMap(() => []);
   _rawSnapshots;
   _uncheckedKeys;
   _snapshotFormat;
   _environment;
   _fileExists;
-  added;
+  added = new CounterMap();
+  matched = new CounterMap();
+  unmatched = new CounterMap();
+  updated = new CounterMap();
   expand;
-  matched;
-  unmatched;
-  updated;
   static async create(testFilePath, options) {
     const snapshotPath = await options.snapshotEnvironment.resolvePath(
       testFilePath
@@ -1847,6 +1870,25 @@ class SnapshotState {
       }
     });
   }
+  clearTest(testId) {
+    this._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);
+    this._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);
+    for (const key of this._testIdToKeys.get(testId)) {
+      const name = keyToTestName(key);
+      const count = this._counters.get(name);
+      if (count > 0) {
+        if (key in this._snapshotData || key in this._initialData) {
+          this._snapshotData[key] = this._initialData[key];
+        }
+        this._counters.set(name, count - 1);
+      }
+    }
+    this._testIdToKeys.delete(testId);
+    this.added.delete(testId);
+    this.updated.delete(testId);
+    this.matched.delete(testId);
+    this.unmatched.delete(testId);
+  }
   _inferInlineSnapshotStack(stacks) {
     const promiseIndex = stacks.findIndex(
       (i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/)
@@ -1864,6 +1906,7 @@ class SnapshotState {
     if (options.stack) {
       this._inlineSnapshots.push({
         snapshot: receivedSerialized,
+        testId: options.testId,
         ...options.stack
       });
     } else if (options.rawSnapshot) {
@@ -1875,15 +1918,6 @@ class SnapshotState {
       this._snapshotData[key] = receivedSerialized;
     }
   }
-  clear() {
-    this._snapshotData = this._initialData;
-    this._counters = /* @__PURE__ */ new Map();
-    this.added = 0;
-    this.matched = 0;
-    this.unmatched = 0;
-    this.updated = 0;
-    this._dirty = false;
-  }
   async save() {
     const hasExternalSnapshots = Object.keys(this._snapshotData).length;
     const hasInlineSnapshots = this._inlineSnapshots.length;
@@ -1932,6 +1966,7 @@ class SnapshotState {
     }
   }
   match({
+    testId,
     testName,
     received,
     key,
@@ -1941,11 +1976,12 @@ class SnapshotState {
     rawSnapshot
   }) {
     var _a, _b;
-    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
-    const count = Number(this._counters.get(testName));
+    this._counters.increment(testName);
+    const count = this._counters.get(testName);
     if (!key) {
       key = testNameToKey(testName, count);
     }
+    this._testIdToKeys.get(testId).push(key);
     if (!(isInline && this._snapshotData[key] !== void 0)) {
       this._uncheckedKeys.delete(key);
     }
@@ -1987,29 +2023,31 @@ ${JSON.stringify(
         this._inlineSnapshots = this._inlineSnapshots.filter((s) => !(s.file === stack.file && s.line === stack.line && s.column === stack.column));
         throw new Error("toMatchInlineSnapshot cannot be called multiple times at the same location.");
       }
-      this._inlineSnapshotStacks.push(stack);
+      this._inlineSnapshotStacks.push({ ...stack, testId });
     }
     if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
       if (this._updateSnapshot === "all") {
         if (!pass) {
           if (hasSnapshot) {
-            this.updated++;
+            this.updated.increment(testId);
           } else {
-            this.added++;
+            this.added.increment(testId);
           }
           this._addSnapshot(key, receivedSerialized, {
             stack,
+            testId,
             rawSnapshot
           });
         } else {
-          this.matched++;
+          this.matched.increment(testId);
         }
       } else {
         this._addSnapshot(key, receivedSerialized, {
           stack,
+          testId,
           rawSnapshot
         });
-        this.added++;
+        this.added.increment(testId);
       }
       return {
         actual: "",
@@ -2020,7 +2058,7 @@ ${JSON.stringify(
       };
     } else {
       if (!pass) {
-        this.unmatched++;
+        this.unmatched.increment(testId);
         return {
           actual: removeExtraLineBreaks(receivedSerialized),
           count,
@@ -2029,7 +2067,7 @@ ${JSON.stringify(
           pass: false
         };
       } else {
-        this.matched++;
+        this.matched.increment(testId);
         return {
           actual: "",
           count,
@@ -2058,10 +2096,10 @@ ${JSON.stringify(
     }
     const status = await this.save();
     snapshot.fileDeleted = status.deleted;
-    snapshot.added = this.added;
-    snapshot.matched = this.matched;
-    snapshot.unmatched = this.unmatched;
-    snapshot.updated = this.updated;
+    snapshot.added = this.added.total();
+    snapshot.matched = this.matched.total();
+    snapshot.unmatched = this.unmatched.total();
+    snapshot.updated = this.updated.total();
     snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
     snapshot.uncheckedKeys = Array.from(uncheckedKeys);
     return snapshot;
@@ -2089,41 +2127,45 @@ class SnapshotClient {
   constructor(options = {}) {
     this.options = options;
   }
-  filepath;
-  name;
-  snapshotState;
   snapshotStateMap = /* @__PURE__ */ new Map();
-  async startCurrentRun(filepath, name, options) {
-    var _a;
-    this.filepath = filepath;
-    this.name = name;
-    if (((_a = this.snapshotState) == null ? void 0 : _a.testFilePath) !== filepath) {
-      await this.finishCurrentRun();
-      if (!this.getSnapshotState(filepath)) {
-        this.snapshotStateMap.set(
-          filepath,
-          await SnapshotState.create(filepath, options)
-        );
-      }
-      this.snapshotState = this.getSnapshotState(filepath);
+  async setup(filepath, options) {
+    if (this.snapshotStateMap.has(filepath)) {
+      return;
     }
+    this.snapshotStateMap.set(
+      filepath,
+      await SnapshotState.create(filepath, options)
+    );
   }
-  getSnapshotState(filepath) {
-    return this.snapshotStateMap.get(filepath);
+  async finish(filepath) {
+    const state = this.getSnapshotState(filepath);
+    const result = await state.pack();
+    this.snapshotStateMap.delete(filepath);
+    return result;
   }
-  clearTest() {
-    this.filepath = void 0;
-    this.name = void 0;
+  skipTest(filepath, testName) {
+    const state = this.getSnapshotState(filepath);
+    state.markSnapshotsAsCheckedForTest(testName);
   }
-  skipTestSnapshots(name) {
-    var _a;
-    (_a = this.snapshotState) == null ? void 0 : _a.markSnapshotsAsCheckedForTest(name);
+  clearTest(filepath, testId) {
+    const state = this.getSnapshotState(filepath);
+    state.clearTest(testId);
+  }
+  getSnapshotState(filepath) {
+    const state = this.snapshotStateMap.get(filepath);
+    if (!state) {
+      throw new Error(
+        `The snapshot state for '${filepath}' is not found. Did you call 'SnapshotClient.setup()'?`
+      );
+    }
+    return state;
   }
   assert(options) {
-    var _a, _b, _c, _d;
+    var _a, _b;
     const {
-      filepath = this.filepath,
-      name = this.name,
+      filepath,
+      name,
+      testId = name,
       message,
       isInline = false,
       properties,
@@ -2136,6 +2178,7 @@ class SnapshotClient {
     if (!filepath) {
       throw new Error("Snapshot cannot be used outside of test");
     }
+    const snapshotState = this.getSnapshotState(filepath);
     if (typeof properties === "object") {
       if (typeof received !== "object" || !received) {
         throw new Error(
@@ -2147,7 +2190,7 @@ class SnapshotClient {
         if (!pass2) {
           throw createMismatchError(
             "Snapshot properties mismatched",
-            (_c = this.snapshotState) == null ? void 0 : _c.expand,
+            snapshotState.expand,
             received,
             properties
           );
@@ -2160,8 +2203,8 @@ class SnapshotClient {
       }
     }
     const testName = [name, ...message ? [message] : []].join(" > ");
-    const snapshotState = this.getSnapshotState(filepath);
     const { actual, expected, key, pass } = snapshotState.match({
+      testId,
       testName,
       received,
       isInline,
@@ -2172,7 +2215,7 @@ class SnapshotClient {
     if (!pass) {
       throw createMismatchError(
         `Snapshot \`${key || "unknown"}\` mismatched`,
-        (_d = this.snapshotState) == null ? void 0 : _d.expand,
+        snapshotState.expand,
         actual == null ? void 0 : actual.trim(),
         expected == null ? void 0 : expected.trim()
       );
@@ -2182,7 +2225,7 @@ class SnapshotClient {
     if (!options.rawSnapshot) {
       throw new Error("Raw snapshot is required");
     }
-    const { filepath = this.filepath, rawSnapshot } = options;
+    const { filepath, rawSnapshot } = options;
     if (rawSnapshot.content == null) {
       if (!filepath) {
         throw new Error("Snapshot cannot be used outside of test");
@@ -2197,14 +2240,6 @@ class SnapshotClient {
     }
     return this.assert(options);
   }
-  async finishCurrentRun() {
-    if (!this.snapshotState) {
-      return null;
-    }
-    const result = await this.snapshotState.pack();
-    this.snapshotState = void 0;
-    return result;
-  }
   clear() {
     this.snapshotStateMap.clear();
   }

package/dist/manager.d.ts

@@ -1,4 +1,4 @@
-import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot-CGKRMgF8.js';
+import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot-BWAfsPv1.js';
 import '@vitest/pretty-format';
 import './environment-Ddx0EDtY.js';
 

package/dist/{rawSnapshot-CGKRMgF8.d.ts → rawSnapshot-BWAfsPv1.d.ts}

@@ -12,6 +12,7 @@ interface SnapshotStateOptions {
     resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
 }
 interface SnapshotMatchOptions {
+    testId: string;
     testName: string;
     received: unknown;
     key?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/snapshot",
   "type": "module",
-  "version": "2.2.0-beta.1",
+  "version": "3.0.0-beta.1",
   "description": "Vitest snapshot manager",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -38,14 +38,14 @@
     "dist"
   ],
   "dependencies": {
-    "magic-string": "^0.30.12",
+    "magic-string": "^0.30.14",
     "pathe": "^1.1.2",
-    "@vitest/pretty-format": "2.2.0-beta.1"
+    "@vitest/pretty-format": "3.0.0-beta.1"
   },
   "devDependencies": {
     "@types/natural-compare": "^1.4.3",
     "natural-compare": "^1.4.0",
-    "@vitest/utils": "2.2.0-beta.1"
+    "@vitest/utils": "3.0.0-beta.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",