expectTypeOf

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

not

Tipo: ExpectTypeOf

Puedes negar cualquier aserción utilizando la propiedad .not.

toEqualTypeOf

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

Este comparador verifica si los tipos son idénticos. No fallará si dos objetos tienen diferentes valores pero el mismo tipo. Sin embargo, fallará si un objeto carece de una propiedad.

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 comparador verifica si el tipo esperado extiende al tipo proporcionado. Es diferente de toEqualTypeOf y más similar a toMatchObject() de expect. Con este comparador, puedes verificar si un objeto es compatible con un 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>

Puedes usar .extract para refinar los tipos para pruebas posteriores, extrayendo un tipo específico de una unión.

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

Si no se encuentra ningún tipo coincidente en la unión, .extract devolverá never.

exclude

Tipo: ExpectTypeOf<NonExcludedUnion>

Puedes usar .exclude para eliminar tipos de una unión para pruebas 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 }>() // or just .exclude<unknown[] | { xs?: unknown }>()
  .toEqualTypeOf<CSSProperties>();

WARNING

Si no se encuentra ningún tipo que no deba excluirse en la unión, .exclude devolverá never.

returns

Tipo: ExpectTypeOf<ReturnValue>

Puedes usar .returns para extraer el tipo de valor de retorno de una función.

import { expectTypeOf } from 'vitest';

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

WARNING

Si se usa en un tipo que no es una función, devolverá never, impidiendo el encadenamiento con otros comparadores.

parameters

Tipo: ExpectTypeOf<Parameters>

Puedes extraer los tipos de los argumentos de una función con .parameters para realizar aserciones sobre ellos. Los parámetros se devuelven como un array.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Si se usa en un tipo que no es una función, devolverá never, impidiendo el encadenamiento con otros comparadores.

TIP

También puedes usar el comparador .toBeCallableWith como una aserción más expresiva.

parameter

Tipo: (nth: number) => ExpectTypeOf

Puedes extraer el tipo de un argumento específico de una función con .parameter(number) para realizar aserciones sobre él. El índice del parámetro comienza en 0.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Si se usa en un tipo que no es una función, devolverá never, impidiendo el encadenamiento con otros comparadores.

constructorParameters

Tipo: ExpectTypeOf<ConstructorParameters>

Puedes extraer los tipos de los parámetros del constructor como un array y realizar aserciones sobre ellos con este método.

import { expectTypeOf } from 'vitest';

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

WARNING

Si se usa en un tipo que no es una clase o función constructora, devolverá never, impidiendo el encadenamiento con otros comparadores.

TIP

También puedes usar el comparador .toBeConstructibleWith como una aserción más expresiva.

instance

Tipo: ExpectTypeOf<ConstructableInstance>

Esta propiedad da acceso a comparadores que pueden usarse con una instancia del tipo proporcionado.

import { expectTypeOf } from 'vitest';

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

WARNING

Si se usa en un tipo que no es una clase o función constructora, devolverá never, impidiendo el encadenamiento con otros comparadores.

items

Tipo: ExpectTypeOf<T>

Puedes obtener el tipo de los elementos de un array con .items para realizar más aserciones.

import { expectTypeOf } from 'vitest';

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

resolves

Tipo: ExpectTypeOf<ResolvedPromise>

Este comparador extrae el tipo del valor resuelto de una Promise, para realizar otras aserciones.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Si se usa en un tipo que no es una promesa, devolverá never, impidiendo el encadenamiento con otros comparadores.

guards

Tipo: ExpectTypeOf<Guard>

Este comparador extrae el tipo de guarda (por ejemplo, v is number), para que puedas realizar afirmaciones sobre él.

import { expectTypeOf } from 'vitest';

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

WARNING

Si el valor no es una función de guarda, devuelve never, por lo que no podrás encadenarlo con otros comparadores.

asserts

Tipo: ExpectTypeOf<Assert>

Este comparador extrae el tipo de aserción (por ejemplo, assert v is number), para que puedas realizar afirmaciones sobre él.

import { expectTypeOf } from 'vitest';

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

expectTypeOf(assertNumber).asserts.toBeNumber();

WARNING

Si el valor no es una función de aserción, devuelve never, impidiendo el encadenamiento con otros comparadores.

toBeAny

Tipo: () => void

Este comparador verifica si el tipo es any. Si el tipo es más específico, la prueba fallará.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Tipo: () => void

Este comparador verifica si el tipo es unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Tipo: () => void

Este comparador verifica si el tipo es never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Tipo: () => void

Este comparador verifica si el tipo es una función.

import { expectTypeOf } from 'vitest';

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

toBeObject

Tipo: () => void

Este comparador verifica si el tipo es un objeto.

import { expectTypeOf } from 'vitest';

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

toBeArray

Tipo: () => void

Este comparador verifica si el tipo es un Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Tipo: () => void

Este comparador verifica si el tipo es un string.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Tipo: () => void

Este comparador verifica si el tipo es boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Tipo: () => void

Este comparador verifica si el tipo es void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Tipo: () => void

Este comparador verifica si el tipo es un symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Tipo: () => void

Este comparador verifica si el tipo es null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Tipo: () => void

Este comparador verifica si el tipo es undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Tipo: () => void

Este comparador verifica si el tipo especificado puede ser null o undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Tipo: () => void

Este comparador asegura que la función proporcionada puede ser invocada con un conjunto específico de parámetros.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Si se usa en un tipo que no es una función, devolverá never, impidiendo el encadenamiento con otros comparadores.

toBeConstructibleWith

Tipo: () => void

Este comparador asegura que se puede crear una nueva instancia de un tipo utilizando un conjunto específico de parámetros del constructor.

import { expectTypeOf } from 'vitest';

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

WARNING

Si se usa en un tipo que no es una clase o función constructora, devolverá never, impidiendo el encadenamiento con otros comparadores.

toHaveProperty

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

Este comparador verifica si una propiedad existe en el objeto proporcionado. Si existe, también devuelve el mismo conjunto de comparadores para el tipo de esta propiedad, permitiendo encadenar aserciones.

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