expectTypeOf

WARNING

À l'exécution, cette fonction n'a aucun effet. Pour activer la vérification de type, assurez-vous d'utiliser l'option --typecheck.

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

not

Type : ExpectTypeOf

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

toEqualTypeOf

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

Ce matcher vérifie si les types sont strictement égaux. Il ne provoquera pas d'échec si deux objets ont des valeurs différentes mais le même type. Cependant, il échouera si une propriété est manquante dans un objet.

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 matcher vérifie si le type attendu étend le type fourni. Il diffère de toEqual et est plus similaire à toMatchObject() d'expect. Avec ce matcher, vous pouvez 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 affiner les types en vue de tests supplémentaires.

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 n'est trouvé dans l'union, .extract retournera never.

exclude

Type : ExpectTypeOf<NonExcludedUnion>

Vous pouvez utiliser .exclude pour supprimer des types d'une union pour des tests supplémentaires.

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 n'est trouvé dans l'union, .exclude retournera never.

returns

Type : ExpectTypeOf<ReturnValue>

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

import { expectTypeOf } from 'vitest';

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

WARNING

Si utilisé sur un type qui n'est pas une fonction, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

parameters

Type : ExpectTypeOf<Parameters>

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

import { expectTypeOf } from 'vitest';

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

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

WARNING

Si utilisé sur un type qui n'est pas une fonction, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

TIP

Vous pouvez également utiliser le matcher .toBeCallableWith comme assertion plus expressive.

parameter

Type : (nth: number) => ExpectTypeOf

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

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 utilisé sur un type qui n'est pas une fonction, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

constructorParameters

Type : ExpectTypeOf<ConstructorParameters>

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

import { expectTypeOf } from 'vitest';

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

WARNING

Si utilisé sur un type qui n'est pas une fonction, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

TIP

Vous pouvez également utiliser le matcher .toBeConstructibleWith comme assertion plus expressive.

instance

Type : ExpectTypeOf<ConstructableInstance>

Cette propriété donne accès aux matchers qui peuvent être effectués sur une instance du type constructible fourni.

import { expectTypeOf } from 'vitest';

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

WARNING

Si utilisé sur un type qui n'est pas constructible, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

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 matcher extrait le type de la valeur résolue d'une Promise, afin que vous puissiez effectuer d'autres assertions dessus.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Si utilisé sur un type qui n'est pas une promesse, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

guards

Type : ExpectTypeOf<Guard>

Ce matcher extrait le type de la valeur de garde (par exemple, v is number), afin que vous puissiez effectuer des assertions dessus.

import { expectTypeOf } from 'vitest';

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

WARNING

Retourne never si le type n'est pas une fonction de garde, ce qui empêche de le chaîner avec d'autres matchers.

asserts

Type : ExpectTypeOf<Assert>

Ce matcher extrait le type de la valeur d'assertion (par exemple, assert v is number), afin que vous puissiez effectuer des assertions dessus.

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 le type n'est pas une fonction d'assertion, ce qui empêche de le chaîner avec d'autres matchers.

toBeAny

Type : () => void

Avec ce matcher, vous pouvez vérifier si le type fourni est de type any. Si le type est trop spécifique, le test échouera.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Type : () => void

Ce matcher vérifie si le type fourni est de type unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Type : () => void

Ce matcher vérifie si le type fourni est de type never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Type : () => void

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

import { expectTypeOf } from 'vitest';

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

toBeObject

Type : : () => void

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

import { expectTypeOf } from 'vitest';

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

toBeArray

Type : () => void

Ce matcher vérifie si le type fourni est Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Type : () => void

Ce matcher 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 matcher 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 matcher vérifie si le type fourni est void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Type : () => void

Ce matcher vérifie si le type fourni est un symbole.

import { expectTypeOf } from 'vitest';

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

toBeNull

Type : () => void

Ce matcher 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 matcher 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 matcher vérifie si le type fourni peut être null ou undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Type : () => void

Ce matcher garantit que le type de fonction fourni peut être appelé avec un ensemble de paramètres donné.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Si utilisé sur un type qui n'est pas une fonction, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

toBeConstructibleWith

Type : () => void

Ce matcher garantit que le type constructible fourni peut être instancié avec un ensemble de paramètres de constructeur donné.

import { expectTypeOf } from 'vitest';

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

WARNING

Si utilisé sur un type qui n'est pas constructible, il retournera never, ce qui empêche de le chaîner avec d'autres matchers.

toHaveProperty

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

Ce matcher vérifie si une propriété existe sur le type d'objet fourni. S'il existe, il retourne également le même ensemble de matchers pour le type de cette propriété, afin que vous puissiez chaî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