feat: Add BigInt support to number matchers (closes #591)

.changeset/better-lights-lay.md

@@ -0,0 +1,6 @@
+---
+'jest-extended': major
+---
+
+Add BigInt support to number matchers
+and add new toBeBigInt matchers

all.js

@@ -1,4 +1,3 @@
 // override rule to allow running linting before build (dist directory won't exist yet)
 
-// eslint-disable-next-line import/no-unresolved
 require('./dist/all');

src/matchers/index.ts

@@ -7,6 +7,7 @@ export { toBeArrayOfSize } from './toBeArrayOfSize';
 export { toBeBefore } from './toBeBefore';
 export { toBeBeforeOrEqualTo } from './toBeBeforeOrEqualTo';
 export { toBeBetween } from './toBeBetween';
+export { toBeBigInt } from './toBeBigInt';
 export { toBeBoolean } from './toBeBoolean';
 export { toBeDate } from './toBeDate';
 export { toBeDateString } from './toBeDateString';

src/matchers/toBeBigInt.ts

@@ -0,0 +1,20 @@
+export function toBeBigInt(actual: unknown) {
+  // @ts-expect-error OK to have implicit any for this.utils
+  const { printReceived, matcherHint } = this.utils;
+
+  const pass = typeof actual === 'bigint';
+
+  return {
+    pass,
+    message: () =>
+      pass
+        ? matcherHint('.not.toBeBigInt', 'received', '') +
+          '\n\n' +
+          'Expected value to not be an BigInt received:\n' +
+          `  ${printReceived(actual)}`
+        : matcherHint('.toBeBigInt', 'received', '') +
+          '\n\n' +
+          'Expected value to be a BigInt received:\n' +
+          `  ${printReceived(actual)}`,
+  };
+}

src/matchers/toBeEven.ts

@@ -2,7 +2,9 @@ export function toBeEven(actual: unknown) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, matcherHint } = this.utils;
 
-  const pass = isNumber(actual) && isEven(actual);
+  const pass =
+    (typeof actual === 'number' && !isNaN(actual) && actual % 2 === 0) ||
+    (typeof actual === 'bigint' && actual % BigInt(2) === BigInt(0));
 
   return {
     pass,
@@ -18,6 +20,3 @@ export function toBeEven(actual: unknown) {
           ` ${printReceived(actual)}`,
   };
 }
-
-const isNumber = (expected: any) => !isNaN(parseInt(expected));
-const isEven = (expected: any) => expected % 2 === 0;

src/matchers/toBeFinite.ts

@@ -2,7 +2,7 @@ export function toBeFinite(actual: unknown) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, matcherHint } = this.utils;
 
-  const pass = Number.isFinite(actual);
+  const pass = Number.isFinite(actual) || typeof actual === 'bigint';
 
   return {
     pass,

src/matchers/toBeInRange.ts

@@ -1,8 +1,13 @@
-export function toBeInRange(actual: unknown[], min: number, max: number) {
+export function toBeInRange(actual: unknown[], min: number | bigint, max: number | bigint) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, printExpected, matcherHint } = this.utils;
 
-  const element = actual.find((option: any) => option < min || option >= max);
+  const element = actual.find((option: any) => {
+    if (typeof option === 'bigint' && typeof min === 'bigint' && typeof max === 'bigint') {
+      return option < min || option >= max;
+    }
+    return option < min || option >= max;
+  });
 
   const pass = element === undefined;
 

src/matchers/toBeNegative.ts

@@ -2,7 +2,8 @@ export function toBeNegative(actual: unknown) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, matcherHint } = this.utils;
 
-  const pass = isNumber(actual) && isNegative(actual);
+  const pass =
+    (typeof actual === 'number' && !isNaN(actual) && actual < 0) || (typeof actual === 'bigint' && actual < BigInt(0));
 
   return {
     pass,
@@ -18,6 +19,3 @@ export function toBeNegative(actual: unknown) {
           `  ${printReceived(actual)}`,
   };
 }
-
-const isNumber = (value: any) => !isNaN(parseInt(value));
-const isNegative = (value: any) => value < 0;

src/matchers/toBeOdd.ts

@@ -2,7 +2,7 @@ export function toBeOdd(actual: unknown) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, matcherHint } = this.utils;
 
-  const pass = isNumber(actual) && isOdd(actual);
+  const pass = (isNumber(actual) || isBigInt(actual)) && isOdd(actual);
 
   return {
     pass,
@@ -19,5 +19,9 @@ export function toBeOdd(actual: unknown) {
   };
 }
 
-const isNumber = (expected: any) => !isNaN(parseInt(expected));
-const isOdd = (expected: any) => expected % 2 === 1;
+const isNumber = (expected: any) => typeof expected === 'number' && Number.isFinite(expected);
+const isBigInt = (expected: any) => typeof expected === 'bigint';
+const isOdd = (expected: any) => {
+  if (isBigInt(expected)) return expected % 2n === 1n || expected % 2n === -1n;
+  return Math.abs(expected % 2) === 1;
+};

src/matchers/toBePositive.ts

@@ -2,7 +2,7 @@ export function toBePositive(actual: unknown) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived, matcherHint } = this.utils;
 
-  const pass = isNumber(actual) && isPositive(actual);
+  const pass = (isNumber(actual) || isBigInt(actual)) && isPositive(actual);
 
   return {
     pass,
@@ -19,5 +19,9 @@ export function toBePositive(actual: unknown) {
   };
 }
 
-const isNumber = (value: any) => !isNaN(parseInt(value));
-const isPositive = (value: any) => value > 0;
+const isNumber = (value: any) => typeof value === 'number' && !isNaN(value) && isFinite(value);
+const isBigInt = (value: any) => typeof value === 'bigint';
+const isPositive = (value: any) => {
+  if (typeof value === 'bigint') return value > 0n;
+  return value > 0;
+};

src/matchers/toChangeBy.ts

@@ -1,13 +1,20 @@
 /**
  * Use `.toChangeBy` when checking if a value changed by an amount.
  */
-export function toChangeBy(mutator: () => unknown | void, checker: () => number, by: number = 1) {
+export function toChangeBy(mutator: () => unknown | void, checker: () => number | bigint, by: number | bigint = 1) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived: print, matcherHint: hint } = this.utils;
 
   const before = checker();
   mutator();
-  const received = checker() - before;
+  const after = checker();
+
+  let received;
+  if (typeof before === 'bigint' && typeof after === 'bigint') {
+    received = after - before;
+  } else {
+    received = Number(after) - Number(before);
+  }
 
   const passMessage = `
 ${hint('.not.toChangeBy', 'received', '')}\n\nExpected value to not change by ${by}, received:\n  ${print(received)}

src/matchers/toChangeTo.ts

@@ -1,7 +1,7 @@
 /**
  * Use `.toChangeTo` when checking if a value changed to a specific value.
  */
-export function toChangeTo(mutator: () => unknown | void, checker: () => number, to: number) {
+export function toChangeTo<E = unknown>(mutator: () => unknown | void, checker: () => E, to: E) {
   // @ts-expect-error OK to have implicit any for this.utils
   const { printReceived: print, matcherHint: hint } = this.utils;
 

test/matchers/__snapshots__/toBeBigInt.test.ts.snap

@@ -0,0 +1,22 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`.not.toBeInteger fails when given integer 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBeBigInt()</intensity>
+
+Expected value to not be an BigInt received:
+  <red>1n</color>"
+`;
+
+exports[`.toBeBigInt fails when given fraction 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeBigInt()</intensity>
+
+Expected value to be a BigInt received:
+  <red>1.5</color>"
+`;
+
+exports[`.toBeBigInt fails when given integer 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeBigInt()</intensity>
+
+Expected value to be a BigInt received:
+  <red>1</color>"
+`;

test/matchers/__snapshots__/toBeEven.test.ts.snap

@@ -1,12 +1,33 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`.not.toBeEven fails when given an even BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBeEven()</intensity>
+
+Expected value to not be an even number received:
+ <red>2n</color>"
+`;
+
 exports[`.not.toBeEven fails when given an even number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toBeEven()</intensity>
 
 Expected value to not be an even number received:
  <red>2</color>"
 `;
 
+exports[`.toBeEven fails when given odd BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeEven()</intensity>
+
+Expected value to be an even number received:
+ <red>1n</color>"
+`;
+
+exports[`.toBeEven fails when given odd BigInt 2`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeEven()</intensity>
+
+Expected value to be an even number received:
+ <red>-3n</color>"
+`;
+
 exports[`.toBeEven fails when not given an even number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeEven()</intensity>
 

test/matchers/__snapshots__/toBeFinite.test.ts.snap

@@ -1,5 +1,12 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`.not.toBeFinite fails when given a BigInt value 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBeFinite()</intensity>
+
+Expected value to not be finite received:
+  <red>1n</color>"
+`;
+
 exports[`.not.toBeFinite fails when given a finite number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toBeFinite()</intensity>
 

test/matchers/__snapshots__/toBeInRange.test.ts.snap

@@ -1,5 +1,13 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`.not.toBeInRange fails when given BigInt array is in the given range 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBeInRange(</intensity><green>expected</color><dim>)</intensity>
+
+Expected Array to not be in range <green>4n</color>, <green>10n</color>
+Received:
+  <red>[4n, 5n, 7n, 9n]</color>"
+`;
+
 exports[`.not.toBeInRange fails when given array is in the given range 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toBeInRange(</intensity><green>expected</color><dim>)</intensity>
 
@@ -8,6 +16,13 @@ Received:
   <red>[4, 5, 7, 9]</color>"
 `;
 
+exports[`.toBeInRange fails when given BigInt array is not in a given range 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeInRange(</intensity><green>expected</color><dim>)</intensity>
+
+Expected: Array elements to be in range (<green>4n</color>, <green>8n</color>)
+Received: Array element out of range <red>9n</color>"
+`;
+
 exports[`.toBeInRange fails when given array is not in a given range 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeInRange(</intensity><green>expected</color><dim>)</intensity>
 

test/matchers/__snapshots__/toBeNegative.test.ts.snap

@@ -1,5 +1,12 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`.not.toBeNegative fails when given negative BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBeNegative()</intensity>
+
+Expected value to not be a negative number received:
+  <red>-1n</color>"
+`;
+
 exports[`.not.toBeNegative fails when given negative number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toBeNegative()</intensity>
 
@@ -14,9 +21,23 @@ Expected value to be a negative number received:
   <red>Infinity</color>"
 `;
 
+exports[`.toBeNegative fails when given positive BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeNegative()</intensity>
+
+Expected value to be a negative number received:
+  <red>1n</color>"
+`;
+
 exports[`.toBeNegative fails when given positive number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeNegative()</intensity>
 
 Expected value to be a negative number received:
   <red>1</color>"
 `;
+
+exports[`.toBeNegative fails when given zero BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeNegative()</intensity>
+
+Expected value to be a negative number received:
+  <red>0n</color>"
+`;

test/matchers/__snapshots__/toBeOdd.test.ts.snap

@@ -39,33 +39,47 @@ exports[`.toBeOdd fails when given not given an odd number 5`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
 
 Expected value to be odd received:
-  <red>{}</color>"
+  <red>2n</color>"
 `;
 
 exports[`.toBeOdd fails when given not given an odd number 6`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
 
 Expected value to be odd received:
-  <red>[Function anonymous]</color>"
+  <red>{}</color>"
 `;
 
 exports[`.toBeOdd fails when given not given an odd number 7`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
 
 Expected value to be odd received:
-  <red>undefined</color>"
+  <red>[Function anonymous]</color>"
 `;
 
 exports[`.toBeOdd fails when given not given an odd number 8`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
 
 Expected value to be odd received:
-  <red>null</color>"
+  <red>undefined</color>"
 `;
 
 exports[`.toBeOdd fails when given not given an odd number 9`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
 
+Expected value to be odd received:
+  <red>null</color>"
+`;
+
+exports[`.toBeOdd fails when given not given an odd number 10`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
+
 Expected value to be odd received:
   <red>NaN</color>"
 `;
+
+exports[`.toBeOdd fails when given not given an odd number 11`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBeOdd()</intensity>
+
+Expected value to be odd received:
+  <red>Symbol(foo)</color>"
+`;

test/matchers/__snapshots__/toBePositive.test.ts.snap

@@ -1,12 +1,26 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`.not.toBePositive fails when given a positive BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).not.toBePositive()</intensity>
+
+Expected value to not be positive received:
+  <red>5n</color>"
+`;
+
 exports[`.not.toBePositive fails when given a positive number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toBePositive()</intensity>
 
 Expected value to not be positive received:
   <red>5</color>"
 `;
 
+exports[`.toBePositive fails when not given a positive BigInt 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toBePositive()</intensity>
+
+Expected value to be positive received:
+  <red>-1n</color>"
+`;
+
 exports[`.toBePositive fails when not given a positive number 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toBePositive()</intensity>