expectTypeOf

类型: <T>(a: unknown) => ExpectTypeOf

WARNING

在运行时，此函数不执行任何操作。要 enable typechecking，不要忘记传递 --typecheck 标志。

not

类型: ExpectTypeOf
你可以使用 .not 属性否定所有断言。

toEqualTypeOf

类型: <T>(expected: T) => void
该匹配器将检查类型是否完全相同。如果两个对象具有不同的值但类型相同，则此匹配器不会失败。但是，如果对象缺少属性，它将失败。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
({ a
: 1 }).toEqualTypeOf
<{ a
: number }>()
expectTypeOf
({ a
: 1 }).toEqualTypeOf
({ a
: 1 })
expectTypeOf
({ a
: 1 }).toEqualTypeOf
({ a
: 2 })
expectTypeOf
({ a
: 1, b
: 1 }).not
.toEqualTypeOf
<{ a
: number }>()

toMatchTypeOf

类型: <T>(expected: T) => void

此匹配器检查期望类型是否扩展了提供的类型。它不同于 toEqual，更类似于 expect's toMatchObject()。使用此匹配器，你可以检查对象是否“匹配”类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
({ a
: 1, b
: 1 }).toMatchTypeOf
({ a
: 1 })
expectTypeOf
<number>().toMatchTypeOf
<string | number>()
expectTypeOf
<string | number>().not
.toMatchTypeOf
<number>()

extract

类型: ExpectTypeOf<ExtractedUnion>

你可以使用 .extract 来缩小类型以进行进一步测试。

import { expectTypeOf
 } from 'vitest'

type ResponsiveProp
<T
> = T
 | T
[] | { xs
?: T
; sm
?: T
; md
?: T
 }

interface CSSProperties {
  margin
?: string
  padding
?: string
}

function getResponsiveProp
<T
>(_props
: T
): ResponsiveProp
<T
> {
  return {}
}

const cssProperties
: CSSProperties = { margin
: '1px', padding
: '2px' }

expectTypeOf
(getResponsiveProp
(cssProperties
))
  .extract
<{ xs
?: any }>() // extracts the last type from a union
  .toEqualTypeOf
<{
    xs
?: CSSProperties
    sm
?: CSSProperties
    md
?: CSSProperties
  }>()

expectTypeOf
(getResponsiveProp
(cssProperties
))
  .extract
<unknown[]>() // extracts an array from a union
  .toEqualTypeOf
<CSSProperties[]>()

WARNING

如果在联合类型中找不到类型，.extract 将返回 never。

exclude

类型: ExpectTypeOf<NonExcludedUnion>

你可以使用 .exclude 从联合中删除类型以进行进一步测试。

import { expectTypeOf } from 'vitest'

type ResponsiveProp<T> = T | T[] | { xs?: T; sm?: T; md?: T }

interface CSSProperties { margin?: string; padding?: string }

function getResponsiveProp<T>(\_props: T): ResponsiveProp<T> {
return {}
}

const cssProperties: CSSProperties = { margin: '1px', padding: '2px' }

expectTypeOf(getResponsiveProp(cssProperties))
.exclude<unknown[]>()
.exclude<{ xs?: unknown }>() // or just .exclude<unknown[] | { xs?: unknown }>()
.toEqualTypeOf<CSSProperties>()

WARNING

如果在联合类型中找不到类型，.extract 将返回 never。

returns

类型: ExpectTypeOf<ReturnValue>

你可以使用 .returns 来提取函数类型的返回值。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(() => {}).returns
.toBeVoid
()
expectTypeOf
((a
: number) => [a
, a
]).returns
.toEqualTypeOf
([1, 2])

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

parameters

类型: ExpectTypeOf<Parameters>

你可以使用 .parameters 提取函数参数以对其值执行断言。参数以数组形式返回。

import { expectTypeOf
 } from 'vitest'

type NoParam
 = () => void
type HasParam
 = (s
: string) => void

expectTypeOf
<NoParam
>().parameters
.toEqualTypeOf
<[]>()
expectTypeOf
<HasParam
>().parameters
.toEqualTypeOf
<[string]>()

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

TIP

你还可以使用 .toBeCallableWith 匹配器作为更具表现力的断言。

parameter

类型: (nth: number) => ExpectTypeOf

你可以使用 .parameter(number) 调用提取某个函数参数，以对其执行其他断言。

import { expectTypeOf
 } from 'vitest'

function foo
(a
: number, b
: string) {
  return [a
, b
]
}

expectTypeOf
(foo
).parameter
(0).toBeNumber
()
expectTypeOf
(foo
).parameter
(1).toBeString
()

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

constructorParameters

类型: ExpectTypeOf<ConstructorParameters>

你可以将构造函数参数提取为数组元素，并使用此方法对它们执行断言。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(Date
).constructorParameters
.toEqualTypeOf
<
  [] | [string | number | Date]
>()

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

TIP

你还可以使用 .toBeConstructibleWith 匹配器作为更具表现力的断言。

instance

类型: ExpectTypeOf<ConstructableInstance>

此属性允许访问可以在所提供类的实例上执行匹配器。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(Date
).instance
.toHaveProperty
('toISOString')

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

items

类型: ExpectTypeOf<T>

你可以使用 .items 获取数组项类型以执行进一步的断言。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
([1, 2, 3]).items
.toEqualTypeOf
<number>()
expectTypeOf
([1, 2, 3]).items
.not
.toEqualTypeOf
<string>()

resolves

类型: ExpectTypeOf<ResolvedPromise>

此匹配器提取 Promise 的已解析值，因此你可以对其执行其他断言。

import { expectTypeOf
 } from 'vitest'

async function asyncFunc
() {
  return 123
}

expectTypeOf
(asyncFunc
).returns
.resolves
.toBeNumber
()
expectTypeOf
(Promise
.resolve
('string')).resolves
.toBeString
()

WARNING

如果用于非承诺类型，它将返回 never，因此你将无法将它与其他匹配器链接起来。

guards

类型: ExpectTypeOf<Guard>

此匹配器提取保护值（例如，v is number），因此你可以对其执行断言。

import { expectTypeOf
 } from 'vitest'

function isString
(v
: any): v
 is string {
  return typeof v
 === 'string'
}

expectTypeOf
(isString
).guards
.toBeString
()

WARNING

如果该值不是保护函数，则返回 never，因此你将无法将它与其他匹配器链接起来。

asserts

类型: ExpectTypeOf<Assert>

此匹配器提取断言值（例如，assert v is number），因此你可以对其执行断言。

import { expectTypeOf
 } from 'vitest'

function assertNumber
(v
: any): asserts v
 is number {
  if (typeof v
 !== 'number')
    throw new TypeError
('Nope !')
}

expectTypeOf
(assertNumber
).asserts
.toBeNumber
()

WARNING

如果该值不是断言函数，则返回 never，因此你将无法将它与其他匹配器链接起来。

toBeAny

类型: () => void

使用此匹配器，你可以检查提供的类型是否为 any 类型。如果类型太具体，测试将失败。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
<any>().toBeAny
()
expectTypeOf
({} as any).toBeAny
()
expectTypeOf
('string').not
.toBeAny
()

toBeUnknown

类型: () => void

此匹配器检查提供的类型是否为 unknown 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
().toBeUnknown
()
expectTypeOf
({} as unknown).toBeUnknown
()
expectTypeOf
('string').not
.toBeUnknown
()

toBeNever

类型: () => void

此匹配器检查提供的类型是否为 never 类型。

import { expectTypeOf } from 'vitest'

expectTypeOf<never>().toBeNever()
expectTypeOf((): never => {}).returns.toBeNever()

toBeFunction

类型: () => void

此匹配器检查提供的类型是否为 function 类型。

import { expectTypeOf } from 'vitest'

expectTypeOf(42).not.toBeFunction()
expectTypeOf((): never => {}).toBeFunction()

toBeObject

类型: () => void

此匹配器检查提供的类型是否为 object 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(42).not
.toBeObject
()
expectTypeOf
({}).toBeObject
()

toBeArray

类型: () => void

此匹配器检查提供的类型是否为 Array<T> 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(42).not
.toBeArray
()
expectTypeOf
([]).toBeArray
()
expectTypeOf
([1, 2]).toBeArray
()
expectTypeOf
([{}, 42]).toBeArray
()

toBeString

类型: () => void

此匹配器检查提供的类型是否为 string 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(42).not
.toBeString
()
expectTypeOf
('').toBeString
()
expectTypeOf
('a').toBeString
()

toBeBoolean

类型: () => void

此匹配器检查提供的类型是否为 boolean 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(42).not
.toBeBoolean
()
expectTypeOf
(true).toBeBoolean
()
expectTypeOf
<boolean>().toBeBoolean
()

toBeVoid

类型: () => void

此匹配器检查提供的类型是否为 void 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(() => {}).returns
.toBeVoid
()
expectTypeOf
<void>().toBeVoid
()

toBeSymbol

类型: () => void

此匹配器检查提供的类型是否为 symbol 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(Symbol
(1)).toBeSymbol
()
expectTypeOf
<symbol>().toBeSymbol
()

toBeNull

类型: () => void

此匹配器检查提供的类型是否为 null 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(null).toBeNull
()
expectTypeOf
<null>().toBeNull
()
expectTypeOf
(undefined
).not
.toBeNull
()

toBeUndefined

类型: () => void

此匹配器检查提供的类型是否为 undefined 类型。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(undefined
).toBeUndefined
()
expectTypeOf
<undefined>().toBeUndefined
()
expectTypeOf
(null).not
.toBeUndefined
()

toBeNullable

类型: () => void

此匹配器会检查你是否可以对提供的类型使用 null 或 undefined。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
<1 | undefined>().toBeNullable
()
expectTypeOf
<1 | null>().toBeNullable
()
expectTypeOf
<1 | undefined | null>().toBeNullable
()

toBeCallableWith

类型: () => void

此匹配器确保你可以使用一组参数作为参数来调用函数。

import { expectTypeOf
 } from 'vitest'

type NoParam
 = () => void
type HasParam
 = (s
: string) => void

expectTypeOf
<NoParam
>().toBeCallableWith
()
expectTypeOf
<HasParam
>().toBeCallableWith
('some string')

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

toBeConstructibleWith

类型: () => void

此匹配器确保你可以使用一组构造函数作为参数创建一个新实例。

import { expectTypeOf
 } from 'vitest'

expectTypeOf
(Date
).toBeConstructibleWith
(new Date
())
expectTypeOf
(Date
).toBeConstructibleWith
('01-01-2000')

WARNING

如果用在非函数类型上，它将返回 never，因此你将无法将它与其他匹配器链接起来。

toHaveProperty

类型: <K extends keyof T>(property: K) => ExpectTypeOf<T[K>

此匹配器检查提供的对象上是否存在属性。如果它存在，它还会为该属性的类型返回同一组匹配器，因此你可以一个接一个地链接断言。

import { expectTypeOf
 } from 'vitest'

const obj
 = { a
: 1, b
: '' }

expectTypeOf
(obj
).toHaveProperty
('a')
expectTypeOf
(obj
).not
.toHaveProperty
('c')

expectTypeOf
(obj
).toHaveProperty
('a').toBeNumber
()
expectTypeOf
(obj
).toHaveProperty
('b').toBeString
()
expectTypeOf
(obj
).toHaveProperty
('a').not
.toBeString
()

expectTypeOf ​

not ​

toEqualTypeOf ​

toMatchTypeOf ​

extract ​

exclude ​

returns ​

parameters ​

parameter ​

constructorParameters ​

instance ​

items ​

resolves ​

guards ​

asserts ​

toBeAny ​

toBeUnknown ​

toBeNever ​

toBeFunction ​

toBeObject ​

toBeArray ​

toBeString ​

toBeBoolean ​

toBeVoid ​

toBeSymbol ​

toBeNull ​

toBeUndefined ​

toBeNullable ​

toBeCallableWith ​

toBeConstructibleWith ​

toHaveProperty ​

expectTypeOf

not

toEqualTypeOf

toMatchTypeOf

extract

exclude

returns

parameters

parameter

constructorParameters

instance

items

resolves

guards

asserts

toBeAny

toBeUnknown

toBeNever

toBeFunction

toBeObject

toBeArray

toBeString

toBeBoolean

toBeVoid

toBeSymbol

toBeNull

toBeUndefined

toBeNullable

toBeCallableWith

toBeConstructibleWith

toHaveProperty