expectTypeOf

WARNING

Během běhu tato funkce neprovádí žádnou akci. Pro povolení kontroly typů nezapomeňte použít příznak --typecheck.

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

not

Typ: ExpectTypeOf

Všechna tvrzení můžete negovat pomocí vlastnosti .not.

toEqualTypeOf

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

Tento matcher kontroluje, zda jsou typy zcela shodné. Tento matcher neselže, pokud dva objekty mají různé hodnoty, ale stejný typ. Pokud však objektu chybí vlastnost, selže.

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 kontroluje, zda očekávaný typ rozšiřuje poskytnutý typ. Liší se od toEqual a je podobnější toMatchObject() z expect. S tímto matcherem můžete ověřit, zda objekt „odpovídá“ danému 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>

Pomocí .extract můžete zúžit typy pro další ověřová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 objektový typ z unie
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

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

WARNING

Pokud se v unii nenajde žádný odpovídající typ, .extract vrátí never.

exclude

Typ: ExpectTypeOf<NonExcludedUnion>

Můžete použít .exclude k odstranění typů z unie pro další ověřová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 unii není nalezen žádný typ, .exclude vrátí never.

returns

Typ: ExpectTypeOf<ReturnValue>

Můžete použít .returns k extrakci návratové hodnoty 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, což znemožní jeho řetězení s jinými matchery.

parameters

Typ: ExpectTypeOf<Parameters>

Parametry funkce můžete extrahovat pomocí .parameters a provádět na nich tvrzení. Parametry jsou vráceny jako pole.

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, což znemožní jeho řetězení s jinými matchery.

TIP

Můžete také použít matcher .toBeCallableWith pro expresivnější tvrzení.

parameter

Typ: (nth: number) => ExpectTypeOf

Můžete extrahovat určitý argument funkce pomocí volání .parameter(number) a provádět na něm další tvrzení.

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, což znemožní jeho řetězení s jinými matchery.

constructorParameters

Typ: ExpectTypeOf<ConstructorParameters>

Pomocí této metody můžete extrahovat parametry konstruktoru jako pole hodnot a provádět na nich tvrzení.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, což znemožní jeho řetězení s jinými matchery.

TIP

Můžete také použít matcher .toBeConstructibleWith jako expresivnější tvrzení.

instance

Typ: ExpectTypeOf<ConstructableInstance>

Tato vlastnost poskytuje přístup k matcherům, které lze provádět na instanci poskytnuté třídy.

import { expectTypeOf } from 'vitest';

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

WARNING

Pokud je použit na typ, který není funkcí, vrátí never, což znemožní jeho řetězení s jinými matchery.

items

Typ: ExpectTypeOf<T>

Typ prvků pole můžete získat pomocí .items a provádět další tvrzení.

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á výslednou hodnotu Promise, takže na 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 se použije na typ, který není promise, vrátí never, takže jej nebudete moci řetězit s jinými matchery.

guards

Typ: ExpectTypeOf<Guard>

Tento matcher získá typovou informaci z guardu (např. v is number), takže na ní 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 funkcí, takže ji nebudete moci řetězit s jinými matchery.

asserts

Typ: ExpectTypeOf<Assert>

Tento matcher získá typovou informaci z assertu (např. assert v is number), takže na ní 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 funkcí, takže ji nebudete moci řetězit s jinými matchery.

toBeAny

Typ: () => void

Pomocí tohoto matcheru můžete zkontrolovat, zda je poskytnutý typ any. Pokud je typ příliš konkrétní, test selže.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ unknown.

import { expectTypeOf } from 'vitest';

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

toBeNever

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ never.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ funkce.

import { expectTypeOf } from 'vitest';

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

toBeObject

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ objekt.

import { expectTypeOf } from 'vitest';

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

toBeArray

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ Array<T>.

import { expectTypeOf } from 'vitest';

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

toBeString

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ řetězec.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ boolean.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ void.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ symbol.

import { expectTypeOf } from 'vitest';

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

toBeNull

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ null.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Typ: () => void

Tento matcher kontroluje, zda je poskytnutý typ undefined.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Typ: () => void

Tento matcher ověřuje, zda daný typ umožňuje hodnoty null nebo undefined.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Typ: () => void

Tento matcher ověří, že danou funkci lze volat s uvedenými parametry.

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, což znemožní jeho řetězení s jinými matchery.

toBeConstructibleWith

Typ: () => void

Tento matcher zajišťuje, že můžete vytvořit novou instanci s určitými parametry 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, což znemožní jeho řetězení s jinými matchery.

toHaveProperty

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

Tento matcher kontroluje, zda daná vlastnost existuje na poskytnutém objektu. Pokud existuje, vrátí také stejnou sadu matcherů pro typ této vlastnosti, což umožňuje řetězení 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