feat: BigInt Support

.eslintrc.js

@@ -26,7 +26,11 @@ module.exports = {
         ],
         'import/order': 'error',
         'no-dupe-class-members': 'off',
+        // ts handles this check for us, also eslint does not include Bigint
+        'no-undef': 'off',
         'no-unused-vars': 'off',
+        // ts handles this check for us, also eslint does not include bigint
+        'valid-typeof': 'off',
       },
     },
     // to make it more suitable for running on code examples in docs/ folder

CHANGELOG.md

@@ -11,6 +11,11 @@
 - `[expect]` Improve report when matcher fails, part 17 ([#8349](https://github.com/facebook/jest/pull/8349))
 - `[expect]` Improve report when matcher fails, part 18 ([#8356](https://github.com/facebook/jest/pull/8356))
 - `[expect]` Improve report when matcher fails, part 19 ([#8367](https://github.com/facebook/jest/pull/8367))
+- `[expect]` Add BigInt Support to `toBeGreaterThan`, `toBeGreaterThanOrEqual`, `toBeLessThan` and `toBeLessThanOrEqual` ([#8382](https://github.com/facebook/jest/pull/8382))
+- `[jest-get-type]` Add BigInt Support. ([#8382](https://github.com/facebook/jest/pull/8382))
+- `[jest-matcher-utils]`- Add BigInt Support to `ensureNumbers` `ensureActualIsNumber`, `ensureExpectedIsNumber` ([#8382](https://github.com/facebook/jest/pull/8382))
+- `[babel-plugin-jest-hoist]` Add BigInt to `WHITELISTED_IDENTIFIERS`([#8382](https://github.com/facebook/jest/pull/8382))
+- `[babel-preset-jest]` Add @babel/plugin-syntax-bigint`([#8382](https://github.com/facebook/jest/pull/8382))
 
 ### Fixes
 
@@ -31,6 +36,7 @@
 - `[@jest/reporters]` Migrate away from `istanbul-api` ([#8294](https://github.com/facebook/jest/pull/8294))
 - `[*]` Delete obsolete emails tag from header comment in test files ([#8377](https://github.com/facebook/jest/pull/8377))
 - `[expect]` optimize compare nodes ([#8368](https://github.com/facebook/jest/pull/8368))
+- `[eslintrc]` Disable valid-typeof, no-undef for ts overrides ([#8382](https://github.com/facebook/jest/pull/8382))
 
 ### Performance
 

packages/babel-plugin-jest-hoist/src/index.ts

@@ -25,6 +25,7 @@ const WHITELISTED_IDENTIFIERS: Set<string> = new Set([
   'Array',
   'ArrayBuffer',
   'Boolean',
+  'BigInt',
   'DataView',
   'Date',
   'Error',

packages/babel-preset-jest/index.js

@@ -9,5 +9,6 @@ module.exports = () => ({
   plugins: [
     require.resolve('babel-plugin-jest-hoist'),
     require.resolve('@babel/plugin-syntax-object-rest-spread'),
+    require.resolve('@babel/plugin-syntax-bigint'),
   ],
 });

packages/babel-preset-jest/package.json

@@ -9,6 +9,7 @@
   "license": "MIT",
   "main": "index.js",
   "dependencies": {
+    "@babel/plugin-syntax-bigint": "^7.0.0",
     "@babel/plugin-syntax-object-rest-spread": "^7.0.0",
     "babel-plugin-jest-hoist": "^24.6.0"
   },

packages/expect/src/__tests__/matchers.test.js

@@ -20,6 +20,9 @@ afterAll(() => {
   chalk.enabled = chalkEnabled;
 });
 
+/* global BigInt */
+const isBigIntDefined = typeof BigInt === 'function';
+
 it('should throw if passed two arguments', () => {
   expect(() => jestExpect('foo', 'bar')).toThrow(
     new Error('Expect takes at most one argument.'),
@@ -198,6 +201,11 @@ describe('.toBe()', () => {
     jestExpect(null).toBe(null);
     jestExpect(undefined).toBe(undefined);
     jestExpect(NaN).toBe(NaN);
+    if (isBigIntDefined) {
+      jestExpect(BigInt(1)).not.toBe(BigInt(2));
+      jestExpect(BigInt(1)).not.toBe(1);
+      jestExpect(BigInt(1)).toBe(BigInt(1));
+    }
   });
 
   [
@@ -226,12 +234,30 @@ describe('.toBe()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [[BigInt(1), BigInt(2)], [{a: BigInt(1)}, {a: BigInt(1)}]].forEach(
+      ([a, b]) => {
+        it(`fails for: ${stringify(a)} and ${stringify(b)}`, () => {
+          expect(() => jestExpect(a).toBe(b)).toThrowError('toBe');
+        });
+      },
+    );
+  }
+
   [false, 1, 'a', undefined, null, {}, []].forEach(v => {
     it(`fails for '${stringify(v)}' with '.not'`, () => {
       expect(() => jestExpect(v).not.toBe(v)).toThrowErrorMatchingSnapshot();
     });
   });
 
+  if (isBigIntDefined) {
+    [BigInt(1), BigInt('1')].forEach(v => {
+      it(`fails for '${stringify(v)}' with '.not'`, () => {
+        expect(() => jestExpect(v).not.toBe(v)).toThrowError('toBe');
+      });
+    });
+  }
+
   it('does not crash on circular references', () => {
     const obj = {};
     obj.circular = obj;
@@ -446,6 +472,17 @@ describe('.toEqual()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [[BigInt(1), BigInt(2)], [BigInt(1), 1]].forEach(([a, b]) => {
+      test(`{pass: false} expect(${stringify(a)}).toEqual(${stringify(
+        b,
+      )})`, () => {
+        expect(() => jestExpect(a).toEqual(b)).toThrowError('toEqual');
+        jestExpect(a).not.toEqual(b);
+      });
+    });
+  }
+
   [
     [true, true],
     [1, 1],
@@ -577,6 +614,25 @@ describe('.toEqual()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [
+      [BigInt(1), BigInt(1)],
+      [BigInt(0), BigInt('0')],
+      [[BigInt(1)], [BigInt(1)]],
+      [[BigInt(1), 2], [BigInt(1), 2]],
+      [Immutable.List([BigInt(1)]), Immutable.List([BigInt(1)])],
+      [{a: BigInt(99)}, {a: BigInt(99)}],
+      [new Set([BigInt(1), BigInt(2)]), new Set([BigInt(1), BigInt(2)])],
+    ].forEach(([a, b]) => {
+      test(`{pass: true} expect(${stringify(a)}).not.toEqual(${stringify(
+        b,
+      )})`, () => {
+        jestExpect(a).toEqual(b);
+        expect(() => jestExpect(a).not.toEqual(b)).toThrowError('toEqual');
+      });
+    });
+  }
+
   test('assertion error matcherResult property contains matcher name, expected and actual values', () => {
     const actual = {a: 1};
     const expected = {a: 2};
@@ -769,6 +825,19 @@ describe('.toBeTruthy(), .toBeFalsy()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [BigInt(1)].forEach(v => {
+      test(`'${stringify(v)}' is truthy`, () => {
+        jestExpect(v).toBeTruthy();
+        jestExpect(v).not.toBeFalsy();
+
+        expect(() => jestExpect(v).not.toBeTruthy()).toThrowError('toBeTruthy');
+
+        expect(() => jestExpect(v).toBeFalsy()).toThrowError('toBeFalsy');
+      });
+    });
+  }
+
   [false, null, NaN, 0, '', undefined].forEach(v => {
     test(`'${stringify(v)}' is falsy`, () => {
       jestExpect(v).toBeFalsy();
@@ -781,6 +850,19 @@ describe('.toBeTruthy(), .toBeFalsy()', () => {
       ).toThrowErrorMatchingSnapshot();
     });
   });
+
+  if (isBigIntDefined) {
+    [BigInt(0)].forEach(v => {
+      test(`'${stringify(v)}' is falsy`, () => {
+        jestExpect(v).toBeFalsy();
+        jestExpect(v).not.toBeTruthy();
+
+        expect(() => jestExpect(v).toBeTruthy()).toThrowError('toBeTruthy');
+
+        expect(() => jestExpect(v).not.toBeFalsy()).toThrowError('toBeFalsy');
+      });
+    });
+  }
 });
 
 describe('.toBeNaN()', () => {
@@ -837,6 +919,23 @@ describe('.toBeDefined(), .toBeUndefined()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [BigInt(1)].forEach(v => {
+      test(`'${stringify(v)}' is defined`, () => {
+        jestExpect(v).toBeDefined();
+        jestExpect(v).not.toBeUndefined();
+
+        expect(() => jestExpect(v).not.toBeDefined()).toThrowError(
+          'toBeDefined',
+        );
+
+        expect(() => jestExpect(v).toBeUndefined()).toThrowError(
+          'toBeUndefined',
+        );
+      });
+    });
+  }
+
   test('undefined is undefined', () => {
     jestExpect(undefined).toBeUndefined();
     jestExpect(undefined).not.toBeDefined();
@@ -931,6 +1030,105 @@ describe(
       });
     });
 
+    if (isBigIntDefined) {
+      test('can compare BigInt to Numbers', () => {
+        const a = BigInt(2);
+        jestExpect(a).toBeGreaterThan(1);
+        jestExpect(a).toBeGreaterThanOrEqual(2);
+        jestExpect(2).toBeLessThanOrEqual(a);
+        jestExpect(a).toBeLessThan(3);
+        jestExpect(a).toBeLessThanOrEqual(2);
+      });
+
+      [
+        [BigInt(1), BigInt(2)],
+        [BigInt(0x11), BigInt(0x22)],
+        [-1, BigInt(2)],
+      ].forEach(([small, big]) => {
+        it(`{pass: true} expect(${stringify(small)}).toBeLessThan(${stringify(
+          big,
+        )})`, () => {
+          jestExpect(small).toBeLessThan(big);
+        });
+
+        it(`{pass: false} expect(${stringify(big)}).toBeLessThan(${stringify(
+          small,
+        )})`, () => {
+          jestExpect(big).not.toBeLessThan(small);
+        });
+
+        it(`{pass: true} expect(${stringify(big)}).toBeGreaterThan(${stringify(
+          small,
+        )})`, () => {
+          jestExpect(big).toBeGreaterThan(small);
+        });
+
+        it(`{pass: false} expect(${stringify(
+          small,
+        )}).toBeGreaterThan(${stringify(big)})`, () => {
+          jestExpect(small).not.toBeGreaterThan(big);
+        });
+
+        it(`{pass: true} expect(${stringify(
+          small,
+        )}).toBeLessThanOrEqual(${stringify(big)})`, () => {
+          jestExpect(small).toBeLessThanOrEqual(big);
+        });
+
+        it(`{pass: false} expect(${stringify(
+          big,
+        )}).toBeLessThanOrEqual(${stringify(small)})`, () => {
+          jestExpect(big).not.toBeLessThanOrEqual(small);
+        });
+
+        it(`{pass: true} expect(${stringify(
+          big,
+        )}).toBeGreaterThanOrEqual(${stringify(small)})`, () => {
+          jestExpect(big).toBeGreaterThanOrEqual(small);
+        });
+
+        it(`{pass: false} expect(${stringify(
+          small,
+        )}).toBeGreaterThanOrEqual(${stringify(big)})`, () => {
+          jestExpect(small).not.toBeGreaterThanOrEqual(big);
+        });
+
+        it(`throws: [${stringify(small)}, ${stringify(big)}]`, () => {
+          expect(() => jestExpect(small).toBeGreaterThan(big)).toThrowError(
+            'toBeGreaterThan',
+          );
+
+          expect(() => jestExpect(small).not.toBeLessThan(big)).toThrowError(
+            'toBeLessThan',
+          );
+
+          expect(() => jestExpect(big).not.toBeGreaterThan(small)).toThrowError(
+            'toBeGreaterThan',
+          );
+
+          expect(() => jestExpect(big).toBeLessThan(small)).toThrowError(
+            'toBeLessThan',
+          );
+
+          expect(() =>
+            jestExpect(small).toBeGreaterThanOrEqual(big),
+          ).toThrowError('toBeGreaterThanOrEqual');
+
+          expect(() =>
+            jestExpect(small).not.toBeLessThanOrEqual(big),
+          ).toThrowError('toBeLessThanOrEqual');
+
+          expect(() =>
+            jestExpect(big).not.toBeGreaterThanOrEqual(small),
+          ).toThrowError('toBeGreaterThanOrEqual');
+
+          expect(() => jestExpect(big).toBeLessThanOrEqual(small)).toThrowError(
+            'toBeLessThanOrEqual',
+          );
+        });
+      });
+    }
+
     [
       [1, 1],
       [Number.MIN_VALUE, Number.MIN_VALUE],
@@ -951,6 +1149,26 @@ describe(
         ).toThrowErrorMatchingSnapshot();
       });
     });
+
+    if (isBigIntDefined) {
+      [
+        [BigInt(1), BigInt(1)],
+        [BigInt(Number.MAX_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER)],
+      ].forEach(([n1, n2]) => {
+        test(`equal numbers: [${n1}, ${n2}]`, () => {
+          jestExpect(n1).toBeGreaterThanOrEqual(n2);
+          jestExpect(n1).toBeLessThanOrEqual(n2);
+
+          expect(() =>
+            jestExpect(n1).not.toBeGreaterThanOrEqual(n2),
+          ).toThrowError('toBeGreaterThanOrEqual');
+
+          expect(() => jestExpect(n1).not.toBeLessThanOrEqual(n2)).toThrowError(
+            'toBeLessThanOrEqual',
+          );
+        });
+      });
+    }
   },
 );
 
@@ -1000,6 +1218,21 @@ describe('.toContain(), .toContainEqual()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [
+      [[BigInt(1), BigInt(2), BigInt(3), BigInt(4)], BigInt(1)],
+      [[1, 2, 3, BigInt(3), 4], BigInt(3)],
+    ].forEach(([list, v]) => {
+      it(`'${stringify(list)}' contains '${stringify(v)}'`, () => {
+        jestExpect(list).toContain(v);
+
+        expect(() => jestExpect(list).not.toContain(v)).toThrowError(
+          'toContain',
+        );
+      });
+    });
+  }
+
   [
     [[1, 2, 3], 4],
     [[null, undefined], 1],
@@ -1015,6 +1248,16 @@ describe('.toContain(), .toContainEqual()', () => {
     });
   });
 
+  if (isBigIntDefined) {
+    [[[BigInt(1), BigInt(2), BigInt(3)], 3]].forEach(([list, v]) => {
+      it(`'${stringify(list)}' does not contain '${stringify(v)}'`, () => {
+        jestExpect(list).not.toContain(v);
+
+        expect(() => jestExpect(list).toContain(v)).toThrowError('toContain');
+      });
+    });
+  }
+
   test('error cases', () => {
     expect(() => jestExpect(null).toContain(1)).toThrowErrorMatchingSnapshot();
   });