expectTypeOf

WARNING

Lors de l'exécution, cette fonction ne fait rien. Pour activer la vérification de type, n'oubliez pas de passer l'indicateur --typecheck.

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

not

Type: ExpectTypeOf

Vous pouvez nier toutes les assertions en utilisant la propriété .not.

toEqualTypeOf

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

Ce comparateur vérifie si les types sont strictement identiques. Il ne détectera pas de différence si deux objets ont des valeurs différentes, mais le même type. Cependant, il échouera si un objet ne possède pas une propriété.

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

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

Ce comparateur vérifie si le type attendu hérite du type fourni. Il diffère de toEqualTypeOf et se rapproche de toMatchObject() de expect. Il permet de vérifier si un objet "correspond" à un type.

import { expectTypeOf } from 'vitest';

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

extract

Type: ExpectTypeOf<ExtractedUnion>

Vous pouvez utiliser .extract pour extraire des types spécifiques d'une union, permettant des tests plus précis.

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 }>() // extrait le dernier type d'une union
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // extrait un tableau d'une union
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Si aucun type ne correspond dans l'union, .extract retournera never.

exclude

Type: ExpectTypeOf<NonExcludedUnion>

Vous pouvez utiliser .exclude pour supprimer des types d'une union, permettant des tests plus précis.

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

WARNING

Si aucun type ne correspond dans l'union, .exclude retournera never.

returns

Type: ExpectTypeOf<ReturnValue>

Vous pouvez utiliser .returns pour extraire le type de retour d'une fonction.

import { expectTypeOf } from 'vitest';

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

WARNING

S'il est utilisé sur un type qui n'est pas une fonction, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

parameters

Type: ExpectTypeOf<Parameters>

Vous pouvez extraire les types des arguments d'une fonction avec .parameters pour effectuer des assertions sur leur type. Les paramètres sont retournés sous forme de tableau.

import { expectTypeOf } from 'vitest';

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

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

WARNING

S'il est utilisé sur un type qui n'est pas une fonction, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

TIP

Vous pouvez également utiliser le comparateur .toBeCallableWith pour une assertion plus expressive.

parameter

Type: (nth: number) => ExpectTypeOf

Vous pouvez extraire le type d'un argument spécifique d'une fonction avec .parameter(number) pour effectuer d'autres assertions.

import { expectTypeOf } from 'vitest';

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

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

WARNING

S'il est utilisé sur un type qui n'est pas une fonction, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

constructorParameters

Type: ExpectTypeOf<ConstructorParameters>

Vous pouvez extraire les types des paramètres du constructeur sous forme de tableau et effectuer des assertions dessus avec cette méthode.

import { expectTypeOf } from 'vitest';

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

WARNING

S'il est utilisé sur un type qui n'est pas un constructeur, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

TIP

Vous pouvez également utiliser le comparateur .toBeConstructibleWith pour une assertion plus expressive.

instance

Type: ExpectTypeOf<ConstructableInstance>

Cette propriété donne accès aux comparateurs qui peuvent être utilisés sur une instance de la classe fournie.

import { expectTypeOf } from 'vitest';

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

WARNING

S'il est utilisé sur un type qui n'est pas un constructeur, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

items

Type: ExpectTypeOf<T>

Vous pouvez obtenir le type des éléments d'un tableau avec .items pour effectuer d'autres assertions.

import { expectTypeOf } from 'vitest';

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

resolves

Type: ExpectTypeOf<ResolvedPromise>

Ce comparateur extrait le type de la valeur résolue d'une Promise, ce qui vous permet d'effectuer d'autres assertions.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

S'il est utilisé sur un type qui n'est pas une Promise, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

guards

Type: ExpectTypeOf<Guard>

Ce comparateur extrait le type de garde (par exemple, v is number), ce qui vous permet d'effectuer des assertions.

import { expectTypeOf } from 'vitest';

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

WARNING

Retourne never si la valeur n'est pas une fonction de garde, et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

asserts

Type: ExpectTypeOf<Assert>

Ce comparateur extrait le type d'assertion (par exemple, assert v is number), ce qui vous permet d'effectuer des assertions.

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

Retourne never si la valeur n'est pas une fonction d'assertion, et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

toBeAny

Type: () => void

Ce comparateur vérifie si le type fourni est de type any. Si le type est plus spécifique, le test échouera.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Type: () => void

Ce comparateur vérifie si le type fourni est un type unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Type: () => void

Ce comparateur vérifie si le type fourni est un type never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Type: () => void

Ce comparateur vérifie si le type fourni est une fonction.

import { expectTypeOf } from 'vitest';

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

toBeObject

Type: () => void

Ce comparateur vérifie si le type fourni est un objet.

import { expectTypeOf } from 'vitest';

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

toBeArray

Type: () => void

Ce comparateur vérifie si le type fourni est un tableau.

import { expectTypeOf } from 'vitest';

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

toBeString

Type: () => void

Ce comparateur vérifie si le type fourni est une chaîne de caractères.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Type: () => void

Ce comparateur vérifie si le type fourni est un booléen.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Type: () => void

Ce comparateur vérifie si le type fourni est de type void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Type: () => void

Ce comparateur vérifie si le type fourni est un symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Type: () => void

Ce comparateur vérifie si le type fourni est null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Type: () => void

Ce comparateur vérifie si le type fourni est undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Type: () => void

Ce comparateur vérifie si le type fourni accepte null ou undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Type: () => void

Ce comparateur vérifie que la fonction fournie peut être appelée avec un ensemble de paramètres.

import { expectTypeOf } from 'vitest';

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

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

WARNING

S'il est utilisé sur un type qui n'est pas une fonction, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

toBeConstructibleWith

Type: () => void

Ce comparateur garantit qu'une nouvelle instance peut être créée avec un ensemble de paramètres de constructeur.

import { expectTypeOf } from 'vitest';

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

WARNING

S'il est utilisé sur un type qui n'est pas un constructeur, il retournera never et vous ne pourrez pas l'utiliser avec d'autres comparateurs.

toHaveProperty

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

Ce comparateur vérifie si une propriété existe sur l'objet donné. S'il existe, il retourne également le même ensemble de comparateurs pour le type de cette propriété, permettant ainsi d'enchaîner les assertions.

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