expectTypeOf

Típus: <T>(a: unknown) => ExpectTypeOf

not

Típus: ExpectTypeOf

A .not metódussal negálhatod az összes állítást.

toEqualTypeOf

Típus: <T>(expected: T) => void

Ez a matcher azt ellenőrzi, hogy a típusok pontosan megegyeznek-e. Nem jelez hibát, ha két objektumnak eltérő értékei vannak, de a típusuk azonos. Viszont hibát jelez, ha egy objektumból hiányzik egy tulajdonság.

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

Típus: <T>(expected: T) => void

Ez a matcher azt ellenőrzi, hogy az elvárt típus kiterjeszti-e a megadott típust. Működése eltér a toEqual-től, és inkább az expect toMatchObject() függvényéhez hasonlít. Ezzel a matcherrel ellenőrizheted, hogy egy objektum "illeszkedik-e" egy típushoz.

import { expectTypeOf } from 'vitest';

expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 1 });
expectTypeOf<number>().toMatchTypeOf<string | number>();
expectTypeOf<string | number>().not.toMatchTypeOf<number>();

extract

Típus: ExpectTypeOf<ExtractedUnion>

A .extract segítségével szűkítheted a típusokat további teszteléshez.

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 }>() // Kiválasztja az utolsó típust egy unióból
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // Kiválaszt egy tömböt egy unióból
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Ha az unióban nem található a megadott típus, a .extract never értéket ad vissza.

exclude

Típus: ExpectTypeOf<NonExcludedUnion>

A .exclude segítségével kizárhatsz típusokat egy unióból további teszteléshez.

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

WARNING

Ha az unióban nem található a megadott típus, a .exclude never értéket ad vissza.

returns

Típus: ExpectTypeOf<ReturnValue>

A .returns segítségével kinyerheted egy függvény típusának visszatérési értékét.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

parameters

Típus: ExpectTypeOf<Parameters>

A függvény argumentumait a .parameters segítségével kérheted le, hogy állításokat végezhess az értékükön. A paraméterek tömbként kerülnek visszaadásra.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

TIP

Használhatod a .toBeCallableWith illesztőt is, ami kifejezőbb állítást tesz lehetővé.

parameter

Típus: (nth: number) => ExpectTypeOf

Egy adott függvény argumentumát a .parameter(number) hívással kérheted le, hogy további állításokat végezhess rajta.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

constructorParameters

Típus: ExpectTypeOf<ConstructorParameters>

A konstruktor paramétereit értéktömbként kérheted le, és állításokat végezhetsz rajtuk ezzel a módszerrel.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

TIP

Használhatod a .toBeConstructibleWith illesztőt is, ami kifejezőbb állítást tesz lehetővé.

instance

Típus: ExpectTypeOf<ConstructableInstance>

Ez a tulajdonság hozzáférést biztosít a matcherekhez, amelyek a megadott osztály egy példányán futtathatók.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

items

Típus: ExpectTypeOf<T>

A .items segítségével lekérheted a tömb elemének típusát további állításokhoz.

import { expectTypeOf } from 'vitest';

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

resolves

Típus: ExpectTypeOf<ResolvedPromise>

Ez az illesztő lekéri egy Promise feloldott értékének típusát, így további állításokat is végezhetsz rajta.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Ha nem promise típuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

guards

Típus: ExpectTypeOf<Guard>

Ez az illesztő lekéri a típusvédő értékét (pl. v is number), így állításokat végezhetsz vele.

import { expectTypeOf } from 'vitest';

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

WARNING

never értéket ad vissza, ha az érték nem típusvédő függvény, ezért nem láncolhatod más illesztőkkel.

asserts

Típus: ExpectTypeOf<Assert>

Ez az illesztő lekéri a típusellenőrző értékét (pl. assert v is number), így állításokat végezhetsz rajta.

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

never értéket ad vissza, ha az érték nem típusellenőrző függvény, ezért nem láncolhatod más illesztőkkel.

toBeAny

Típus: () => void

Ezzel az illesztővel ellenőrizheted, hogy a megadott típus any típus-e. Ha a típus ennél specifikusabb, a teszt sikertelen lesz.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus unknown típus-e.

import { expectTypeOf } from 'vitest';

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

toBeNever

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus never típus-e.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus function típus-e.

import { expectTypeOf } from 'vitest';

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

toBeObject

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus object típus-e.

import { expectTypeOf } from 'vitest';

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

toBeArray

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus Array<T> típus-e.

import { expectTypeOf } from 'vitest';

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

toBeString

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus string típus-e.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus boolean típus-e.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus void típus-e.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus symbol típus-e.

import { expectTypeOf } from 'vitest';

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

toBeNull

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus null típus-e.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus undefined típus-e.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Típus: () => void

Ez az illesztő ellenőrzi, hogy a megadott típus használható-e null vagy undefined értékkel.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Típus: () => void

Ez az illesztő biztosítja, hogy a megadott függvény meghívható a megadott paraméterekkel.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

toBeConstructibleWith

Típus: () => void

Ez az illesztő biztosítja, hogy létrehozható egy új példány a konstruktorral a megadott paraméterekkel.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvénytípuson használod, akkor never értéket ad vissza, ezért nem láncolhatod más illesztőkkel.

toHaveProperty

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

Ez az illesztő ellenőrzi, hogy létezik-e egy adott tulajdonság a megadott objektumon. Ha létezik, akkor visszaadja ugyanazt az illesztőkészletet a tulajdonság típusához, lehetővé téve az állítások láncolását.

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