expectTypeOf

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

not

Tip: ExpectTypeOf

.not özelliği ile tüm karşılaştırmaların olumsuzunu alabilirsiniz.

toEqualTypeOf

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

Bu eşleştirici, tiplerin birbirine tam olarak eşit olup olmadığını kontrol eder. İki nesnenin değerleri farklı olsa bile tipleri aynıysa bu eşleştirici başarısız olmaz. Ancak bir nesnede bir özellik eksikse hata verir.

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

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

Bu eşleştirici, beklenen tipin sağlanan tipi genişletip genişletmediğini kontrol eder. toEqual'dan farklıdır ve expect'in toMatchObject()'ine daha çok benzer. Bu eşleştirici ile bir nesnenin bir tipe uyumlu olup olmadığını kontrol edebilirsiniz.

import { expectTypeOf } from 'vitest';

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

extract

Tip: ExpectTypeOf<ExtractedUnion>

Daha fazla test yapmak için tipleri daraltmak üzere .extract kullanabilirsiniz.

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 }>() // union'dan belirtilen türü alır
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // union'dan bir dizi çıkarır
  .toEqualTypeOf<CSSProperties[]>();

WARNING

Union'da hiçbir eşleşen tip bulunamazsa, .extract never döndürür.

exclude

Tip: ExpectTypeOf<NonExcludedUnion>

Daha fazla test için union'dan tipleri kaldırmak için .exclude kullanabilirsiniz.

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

WARNING

Union'da hiçbir tip bulunamazsa, .exclude never döndürür.

returns

Tip: ExpectTypeOf<ReturnValue>

Bir fonksiyon tipinin dönüş değerini elde etmek için .returns kullanabilirsiniz.

import { expectTypeOf } from 'vitest';

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

parameters

Tip: ExpectTypeOf<Parameters>

Fonksiyon argümanlarına ait türleri, değerleri üzerinde iddialarda bulunmak için .parameters ile elde edebilirsiniz. Parametreler bir dizi olarak döndürülür.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

TIP

Daha anlamlı bir iddia olarak .toBeCallableWith eşleştiricisini de kullanabilirsiniz.

parameter

Tip: (nth: number) => ExpectTypeOf

Üzerinde başka iddialarda bulunmak için .parameter(number) fonksiyonu ile belirli bir fonksiyon argümanının türünü elde edebilirsiniz.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

constructorParameters

Tip: ExpectTypeOf<ConstructorParameters>

Kurucu parametrelerinin türlerini bir dizi olarak elde edebilir ve bu yöntemle üzerlerinde iddialarda bulunabilirsiniz.

import { expectTypeOf } from 'vitest';

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

TIP

Daha anlamlı bir iddia olarak .toBeConstructibleWith eşleştiricisini de kullanabilirsiniz.

instance

Tip: ExpectTypeOf<ConstructableInstance>

Bu özellik, sağlanan sınıfın bir örneği üzerinde kullanılabilecek eşleştiricilere erişim sağlar.

import { expectTypeOf } from 'vitest';

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

items

Tip: ExpectTypeOf<T>

Daha fazla iddiada bulunmak için .items ile dizi öğesi tipini alabilirsiniz.

import { expectTypeOf } from 'vitest';

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

resolves

Tip: ExpectTypeOf<ResolvedPromise>

Bu eşleştirici, bir Promise'in çözümlenmiş değerinin türünü elde eder, böylece üzerinde başka iddialarda bulunabilirsiniz.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Promise olmayan bir tipte kullanılırsa, never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

guards

Tip: ExpectTypeOf<Guard>

Bu eşleştirici, guard türünü (örneğin, v is number) elde eder, böylece üzerinde iddialarda bulunabilirsiniz.

import { expectTypeOf } from 'vitest';

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

WARNING

Değer bir guard fonksiyonu değilse never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

asserts

Tip: ExpectTypeOf<Assert>

Bu eşleştirici, assert türünü (örneğin, assert v is number) elde eder, böylece üzerinde iddialarda bulunabilirsiniz.

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

Değer bir assert fonksiyonu değilse never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

toBeAny

Tip: () => void

Bu eşleştirici ile sağlanan tipin any tipi olup olmadığını kontrol edebilirsiniz. Tip çok spesifikse, test başarısız olur.

import { expectTypeOf } from 'vitest';

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

toBeUnknown

Tip: () => void

Bu eşleştirici, sağlanan tipin unknown tipi olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeNever

Tip: () => void

Bu eşleştirici, sağlanan tipin bir never tipi olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeFunction

Tip: () => void

Bu eşleştirici, sağlanan tipin bir function olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeObject

Tip: () => void

Bu eşleştirici, sağlanan tipin bir object olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeArray

Tip: () => void

Bu eşleştirici, sağlanan tipin Array<T> olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeString

Tip: () => void

Bu eşleştirici, sağlanan tipin bir string olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeBoolean

Tip: () => void

Bu eşleştirici, sağlanan tipin boolean olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeVoid

Tip: () => void

Bu eşleştirici, sağlanan tipin void olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeSymbol

Tip: () => void

Bu eşleştirici, sağlanan tipin bir symbol olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeNull

Tip: () => void

Bu eşleştirici, sağlanan tipin null olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeUndefined

Tip: () => void

Bu eşleştirici, sağlanan tipin undefined olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeNullable

Tip: () => void

Bu eşleştirici, sağlanan tipin null veya undefined değerlerini alabilir olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Tip: () => void

Bu eşleştirici, sağlanan fonksiyonun belirtilen parametrelerle çağrılabilir olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

toBeConstructibleWith

Tip: () => void

Bu eşleştirici, belirtilen kurucu parametreleri ile yeni bir örnek oluşturulabilir olup olmadığını kontrol eder.

import { expectTypeOf } from 'vitest';

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

WARNING

Fonksiyon türünde olmayan bir değere uygulanırsa never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

toHaveProperty

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

Bu eşleştirici, sağlanan nesnede bir özelliğin olup olmadığını kontrol eder. Eğer özellik varsa, bu özelliğin türü için de aynı eşleştirici kümesini döndürür, böylece iddiaları zincirleme şekilde kullanabilirsiniz.

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