expectTypeOf

WARNING

W czasie wykonania ta funkcja nic nie robi. Aby włączyć sprawdzanie typów, nie zapomnij dodać flagi --typecheck.

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 matcher sprawdza, czy typy są całkowicie równe. Nie zakończy się niepowodzeniem, jeśli dwa obiekty mają różne wartości, ale ten sam typ. Zakończy się jednak niepowodzeniem, jeśli obiektowi 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 matcher sprawdza, czy typ oczekiwany rozszerza podany typ. Różni się od toEqual i jest bardziej podobny do toMatchObject() z biblioteki expect. Za pomocą tego matchera możesz 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 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 ostatni typ z typu unii
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

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

WARNING

Jeśli w typie unii nie zostanie znaleziony żaden typ, .extract zwróci never.

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

Możesz użyć .exclude, aby usunąć typy z 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))
  .exclude<unknown[]>()
  .exclude<{ xs?: unknown }>() // lub po prostu .exclude<unknown[] | { xs?: unknown }>()
  .toEqualTypeOf<CSSProperties>();

WARNING

Jeśli w unii nie zostanie znaleziony żaden typ, .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

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

parameters

Typ: ExpectTypeOf<Parameters>

Możesz wyodrębnić argumenty funkcji za pomocą .parameters, aby wykonać asercje na ich wartości. Parametry są zwracane jako tablica.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

TIP

Możesz również użyć matchera .toBeCallableWith jako bardziej ekspresyjnej asercji.

parameter

Typ: (nth: number) => ExpectTypeOf

Możesz wyodrębnić określony argument funkcji za pomocą metody .parameter(number), aby wykonać na nim inne asercje.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

Możesz wyodrębnić parametry konstruktora jako tablicę wartości i wykonać na nich asercje tą metodą.

import { expectTypeOf } from 'vitest';

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

TIP

Możesz również użyć matchera .toBeConstructibleWith jako bardziej ekspresyjnej asercji.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Ta właściwość umożliwia dostęp do matcherów, które można wykonywać na instancji dostarczonej klasy.

import { expectTypeOf } from 'vitest';

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

items

Typ: ExpectTypeOf<T>

Możesz uzyskać typ elementu 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 matcher wyodrębnia wartość rozwiązaną przez Promise, co pozwala na wykonanie na niej innych asercji.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Jeśli użyte na typie niebędącym obietnicą, zwróci never, co uniemożliwi łączenie z innymi matcherami.

guards

Typ: ExpectTypeOf<Guard>

Ten matcher wyodrębnia typ funkcji strażnika (np. v is number), dzięki czemu możesz wykonać 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ą strażnika, co uniemożliwi łączenie z innymi matcherami.

asserts

Typ: ExpectTypeOf<Assert>

Ten matcher wyodrębnia typ funkcji asercji (np. assert v is number), co pozwala na wykonanie na niej asercji.

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, co uniemożliwi łączenie z innymi matcherami.

toBeAny

Typ: () => void

Ten matcher pozwala sprawdzić, czy podany typ jest typu any. Jeśli typ jest zbyt szczegółowy, test zakończy się niepowodzeniem.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu funkcja.

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu obiekt.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu string.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Typ: () => void

Ten matcher sprawdza, czy podany typ jest typu undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Typ: () => void

Ten matcher sprawdza, czy podany typ może przyjmować wartości null lub undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Ten matcher zapewnia, że możesz wywołać podaną funkcję z zestawem parametrów.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

toBeConstructibleWith

Typ: () => void

Ten matcher zapewnia, że możesz utworzyć nową instancję z zestawem parametrów konstruktora.

import { expectTypeOf } from 'vitest';

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

WARNING

Jeśli użyte na typie niebędącym funkcją, zwróci never, co uniemożliwi łączenie z innymi matcherami.

toHaveProperty

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

Ten matcher sprawdza, czy właściwość istnieje w podanym obiekcie. Jeśli istnieje, zwraca również ten sam zestaw matcherów dla typu tej właściwości, co pozwala na łączenie kolejnych asercji.

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