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

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

@@ -0,0 +1,34 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`.toFailTestWith logs failure correctly when callback fails with .not: toFailTestAndMatchSnapshot 1`] = `
+"expect(callback).not.toFailTestWith(expectedMessage)
+Expected:
+  Not failure with /expect/i
+  Received: Callback failed with:
+>>>>
+expect(received).toBe(expected) // Object.is equality
+
+Expected: false
+Received: true
+<<<<"
+`;
+
+exports[`.toFailTestWith logs failure correctly when callback returns an unexpected value: toFailTestAndMatchSnapshot 1`] = `
+"expect(callback).toFailTestWith(expectedMessage)
+Expected:
+  Failure with /random text/i
+  Received: Callback failed with:
+>>>>
+expect(received).toBe(expected) // Object.is equality
+
+Expected: \\"goodbye\\"
+Received: \\"hello\\"
+<<<<"
+`;
+
+exports[`.toFailTestWith logs failure correctly when callback succeeds: toFailTestAndMatchSnapshot 1`] = `
+"expect(callback).toFailTestWith(expectedMessage)
+Expected:
+  Failure with \\"whatever\\"
+  Received: Callback succeeded"
+`;

package/src/matchers/toFailTestWith/index.ts

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
+import { Failure, Success } from '../../ts-utils';
+import { matcherName, predicate } from './predicate';
+
+import { matcherHint } from 'jest-matcher-utils';
+import { printExpectedResult } 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 .toFailTestWith to test a custom matcher by
+       * verifying that a test case fails as expected and
+       * reports an error matching a supplied value.
+       * @param expected -
+       */
+      toFailTestWith<T>(expected: string | string[] | RegExp): R;
+    }
+  }
+}
+
+function passMessage<T>(cbResult: Success<string>, expected: RegExp | string | string[]): () => string {
+  return () =>
+    [
+      matcherHint(`.not.${matcherName}`, 'callback', 'expectedMessage'),
+      printExpectedResult('failure', false, expected),
+      `  Received: Callback failed with:\n>>>>\n${cbResult.value}\n<<<<`
+    ].join('\n');
+}
+
+function failMessage<T>(cbResult: Failure<string>, expected: RegExp | string | string[]): () => string {
+  return () =>
+    [
+      matcherHint(`${matcherName}`, 'callback', 'expectedMessage'),
+      printExpectedResult('failure', true, expected),
+      cbResult.message === ''
+        ? '  Received: Callback succeeded'
+        : `  Received: Callback failed with:\n>>>>\n${cbResult.message}\n<<<<`
+    ].join('\n');
+}
+
+export default {
+  toFailTestWith: function <T>(
+    cb: () => void,
+    expected: RegExp | string | string[]
+  ): jest.CustomMatcherResult {
+    const cbResult = predicate(cb, expected);
+    if (cbResult.isSuccess()) {
+      return { pass: true, message: passMessage(cbResult, expected) };
+    }
+
+    return { pass: false, message: failMessage(cbResult, expected) };
+  }
+};

package/src/matchers/toFailTestWith/predicate.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,no-unused-vars */
+import { equals } from '@jest/expect-utils';
+import { stringify } from 'jest-matcher-utils';
+import { Result, captureResult, fail, succeed } from '../../ts-utils';
+
+export const matcherName: string = 'toFailTestWith';
+
+export function predicate<T>(cb: () => void, expected: string | string[] | RegExp): Result<string> {
+  const cbResult = captureResult(() => cb());
+  if (cbResult.isFailure()) {
+    let success = false;
+    if (expected instanceof RegExp) {
+      success = cbResult.message.match(expected) !== null;
+    } else if (typeof expected === 'string') {
+      success = cbResult.message === expected;
+    } else if (Array.isArray(expected)) {
+      success = equals(cbResult.message.split('\n'), expected);
+    } else {
+      return fail(`Unsupported expected value "${stringify(expected)}" for toFailTestWith`);
+    }
+    return success ? succeed(cbResult.message) : fail(cbResult.message);
+  }
+  return fail('');
+}

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

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

package/src/matchers/toFailWith/index.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,41 @@
+// 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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,82 @@
+// 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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,17 @@
+// 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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,15 @@
+// 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"
+`;