expectTypeOf

WARNING

Durante a execução, esta função não realiza nenhuma operação. Para habilitar a verificação de tipo, não se esqueça de passar a flag --typecheck.

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 exatamente iguais. Ele não falhará se dois objetos tiverem valores diferentes, mas o mesmo tipo. No entanto, ele falhará se um objeto não possuir 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 em questão estende o tipo fornecido. É diferente de toEqual e é mais semelhante ao toMatchObject() do expect. Com este matcher, você pode verificar se um objeto se encaixa em 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 filtrar tipos para 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 tipo final 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 excluir tipos de uma união para testes posteriores.

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 }>() // ou apenas .exclude<unknown[] | { xs?: unknown }>()
  .toEqualTypeOf<CSSProperties>();

WARNING

Se nenhum tipo for encontrado na união, .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 seja uma função, retornará never, impedindo o encadeamento com outros matchers.

parameters

Tipo: ExpectTypeOf<Parameters>

Você pode extrair os parâmetros da função com .parameters para realizar asserções sobre seus tipos/valores. 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 seja uma função, retornará never, impedindo o encadeamento 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 um argumento específico da função com a chamada .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 seja uma função, retornará never, impedindo o encadeamento com outros matchers.

constructorParameters

Tipo: ExpectTypeOf<ConstructorParameters>

Você pode extrair os parâmetros do construtor como um array de valores 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 seja uma função, retornará never, impedindo o encadeamento com outros matchers.

TIP

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

instance

Tipo: ExpectTypeOf<ConstructableInstance>

Esta propriedade fornece acesso aos matchers que podem ser aplicados a uma instância da classe fornecida.

import { expectTypeOf } from 'vitest';

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

WARNING

Se usado em um tipo que não seja uma função, retornará never, impedindo o encadeamento 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 valor de resolução 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 seja uma Promise, retornará never, impedindo o encadeamento 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, impedindo o encadeamento com outros matchers.

asserts

Tipo: ExpectTypeOf<Assert>

Este matcher extrai o tipo de asserção (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 asserção, impedindo o encadeamento com outros matchers.

toBeAny

Tipo: () => void

Com este matcher você pode verificar se o tipo fornecido é any. Se o tipo for excessivamente 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 é 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 é never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Tipo: () => void

Este matcher verifica se o tipo fornecido é uma função.

import { expectTypeOf } from 'vitest';

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

toBeObject

Tipo: () => void

Este matcher verifica se o tipo fornecido é um objeto.

import { expectTypeOf } from 'vitest';

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

toBeArray

Tipo: () => void

Este matcher verifica se o tipo fornecido é um 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 é um 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 símbolo.

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 pode ser null ou undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Tipo: () => void

Este matcher garante que você pode chamar a função fornecida com determinados 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 seja uma função, retornará never, impedindo o encadeamento com outros matchers.

toBeConstructibleWith

Tipo: () => void

Este matcher garante que você pode criar uma nova instância com determinados parâmetros do 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 seja uma função, retornará never, impedindo o encadeamento 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 dessa propriedade, permitindo que você encadeie 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