@vitest/expect 0.29.8 → 0.30.1

package/dist/index.d.ts

@@ -5,11 +5,31 @@ export { setupColors } from '@vitest/utils';
 type Formatter = (input: string | number | null | undefined) => string;
 
 declare function getMatcherUtils(): {
-    EXPECTED_COLOR: (input: unknown) => string;
-    RECEIVED_COLOR: (input: unknown) => string;
-    INVERTED_COLOR: (input: unknown) => string;
-    BOLD_WEIGHT: (input: unknown) => string;
-    DIM_COLOR: (input: unknown) => string;
+    EXPECTED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    RECEIVED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    INVERTED_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    BOLD_WEIGHT: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
+    DIM_COLOR: {
+        (input: unknown): string;
+        open: string;
+        close: string;
+    };
     matcherHint: (matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions) => string;
     printReceived: (object: unknown) => string;
     printExpected: (value: unknown) => string;
@@ -151,19 +171,19 @@ declare function fnNameFor(func: Function): string;
 declare function hasProperty(obj: object | null, property: string): boolean;
 declare function isImmutableUnorderedKeyed(maybeKeyed: any): boolean;
 declare function isImmutableUnorderedSet(maybeSet: any): boolean;
-declare const iterableEquality: (a: any, b: any, aStack?: Array<any>, bStack?: Array<any>) => boolean | undefined;
-declare const subsetEquality: (object: unknown, subset: unknown) => boolean | undefined;
-declare const typeEquality: (a: any, b: any) => boolean | undefined;
-declare const arrayBufferEquality: (a: unknown, b: unknown) => boolean | undefined;
-declare const sparseArrayEquality: (a: unknown, b: unknown) => boolean | undefined;
-declare const generateToBeMessage: (deepEqualityName: string, expected?: string, actual?: string) => string;
+declare function iterableEquality(a: any, b: any, aStack?: Array<any>, bStack?: Array<any>): boolean | undefined;
+declare function subsetEquality(object: unknown, subset: unknown): boolean | undefined;
+declare function typeEquality(a: any, b: any): boolean | undefined;
+declare function arrayBufferEquality(a: unknown, b: unknown): boolean | undefined;
+declare function sparseArrayEquality(a: unknown, b: unknown): boolean | undefined;
+declare function generateToBeMessage(deepEqualityName: string, expected?: string, actual?: string): string;
 
 declare const MATCHERS_OBJECT: unique symbol;
 declare const JEST_MATCHERS_OBJECT: unique symbol;
 declare const GLOBAL_EXPECT: unique symbol;
 
-declare const getState: <State extends MatcherState = MatcherState>(expect: Vi.ExpectStatic) => State;
-declare const setState: <State extends MatcherState = MatcherState>(state: Partial<State>, expect: Vi.ExpectStatic) => void;
+declare function getState<State extends MatcherState = MatcherState>(expect: Vi.ExpectStatic): State;
+declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: Vi.ExpectStatic): void;
 
 declare const JestChaiExpect: ChaiPlugin;
 

package/dist/index.js

@@ -22,13 +22,15 @@ if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
     })
   });
 }
-const getState = (expect) => globalThis[MATCHERS_OBJECT].get(expect);
-const setState = (state, expect) => {
+function getState(expect) {
+  return globalThis[MATCHERS_OBJECT].get(expect);
+}
+function setState(state, expect) {
   const map = globalThis[MATCHERS_OBJECT];
   const current = map.get(expect) || {};
   Object.assign(current, state);
   map.set(expect, current);
-};
+}
 
 function getMatcherUtils() {
   const c = () => getColors();
@@ -41,6 +43,7 @@ function getMatcherUtils() {
     const {
       comment = "",
       isDirectExpectCall = false,
+      // seems redundant with received === ''
       isNot = false,
       promise = "",
       secondArgument = "",
@@ -98,11 +101,7 @@ function getMatcherUtils() {
   };
 }
 function diff(a, b, options) {
-  const c = getColors();
-  return unifiedDiff(stringify(b), stringify(a), {
-    colorDim: c.dim,
-    colorSuccess: c.green,
-    colorError: c.red,
+  return unifiedDiff(b, a, {
     showLegend: options == null ? void 0 : options.showLegend
   });
 }
@@ -258,8 +257,10 @@ function isImmutableUnorderedSet(maybeSet) {
   return !!(maybeSet && maybeSet[IS_SET_SENTINEL] && !maybeSet[IS_ORDERED_SENTINEL]);
 }
 const IteratorSymbol = Symbol.iterator;
-const hasIterator = (object) => !!(object != null && object[IteratorSymbol]);
-const iterableEquality = (a, b, aStack = [], bStack = []) => {
+function hasIterator(object) {
+  return !!(object != null && object[IteratorSymbol]);
+}
+function iterableEquality(a, b, aStack = [], bStack = []) {
   if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b))
     return void 0;
   if (a.constructor !== b.constructor)
@@ -334,15 +335,17 @@ const iterableEquality = (a, b, aStack = [], bStack = []) => {
   aStack.pop();
   bStack.pop();
   return true;
-};
-const hasPropertyInObject = (object, key) => {
+}
+function hasPropertyInObject(object, key) {
   const shouldTerminate = !object || typeof object !== "object" || object === Object.prototype;
   if (shouldTerminate)
     return false;
   return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
-};
-const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date);
-const subsetEquality = (object, subset) => {
+}
+function isObjectWithKeys(a) {
+  return isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date);
+}
+function subsetEquality(object, subset) {
   const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
     if (!isObjectWithKeys(subset2))
       return void 0;
@@ -361,13 +364,13 @@ const subsetEquality = (object, subset) => {
     });
   };
   return subsetEqualityWithContext()(object, subset);
-};
-const typeEquality = (a, b) => {
+}
+function typeEquality(a, b) {
   if (a == null || b == null || a.constructor === b.constructor)
     return void 0;
   return false;
-};
-const arrayBufferEquality = (a, b) => {
+}
+function arrayBufferEquality(a, b) {
   if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer))
     return void 0;
   const dataViewA = new DataView(a);
@@ -379,15 +382,15 @@ const arrayBufferEquality = (a, b) => {
       return false;
   }
   return true;
-};
-const sparseArrayEquality = (a, b) => {
+}
+function sparseArrayEquality(a, b) {
   if (!Array.isArray(a) || !Array.isArray(b))
     return void 0;
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
   return equals(a, b, [iterableEquality, typeEquality], true) && equals(aKeys, bKeys);
-};
-const generateToBeMessage = (deepEqualityName, expected = "#{this}", actual = "#{exp}") => {
+}
+function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
   const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
   if (["toStrictEqual", "toEqual"].includes(deepEqualityName))
     return `${toBeMessage}
@@ -398,12 +401,13 @@ Expected: ${expected}
 Received: serializes to the same string
 `;
   return toBeMessage;
-};
+}
 
 class AsymmetricMatcher {
   constructor(sample, inverse = false) {
     this.sample = sample;
     this.inverse = inverse;
+    // should have "jest" to be compatible with its ecosystem
     this.$$typeof = Symbol.for("jest.asymmetricMatcher");
   }
   getMatcherContext(expect) {
@@ -620,6 +624,20 @@ const JestAsymmetricMatchers = (chai, utils) => {
   };
 };
 
+function recordAsyncExpect(test, promise) {
+  if (test) {
+    promise = promise.finally(() => {
+      const index = test.promises.indexOf(promise);
+      if (index !== -1)
+        test.promises.splice(index, 1);
+    });
+    if (!test.promises)
+      test.promises = [];
+    test.promises.push(promise);
+  }
+  return promise;
+}
+
 const JestChaiExpect = (chai, utils) => {
   const c = () => getColors();
   function def(name, fn) {
@@ -1050,7 +1068,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
   def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const lastCall = spy.mock.calls[spy.calls.length - 1];
+    const lastCall = spy.mock.calls[spy.mock.calls.length - 1];
     this.assert(
       equals(lastCall, args, [iterableEquality]),
       `expected last "${spyName}" call to have been called with #{exp}`,
@@ -1164,7 +1182,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
   def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
     const spy = getSpy(this);
     const spyName = spy.getMockName();
-    const { value: lastResult } = spy.mock.results[spy.returns.length - 1];
+    const { value: lastResult } = spy.mock.results[spy.mock.results.length - 1];
     const pass = equals(lastResult, value);
     this.assert(
       pass,
@@ -1197,6 +1215,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
   utils.addProperty(chai.Assertion.prototype, "resolves", function __VITEST_RESOLVES__() {
     utils.flag(this, "promise", "resolves");
     utils.flag(this, "error", new Error("resolves"));
+    const test = utils.flag(this, "vitest-test");
     const obj = utils.flag(this, "object");
     if (typeof (obj == null ? void 0 : obj.then) !== "function")
       throw new TypeError(`You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`);
@@ -1206,7 +1225,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
         if (typeof result !== "function")
           return result instanceof chai.Assertion ? proxy : result;
         return async (...args) => {
-          return obj.then(
+          const promise = obj.then(
             (value) => {
               utils.flag(this, "object", value);
               return result.call(this, ...args);
@@ -1215,6 +1234,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
               throw new Error(`promise rejected "${String(err)}" instead of resolving`);
             }
           );
+          return recordAsyncExpect(test, promise);
         };
       }
     });
@@ -1223,6 +1243,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
   utils.addProperty(chai.Assertion.prototype, "rejects", function __VITEST_REJECTS__() {
     utils.flag(this, "promise", "rejects");
     utils.flag(this, "error", new Error("rejects"));
+    const test = utils.flag(this, "vitest-test");
     const obj = utils.flag(this, "object");
     const wrapper = typeof obj === "function" ? obj() : obj;
     if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function")
@@ -1233,7 +1254,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
         if (typeof result !== "function")
           return result instanceof chai.Assertion ? proxy : result;
         return async (...args) => {
-          return wrapper.then(
+          const promise = wrapper.then(
             (value) => {
               throw new Error(`promise resolved "${String(value)}" instead of rejecting`);
             },
@@ -1242,6 +1263,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
               return result.call(this, ...args);
             }
           );
+          return recordAsyncExpect(test, promise);
         };
       }
     });
@@ -1249,7 +1271,7 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
   });
 };
 
-const getMatcherState = (assertion, expect) => {
+function getMatcherState(assertion, expect) {
   const obj = assertion._obj;
   const isNot = util.flag(assertion, "negate");
   const promise = util.flag(assertion, "promise") || "";
@@ -1266,6 +1288,7 @@ const getMatcherState = (assertion, expect) => {
     utils: jestUtils,
     promise,
     equals,
+    // needed for built-in jest-snapshots, but we don't use it
     suppressedErrors: []
   };
   return {
@@ -1273,7 +1296,7 @@ const getMatcherState = (assertion, expect) => {
     isNot,
     obj
   };
-};
+}
 class JestExtendError extends Error {
   constructor(message, actual, expected) {
     super(message);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "0.29.8",
+  "version": "0.30.1",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "repository": {
@@ -25,8 +25,8 @@
   ],
   "dependencies": {
     "chai": "^4.3.7",
-    "@vitest/utils": "0.29.8",
-    "@vitest/spy": "0.29.8"
+    "@vitest/spy": "0.30.1",
+    "@vitest/utils": "0.30.1"
   },
   "devDependencies": {
     "picocolors": "^1.0.0"