feat: support BigInt for jest assertions

packages/vitest/src/index.ts

@@ -84,8 +84,8 @@ declare global {
       toContainEqual<E>(item: E): void
       toBeTruthy(): void
       toBeFalsy(): void
-      toBeGreaterThan(num: number): void
-      toBeGreaterThanOrEqual(num: number): void
+      toBeGreaterThan(num: number | bigint): void
+      toBeGreaterThanOrEqual(num: number | bigint): void
       toBeLessThan(num: number): void
       toBeLessThanOrEqual(num: number): void
       toBeNaN(): void

packages/vitest/src/integrations/chai/jest-expect.ts

@@ -2,6 +2,7 @@ import type { EnhancedSpy } from '../jest-mock'
 import { isMockFunction } from '../jest-mock'
 import { addSerializer } from '../snapshot/port/plugins'
 import type { Constructable } from '../../types'
+import { assertTypes } from '../../utils'
 import type { ChaiPlugin, MatcherState } from './types'
 import { arrayBufferEquality, iterableEquality, equals as jestEquals, sparseArrayEquality, subsetEquality, typeEquality } from './jest-utils'
 import type { AsymmetricMatcher } from './jest-asymmetric-matchers'
@@ -160,11 +161,29 @@ export const JestChaiExpect: ChaiPlugin = (chai, utils) => {
       obj,
     )
   })
-  def('toBeGreaterThan', function(expected: number) {
-    return this.to.greaterThan(expected)
+  def('toBeGreaterThan', function(expected: number | bigint) {
+    const actual = this._obj
+    assertTypes(actual, 'actual', ['number', 'bigint'])
+    assertTypes(expected, 'expected', ['number', 'bigint'])
+    return this.assert(
+      actual > expected,
+      `expected ${actual} to be above ${expected}`,
+      `expected ${actual} not to be above ${expected}`,
+      actual,
+      expected,
+    )
   })
   def('toBeGreaterThanOrEqual', function(expected: number) {
-    return this.to.greaterThanOrEqual(expected)
+    const actual = this._obj
+    assertTypes(actual, 'actual', ['number', 'bigint'])
+    assertTypes(expected, 'expected', ['number', 'bigint'])
+    return this.assert(
+      actual >= expected,
+      `expected ${actual} to be above ${expected}`,
+      `expected ${actual} not to be above ${expected}`,
+      actual,
+      expected,
+    )
   })
   def('toBeLessThan', function(expected: number) {
     return this.to.lessThan(expected)

packages/vitest/src/utils/base.ts

@@ -99,3 +99,9 @@ export function deepMerge<T extends object = object, S extends object = T>(targe
 function isMergableObject(item: any): item is Object {
   return isPlainObject(item) && !Array.isArray(item)
 }
+
+export function assertTypes(value: unknown, name: string, types: string[]): void {
+  const receivedType = typeof value
+  const pass = types.includes(receivedType)
+  if (!pass) throw new TypeError(`${name} value must be ${types.join(' or ')}, received "${receivedType}"`)
+}

test/core/test/jest-expect.test.ts

@@ -22,8 +22,19 @@ describe('jest-expect', () => {
     expect([{ text: 'Hello' }]).toContainEqual({ text: 'Hello' })
     expect([{ text: 'Bye' }]).not.toContainEqual({ text: 'Hello' })
     expect(1).toBeGreaterThan(0)
+
+    expect(BigInt(1)).toBeGreaterThan(BigInt(0))
+    expect(1).toBeGreaterThan(BigInt(0))
+    expect(BigInt(1)).toBeGreaterThan(0)
+
     expect(1).toBeGreaterThanOrEqual(1)
     expect(1).toBeGreaterThanOrEqual(0)
+
+    expect(BigInt(1)).toBeGreaterThanOrEqual(BigInt(1))
+    expect(BigInt(1)).toBeGreaterThanOrEqual(BigInt(0))
+    expect(BigInt(1)).toBeGreaterThanOrEqual(1)
+    expect(1).toBeGreaterThanOrEqual(BigInt(1))
+
     expect(0).toBeLessThan(1)
     expect(1).toBeLessThanOrEqual(1)
     expect(0).toBeLessThanOrEqual(1)

test/core/test/utils.spec.ts

@@ -1,7 +1,25 @@
 import { describe, expect, test } from 'vitest'
-import { deepMerge } from '../../../packages/vitest/src/utils'
+import { assertTypes, deepMerge } from '../../../packages/vitest/src/utils'
 import { deepMergeSnapshot } from '../../../packages/vitest/src/integrations/snapshot/port/utils'
 
+describe('assertTypes', () => {
+  test('the type of value should be number', () => {
+    const value = 5
+    const value_string = '5'
+    assertTypes(value, 'value', ['number'])
+    expect(() => assertTypes(value_string, 'value_string', ['number'])).toThrow()
+  })
+
+  test('the type of value should be number or BigInt', () => {
+    const value_number = 5
+    const value_bigint = BigInt(5)
+    const value_string = '5'
+    assertTypes(value_number, 'value_number', ['number', 'bigint'])
+    assertTypes(value_bigint, 'value_bigint', ['number', 'bigint'])
+    expect(() => assertTypes(value_string, 'value_string', ['number', 'bigint'])).toThrow()
+  })
+})
+
 describe('deepMerge', () => {
   test('non plain objects retain their prototype, arrays are not merging, plain objects are merging', () => {
     class Test {