chore(expect): use matcher utils via context instead of direct imports

Author: SimenB

packages/expect/src/extractExpectedAssertionsErrors.ts

@@ -6,14 +6,16 @@
  *
  */
 
-import {
-  EXPECTED_COLOR,
-  RECEIVED_COLOR,
-  matcherHint,
-  pluralize,
-} from 'jest-matcher-utils';
+import {equals, iterableEquality, subsetEquality} from '@jest/expect-utils';
+import * as matcherUtils from 'jest-matcher-utils';
 import {getState, setState} from './jestMatchersObject';
-import type {Expect, ExpectedAssertionsErrors} from './types';
+import type {
+  Expect,
+  ExpectedAssertionsErrors,
+  MatcherContext,
+  MatcherState,
+  MatcherUtils,
+} from './types';
 
 const resetAssertionsLocalState = () => {
   setState({
@@ -23,10 +25,28 @@ const resetAssertionsLocalState = () => {
   });
 };
 
+const utils: MatcherUtils['utils'] = {
+  ...matcherUtils,
+  iterableEquality,
+  subsetEquality,
+};
+
+const matcherUtilsThing: MatcherUtils = {
+  dontThrow: () => {
+    // nothing
+  },
+  equals,
+  utils,
+};
+
 // Create and format all errors related to the mismatched number of `expect`
 // calls and reset the matcher's state.
 const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors'] =
   () => {
+    const matcherContext: MatcherContext = {
+      ...getState<MatcherState>(),
+      ...matcherUtilsThing,
+    };
     const result: ExpectedAssertionsErrors = [];
     const {
       assertionCalls,
@@ -42,16 +62,21 @@ const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors']
       typeof expectedAssertionsNumber === 'number' &&
       assertionCalls !== expectedAssertionsNumber
     ) {
-      const numOfAssertionsExpected = EXPECTED_COLOR(
-        pluralize('assertion', expectedAssertionsNumber),
+      const numOfAssertionsExpected = matcherContext.utils.EXPECTED_COLOR(
+        matcherContext.utils.pluralize('assertion', expectedAssertionsNumber),
       );
 
       expectedAssertionsNumberError!.message =
-        `${matcherHint('.assertions', '', expectedAssertionsNumber.toString(), {
-          isDirectExpectCall: true,
-        })}\n\n` +
-        `Expected ${numOfAssertionsExpected} to be called but received ${RECEIVED_COLOR(
-          pluralize('assertion call', assertionCalls || 0),
+        `${matcherContext.utils.matcherHint(
+          '.assertions',
+          '',
+          expectedAssertionsNumber.toString(),
+          {
+            isDirectExpectCall: true,
+          },
+        )}\n\n` +
+        `Expected ${numOfAssertionsExpected} to be called but received ${matcherContext.utils.RECEIVED_COLOR(
+          matcherContext.utils.pluralize('assertion call', assertionCalls || 0),
         )}.`;
 
       result.push({
@@ -61,10 +86,12 @@ const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors']
       });
     }
     if (isExpectingAssertions && assertionCalls === 0) {
-      const expected = EXPECTED_COLOR('at least one assertion');
-      const received = RECEIVED_COLOR('received none');
+      const expected = matcherContext.utils.EXPECTED_COLOR(
+        'at least one assertion',
+      );
+      const received = matcherContext.utils.RECEIVED_COLOR('received none');
 
-      isExpectingAssertionsError!.message = `${matcherHint(
+      isExpectingAssertionsError!.message = `${matcherContext.utils.matcherHint(
         '.hasAssertions',
         '',
         '',

packages/expect/src/index.ts

@@ -6,8 +6,7 @@
  *
  */
 
-/* eslint-disable local/prefer-spread-eventually */
-
+import type {ChalkFunction} from 'chalk';
 import {equals, iterableEquality, subsetEquality} from '@jest/expect-utils';
 import * as matcherUtils from 'jest-matcher-utils';
 import {isPromise} from 'jest-util';
@@ -150,33 +149,32 @@ export const expect: Expect = (actual: any, ...rest: Array<any>) => {
   return expectation;
 };
 
-const getMessage = (message?: () => string) =>
+const getMessage = (receivedColor: ChalkFunction, message?: () => string) =>
   (message && message()) ||
-  matcherUtils.RECEIVED_COLOR('No message was specified for this matcher.');
-
-const makeResolveMatcher =
-  (
-    matcherName: string,
-    matcher: RawMatcherFn,
-    isNot: boolean,
-    actual: Promise<any>,
-    outerErr: JestAssertionError,
-  ): PromiseMatcherFn =>
-  (...args) => {
+  receivedColor('No message was specified for this matcher.');
+
+const makeResolveMatcher = (
+  matcherName: string,
+  matcher: RawMatcherFn,
+  isNot: boolean,
+  actual: Promise<any>,
+  outerErr: JestAssertionError,
+): PromiseMatcherFn =>
+  function (...args) {
     const options = {
       isNot,
       promise: 'resolves',
     };
 
     if (!isPromise(actual)) {
       throw new JestAssertionError(
-        matcherUtils.matcherErrorMessage(
-          matcherUtils.matcherHint(matcherName, undefined, '', options),
-          `${matcherUtils.RECEIVED_COLOR('received')} value must be a promise`,
-          matcherUtils.printWithType(
+        this.utils.matcherErrorMessage(
+          this.utils.matcherHint(matcherName, undefined, '', options),
+          `${this.utils.RECEIVED_COLOR('received')} value must be a promise`,
+          this.utils.printWithType(
             'Received',
             actual,
-            matcherUtils.printReceived,
+            this.utils.printReceived,
           ),
         ),
       );
@@ -187,33 +185,27 @@ const makeResolveMatcher =
     return actual.then(
       result =>
         makeThrowingMatcher(matcher, isNot, 'resolves', result, innerErr).apply(
-          null,
+          this,
           args,
         ),
       reason => {
         outerErr.message =
-          `${matcherUtils.matcherHint(
-            matcherName,
-            undefined,
-            '',
-            options,
-          )}\n\n` +
+          `${this.utils.matcherHint(matcherName, undefined, '', options)}\n\n` +
           'Received promise rejected instead of resolved\n' +
-          `Rejected to value: ${matcherUtils.printReceived(reason)}`;
+          `Rejected to value: ${this.utils.printReceived(reason)}`;
         return Promise.reject(outerErr);
       },
     );
   };
 
-const makeRejectMatcher =
-  (
-    matcherName: string,
-    matcher: RawMatcherFn,
-    isNot: boolean,
-    actual: Promise<any> | (() => Promise<any>),
-    outerErr: JestAssertionError,
-  ): PromiseMatcherFn =>
-  (...args) => {
+const makeRejectMatcher = (
+  matcherName: string,
+  matcher: RawMatcherFn,
+  isNot: boolean,
+  actual: Promise<any> | (() => Promise<any>),
+  outerErr: JestAssertionError,
+): PromiseMatcherFn =>
+  function (...args) {
     const options = {
       isNot,
       promise: 'rejects',
@@ -224,15 +216,15 @@ const makeRejectMatcher =
 
     if (!isPromise(actualWrapper)) {
       throw new JestAssertionError(
-        matcherUtils.matcherErrorMessage(
-          matcherUtils.matcherHint(matcherName, undefined, '', options),
-          `${matcherUtils.RECEIVED_COLOR(
+        this.utils.matcherErrorMessage(
+          this.utils.matcherHint(matcherName, undefined, '', options),
+          `${this.utils.RECEIVED_COLOR(
             'received',
           )} value must be a promise or a function returning a promise`,
-          matcherUtils.printWithType(
+          this.utils.printWithType(
             'Received',
             actual,
-            matcherUtils.printReceived,
+            this.utils.printReceived,
           ),
         ),
       );
@@ -243,24 +235,25 @@ const makeRejectMatcher =
     return actualWrapper.then(
       result => {
         outerErr.message =
-          `${matcherUtils.matcherHint(
-            matcherName,
-            undefined,
-            '',
-            options,
-          )}\n\n` +
+          `${this.utils.matcherHint(matcherName, undefined, '', options)}\n\n` +
           'Received promise resolved instead of rejected\n' +
-          `Resolved to value: ${matcherUtils.printReceived(result)}`;
+          `Resolved to value: ${this.utils.printReceived(result)}`;
         return Promise.reject(outerErr);
       },
       reason =>
         makeThrowingMatcher(matcher, isNot, 'rejects', reason, innerErr).apply(
-          null,
+          this,
           args,
         ),
     );
   };
 
+const utils: MatcherUtils['utils'] = Object.freeze({
+  ...matcherUtils,
+  iterableEquality,
+  subsetEquality,
+});
+
 const makeThrowingMatcher = (
   matcher: RawMatcherFn,
   isNot: boolean,
@@ -270,11 +263,6 @@ const makeThrowingMatcher = (
 ): ThrowingMatcherFn =>
   function throwingMatcher(...args): any {
     let throws = true;
-    const utils: MatcherUtils['utils'] = {
-      ...matcherUtils,
-      iterableEquality,
-      subsetEquality,
-    };
 
     const matcherUtilsThing: MatcherUtils = {
       // When throws is disabled, the matcher will not throw errors during test
@@ -299,7 +287,7 @@ const makeThrowingMatcher = (
       result: SyncExpectationResult,
       asyncError?: JestAssertionError,
     ) => {
-      _validateResult(result);
+      _validateResult(this.utils.stringify, result);
 
       getState().assertionCalls++;
 
@@ -400,7 +388,10 @@ expect.objectContaining = objectContaining;
 expect.stringContaining = stringContaining;
 expect.stringMatching = stringMatching;
 
-const _validateResult = (result: any) => {
+const _validateResult = (
+  stringify: typeof matcherUtils['stringify'],
+  result: any,
+) => {
   if (
     typeof result !== 'object' ||
     typeof result.pass !== 'boolean' ||
@@ -413,7 +404,7 @@ const _validateResult = (result: any) => {
         'Matcher functions should ' +
         'return an object in the following format:\n' +
         '  {message?: string | function, pass: boolean}\n' +
-        `'${matcherUtils.stringify(result)}' was returned`,
+        `'${stringify(result)}' was returned`,
     );
   }
 };