expectTypeOf

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

not

Typ: ExpectTypeOf

Pomocí vlastnosti .not můžete negovat jakékoli tvrzení.

toEqualTypeOf

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

Tento matcher ověřuje, zda jsou typy přesně shodné. Neselže, pokud mají dva objekty různé hodnoty, ale shodný typ. Selže, pokud objektu chybí vlastnost.

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

Tento matcher ověřuje, zda typ expect rozšiřuje zadaný typ. Liší se od toEqualTypeOf a je podobnější toMatchObject() z expect. Umožňuje zkontrolovat, zda objekt "odpovídá" 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>

.extract slouží k zúžení typů v rámci unionu pro další testování.

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 }>() // extrahuje poslední typ z unionu
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // extrahuje pole z unionu
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Pokud v unionu není nalezen odpovídající typ, .extract vrátí never.

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

.exclude slouží k odebrání typů z unionu pro další testování.

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

WARNING

Pokud v unionu není nalezen žádný typ k vyloučení, .exclude vrátí never.

returns

Typ: ExpectTypeOf<ReturnValue>

.returns slouží k extrahování návratového typu funkce.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

parameters

Typ: ExpectTypeOf<Parameters>

.parameters slouží k získání argumentů funkce jako pole a k provádění tvrzení o jejich typech.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

TIP

Pro expresivnější tvrzení můžete použít matcher .toBeCallableWith.

parameter

Typ: (nth: number) => ExpectTypeOf

.parameter(number) slouží k extrahování konkrétního argumentu funkce (podle indexu) a k provádění dalších tvrzení o jeho typu.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

.constructorParameters slouží k extrahování parametrů konstruktoru jako pole a k provádění tvrzení o jejich typech.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

TIP

Pro expresivnější tvrzení můžete použít matcher .toBeConstructibleWith.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Vlastnost .instance poskytuje přístup k matcherům, které lze použít na instanci zadané třídy.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

items

Typ: ExpectTypeOf<T>

.items slouží k získání typu položek v poli a k provádění dalších tvrzení o tomto typu.

import { expectTypeOf } from 'vitest';

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

resolves

Typ: ExpectTypeOf<ResolvedPromise>

Tento matcher získá vyřešenou hodnotu Promise, takže s ní můžete provádět další tvrzení.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Pokud je použit na typ, který není Promise, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

guards

Typ: ExpectTypeOf<Guard>

Tento matcher extrahuje typ guard funkce (např. v is number), takže s ním můžete provádět tvrzení.

import { expectTypeOf } from 'vitest';

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

WARNING

Vrátí never, pokud hodnota není guard funkce, a proto ji nelze zřetězit s dalšími matchery.

asserts

Typ: ExpectTypeOf<Assert>

Tento matcher extrahuje typ assert funkce (např. assert v is number), takže s ním můžete provádět tvrzení.

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

Vrátí never, pokud hodnota není assert funkce, a proto ji nelze zřetězit s dalšími matchery.

toBeAny

Typ: () => void

Ověřuje, zda je zadaný typ any. Test selže, pokud je typ příliš konkrétní.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Typ: () => void

Ověřuje, zda je zadaný typ unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Ověřuje, zda je zadaný typ never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

Ověřuje, zda je zadaný typ function.

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Ověřuje, zda je zadaný typ object.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Ověřuje, zda je zadaný typ Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Typ: () => void

Ověřuje, zda je zadaný typ string.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Typ: () => void

Ověřuje, zda je zadaný typ boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Typ: () => void

Ověřuje, zda je zadaný typ void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

Ověřuje, zda je zadaný typ symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Ověřuje, zda je zadaný typ null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Typ: () => void

Ověřuje, zda je zadaný typ undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Typ: () => void

Ověřuje, zda daný typ může být null nebo undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Zajišťuje, že zadanou funkci lze volat s danou sadou parametrů.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

toBeConstructibleWith

Typ: () => void

Zajišťuje, že lze vytvořit novou instanci s danou sadou parametrů konstruktoru.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, a proto jej nelze zřetězit s dalšími matchery.

toHaveProperty

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

Ověřuje, zda vlastnost existuje v zadaném objektu. Pokud existuje, vrací stejnou sadu matcherů pro typ této vlastnosti, takže můžete zřetězit tvrzení.

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