fix: switch ExpectStatic any types to AsymmetricMatcher<unknown>, with DeeplyAllowMatchers<T> (#7016)

Author: JoshuaKGoldberg

packages/expect/src/types.ts

@@ -9,6 +9,7 @@
 import type { MockInstance } from '@vitest/spy'
 import type { Constructable } from '@vitest/utils'
 import type { Formatter } from 'tinyrainbow'
+import type { AsymmetricMatcher } from './jest-asymmetric-matchers'
 import type { diff, getMatcherUtils, stringify } from './jest-matcher-utils'
 
 export type ChaiPlugin = Chai.ChaiPlugin
@@ -99,8 +100,8 @@ export interface ExpectStatic
   AsymmetricMatchersContaining {
   <T>(actual: T, message?: string): Assertion<T>
   extend: (expects: MatchersObject) => void
-  anything: () => any
-  any: (constructor: unknown) => any
+  anything: () => AsymmetricMatcher<unknown>
+  any: (constructor: unknown) => AsymmetricMatcher<unknown>
   getState: () => MatcherState
   setState: (state: Partial<MatcherState>) => void
   not: AsymmetricMatchersContaining
@@ -146,15 +147,15 @@ export interface AsymmetricMatchersContaining extends CustomMatcher {
    * @example
    * expect({ a: '1', b: 2 }).toEqual(expect.objectContaining({ a: '1' }))
    */
-  objectContaining: <T = any>(expected: T) => any
+  objectContaining: <T = any>(expected: DeeplyAllowMatchers<T>) => any
 
   /**
    * Matches if the received array contains all elements in the expected array.
    *
    * @example
    * expect(['a', 'b', 'c']).toEqual(expect.arrayContaining(['b', 'a']));
    */
-  arrayContaining: <T = unknown>(expected: Array<T>) => any
+  arrayContaining: <T = unknown>(expected: Array<DeeplyAllowMatchers<T>>) => any
 
   /**
    * Matches if the received string or regex matches the expected pattern.
@@ -177,6 +178,14 @@ export interface AsymmetricMatchersContaining extends CustomMatcher {
   closeTo: (expected: number, precision?: number) => any
 }
 
+export type DeeplyAllowMatchers<T> = T extends Array<infer Element>
+  ? (DeeplyAllowMatchers<Element> | Element)[]
+  : T extends object
+    ? {
+        [K in keyof T]: DeeplyAllowMatchers<T[K]> | AsymmetricMatcher<unknown>
+      }
+    : T
+
 export interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
   /**
    * Used when you want to check that two objects have the same value.
@@ -185,15 +194,15 @@ export interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMa
    * @example
    * expect(user).toEqual({ name: 'Alice', age: 30 });
    */
-  toEqual: <E>(expected: E) => void
+  toEqual: <E>(expected: DeeplyAllowMatchers<E>) => void
 
   /**
    * Use to test that objects have the same types as well as structure.
    *
    * @example
    * expect(user).toStrictEqual({ name: 'Alice', age: 30 });
    */
-  toStrictEqual: <E>(expected: E) => void
+  toStrictEqual: <E>(expected: DeeplyAllowMatchers<E>) => void
 
   /**
    * Checks that a value is what you expect. It calls `Object.is` to compare values.
@@ -223,7 +232,7 @@ export interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMa
    *   address: { city: 'Wonderland' }
    * });
    */
-  toMatchObject: <E extends object | any[]>(expected: E) => void
+  toMatchObject: <E extends object | any[]>(expected: DeeplyAllowMatchers<E>) => void
 
   /**
    * Used when you want to check that an item is in a list.

test/core/test/expect.test-d.ts

@@ -0,0 +1,114 @@
+/* eslint-disable no-lone-blocks */
+
+import { expect, test } from 'vitest'
+
+test('expect.* allows asymmetrict mattchers with different types', () => {
+  // types.ts examples: stringContaining
+  expect('I have an apple').toEqual(expect.stringContaining('apple'))
+  expect('I have an apple').toEqual<string>(expect.stringContaining('apple'))
+
+  expect({ a: 'test string' }).toEqual({ a: expect.stringContaining('test') })
+  expect({ a: 'test string' }).toEqual<{ a: string }>({ a: expect.stringContaining('test') })
+
+  // types.ts examples: objectContaining
+  expect({ a: '1', b: 2 }).toEqual(expect.objectContaining({ a: '1' }))
+  expect({ a: '1', b: 2 }).toEqual<{ a: string; b: string }>(expect.objectContaining({ a: '1' }))
+
+  // types.ts examples: arrayContaining
+  expect(['a', 'b', 'c']).toEqual(expect.arrayContaining(['b', 'a']))
+  expect(['a', 'b', 'c']).toEqual<string[]>(expect.arrayContaining(['b', 'a']))
+
+  // types.ts examples: stringMatching
+  expect('hello world').toEqual(expect.stringMatching(/^hello/))
+  expect('hello world').toEqual<string>(expect.stringMatching(/^hello/))
+
+  expect('hello world').toEqual(expect.stringMatching('hello'))
+  expect('hello world').toEqual<string>(expect.stringMatching('hello'))
+
+  // types.ts examples: closeTo
+  expect(10.45).toEqual(expect.closeTo(10.5, 1))
+  expect(10.45).toEqual<number>(expect.closeTo(10.5, 1))
+
+  expect(5.11).toEqual(expect.closeTo(5.12))
+  expect(5.11).toEqual<number>(expect.closeTo(5.12))
+
+  // expect.any(String)
+  // https://github.com/vitest-dev/vitest/pull/7016#issuecomment-2517674066
+  {
+    const obj = {
+      id: '',
+      name: '',
+    }
+
+    expect(obj).toEqual({
+      id: expect.any(String),
+      name: 'Amelia',
+    })
+
+    expect(obj).toEqual<{
+      id: string
+      name: string
+    }>({
+      id: expect.any(String),
+      name: 'Amelia',
+    })
+  }
+
+  // expect.any(Date)
+  // https://github.com/vitest-dev/vitest/issues/4543#issuecomment-1817960296
+  // https://github.com/vitest-dev/vitest/issues/4543#issuecomment-1817967628
+  // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/62831#issue-1418959169
+  {
+    const actual = {} as {
+      foo: string
+      bar: string
+      createdAt: Date
+    }
+
+    expect(actual).toEqual({
+      foo: 'foo',
+      bar: 'bar',
+      createdAt: expect.any(Date),
+    })
+
+    expect(actual).toEqual<{
+      foo: string
+      bar: string
+      createdAt: Date
+    }>({
+      foo: 'foo',
+      bar: 'bar',
+      createdAt: expect.any(Date),
+    })
+
+    expect(actual).toEqual<{
+      foo: string
+      bar: string
+      createdAt: Date
+    }[]>([
+      {
+        foo: 'foo',
+        bar: 'bar',
+        createdAt: expect.any(Date),
+      },
+    ])
+  }
+
+  // expect.arrayContaining
+  // https://github.com/jestjs/jest/issues/13812#issue-1555843276
+  {
+    expect([1, 2, 3]).toEqual(expect.arrayContaining(['a']))
+    expect([1, 2, 3]).toEqual<number[]>(expect.arrayContaining(['a']))
+
+    expect([1, 2, 3]).toEqual(expect.arrayContaining([expect.any(Number)]))
+    expect([1, 2, 3]).toEqual<number[]>(expect.arrayContaining([expect.any(Number)]))
+
+    expect([1, 2, 3]).toEqual(expect.arrayContaining([expect.anything()]))
+    expect([1, 2, 3]).toEqual<number[]>(expect.arrayContaining([expect.anything()]))
+  }
+
+  // expect.any(Array)
+  // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/62831/files#diff-ff7b882e4a29e7fe0e348a6bdf8b11774d606eaa221009b166b01389576d921fR1237
+  expect({ list: [1, 2, 3] }).toMatchObject({ list: expect.any(Array) })
+  expect({ list: [1, 2, 3] }).toMatchObject<{ list: number[] }>({ list: expect.any(Array) })
+})

test/typescript/test-d/vi.test-d.ts renamed to test/core/test/vi.test-d.ts

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "include": ["./**/*.test-d.ts"]
+}

test/core/tsconfig.typecheck.json

@@ -71,6 +71,10 @@ export default defineConfig({
       provider: 'istanbul',
       reporter: ['text', 'html'],
     },
+    typecheck: {
+      enabled: true,
+      tsconfig: './tsconfig.typecheck.json',
+    },
     environmentMatchGlobs: [
       ['**/*.dom.test.ts', 'happy-dom'],
       ['test/env-glob-dom/**', 'jsdom'],