Skip to content

expectTypeOf

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

WARNING

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

not

  • 类型: ExpectTypeOf

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

toEqualTypeOf

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

    该匹配器将检查类型是否完全相同。如果两个对象具有不同的值但类型相同,则此匹配器不会失败。但是,如果对象缺少属性,它将失败。

ts
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()。使用此匹配器,你可以检查对象是否“匹配”类型。

ts
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 来缩小类型以进行进一步测试。

ts
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 从联合中删除类型以进行进一步测试。

ts
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 来提取函数类型的返回值。

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(() => {}).
returns
.
toBeVoid
()
expectTypeOf
((
a
: number) => [
a
,
a
]).
returns
.
toEqualTypeOf
([1, 2])

WARNING

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

parameters

  • 类型: ExpectTypeOf<Parameters>

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

ts
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) 调用提取某个函数参数,以对其执行其他断言。

ts
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>

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(
Date
).
constructorParameters
.
toEqualTypeOf
<
[] | [string | number | Date] >()

WARNING

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

TIP

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

instance

  • 类型: ExpectTypeOf<ConstructableInstance>

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(
Date
).
instance
.
toHaveProperty
('toISOString')

WARNING

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

items

  • 类型: ExpectTypeOf<T>

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
([1, 2, 3]).
items
.
toEqualTypeOf
<number>()
expectTypeOf
([1, 2, 3]).
items
.
not
.
toEqualTypeOf
<string>()

resolves

  • 类型: ExpectTypeOf<ResolvedPromise>

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

ts
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),因此你可以对其执行断言。

ts
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),因此你可以对其执行断言。

ts
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 类型。如果类型太具体,测试将失败。

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
<any>().
toBeAny
()
expectTypeOf
({} as any).
toBeAny
()
expectTypeOf
('string').
not
.
toBeAny
()

toBeUnknown

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
().
toBeUnknown
()
expectTypeOf
({} as unknown).
toBeUnknown
()
expectTypeOf
('string').
not
.
toBeUnknown
()

toBeNever

  • 类型: () => void

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

ts
import { expectTypeOf } from 'vitest'

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

toBeFunction

  • 类型: () => void

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

ts
import { expectTypeOf } from 'vitest'

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

toBeObject

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(42).
not
.
toBeObject
()
expectTypeOf
({}).
toBeObject
()

toBeArray

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(42).
not
.
toBeArray
()
expectTypeOf
([]).
toBeArray
()
expectTypeOf
([1, 2]).
toBeArray
()
expectTypeOf
([{}, 42]).
toBeArray
()

toBeString

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(42).
not
.
toBeString
()
expectTypeOf
('').
toBeString
()
expectTypeOf
('a').
toBeString
()

toBeBoolean

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(42).
not
.
toBeBoolean
()
expectTypeOf
(true).
toBeBoolean
()
expectTypeOf
<boolean>().
toBeBoolean
()

toBeVoid

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(() => {}).
returns
.
toBeVoid
()
expectTypeOf
<void>().
toBeVoid
()

toBeSymbol

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(
Symbol
(1)).
toBeSymbol
()
expectTypeOf
<symbol>().
toBeSymbol
()

toBeNull

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(null).
toBeNull
()
expectTypeOf
<null>().
toBeNull
()
expectTypeOf
(
undefined
).
not
.
toBeNull
()

toBeUndefined

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
(
undefined
).
toBeUndefined
()
expectTypeOf
<undefined>().
toBeUndefined
()
expectTypeOf
(null).
not
.
toBeUndefined
()

toBeNullable

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
expectTypeOf
<1 | undefined>().
toBeNullable
()
expectTypeOf
<1 | null>().
toBeNullable
()
expectTypeOf
<1 | undefined | null>().
toBeNullable
()

toBeCallableWith

  • 类型: () => void

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

ts
import { 
expectTypeOf
} from 'vitest'
type
NoParam
= () => void
type
HasParam
= (
s
: string) => void
expectTypeOf
<
NoParam
>().
toBeCallableWith
()
expectTypeOf
<
HasParam
>().
toBeCallableWith
('some string')

WARNING

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

toBeConstructibleWith

  • 类型: () => void

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

ts
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>

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

ts
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
()

Released under the MIT License.