expectTypeOf

WARNING

Zur Laufzeit hat diese Funktion keine Auswirkungen. Um die Typüberprüfung zu aktivieren, müssen Sie das --typecheck-Flag übergeben.

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

not

Typ: ExpectTypeOf

Sie können alle Assertions mithilfe der .not-Eigenschaft negieren.

toEqualTypeOf

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

Dieser Matcher überprüft, ob die Typen vollständig identisch sind. Er schlägt nicht fehl, wenn zwei Objekte unterschiedliche Werte, aber denselben Typ haben. Er schlägt jedoch fehl, wenn einem Objekt eine Eigenschaft fehlt.

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 überprüft, ob der erwartete Typ den angegebenen Typ erweitert. Er unterscheidet sich von toEqual und ähnelt eher expect's toMatchObject(). Mit diesem Matcher können Sie überprü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>

Sie können .extract verwenden, um Typen für weitere Überprüfungen einzugrenzen.

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 letzten Typ aus einer Union
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // extrahiert ein Array aus einer Union
  .toEqualTypeOf<CSSProperties[]>();

WARNING

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

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

Sie können .exclude verwenden, um Typen aus einer Union für weitere Überprüfungen 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 kein Typ in der Union gefunden wird, gibt .exclude never zurück.

returns

Typ: ExpectTypeOf<ReturnValue>

Sie können .returns verwenden, um den Rückgabewert eines Funktionstyps zu extrahieren.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

parameters

Typ: ExpectTypeOf<Parameters>

Sie können Funktionsargumente mit .parameters extrahieren, um Assertions auf deren Wert durchzuführen. 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 auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

TIP

Sie können auch den Matcher .toBeCallableWith als ausdrucksstärkere Assertion verwenden.

parameter

Typ: (nth: number) => ExpectTypeOf

Sie können ein bestimmtes Funktionsargument mit dem Aufruf .parameter(number) extrahieren, um andere Assertions darauf durchzuführen.

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 auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

Sie können Konstruktorparameter als Array von Werten extrahieren und mit dieser Methode Assertions darauf durchführen.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

TIP

Sie können auch den Matcher .toBeConstructibleWith als ausdrucksstärkere Assertion verwenden.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Diese Eigenschaft ermöglicht den Zugriff auf Matcher, die auf einer Instanz der angegebenen Klasse angewendet werden können.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

items

Typ: ExpectTypeOf<T>

Sie können 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 Wert eines aufgelösten Promise, sodass Sie weitere Assertions darauf durchführen können.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Wenn auf einen Nicht-Promise-Typ angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

guards

Typ: ExpectTypeOf<Guard>

Dieser Matcher extrahiert den Guard-Typ (z.B. v is number), sodass Sie Assertions darauf durchführen können.

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 Guard-Funktion ist, sodass Sie es nicht mit anderen Matchern verketten können.

asserts

Typ: ExpectTypeOf<Assert>

Dieser Matcher extrahiert den Assert-Typ (z.B. assert v is number), sodass Sie Assertions darauf durchführen können.

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 Sie es nicht mit anderen Matchern verketten können.

toBeAny

Typ: () => void

Mit diesem Matcher können Sie überprüfen, ob es sich um den Typ any handelt. Wenn der Typ zu spezifisch 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 angegebene Typ unknown ist.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Dieser Matcher überprüft, ob der angegebene Typ never ist.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

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

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Dieser Matcher überprüft, ob der angegebene Typ ein object ist.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Dieser Matcher überprü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 überprü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 überprü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 überprüft, ob der angegebene Typ void ist.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

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

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Dieser Matcher überprü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 überprü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 überprüft, ob Sie null oder undefined mit dem angegebenen Typ verwenden können.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Dieser Matcher stellt sicher, dass Sie die angegebene Funktion mit bestimmten Parametern aufrufen können.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Wenn auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

toBeConstructibleWith

Typ: () => void

Dieser Matcher stellt sicher, dass Sie eine neue Instanz mit bestimmten Konstruktorparametern erzeugen können.

import { expectTypeOf } from 'vitest';

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

WARNING

Wenn auf einen Nicht-Funktionstyp angewendet, wird never zurückgegeben, sodass Sie es nicht mit anderen Matchern verketten können.

toHaveProperty

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

Dieser Matcher überprüft, ob eine Eigenschaft im angegebenen Objekt existiert. Wenn sie existiert, gibt er auch die gleichen Matcher für den Typ dieser Eigenschaft zurück, sodass Sie Assertions miteinander verketten können.

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