expectTypeOf

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

not

Typ: ExpectTypeOf

Możesz zanegować wszystkie asercje, używając właściwości .not.

toEqualTypeOf

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

Ten dopasowywacz sprawdza, czy typy są identyczne. Nie sprawdza wartości, a jedynie typy. Test nie zakończy się niepowodzeniem, jeśli dwa obiekty mają różne wartości, ale ten sam typ. Natomiast zakończy się niepowodzeniem, jeśli w obiekcie brakuje właściwości.

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

Ten dopasowywacz sprawdza, czy typ oczekiwany jest zgodny z podanym typem (tj. czy oczekiwany typ rozszerza podany typ). Działa podobnie do toMatchObject() z expect, a nie do toEqual. Pozwala sprawdzić, czy obiekt "pasuje" do typu.

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>

Możesz użyć .extract, aby zawęzić typy unii do dalszych testów.

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 }>() // wyodrębnia typ { xs?: any } z unii
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // wyodrębnia typ unknown[] z unii
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Jeśli żaden typ z unii nie pasuje do podanego, .extract zwróci never.

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

Możesz użyć .exclude, aby usunąć typy z unii w celu dalszych testów.

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

WARNING

Jeśli żaden typ z unii nie pasuje do podanego, .exclude zwróci never.

returns

Typ: ExpectTypeOf<ReturnValue>

Możesz użyć .returns, aby wyodrębnić typ wartości zwracanej przez funkcję.

import { expectTypeOf } from 'vitest';

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

WARNING

Użycie na typie, który nie jest funkcją, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

parameters

Typ: ExpectTypeOf<Parameters>

Możesz wyodrębnić typy parametrów funkcji za pomocą .parameters, aby wykonać asercje na ich typach. Parametry są zwracane jako tablica typów.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Użycie na typie, który nie jest funkcją, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

TIP

Możesz również użyć dopasowywacza .toBeCallableWith jako bardziej ekspresywnej asercji.

parameter

Typ: (nth: number) => ExpectTypeOf

Możesz wyodrębnić typ określonego argumentu funkcji za pomocą wywołania .parameter(number), aby wykonać na nim dalsze asercje. number to indeks argumentu (liczony od 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

Użycie na typie, który nie jest funkcją, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

Możesz wyodrębnić typy parametrów konstruktora jako tablicę typów i wykonywać na nich asercje.

import { expectTypeOf } from 'vitest';

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

WARNING

Użycie na typie, który nie jest konstruktorem, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

TIP

Możesz również użyć dopasowywacza .toBeConstructibleWith jako bardziej ekspresywnej asercji.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Ta właściwość daje dostęp do dopasowywaczy, które można wykonać na instancji danej klasy.

import { expectTypeOf } from 'vitest';

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

WARNING

Użycie na typie, który nie jest konstruktorem, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

items

Typ: ExpectTypeOf<T>

Możesz pobrać typ elementów tablicy za pomocą .items, aby wykonać dalsze asercje.

import { expectTypeOf } from 'vitest';

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

resolves

Typ: ExpectTypeOf<ResolvedPromise>

Ten dopasowywacz wyodrębnia typ wartości, na którą rozwiązuje się Promise, dzięki czemu możesz wykonywać na niej dalsze asercje.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Użycie na typie, który nie jest obietnicą, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

guards

Typ: ExpectTypeOf<Guard>

Ten dopasowywacz wyodrębnia typ predykatu typu (np. v is number), dzięki czemu możesz wykonywać na nim asercje.

import { expectTypeOf } from 'vitest';

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

WARNING

Zwraca never, jeśli wartość nie jest funkcją guard, więc nie będzie można go połączyć z innymi dopasowywaczami.

asserts

Typ: ExpectTypeOf<Assert>

Ten dopasowywacz wyodrębnia typ asercji (np. assert v is number), dzięki czemu możesz wykonywać na niej asercje.

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

Zwraca never, jeśli wartość nie jest funkcją asercji, więc nie będzie można go połączyć z innymi dopasowywaczami.

toBeAny

Typ: () => void

Za pomocą tego dopasowywacza możesz sprawdzić, czy dany typ jest typem any. Jeśli typ jest bardziej szczegółowy niż any, test zakończy się niepowodzeniem.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ jest typem unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ jest typem never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ jest funkcją.

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ jest obiektem.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to string.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ to undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Typ: () => void

Ten dopasowywacz sprawdza, czy dany typ dopuszcza wartości null lub undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Ten dopasowywacz zapewnia, że można wywołać daną funkcję z określonymi parametrami (tj. że typy argumentów pasują do typów parametrów funkcji).

import { expectTypeOf } from 'vitest';

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

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

WARNING

Użycie na typie, który nie jest funkcją, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

toBeConstructibleWith

Typ: () => void

Ten dopasowywacz zapewnia, że można utworzyć nową instancję danej klasy z określonymi parametrami konstruktora (tj. że typy argumentów pasują do typów parametrów konstruktora).

import { expectTypeOf } from 'vitest';

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

WARNING

Użycie na typie, który nie jest konstruktorem, spowoduje zwrócenie never i uniemożliwi dalsze łączenie.

toHaveProperty

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

Ten dopasowywacz sprawdza, czy dana właściwość istnieje w danym obiekcie. Jeśli istnieje, zwraca również ten sam zestaw dopasowywaczy dla typu tej właściwości, dzięki czemu można łączyć asercje jedna po drugiej.

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