expectTypeOf

Tipo: <T>(a: unknown) => ExpectTypeOf

not

Tipo: ExpectTypeOf

Você pode negar todas as asserções usando a propriedade .not.

toEqualTypeOf

Tipo: <T>(expected: T) => void

Este matcher verifica se os tipos são estritamente iguais. Ele não falhará se dois objetos tiverem valores diferentes, mas do mesmo tipo. No entanto, falhará se um objeto não tiver uma propriedade.

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

Tipo: <T>(expected: T) => void

Este matcher verifica se o tipo do valor testado estende o tipo fornecido. É diferente de toEqualTypeOf e mais semelhante ao toMatchObject() de expect. Com este matcher, você pode verificar se um objeto corresponde a um tipo.

import { expectTypeOf } from 'vitest';

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

extract

Tipo: ExpectTypeOf<ExtractedUnion>

Você pode usar .extract para restringir os tipos em testes adicionais.

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 }>() // extrai o último tipo de uma união
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // extrai um array de uma união
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Se nenhum tipo for encontrado na união de tipos, .extract retornará never.

exclude

Tipo: ExpectTypeOf<NonExcludedUnion>

Você pode usar .exclude para remover tipos de uma união em testes adicionais.

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

Se nenhum tipo for encontrado na união de tipos, .exclude retornará never.

returns

Tipo: ExpectTypeOf<ReturnValue>

Você pode usar .returns para extrair o tipo de retorno de uma função.

import { expectTypeOf } from 'vitest';

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

WARNING

Se usado em um tipo que não é uma função, ele retornará never, então você não poderá encadear com outros matchers.

parameters

Tipo: ExpectTypeOf<Parameters>

Você pode extrair os tipos dos parâmetros de uma função com .parameters para realizar asserções sobre eles. Os parâmetros são retornados como um array.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Se usado em um tipo que não é uma função, ele retornará never, então você não poderá encadear com outros matchers.

TIP

Você também pode usar o matcher .toBeCallableWith como uma asserção mais expressiva.

parameter

Tipo: (nth: number) => ExpectTypeOf

Você pode extrair o tipo de um argumento específico de uma função com .parameter(number) para realizar outras asserções sobre ele.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Se usado em um tipo que não é uma função, ele retornará never, então você não poderá encadear com outros matchers.

constructorParameters

Tipo: ExpectTypeOf<ConstructorParameters>

Você pode extrair os tipos dos parâmetros do construtor como um array e realizar asserções sobre eles com este método.

import { expectTypeOf } from 'vitest';

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

WARNING

Se usado em um tipo que não é um construtor, ele retornará never, então você não poderá encadear com outros matchers.

TIP

Você também pode usar o matcher .toBeConstructibleWith como uma asserção mais expressiva.

instance

Tipo: ExpectTypeOf<ConstructableInstance>

Esta propriedade dá acesso a matchers que podem ser executados em uma instância da classe fornecida.

import { expectTypeOf } from 'vitest';

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

WARNING

Se usado em um tipo que não é um construtor, ele retornará never, então você não poderá encadear com outros matchers.

items

Tipo: ExpectTypeOf<T>

Você pode obter o tipo dos itens de um array com .items para realizar asserções adicionais.

import { expectTypeOf } from 'vitest';

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

resolves

Tipo: ExpectTypeOf<ResolvedPromise>

Este matcher extrai o tipo do valor resolvido de uma Promise, para que você possa realizar outras asserções sobre ele.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Se usado em um tipo que não é uma Promise, ele retornará never, então você não poderá encadear com outros matchers.

guards

Tipo: ExpectTypeOf<Guard>

Este matcher extrai o tipo de guarda (por exemplo, v is number), para que você possa realizar asserções sobre ele.

import { expectTypeOf } from 'vitest';

function isString(v: any): v is string {
  return typeof v === 'string';
}
expectTypeOf(isString).guards.toBeString();

WARNING

Retorna never se o valor não for uma função de guarda, então você não poderá encadear com outros matchers.

asserts

Tipo: ExpectTypeOf<Assert>

Este matcher extrai o tipo de assert (por exemplo, assert v is number), para que você possa realizar asserções sobre ele.

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

Retorna never se o valor não for uma função de assert, então você não poderá encadear com outros matchers.

toBeAny

Tipo: () => void

Com este matcher você pode verificar se o tipo fornecido é do tipo any. Se o tipo for mais específico, o teste falhará.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Tipo: () => void

Este matcher verifica se o tipo fornecido é o tipo unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Tipo: () => void

Este matcher verifica se o tipo fornecido é um tipo never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Tipo: () => void

Este matcher verifica se o tipo fornecido é uma function.

import { expectTypeOf } from 'vitest';

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

toBeObject

Tipo: () => void

Este matcher verifica se o tipo fornecido é um object.

import { expectTypeOf } from 'vitest';

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

toBeArray

Tipo: () => void

Este matcher verifica se o tipo fornecido é Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Tipo: () => void

Este matcher verifica se o tipo fornecido é uma string.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Tipo: () => void

Este matcher verifica se o tipo fornecido é boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Tipo: () => void

Este matcher verifica se o tipo fornecido é void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Tipo: () => void

Este matcher verifica se o tipo fornecido é um symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Tipo: () => void

Este matcher verifica se o tipo fornecido é null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Tipo: () => void

Este matcher verifica se o tipo fornecido é undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Tipo: () => void

Este matcher verifica se o tipo fornecido aceita null ou undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Tipo: () => void

Este matcher garante que a função fornecida pode ser chamada com um determinado conjunto de parâmetros.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Se usado em um tipo que não é uma função, ele retornará never, então você não poderá encadear com outros matchers.

toBeConstructibleWith

Tipo: () => void

Este matcher garante que uma nova instância pode ser criada com um determinado conjunto de parâmetros de construtor.

import { expectTypeOf } from 'vitest';

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

WARNING

Se usado em um tipo que não é um construtor, ele retornará never, então você não poderá encadear com outros matchers.

toHaveProperty

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

Este matcher verifica se uma propriedade existe no objeto fornecido. Se existir, ele também retorna o mesmo conjunto de matchers para o tipo desta propriedade, para que você possa encadear asserções.

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