expectTypeOf

WARNING

Bu fonksiyon çalışma zamanında hiçbir işlem gerçekleştirmez. Tip kontrolünü etkinleştirmek için --typecheck bayrağını geçirmeniz gerekir.

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

not

Tip: ExpectTypeOf

.not özelliğini kullanarak tüm doğrulamaları tersine çevirebilirsiniz.

toEqualTypeOf

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

Bu eşleştirici, tiplerin birbirine tamamen eşit olup olmadığını kontrol eder. İki nesne farklı değerlere sahip olsa bile aynı tipe sahipse başarısız olmaz. Ancak bir nesnede bir özellik eksikse başarısız olur.

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 kapsayıp kapsamadığını kontrol eder. toEqual'dan farklıdır ve expect'in toMatchObject()'ine daha benzerdir. Bu eşleştirici ile bir nesnenin bir tiple "eşleşip eşleşmediğini" 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 için tipleri daraltmak amacıyla .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 son tipi ayıklar
  .toEqualTypeOf<{
    xs?: CSSProperties;
    sm?: CSSProperties;
    md?: CSSProperties;
  }>();

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>() // union'dan bir diziyi ayıklar
  .toEqualTypeOf<CSSProperties[]>();

WARNING

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

exclude

Tip: ExpectTypeOf<NonExcludedUnion>

Daha fazla test için birleşimden tipleri kaldırmak amacıyla .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

Birleşimde 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 olmayan bir tip üzerinde kullanılırsa, never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

parameters

Tip: ExpectTypeOf<Parameters>

Fonksiyon argümanlarını .parameters ile çıkararak değerleri üzerinde testler yapabilirsiniz. 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 olmayan bir tip üzerinde kullanılırsa, never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

TIP

Daha açıklayıcı bir doğrulama için .toBeCallableWith eşleştiricisini de kullanabilirsiniz.

parameter

Tip: (nth: number) => ExpectTypeOf

Belirli bir fonksiyon argümanını .parameter(number) çağrısı ile çıkararak üzerinde başka doğrulamalar gerçekleştirebilirsiniz.

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 olmayan bir tip üzerinde kullanılırsa, never döndürür, bu nedenle diğer eşleştiricilerle zincirleme yapılamaz.

constructorParameters

Tip: ExpectTypeOf<ConstructorParameters>

Yapıcı parametrelerini bir değer dizisi olarak çıkarabilir ve bu yöntemle üzerlerinde doğrulamalar gerçekleştirebilirsiniz.

import { expectTypeOf } from 'vitest';

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

WARNING

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

TIP

Daha açıklayıcı bir doğrulama için .toBeConstructibleWith eşleştiricisini de kullanabilirsiniz.

instance

Tip: ExpectTypeOf<ConstructableInstance>

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

import { expectTypeOf } from 'vitest';

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

WARNING

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

items

Tip: ExpectTypeOf<T>

Dizi öğe tipini .items ile alarak daha fazla doğrulama gerçekleştirebilirsiniz.

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ğerini çıkarır, böylece üzerinde başka doğrulamalar gerçekleştirebilirsiniz.

import { expectTypeOf } from 'vitest';

async function asyncFunc() {
  return 123;
}

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

WARNING

Promise olmayan bir tür üzerinde 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 değerini (örn. v is number) çıkarır, böylece üzerinde doğrulamalar gerçekleştirebilirsiniz.

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 değerini (örn. assert v is number) çıkarır, böylece üzerinde doğrulamalar gerçekleştirebilirsiniz.

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 olup olmadığını kontrol edebilirsiniz. Tip çok spesifikse, test başarısız olacaktır.

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 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 never 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 içerebilip içermediğini kontrol eder.

import { expectTypeOf } from 'vitest';

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

toBeCallableWith

Tip: () => void

Bu eşleştirici, sağlanan fonksiyonu verilen parametrelerle çağırabileceğinizi doğrular.

import { expectTypeOf } from 'vitest';

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

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

WARNING

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

toBeConstructibleWith

Tip: () => void

Bu eşleştirici, bir dizi yapıcı parametre ile yeni bir instance oluşturabileceğinizi doğrular.

import { expectTypeOf } from 'vitest';

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

WARNING

Fonksiyon olmayan bir tip üzerinde kullanılı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 var olup olmadığını kontrol eder. Varsa, bu özelliğin tipi için aynı eşleştirici kümesini de döndürür, böylece doğrulamaları zincirleme olarak 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