@fgv/ts-utils-jest 5.0.0-21 → 5.0.0-23

package/src/matchers/toFailWith/index.ts

@@ -1,52 +0,0 @@
-import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
-import { matcherName, predicate } from './predicate';
-
-import { Result } from '@fgv/ts-utils';
-import { matcherHint } from 'jest-matcher-utils';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toFailWith to verify that a Result<T> is a failure
-       * that matches a supplied string, RegExp or undefined value
-       * @param message -
-       */
-      toFailWith(message: string | RegExp | undefined): R;
-    }
-  }
-}
-
-function passMessage<T>(received: Result<T>, expected: string | RegExp | undefined): () => string {
-  return () =>
-    [
-      matcherHint(`.not.${matcherName}`),
-      printExpectedResult('failure', false, expected),
-      printReceivedResult(received)
-    ].join('\n');
-}
-
-function failMessage<T>(received: Result<T>, expected: string | RegExp | undefined): () => string {
-  return () =>
-    [
-      matcherHint(`${matcherName}`),
-      printExpectedResult('failure', true, expected),
-      printReceivedResult(received)
-    ].join('\n');
-}
-
-export default {
-  toFailWith: function <T>(
-    received: Result<T>,
-    expected: string | RegExp | undefined
-  ): jest.CustomMatcherResult {
-    const pass = predicate(received, expected);
-    if (pass) {
-      return { pass: true, message: passMessage(received, expected) };
-    }
-
-    return { pass: false, message: failMessage(received, expected) };
-  }
-};

package/src/matchers/toFailWith/predicate.ts

@@ -1,16 +0,0 @@
-import { Result } from '../../ts-utils';
-
-export const matcherName: string = 'toFailWith';
-
-export function predicate<T>(received: Result<T>, expected: string | RegExp | undefined): boolean {
-  if (received.isFailure()) {
-    if (expected === undefined) {
-      return received.message === undefined;
-    } else if (expected instanceof RegExp) {
-      return received.message.match(expected) !== null;
-    } else {
-      return received.message === expected;
-    }
-  }
-  return false;
-}

package/src/matchers/toFailWithDetail/__snapshots__/index.test.ts.snap

@@ -1,41 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toFailWithDetail reports details correctly on a failure due to a success result: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).toFailWith(expected)
-Expected:
-  Failure with \\"hello\\"
-  Detail: \\"\\"detail\\"\\"
-Received:
-  Success with \\"\\"hello\\"\\"
-  Detail: \\"undefined\\""
-`;
-
-exports[`.toFailWithDetail reports details correctly on a failure due to non-matching detail value: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).toFailWith(expected)
-Expected:
-  Failure with \\"error\\"
-  Detail: \\"\\"detail\\"\\"
-Received:
-  Failure with \\"error\\"
-  Detail: \\"\\"other detail\\"\\""
-`;
-
-exports[`.toFailWithDetail reports details correctly on a failure due to non-matching failure value: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).toFailWith(expected)
-Expected:
-  Failure with \\"error\\"
-  Detail: \\"\\"detail\\"\\"
-Received:
-  Failure with \\"oops\\"
-  Detail: \\"\\"detail\\"\\""
-`;
-
-exports[`.toFailWithDetail reports details correctly on a failure with a .not: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).not.toFailWith(expected)
-Expected:
-  Not failure with \\"oops\\"
-  Detail: \\"\\"detail\\"\\"
-Received:
-  Failure with \\"oops\\"
-  Detail: \\"\\"detail\\"\\""
-`;

package/src/matchers/toFailWithDetail/index.ts

@@ -1,63 +0,0 @@
-import { DetailedResult, ResultDetailType } from '@fgv/ts-utils';
-import { printExpectedDetailedResult, printReceivedDetailedResult } from '../../utils/matcherHelpers';
-import { matcherName, predicate } from './predicate';
-
-import { matcherHint } from 'jest-matcher-utils';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toFailWithDetail to verify that a DetailedResult<T> is
-       * a failure that matches both a supplied expected failure message
-       * (string, RegExp or undefined) and a supplied failure detail.
-       * @param message -
-       */
-      toFailWithDetail(message: string | RegExp | undefined, detail: ResultDetailType<T>): R;
-    }
-  }
-}
-
-function passMessage<T, TD>(
-  received: DetailedResult<T, TD>,
-  expectedMessage: string | RegExp | undefined,
-  expectedDetail: TD
-): () => string {
-  return () =>
-    [
-      matcherHint(`.not.${matcherName}`),
-      printExpectedDetailedResult('failure', false, expectedMessage, expectedDetail),
-      printReceivedDetailedResult(received)
-    ].join('\n');
-}
-
-function failMessage<T, TD>(
-  received: DetailedResult<T, TD>,
-  expectedMessage: string | RegExp | undefined,
-  expectedDetail: TD
-): () => string {
-  return () =>
-    [
-      matcherHint(`${matcherName}`),
-      printExpectedDetailedResult('failure', true, expectedMessage, expectedDetail),
-      printReceivedDetailedResult(received)
-    ].join('\n');
-}
-
-export default {
-  toFailWithDetail: function <T extends DetailedResult<unknown, unknown>>(
-    received: T,
-    expectedMessage: string | RegExp | undefined,
-    expectedDetail: ResultDetailType<T>
-  ): jest.CustomMatcherResult {
-    const pass = predicate(received, expectedMessage, expectedDetail);
-    if (pass) {
-      return { pass: true, message: passMessage(received, expectedMessage, expectedDetail) };
-    }
-
-    return { pass: false, message: failMessage(received, expectedMessage, expectedDetail) };
-  }
-};

package/src/matchers/toFailWithDetail/predicate.ts

@@ -1,27 +0,0 @@
-import { equals } from '@jest/expect-utils';
-import { DetailedResult } from '../../ts-utils';
-
-export const matcherName: string = 'toFailWith';
-
-export function predicate<T, TD>(
-  received: DetailedResult<T, TD>,
-  expectedResult: string | RegExp | undefined,
-  expectedDetail: TD
-): boolean {
-  if (received.isFailure()) {
-    if (expectedResult === undefined) {
-      if (received.message !== undefined) {
-        return false;
-      }
-    } else if (expectedResult instanceof RegExp) {
-      if (received.message.match(expectedResult) === null) {
-        return false;
-      }
-    } else if (received.message !== expectedResult) {
-      return false;
-    }
-
-    return equals(received.detail, expectedDetail);
-  }
-  return false;
-}

package/src/matchers/toHaveBeenCalledWithArgumentsMatching/__snapshots__/index.test.ts.snap

@@ -1,82 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with few calls 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [Any<String>]
-Received (1 total):
-*000: [\\"arg1\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with many calls "for a call in the middle" 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [\\"arg3\\"]
-Received (7 total):
- 002: [\\"arg2\\"]
-*003: [\\"arg3\\"]
- 004: [\\"arg4\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with many calls "for the first call" 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [\\"arg0\\"]
-Received (7 total):
-*000: [\\"arg0\\"]
- 001: [\\"arg1\\"]
- 002: [\\"arg2\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with many calls "for the last call" 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [\\"arg6\\"]
-Received (7 total):
- 004: [\\"arg4\\"]
- 005: [\\"arg5\\"]
-*006: [\\"arg6\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with many calls "for the second call" 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [StringMatching /1/]
-Received (7 total):
- 000: [\\"arg0\\"]
-*001: [\\"arg1\\"]
- 002: [\\"arg2\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a .not test fails with many calls "for the second-to-last-call" 1`] = `
-"expect(received).not.toHaveBeenCalledWithArgumentsMatching(expected)
-Expected no call with arguments matching:
-      [\\"arg5\\"]
-Received (7 total):
- 004: [\\"arg4\\"]
-*005: [\\"arg5\\"]
- 006: [\\"arg6\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if a call is not matched 1`] = `
-"expect(received).toHaveBeenCalledWithArgumentsMatching(expected)
-Expected call with arguments matching:
-      [\\"call7\\"]
-Received (6 total):
- 003: [\\"call4\\"]
- 004: [\\"call5\\"]
- 005: [\\"call6\\"]"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching reports a helpful message if function was not called 1`] = `
-"expect(received).toHaveBeenCalledWithArgumentsMatching(expected)
-Expected call with arguments matching:
-      [\\"call7\\"]
-Received (0 total):"
-`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching throws if argument is "an object" 1`] = `"Test error: toHaveBeenCalledWithArgumentsMatching called with other than jest.Mock"`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching throws if argument is "not a mock function" 1`] = `"Test error: toHaveBeenCalledWithArgumentsMatching called with other than jest.Mock"`;
-
-exports[`.toHaveBeenCalledWithArgumentsMatching throws if argument is "null" 1`] = `"Test error: toHaveBeenCalledWithArgumentsMatching called with other than jest.Mock"`;

package/src/matchers/toHaveBeenCalledWithArgumentsMatching/index.ts

@@ -1,100 +0,0 @@
-import { getTypeOfProperty, getValueOfPropertyOrDefault } from '@fgv/ts-utils';
-import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
-import { IMatchedCall, matcherName, predicate } from './predicate';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R> {
-      /**
-       * Use .toSucceedWith to verify that a Result<T> is a success
-       * and that the result value matches the supplied value
-       * @param expected -
-       */
-      toHaveBeenCalledWithArgumentsMatching(expected: unknown): R;
-    }
-  }
-}
-
-function getRange(length: number, cursor: number): { start: number; end: number } {
-  // less than 3 return everything
-  if (length < 3) {
-    return { start: 0, end: length };
-  }
-
-  if (cursor === 0) {
-    return { start: 0, end: 3 };
-  } else if (cursor >= length - 1) {
-    return { start: length - 3, end: length };
-  }
-  return { start: cursor - 1, end: cursor + 2 };
-}
-
-function formatOneCall(index: number, received: unknown, cursor: boolean): string {
-  const indexString = index.toLocaleString([], { maximumFractionDigits: 0, minimumIntegerDigits: 3 });
-  const cursorString = cursor ? '*' : ' ';
-  return `${cursorString}${indexString}: ${printReceived(received)}`;
-}
-
-function formatArgsMessage(received: jest.Mock, cursor?: number): string[] {
-  const calls = received.mock.calls;
-
-  if (calls.length > 0) {
-    // if there's no cursor, show the last 3
-    const { start, end } = getRange(calls.length, cursor !== undefined ? cursor : calls.length - 1);
-    const callsToShow = calls.slice(start, end);
-    return callsToShow.map((c, i) => formatOneCall(start + i, c, start + i === cursor));
-  }
-  return [];
-}
-
-function passMessage(received: jest.Mock, expected: unknown, matched: IMatchedCall): () => string {
-  return () =>
-    [
-      matcherHint(`.not.${matcherName}`),
-      'Expected no call with arguments matching:',
-      `      ${printExpected(expected)}`,
-      `Received (${received.mock.calls.length} total):`,
-      ...formatArgsMessage(received, matched.index)
-    ].join('\n');
-}
-
-function failMessage(received: jest.Mock, expected: unknown): () => string {
-  return () =>
-    [
-      matcherHint(`${matcherName}`),
-      'Expected call with arguments matching:',
-      `      ${printExpected(expected)}`,
-      `Received (${received.mock.calls.length} total):`,
-      ...formatArgsMessage(received)
-    ].join('\n');
-}
-
-function isMock(received: unknown): received is jest.Mock {
-  if (received !== null && !Array.isArray(received)) {
-    return (
-      getValueOfPropertyOrDefault('_isMockFunction', received as object) === true &&
-      getTypeOfProperty('mock', received as object) === 'object'
-    );
-  }
-  return false;
-}
-
-export default {
-  toHaveBeenCalledWithArgumentsMatching: function (
-    received: jest.Mock,
-    expected: unknown
-  ): jest.CustomMatcherResult {
-    if (!isMock(received)) {
-      throw new Error('Test error: toHaveBeenCalledWithArgumentsMatching called with other than jest.Mock');
-    }
-
-    const matched = predicate(received, expected);
-    if (matched !== undefined) {
-      return { pass: true, message: passMessage(received, expected, matched) };
-    }
-
-    return { pass: false, message: failMessage(received, expected) };
-  }
-};

package/src/matchers/toHaveBeenCalledWithArgumentsMatching/predicate.ts

@@ -1,18 +0,0 @@
-import { equals } from '@jest/expect-utils';
-
-export const matcherName: string = 'toHaveBeenCalledWithArgumentsMatching';
-
-export interface IMatchedCall {
-  index: number;
-  arguments: unknown[];
-}
-
-export function predicate(received: jest.Mock, expected: unknown): undefined | IMatchedCall {
-  for (let i = 0; i < received.mock.calls.length; i++) {
-    const args = received.mock.calls[i];
-    if (equals(args, expected)) {
-      return { index: i, arguments: args };
-    }
-  }
-  return undefined;
-}

package/src/matchers/toSucceed/__snapshots__/index.test.ts.snap

@@ -1,17 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toSucceed reports details for a failed .not test: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).not.toSucceed(expected)
-Expected:
-  Not success
-Received:
-  Success with \\"hello\\""
-`;
-
-exports[`.toSucceed reports details for a failed test: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).toSucceed(expected)
-Expected:
-  Success
-Received:
-  Failure with \\"oops\\""
-`;

package/src/matchers/toSucceed/index.ts

@@ -1,45 +0,0 @@
-import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
-import { matcherName, predicate } from './predicate';
-
-import { Result } from '@fgv/ts-utils';
-import { matcherHint } from 'jest-matcher-utils';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toSucceed to verify that a Result<T> is a success
-       */
-      toSucceed(): R;
-    }
-  }
-}
-
-function passMessage<T>(received: Result<T>): () => string {
-  return () =>
-    [
-      matcherHint(`.not.${matcherName}`),
-      printExpectedResult('success', false),
-      printReceivedResult(received)
-    ].join('\n');
-}
-
-function failMessage<T>(received: Result<T>): () => string {
-  return () =>
-    [matcherHint(`${matcherName}`), printExpectedResult('success', true), printReceivedResult(received)].join(
-      '\n'
-    );
-}
-
-export default {
-  toSucceed: function <T>(received: Result<T>): jest.CustomMatcherResult {
-    const pass = predicate(received);
-    if (pass) {
-      return { pass: true, message: passMessage(received) };
-    }
-
-    return { pass: false, message: failMessage(received) };
-  }
-};

package/src/matchers/toSucceed/predicate.ts

@@ -1,7 +0,0 @@
-import { Result } from '../../ts-utils';
-
-export const matcherName: string = 'toSucceed';
-
-export function predicate<T>(received: Result<T>): boolean {
-  return received.isSuccess();
-}

package/src/matchers/toSucceedAndMatchInlineSnapshot/__snapshots__/index.test.ts.snap

@@ -1,15 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toSucceedAndMatchSnapshot logs details correctly for a failed result: toFailTestAndMatchSnapshot 1`] = `
-"expect(callback).toSucceedAndMatchInlineSnapshot(expected)
-Expected:
-  Callback to succeed with a result that matches the snapshot
-Received:
-  Failure with \\"oopsy\\""
-`;
-
-exports[`.toSucceedAndMatchSnapshot logs details correctly for a failed result: toFailTestAndMatchSnapshot 2`] = `
-"expect(received).not.toMatchInlineSnapshot(properties, snapshot)
-
-Matcher error: Snapshot matchers cannot be used with not"
-`;

package/src/matchers/toSucceedAndMatchInlineSnapshot/index.ts

@@ -1,44 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
-import { Result } from '@fgv/ts-utils';
-import { matcherHint } from 'jest-matcher-utils';
-import { Context, toMatchInlineSnapshot } from 'jest-snapshot';
-import { printReceivedResult } from '../../utils/matcherHelpers';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toSucceedAndMatchInlineSnapshot to verify that a Result<T> is a success
-       * and that the result value matches an inline snapshot
-       */
-      toSucceedAndMatchInlineSnapshot<T>(snapshot: string | undefined): R;
-    }
-  }
-}
-
-const matcherName: string = 'toSucceedAndMatchInlineSnapshot';
-
-export default {
-  toSucceedAndMatchInlineSnapshot: function <T>(
-    this: jest.MatcherContext,
-    received: Result<T>,
-    snapshot: string | undefined
-  ): jest.CustomMatcherResult {
-    const context = this as unknown as Context;
-    if (received.isFailure()) {
-      return {
-        pass: false,
-        message: (): string => {
-          return [
-            matcherHint(`${matcherName}`, 'callback'),
-            'Expected:\n  Callback to succeed with a result that matches the snapshot',
-            printReceivedResult(received)
-          ].join('\n');
-        }
-      };
-    }
-    return toMatchInlineSnapshot.call(context, received.value, {}, snapshot) as jest.CustomMatcherResult;
-  }
-};

package/src/matchers/toSucceedAndMatchSnapshot/__snapshots__/index.test.ts.snap

@@ -1,27 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toSucceedAndMatchSnapshot logs details correctly for a failed result: toFailTestAndMatchSnapshot 1`] = `
-"expect(callback).toSucceedAndMatchSnapshot(expected)
-Expected:
-  Callback to succeed with a result that matches the snapshot
-Received:
-  Failure with \\"oopsy\\""
-`;
-
-exports[`.toSucceedAndMatchSnapshot logs details correctly for a failed result: toFailTestAndMatchSnapshot 2`] = `
-"expect(received).not.toMatchSnapshot(hint)
-
-Matcher error: Snapshot matchers cannot be used with not"
-`;
-
-exports[`.toSucceedAndMatchSnapshot passes for a success result that matches the snapshot: toSucceedAndMatchSnapshot 1`] = `
-Object {
-  "nestedObject": Object {
-    "anArray": Array [
-      "element 1",
-      "element 2",
-    ],
-  },
-  "someField": "this is a value",
-}
-`;

package/src/matchers/toSucceedAndMatchSnapshot/index.ts

@@ -1,47 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
-import { Result } from '@fgv/ts-utils';
-import { matcherHint } from 'jest-matcher-utils';
-import { Context, toMatchSnapshot } from 'jest-snapshot';
-import { printReceivedResult } from '../../utils/matcherHelpers';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,  @typescript-eslint/naming-convention
-    interface Matchers<R, T> {
-      /**
-       * Use .toSucceedAndMatchSnapshot to verify that a Result<T> is a success
-       * and that the result value matches a stored snapshot
-       */
-      toSucceedAndMatchSnapshot<T>(): R;
-    }
-  }
-}
-
-const matcherName: string = 'toSucceedAndMatchSnapshot';
-
-export default {
-  toSucceedAndMatchSnapshot: function <T>(
-    this: jest.MatcherContext,
-    received: Result<T>
-  ): jest.CustomMatcherResult {
-    const context = this as unknown as Context;
-    if (received.isFailure()) {
-      return {
-        pass: false,
-        message: (): string => {
-          return [
-            matcherHint(`${matcherName}`, 'callback'),
-            'Expected:\n  Callback to succeed with a result that matches the snapshot',
-            printReceivedResult(received)
-          ].join('\n');
-        }
-      };
-    }
-    return toMatchSnapshot.call(
-      context,
-      received.value,
-      'toSucceedAndMatchSnapshot'
-    ) as jest.CustomMatcherResult;
-  }
-};

package/src/matchers/toSucceedAndSatisfy/__snapshots__/index.test.ts.snap

@@ -1,37 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`.toSucceedAndSatisfy reports details when callback fails an expectation: toFailTestAndMatchSnapshot 1`] = `
-"expect(received).toBe(expected) // Object.is equality
-
-Expected: \\"goodbye\\"
-Received: \\"hello\\""
-`;
-
-exports[`.toSucceedAndSatisfy reports details when callback returns false: toFailTestAndMatchSnapshot 1`] = `
-"expect(result).toSucceedAndSatisfy(callback)
-Expected:
-  Success with \\"successful callback\\"
-Received:
-  Success with \\"hello\\"
-  Callback returned false"
-`;
-
-exports[`.toSucceedAndSatisfy reports details when callback throws an exception: toFailTestAndMatchSnapshot 1`] = `"UH OH AN ERROR"`;
-
-exports[`.toSucceedAndSatisfy reports details when received is a failure result: toFailTestAndMatchSnapshot 1`] = `
-"expect(result).toSucceedAndSatisfy(callback)
-Expected:
-  Success with \\"successful callback\\"
-Received:
-  Failure with \\"oops\\"
-  Callback was not invoked"
-`;
-
-exports[`.toSucceedAndSatisfy reports details with success and .not: toFailTestAndMatchSnapshot 1`] = `
-"expect(result).not.toSucceedAndSatisfy(callback)
-Expected:
-  Not success with \\"successful callback\\"
-Received:
-  Success with \\"hello\\"
-  Callback returned true"
-`;