expectTypeOf

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

not

Typ: ExpectTypeOf

Mit der .not-Eigenschaft kannst du alle nachfolgenden Assertions negieren.

toEqualTypeOf

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

Dieser Matcher überprüft, ob die Typen exakt übereinstimmen. Der Matcher schlägt nicht fehl, wenn zwei Objekte unterschiedliche Werte, aber den gleichen Typ haben. Er schlägt jedoch fehl, wenn einem Objekt eine Eigenschaft fehlt oder eine zusätzliche Eigenschaft vorhanden ist.

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

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

Dieser Matcher prüft, ob der Typ des zu prüfenden Wertes den erwarteten Typ erweitert (d.h. kompatibel ist). Er unterscheidet sich von toEqualTypeOf und ähnelt eher toMatchObject() von expect. Mit diesem Matcher kannst du prüfen, ob ein Objekt einem Typ "entspricht".

import { expectTypeOf } from 'vitest';

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

extract

Typ: ExpectTypeOf<ExtractedUnion>

Du kannst .extract verwenden, um einen bestimmten Typ aus einer Union für weitere Tests zu extrahieren.

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 }>() // extrahiert den Typ `{ xs?: any }` aus der Union
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // extrahiert den Array-Typ aus der Union
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Wenn der angegebene Typ nicht in der Union gefunden wird, gibt .extract never zurück.

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

Du kannst .exclude verwenden, um einen oder mehrere Typen aus einer Union für weitere Tests zu entfernen.

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

WARNING

Wenn der angegebene Typ nicht in der Union gefunden wird, gibt .exclude never zurück.

returns

Typ: ExpectTypeOf<ReturnValue>

Du kannst .returns verwenden, um den Rückgabetyp eines Funktionstyps zu extrahieren.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn .returns auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

parameters

Typ: ExpectTypeOf<Parameters>

Du kannst Funktionsargumente mit .parameters extrahieren, um Assertions auf ihre Typen durchzuführen. Die Parameter werden als Array zurückgegeben.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Wenn .parameters auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

TIP

Du kannst auch den Matcher .toBeCallableWith als eine aussagekräftigere Assertion verwenden.

parameter

Typ: (nth: number) => ExpectTypeOf

Du kannst ein bestimmtes Funktionsargument mit dem Aufruf .parameter(number) extrahieren, um andere Assertions auf seinen Typ durchzuführen. number ist der Index des Parameters (beginnend bei 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

Wenn .parameter auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

Du kannst Konstruktorparameter als Array von Typen extrahieren und mit dieser Methode Assertions durchführen.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn .constructorParameters auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

TIP

Du kannst auch den Matcher .toBeConstructibleWith als eine aussagekräftigere Assertion verwenden.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Diese Eigenschaft gibt Zugriff auf Matcher, die auf dem Typ einer Instanz der angegebenen Klasse ausgeführt werden können.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn .instance auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

items

Typ: ExpectTypeOf<T>

Du kannst den Typ der Array-Elemente mit .items abrufen, um weitere Assertions durchzuführen.

import { expectTypeOf } from 'vitest';

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

resolves

Typ: ExpectTypeOf<ResolvedPromise>

Dieser Matcher extrahiert den Typ des aufgelösten Wertes einer Promise, sodass du andere Assertions darauf durchführen kannst.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Wenn .resolves auf einen Nicht-Promise-Typ angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

guards

Typ: ExpectTypeOf<Guard>

Dieser Matcher extrahiert den Typ des Guard (Type Guard Function), sodass du Assertions darauf durchführen kannst.

import { expectTypeOf } from 'vitest';

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

WARNING

Gibt never zurück, wenn der Wert keine Type-Guard-Funktion ist, sodass du ihn nicht mit anderen Matchern verketten kannst.

asserts

Typ: ExpectTypeOf<Assert>

Dieser Matcher extrahiert den Typ der Assert-Funktion, sodass du Assertions darauf durchführen kannst.

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

Gibt never zurück, wenn der Wert keine Assert-Funktion ist, sodass du ihn nicht mit anderen Matchern verketten kannst.

toBeAny

Typ: () => void

Mit diesem Matcher kannst du prüfen, ob der angegebene Typ ein any-Typ ist. Wenn der Typ spezifischer als any ist, schlägt der Test fehl.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Typ: () => void

Dieser Matcher überprüft, ob der Typ unknown ist.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Dieser Matcher prüft, ob der Typ never ist.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ eine function ist.

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ ein object ist. Beachte, dass Arrays auch Objekte sind.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ Array<T> ist.

import { expectTypeOf } from 'vitest';

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

toBeString

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ ein string ist.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ boolean ist.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ void ist.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ ein symbol ist.

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ null ist.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ undefined ist.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Typ: () => void

Dieser Matcher prüft, ob der angegebene Typ null oder undefined enthalten kann (d.h. ob null oder undefined dem Typ zugewiesen werden kann).

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Dieser Matcher stellt sicher, dass die angegebene Funktion mit den angegebenen Parametern aufgerufen werden kann (d.h. die Parameter sind typkompatibel).

import { expectTypeOf } from 'vitest';

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

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

WARNING

Wenn .toBeCallableWith auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

toBeConstructibleWith

Typ: () => void

Dieser Matcher stellt sicher, dass eine neue Instanz der angegebenen Klasse mit den angegebenen Konstruktorparametern erstellt werden kann (d.h. die Parameter sind typkompatibel).

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn .toBeConstructibleWith auf einen Nicht-Funktionstyp angewendet wird, gibt er never zurück, sodass du ihn nicht mit anderen Matchern verketten kannst.

toHaveProperty

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

Dieser Matcher prüft, ob eine Eigenschaft mit dem angegebenen Namen im angegebenen Objekt vorhanden ist. Wenn sie vorhanden ist, gibt er auch den gleichen Satz von Matchern für den Typ dieser Eigenschaft zurück, sodass du die Assertions verketten kannst.

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