expectTypeOf

WARNING

Futtatás közben ez a függvény nem végez semmilyen műveletet. A típusellenőrzés engedélyezéséhez ne felejtsd el átadni a --typecheck jelzőt.

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

not

Típus: ExpectTypeOf

Minden állítást tagadhatsz a .not tulajdonság használatával.

toEqualTypeOf

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

Ez az összehasonlító ellenőrzi, hogy a típusok teljesen egyenlőek-e. Ez az összehasonlító nem jelez hibát, ha két objektumnak különböző értékei vannak, de azonos a típusa. Azonban 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 az összehasonlító ellenőrzi, hogy az elvárt típus kiterjeszti-e a megadott típust. Ez különbözik a toEqual-tól, és inkább hasonlít az expect toMatchObject() metódusához. Ezzel az összehasonlítóval 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 }>() // kinyeri az unió utolsó típusát
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

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

WARNING

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

exclude

Típus: ExpectTypeOf<NonExcludedUnion>

A .exclude segítségével eltávolíthatsz 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 csak .exclude<unknown[] | { xs?: unknown }>()
  .toEqualTypeOf<CSSProperties>();

WARNING

Ha nem található típus az unióban, a .exclude never-t ad vissza.

returns

Típus: ExpectTypeOf<ReturnValue>

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

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

parameters

Típus: ExpectTypeOf<Parameters>

A .parameters segítségével kinyerheted a függvény paramétereit, hogy állításokat hajts végre rajtuk. 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ény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

TIP

Használhatod a .toBeCallableWith összehasonlítót is, mint kifejezőbb állítást.

parameter

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

Egy adott függvény argumentumát a .parameter(number) hívással nyerheted ki, hogy további állításokat hajts végre 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ény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

constructorParameters

Típus: ExpectTypeOf<ConstructorParameters>

Ezzel a metódussal kinyerheted a konstruktor paramétereit értékek tömbjeként, és állításokat hajthatsz végre rajtuk.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

TIP

Használhatod a .toBeConstructibleWith összehasonlítót is, mint kifejezőbb állítást.

instance

Típus: ExpectTypeOf<ConstructableInstance>

Ez a tulajdonság hozzáférést nyújt a matcherekhez, amelyek a megadott osztály egy példányán hajthatók végre.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

items

Típus: ExpectTypeOf<T>

A .items segítségével lekérheted a tömb elemtípusát további állítások végrehajtásához.

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 összehasonlító kinyeri egy Promise feloldott értékét, így más állításokat hajthatsz végre 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álják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

guards

Típus: ExpectTypeOf<Guard>

Ez az összehasonlító kinyeri az őr értékét (pl. v is number), így állításokat hajthatsz végre rajta.

import { expectTypeOf } from 'vitest';

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

WARNING

never-t ad vissza, ha az érték nem őrfüggvény, így nem láncolható más összehasonlítókkal.

asserts

Típus: ExpectTypeOf<Assert>

Ez az összehasonlító kinyeri az állítás értékét (pl. assert v is number), így állításokat hajthatsz végre 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-t ad vissza, ha az érték nem állításfüggvény, így nem láncolható más összehasonlítókkal.

toBeAny

Típus: () => void

Ezzel az összehasonlítóval ellenőrizheted, hogy a megadott típus any típusú-e. Ha a típus túl specifikus, 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító 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 összehasonlító ellenőrzi, hogy a megadott típus tartalmazhat-e null vagy undefined értéket.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Típus: () => void

Ez az összehasonlító biztosítja, hogy a megadott függvényt egy paraméterkészlettel hívhatod meg.

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ény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

toBeConstructibleWith

Típus: () => void

Ez az összehasonlító biztosítja, hogy új példányt hozhatsz létre egy konstruktor paraméterkészlettel.

import { expectTypeOf } from 'vitest';

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

WARNING

Ha nem függvény típuson használják, never-t ad vissza, így nem láncolható más összehasonlítókkal.

toHaveProperty

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

Ez az összehasonlító ellenőrzi, hogy egy tulajdonság létezik-e a megadott objektumon. Ha létezik, akkor ugyanazt az összehasonlító készletet adja vissza a tulajdonság típusára, így az állítások láncolhatók egymás után.

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