assert

Vitest, iddiaları doğrulamak amacıyla chai kütüphanesinden assert metodunu yeniden kullanır.

assert

• Tür: (expression: any, message?: string) => asserts expression

Verilen expression'ın doğru (truthy) bir değer olduğunu, aksi takdirde doğrulamanın başarısız olacağını belirtir.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', "foo, bar'a eşit olmamalıdır");
});

fail

• Tür:
  • (message?: string) => never
  • <T>(actual: T, expected: T, message?: string, operator?: string) => never

Bir iddia hatası oluşturur.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('başarısızlık mesajı');
  assert.fail('foo', 'bar', 'foo bar değil', '===');
});

isOk

• Tür: <T>(value: T, message?: string) => void
• Takma Adı: ok

Verilen value'nun doğru (truthy) bir değer olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'her doğru değer kabul edilir');
  assert.isOk(true, 'bu geçerli olacak çünkü true doğru bir değerdir');
});

isNotOk

• Tür: <T>(value: T, message?: string) => void
• Takma Adı: notOk

Verilen value'nun yanlış (falsy) bir değer olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('', 'bu geçerli olacak, boş string yanlış bir değerdir');
  assert.isNotOk(false, 'bu da geçerli olacak çünkü false yanlış bir değerdir');
});

equal

• Tür: <T>(actual: T, expected: T, message?: string) => void

actual ve expected'ın gevşek eşitliğini (==) kontrol eder. Değerler aynı türe sahip olmasa bile eşit olabilirler.

import { assert, test } from 'vitest';

test('assert.equal', () => {
  assert.equal(Math.sqrt(4), '2');
});

notEqual

• Tür: <T>(actual: T, expected: T, message?: string) => void

actual ve expected'ın gevşek eşitsizliğini (!=) kontrol eder.

import { assert, test } from 'vitest';

test('assert.notEqual', () => {
  assert.notEqual(Math.sqrt(4), 3);
});

strictEqual

• Tür: <T>(actual: T, expected: T, message?: string) => void

actual ve expected'ın katı eşitliğini (===) kontrol eder. Değerlerin hem değeri hem de türü aynı olmalıdır.

import { assert, test } from 'vitest';

test('assert.strictEqual', () => {
  assert.strictEqual(Math.sqrt(4), 2);
});

deepEqual

• Tür: <T>(actual: T, expected: T, message?: string) => void

actual'ın expected'a derinlemesine eşit olduğunu belirtir. Nesnelerin ve dizilerin içeriği karşılaştırılır.

import { assert, test } from 'vitest';

test('assert.deepEqual', () => {
  assert.deepEqual({ color: 'green' }, { color: 'green' });
});

notDeepEqual

• Tür: <T>(actual: T, expected: T, message?: string) => void

actual'ın expected'a derinlemesine eşit olmadığını belirtir.

import { assert, test } from 'vitest';

test('assert.notDeepEqual', () => {
  assert.notDeepEqual({ color: 'green' }, { color: 'red' });
});

isAbove

• Tür: (valueToCheck: number, valueToBeAbove: number, message?: string) => void

valueToCheck'in valueToBeAbove'dan büyük (>) olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, "5, 2'den büyüktür");
});

isAtLeast

• Tür: (valueToCheck: number, valueToBeAtLeast: number, message?: string) => void

valueToCheck'in valueToBeAtLeast'e eşit veya büyük (>=) olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, "5, 2'ye eşit veya büyüktür");
  assert.isAtLeast(3, 3, "3, 3'e eşit veya büyüktür");
});

isBelow

• Tür: (valueToCheck: number, valueToBeBelow: number, message?: string) => void

valueToCheck'in valueToBeBelow'dan küçük (<) olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, "3, 6'dan küçüktür");
});

isAtMost

• Tür: (valueToCheck: number, valueToBeAtMost: number, message?: string) => void

valueToCheck'in valueToBeAtMost'e eşit veya küçük (<=) olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, "3, 6'ya eşit veya küçüktür");
  assert.isAtMost(4, 4, "4, 4'e eşit veya küçüktür");
});

isTrue

• Tür: <T>(value: T, message?: string) => void

value'nun true (doğru) olduğunu belirtir. Değerin boolean true olması gerekir.

import { assert, test } from 'vitest';

const testPassed = true;

test('assert.isTrue', () => {
  assert.isTrue(testPassed);
});

isNotTrue

• Tür: <T>(value: T, message?: string) => void

value'nun true (doğru) olmadığını belirtir. Değerin boolean true olmaması gerekir.

import { assert, test } from 'vitest';

const testPassed = 'ok';

test('assert.isNotTrue', () => {
  assert.isNotTrue(testPassed);
});

isFalse

• Tür: <T>(value: T, message?: string) => void

value'nun false (yanlış) olduğunu belirtir. Değerin boolean false olması gerekir.

import { assert, test } from 'vitest';

const testPassed = false;

test('assert.isFalse', () => {
  assert.isFalse(testPassed);
});

isNotFalse

• Tür: <T>(value: T, message?: string) => void

value'nun false (yanlış) olmadığını belirtir. Değerin boolean false olmaması gerekir.

import { assert, test } from 'vitest';

const testPassed = 'no';

test('assert.isNotFalse', () => {
  assert.isNotFalse(testPassed);
});

isNull

• Tür: <T>(value: T, message?: string) => void

value'nun null olduğunu belirtir.

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, "hata null'dır");
});

isNotNull

• Tür: <T>(value: T, message?: string) => void

value'nun null olmadığını belirtir.

import { assert, test } from 'vitest';

const error = { message: 'hata oluştu' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'hata null değildir, bir nesnedir');
});

isNaN

• Tür: <T>(value: T, message?: string) => void

value'nun NaN (Sayı Değil) olduğunu belirtir.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

test('assert.isNaN', () => {
  assert.isNaN(calculation, '1 * "vitest" NaN\'dır');
});

isNotNaN

• Tür: <T>(value: T, message?: string) => void

value'nun NaN (Sayı Değil) olmadığını belirtir.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, "1 * 2 NaN değildir, 2'dir");
});

exists

• Tür: <T>(value: T, message?: string) => void

value'nun null veya undefined olmadığını belirtir.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo ne null ne de undefined');
});

notExists

• Tür: <T>(value: T, message?: string) => void

value'nun null veya undefined olduğunu kontrol eder.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo null, bu yüzden mevcut değil');
  assert.notExists(bar, 'bar undefined, bu yüzden mevcut değil');
});

isUndefined

• Tür: <T>(value: T, message?: string) => void

value'nun undefined olduğunu kontrol eder.

import { assert, test } from 'vitest';

const name = undefined;

test('assert.isUndefined', () => {
  assert.isUndefined(name, "ad undefined'dır");
});

isDefined

• Tür: <T>(value: T, message?: string) => void

value'nun undefined olmadığını, yani tanımlı olduğunu kontrol eder.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'ad undefined değildir');
});

isFunction

• Tür: <T>(value: T, message?: string) => void
• Takma Adı: isCallablevalue'nun bir fonksiyon olduğunu kontrol eder.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'ad bir fonksiyondur');
});

isNotFunction

• Tür: <T>(value: T, message?: string) => void
• Takma Adı: isNotCallable

value'nun bir fonksiyon olmadığını kontrol eder.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, "ad bir fonksiyon değildir, bir string'dir");
});

isObject

• Tür: <T>(value: T, message?: string) => void

value'nun bir Object türünde nesne olduğunu belirtir (Object.prototype.toString tarafından belirlendiği gibi). Bu doğrulama, alt sınıflı nesneler için de geçerlidir.

import { assert, test } from 'vitest';

const someThing = { color: 'red', shape: 'circle' };

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing bir nesnedir');
});

isNotObject

• Tür: <T>(value: T, message?: string) => void

value'nun, Object.prototype.toString tarafından belirlenen Object türünde bir nesne olmadığını belirtir. Bu doğrulama, alt sınıf nesneleriyle eşleşmez.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing bir nesne değil, string');
});

isArray

• Tür: <T>(value: T, message?: string) => void

value'nun bir dizi (array) olduğunu belirtir.

import { assert, test } from 'vitest';

const color = ['red', 'green', 'yellow'];

test('assert.isArray', () => {
  assert.isArray(color, 'color bir dizi');
});

isNotArray

• Tür: <T>(value: T, message?: string) => void

value'nun bir dizi (array) olmadığını belirtir.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color bir dizi değil, string');
});

isString

• Tür: <T>(value: T, message?: string) => void

value'nun bir string (dize) olduğunu belirtir.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color bir dize');
});

isNotString

• Tür: <T>(value: T, message?: string) => void

value'nun bir string (dize) olmadığını belirtir.

import { assert, test } from 'vitest';

const color = ['red', 'green', 'yellow'];

test('assert.isNotString', () => {
  assert.isNotString(color, 'color bir dize değil, dizi');
});

isNumber

• Tür: <T>(value: T, message?: string) => void

value'nun bir sayı (number) olduğunu belirtir.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors bir sayı');
});

isNotNumber

• Tür: <T>(value: T, message?: string) => void

value'nun bir sayı (number) olmadığını belirtir.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors bir sayı değil, dize');
});

isFinite

• Tür: <T>(value: T, message?: string) => void

value'nun sonlu (finite) bir sayı olduğunu belirtir (NaN veya Infinity olmayan).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors NaN veya Infinity olmayan sonlu bir sayı');
});

isBoolean

• Tür: <T>(value: T, message?: string) => void

value'nun bir boolean (mantıksal değer) olduğunu belirtir.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady bir mantıksal değer');
});

isNotBoolean

• Tür: <T>(value: T, message?: string) => void

value'nun bir boolean (mantıksal değer) olmadığını belirtir.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isBoolean(isReady, 'isReady bir boolean değil, string');
});

typeOf

• Tür: <T>(value: T, name: string, message?: string) => void

value'nun türünün, Object.prototype.toString tarafından belirlendiği gibi name ile aynı olduğunu belirtir.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'bir nesnemiz var');
  assert.typeOf(['red', 'green'], 'array', 'bir dizimiz var');
  assert.typeOf('red', 'string', 'bir stringimiz var');
  assert.typeOf(/red/, 'regexp', 'bir regular expressionımız var');
  assert.typeOf(null, 'null', 'bir null değerimiz var');
  assert.typeOf(undefined, 'undefined', 'bir undefined değerimiz var');
});

notTypeOf

• Tür: <T>(value: T, name: string, message?: string) => void

value'nun türünün, Object.prototype.toString tarafından belirlendiği gibi name ile aynı olmadığını belirtir.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" bir sayı değil');
});

instanceOf

• Tür: <T>(value: T, constructor: Function, message?: string) => void

value'nun constructor fonksiyonunun bir örneği (instance) olduğunu belirtir.

import { assert, test } from 'vitest';

function Person(name) {
  this.name = name;
}
const foo = new Person('foo');

class Tea {
  constructor(name) {
    this.name = name;
  }
}
const coffee = new Tea('coffee');

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Person, 'foo, Person sınıfının bir örneği');
  assert.instanceOf(coffee, Tea, 'coffee, Tea sınıfının bir örneği');
});

notInstanceOf

• Tür: <T>(value: T, constructor: Function, message?: string) => void

value'nun constructor fonksiyonunun bir örneği (instance) olmadığını belirtir.

import { assert, test } from 'vitest';

function Person(name) {
  this.name = name;
}
const foo = new Person('foo');

class Tea {
  constructor(name) {
    this.name = name;
  }
}
const coffee = new Tea('coffee');

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Tea, 'foo, Tea sınıfının bir örneği değil');
});

include

• Tür:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: Partial<T>, message?: string) => void

haystack'in needle'ı içerdiğini belirtir. Dizi elemanlarını, string alt dizelerini veya nesne özelliklerini kontrol etmek için kullanılabilir.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'dizi değeri içeriyor');
  assert.include('foobar', 'foo', 'string alt dizeyi içeriyor');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'nesne özelliği içeriyor'
  );
});

notInclude

• Tür:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: Partial<T>, message?: string) => void

haystack'in needle'ı içermediğini belirtir. Dizi elemanlarının, string alt dizelerinin veya nesne özelliklerinin yokluğunu kontrol etmek için kullanılabilir.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, "dizi 4'ü içermiyor");
  assert.notInclude('foobar', 'baz', "foobar, baz'ı içermiyor");
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'nesne özelliği içermiyor'
  );
});

deepInclude

• Tür:
• (haystack: string, needle: string, message?: string) => void
• <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
• <T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void

haystack'in needle'ı içerdiğini belirtir. Dizi elemanlarını veya nesne özelliklerini derinlemesine (deeply) karşılaştırarak kontrol etmek için kullanılabilir. Derin eşitlik (deep equality) kullanılır.

import { assert, test } from 'vitest';

const obj1 = { a: 1 };
const obj2 = { b: 2 };

test('assert.deepInclude', () => {
  assert.deepInclude([obj1, obj2], { a: 1 });
  assert.deepInclude({ foo: obj1, bar: obj2 }, { foo: { a: 1 } });
});

notDeepInclude

• Tür:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void

haystack'in needle'ı içermediğini belirtir. Dizi elemanlarının veya nesne özelliklerinin derinlemesine (deeply) karşılaştırılarak yokluğunu kontrol etmek için kullanılabilir. Derin eşitlik (deep equality) kontrolü yapılır.

import { assert, test } from 'vitest';

const obj1 = { a: 1 };
const obj2 = { b: 2 };

test('assert.notDeepInclude', () => {
  assert.notDeepInclude([obj1, obj2], { a: 10 });
  assert.notDeepInclude({ foo: obj1, bar: obj2 }, { foo: { a: 10 } });
});

nestedInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içerdiğini belirtir. İç içe geçmiş (nested) nesne özelliklerini nokta ve köşeli parantez notasyonu ile kontrol etmeyi sağlar. Özel karakterler çift ters eğik çizgi (double backslash) ile escape edilebilir.

import { assert, test } from 'vitest';

test('assert.nestedInclude', () => {
  assert.nestedInclude({ '.a': { b: 'x' } }, { '\\.a.[b]': 'x' });
  assert.nestedInclude({ a: { '[b]': 'x' } }, { 'a.\\[b\\]': 'x' });
});

notNestedInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içermediğini belirtir. İç içe geçmiş (nested) nesne özelliklerinin yokluğunu nokta ve köşeli parantez notasyonu ile kontrol etmeyi sağlar. Özel karakterler çift ters eğik çizgi (double backslash) ile escape edilebilir.

import { assert, test } from 'vitest';

test('assert.nestedInclude', () => {
  assert.notNestedInclude({ '.a': { b: 'x' } }, { '\\.a.b': 'y' });
  assert.notNestedInclude({ a: { '[b]': 'x' } }, { 'a.\\[b\\]': 'y' });
});

deepNestedInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içerdiğini doğrular. İç içe geçmiş (nested) nesne özelliklerini derinlemesine (deeply) karşılaştırarak nokta ve köşeli parantez notasyonu ile kontrol etmeyi sağlar. Özel karakterler çift ters eğik çizgi (double backslash) ile escape edilebilir.

import { assert, test } from 'vitest';

test('assert.deepNestedInclude', () => {
  assert.deepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { x: 1 } });
  assert.deepNestedInclude(
    { '.a': { '[b]': { x: 1 } } },
    { '\\.a.\\[b\\]': { x: 1 } }
  );
});

notDeepNestedInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystackin needle'ı içermediğini doğrular. İç içe geçmiş (nested) nesne özelliklerinin derinlemesine (deeply) karşılaştırılarak yokluğunu nokta ve köşeli parantez notasyonu ile kontrol etmeyi sağlar. Özel karakterler çift ters eğik çizgi (double backslash) ile escape edilebilir.

import { assert, test } from 'vitest';

test('assert.notDeepNestedInclude', () => {
  assert.notDeepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { y: 1 } });
  assert.notDeepNestedInclude(
    { '.a': { '[b]': { x: 1 } } },
    { '\\.a.\\[b\\]': { y: 2 } }
  );
});

ownInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içerdiğini belirtir. Kalıtılmış (inherited) özellikleri dikkate almadan, sadece nesnenin kendi (own) özelliklerini kontrol etmek için kullanılabilir.

import { assert, test } from 'vitest';

test('assert.ownInclude', () => {
  assert.ownInclude({ a: 1 }, { a: 1 });
});

notOwnInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içermediğini belirtir. Kalıtılmış (inherited) özellikleri dikkate almadan, sadece nesnenin kendi (own) özelliklerinin yokluğunu kontrol etmek için kullanılabilir.

import { assert, test } from 'vitest';

const obj1 = {
  b: 2,
};

const obj2 = Object.create(obj1);
obj2.a = 1;

test('assert.notOwnInclude', () => {
  assert.notOwnInclude(obj2, { b: 2 });
});

deepOwnInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içerdiğini doğrular. Kalıtılmış özellikleri dikkate almaz ve derinlemesine karşılaştırma yapar. Bir nesnenin özelliklerinin bir alt kümesinin dahil edilmesini doğrulamak için kullanılabilir. haystack (samanlık) ve needle (iğne) terimleri, aranan veri yapısını ve aranan değeri temsil eder.

import { assert, test } from 'vitest';

test('assert.deepOwnInclude', () => {
  assert.deepOwnInclude({ a: { b: 2 } }, { a: { b: 2 } });
});

notDeepOwnInclude

• Tür: (haystack: any, needle: any, message?: string) => void

haystack'in needle'ı içermediğini doğrular. Kalıtılmış özellikleri dikkate almaz ve derinlemesine karşılaştırma yapar. Bir nesnenin özelliklerinin bir alt kümesinin yokluğunu doğrulamak için kullanılabilir. haystack (samanlık) ve needle (iğne) terimleri, aranan veri yapısını ve aranan değeri temsil eder.

import { assert, test } from 'vitest';

test('assert.notDeepOwnInclude', () => {
  assert.notDeepOwnInclude({ a: { b: 2 } }, { a: { c: 3 } });
});

match

• Tür: (value: string, regexp: RegExp, message?: string) => void

value'nun regexp (düzenli ifade) ile eşleştiğini doğrular.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'regexp eşleşiyor');
});

notMatch

• Tür: (value: string, regexp: RegExp, message?: string) => void

value'nun regexp (düzenli ifade) ile eşleşmediğini doğrular.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'regexp eşleşmiyor');
});

property

• Tür: <T>(object: T, property: string, message?: string) => void

object'in property ile belirtilen doğrudan veya kalıtılmış bir özelliğe sahip olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.property', () => {
  assert.property({ tea: { green: 'matcha' } }, 'tea');
  assert.property({ tea: { green: 'matcha' } }, 'toString');
});

notProperty

• Tür: <T>(object: T, property: string, message?: string) => void

object'in property ile belirtilen doğrudan veya kalıtılmış bir özelliğe sahip olmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.notProperty', () => {
  assert.notProperty({ tea: { green: 'matcha' } }, 'coffee');
});

propertyVal

• Tür: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property ile belirtilen ve değeri value olan doğrudan veya kalıtılmış bir özelliğe sahip olduğunu doğrular. Katı eşitlik (===) kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.propertyVal', () => {
  assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
});

notPropertyVal

• Tür: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property ile belirtilen ve değeri value olan doğrudan veya kalıtılmış bir özelliğe sahip olmadığını doğrular. Katı eşitlik (===) kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notPropertyVal', () => {
  assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');
  assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');
});

deepPropertyVal

• Tür: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property ile belirtilen ve değeri value olan doğrudan veya kalıtılmış bir özelliğe sahip olduğunu doğrular. Derinlemesine karşılaştırma kullanır.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', {
    green: 'matcha',
  });
});

notDeepPropertyVal

• Tür: <T, V>(object: T, property: string, value: V, message?: string) => void

object'in property ile belirtilen ve değeri value olan doğrudan veya kalıtılmış bir özelliğe sahip olmadığını doğrular. Derinlemesine karşılaştırma kullanır.

import { assert, test } from 'vitest';

test('assert.notDeepPropertyVal', () => {
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', {
    black: 'matcha',
  });
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', {
    green: 'oolong',
  });
  assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', {
    green: 'matcha',
  });
});

nestedProperty

• Tür: <T>(object: T, property: string, message?: string) => void

object'in property ile belirtilen doğrudan veya kalıtılmış bir özelliğe sahip olduğunu doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanan bir dize olabilir.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  assert.nestedProperty({ tea: { green: 'matcha' } }, 'tea.green');
});

notNestedProperty

• Tür: <T>(object: T, property: string, message?: string) => void

object'in property ile belirtilen doğrudan veya kalıtılmış bir özelliğe sahip olmadığını doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanan bir dize olabilir.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  assert.notNestedProperty({ tea: { green: 'matcha' } }, 'tea.oolong');
});

nestedPropertyVal

• Tür: <T>(object: T, property: string, value: any, message?: string) => void

object'in property ile belirtilen ve değeri value olan bir özelliğe sahip olduğunu doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanabilir. Katı eşitlik (===) kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.nestedPropertyVal', () => {
  assert.nestedPropertyVal({ tea: { green: 'matcha' } }, 'tea.green', 'matcha');
});

notNestedPropertyVal

• Tür: <T>(object: T, property: string, value: any, message?: string) => void

object'in property ile belirtilen ve değeri value olan bir özelliğe sahip olmadığını doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanabilir. Katı eşitlik (===) kontrolü kullanır.

import { assert, test } from 'vitest';

test('assert.notNestedPropertyVal', () => {
  assert.notNestedPropertyVal(
    { tea: { green: 'matcha' } },
    'tea.green',
    'konacha'
  );
  assert.notNestedPropertyVal(
    { tea: { green: 'matcha' } },
    'coffee.green',
    'matcha'
  );
});

deepNestedPropertyVal

• Tür: <T>(object: T, property: string, value: any, message?: string) => void

objectin property ile belirtilen ve değeri value olan bir özelliğe sahip olduğunu doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanabilir. Derinlemesine karşılaştırma kullanır.

import { assert, test } from 'vitest';

test('assert.deepNestedPropertyVal', () => {
  assert.deepNestedPropertyVal(
    { tea: { green: 'matcha' } },
    'tea.green',
    'konacha'
  );
  assert.deepNestedPropertyVal(
    { tea: { green: 'matcha' } },
    'coffee.green',
    'matcha'
  );
});

notDeepNestedPropertyVal

• Tür: <T>(object: T, property: string, value: any, message?: string) => void

objectin property ile belirtilen ve değeri value olan bir özelliğe sahip olmadığını doğrular. property, iç içe geçmiş özellik referansı için nokta ve köşeli parantez notasyonu kullanabilir. Derinlemesine karşılaştırma kullanır.

import { assert, test } from 'vitest';

test('assert.notDeepNestedPropertyVal', () => {
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.green',
    { oolong: 'yum' }
  );
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.green',
    { matcha: 'yuck' }
  );
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.black',
    { matcha: 'yum' }
  );
});

lengthOf

• Tür: <T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void

object'in beklenen length veya size değerine sahip olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'dizi 3 uzunluğunda');
  assert.lengthOf('foobar', 6, 'dize 6 uzunluğunda');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'küme 3 uzunluğunda');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'harita 3 uzunluğunda'
  );
});

hasAnyKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys dizisindeki anahtarlardan en az birine sahip olduğunu doğrular. Anahtar dizisi yerine bir nesne de verilebilir. Bu durumda nesnenin anahtarları kullanılır.

import { assert, test } from 'vitest';

test('assert.hasAnyKeys', () => {
  assert.hasAnyKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'iDontExist', 'baz']);
  assert.hasAnyKeys(
    { foo: 1, bar: 2, baz: 3 },
    { foo: 30, iDontExist: 99, baz: 1337 }
  );
  assert.hasAnyKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ foo: 1 }, 'key']
  );
  assert.hasAnyKeys(new Set([{ foo: 'bar' }, 'anotherKey']), [
    { foo: 'bar' },
    'anotherKey',
  ]);
});

hasAllKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys dizisindeki tüm anahtarlara sahip olduğunu doğrular. Anahtar dizisi yerine bir nesne de verilebilir. Bu durumda nesnenin anahtarları kullanılır.

import { assert, test } from 'vitest';

test('assert.hasAllKeys', () => {
  assert.hasAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'bar', 'baz']);
  assert.hasAllKeys(
    { foo: 1, bar: 2, baz: 3 },
    { foo: 30, bar: 99, baz: 1337 }
  );
  assert.hasAllKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ foo: 1 }, 'key']
  );
  assert.hasAllKeys(
    new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }, 'anotherKey'])
  );
});

containsAllKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in sağlanan keys dizisindeki tüm anahtarlara sahip olduğunu, ancak listelenmeyen başka anahtarlara da sahip olabileceğini doğrular. Anahtar dizisi yerine bir nesne de verilebilir. Bu durumda nesnenin anahtarları kullanılır.

import { assert, test } from 'vitest';

test('assert.containsAllKeys', () => {
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'baz']);
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, ['foo', 'bar', 'baz']);
  assert.containsAllKeys({ foo: 1, bar: 2, baz: 3 }, { foo: 30, baz: 1337 });
  assert.containsAllKeys(
    { foo: 1, bar: 2, baz: 3 },
    { foo: 30, bar: 99, baz: 1337 }
  );
  assert.containsAllKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ foo: 1 }]
  );
  assert.containsAllKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ foo: 1 }, 'key']
  );
  assert.containsAllKeys(
    new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }])
  );
  assert.containsAllKeys(
    new Set([{ foo: 'bar' }, 'anotherKey'], [{ foo: 'bar' }, 'anotherKey'])
  );
});

doesNotHaveAnyKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki hiçbir anahtarı içermediğini doğrular. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.doesNotHaveAnyKeys', () => {
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, [
    'one',
    'two',
    'example',
  ]);
  assert.doesNotHaveAnyKeys(
    { foo: 1, bar: 2, baz: 3 },
    { one: 1, two: 2, example: 'foo' }
  );
  assert.doesNotHaveAnyKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ one: 'two' }, 'example']
  );
  assert.doesNotHaveAnyKeys(
    new Set([{ foo: 'bar' }, 'anotherKey'], [{ one: 'two' }, 'example'])
  );
});

doesNotHaveAllKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki tüm anahtarları içermediğini, yani en az bir anahtarın bulunmadığını doğrular. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.doesNotHaveAllKeys', () => {
  assert.doesNotHaveAnyKeys({ foo: 1, bar: 2, baz: 3 }, [
    'one',
    'two',
    'example',
  ]);
  assert.doesNotHaveAnyKeys(
    { foo: 1, bar: 2, baz: 3 },
    { one: 1, two: 2, example: 'foo' }
  );
  assert.doesNotHaveAnyKeys(
    new Map([
      [{ foo: 1 }, 'bar'],
      ['key', 'value'],
    ]),
    [{ one: 'two' }, 'example']
  );
  assert.doesNotHaveAnyKeys(new Set([{ foo: 'bar' }, 'anotherKey']), [
    { one: 'two' },
    'example',
  ]);
});

hasAnyDeepKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki anahtarlardan en az birini içerdiğini doğrular. Set ve Map veri yapıları anahtar olarak nesneler içerebileceğinden, bu iddiayı derinlemesine bir karşılaştırma yapmak için kullanabilirsiniz. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.hasAnyDeepKeys', () => {
  assert.hasAnyDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [1, 2],
    ]),
    { one: 'one' }
  );
  assert.hasAnyDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [1, 2],
    ]),
    [{ one: 'one' }, { two: 'two' }]
  );
  assert.hasAnyDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [{ two: 'two' }, 'valueTwo'],
    ]),
    [{ one: 'one' }, { two: 'two' }]
  );
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), {
    one: 'one',
  });
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { one: 'one' },
    { three: 'three' },
  ]);
  assert.hasAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { one: 'one' },
    { two: 'two' },
  ]);
});

hasAllDeepKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki tüm anahtarları içerdiğini doğrular. Set ve Map veri yapıları anahtar olarak nesneler içerebileceğinden, bu iddiayı derinlemesine bir karşılaştırma yapmak için kullanabilirsiniz. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.hasAllDeepKeys', () => {
  assert.hasAllDeepKeys(new Map([[{ one: 'one' }, 'valueOne']]), {
    one: 'one',
  });
  assert.hasAllDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [{ two: 'two' }, 'valueTwo'],
    ]),
    [{ one: 'one' }, { two: 'two' }]
  );
  assert.hasAllDeepKeys(new Set([{ one: 'one' }]), { one: 'one' });
  assert.hasAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { one: 'one' },
    { two: 'two' },
  ]);
});

containsAllDeepKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki tüm anahtarları içerdiğini doğrular. Set ve Map veri yapıları anahtar olarak nesneler içerebileceğinden, bu iddiayı derinlemesine bir karşılaştırma yapmak için kullanabilirsiniz. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.containsAllDeepKeys', () => {
  assert.containsAllDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [1, 2],
    ]),
    { one: 'one' }
  );
  assert.containsAllDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [{ two: 'two' }, 'valueTwo'],
    ]),
    [{ one: 'one' }, { two: 'two' }]
  );
  assert.containsAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), {
    one: 'one',
  });
  assert.containsAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { one: 'one' },
    { two: 'two' },
  ]);
});

doesNotHaveAnyDeepKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki hiçbir anahtarı içermediğini doğrular. Set ve Map veri yapıları anahtar olarak nesneler içerebileceğinden, bu iddiayı derinlemesine bir karşılaştırma yapmak için kullanabilirsiniz. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.doesNotHaveAnyDeepKeys', () => {
  assert.doesNotHaveAnyDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [1, 2],
    ]),
    { thisDoesNot: 'exist' }
  );
  assert.doesNotHaveAnyDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [{ two: 'two' }, 'valueTwo'],
    ]),
    [{ twenty: 'twenty' }, { fifty: 'fifty' }]
  );
  assert.doesNotHaveAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), {
    twenty: 'twenty',
  });
  assert.doesNotHaveAnyDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { twenty: 'twenty' },
    { fifty: 'fifty' },
  ]);
});

doesNotHaveAllDeepKeys

• Tür: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

object'in, belirtilen keys dizisindeki tüm anahtarları içermediğini, yani en az bir anahtarın bulunmadığını doğrular. Set ve Map veri yapıları anahtar olarak nesneler içerebileceğinden, bu iddiayı derinlemesine bir karşılaştırma yapmak için kullanabilirsiniz. Anahtar dizisi yerine, anahtarları beklenen anahtar kümesi olarak kullanılacak bir nesne de sağlayabilirsiniz.

import { assert, test } from 'vitest';

test('assert.doesNotHaveAllDeepKeys', () => {
  assert.doesNotHaveAllDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [1, 2],
    ]),
    { thisDoesNot: 'exist' }
  );
  assert.doesNotHaveAllDeepKeys(
    new Map([
      [{ one: 'one' }, 'valueOne'],
      [{ two: 'two' }, 'valueTwo'],
    ]),
    [{ twenty: 'twenty' }, { one: 'one' }]
  );
  assert.doesNotHaveAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), {
    twenty: 'twenty',
  });
  assert.doesNotHaveAllDeepKeys(new Set([{ one: 'one' }, { two: 'two' }]), [
    { one: 'one' },
    { fifty: 'fifty' },
  ]);
});

throws

• Tür:
  • (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
  • (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void
• Diğer ad:
  • throw
  • Throw

fn fonksiyonunun bir hata fırlatacağını doğrular.

• errorLike bir Error constructor'ı ise, fn'in errorLike türünde bir hata fırlatması beklenir.
• errorLike bir Error örneği ise, fn'in errorLike ile aynı örneği fırlatması beklenir.
• errMsgMatcher sağlanırsa, fırlatılan hatanın mesajının errMsgMatcher ile eşleşmesi beklenir.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Error thrown must have this msg');
  assert.throws(fn, /Error thrown must have a msg that matches this/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Error thrown must be a ReferenceError and have this msg'
  );
  assert.throws(
    fn,
    errorInstance,
    'Error thrown must be the same errorInstance and have this msg'
  );
  assert.throws(
    fn,
    ReferenceError,
    /Error thrown must be a ReferenceError and match this/
  );
  assert.throws(
    fn,
    errorInstance,
    /Error thrown must be the same errorInstance and match this/
  );
});

doesNotThrow

• Tür: (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
• Tür: (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void

fn fonksiyonunun bir hata fırlatmayacağını doğrular.

• errorLike bir Error constructor'ı ise, fn'in errorLike türünde bir hata fırlatmaması beklenir.
• errorLike bir Error örneği ise, fn'in errorLike ile aynı örneği fırlatmaması beklenir.
• errMsgMatcher sağlanırsa, fırlatılan hatanın mesajının errMsgMatcher ile eşleşmemesi beklenir.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Any Error thrown must not have this message');
  assert.doesNotThrow(fn, /Any Error thrown must not match this/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Error must not have this message');
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');
  assert.doesNotThrow(fn, Error, /Error must not match this/);
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/);
});

operator

• Tür: (val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void

val1 ve val2 değerlerini, belirtilen operator kullanarak karşılaştırır.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'everything is ok');
});

closeTo

• Tür: (actual: number, expected: number, delta: number, message?: string) => void
• Diğer ad: approximately

actual değerinin, expected değerine +/- delta aralığında yakın olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'numbers are close');
});

sameMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, sıralaması önemli olmaksızın aynı elemanlara sahip olduğunu doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'same members');
});

notSameMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, sıralaması önemli olmaksızın aynı elemanlara sahip olmadığını doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'not same members');
});

sameDeepMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, sıralaması önemli olmaksızın aynı elemanlara sahip olduğunu doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'same deep members'
  );
});

notSameDeepMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, sıralaması önemli olmaksızın aynı elemanlara sahip olmadığını doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'same deep members'
  );
});

sameOrderedMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, aynı sırada aynı elemanlara sahip olduğunu doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'same ordered members');
});

notSameOrderedMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, aynı sırada aynı elemanlara sahip olmadığını doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'not same ordered members'
  );
});

sameDeepOrderedMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin, aynı sırada aynı elemanlara sahip olduğunu doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'same deep ordered members'
  );
});

notSameDeepOrderedMembers

• Tür: <T>(set1: T[], set2: T[], message?: string) => void

set1 ve set2 dizilerinin aynı sıralı ve derinlemesine eşit üyelere sahip olmadığını doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'aynı sıralı derin üyelere sahip değil'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'aynı sıralı derin üyelere sahip değil'
  );
});

includeMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin üyelerini herhangi bir sırada içerdiğini doğrular. Katı eşitlik (===) kontrolü kullanılır. Tekrarlanan öğeler dikkate alınmaz.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'üyeleri içerir');
});

notIncludeMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin üyelerini herhangi bir sırada içermediğini doğrular. Katı eşitlik (===) kontrolü kullanılır. Tekrarlanan öğeler dikkate alınmaz.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'üyeleri içermez');
});

includeDeepMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin üyelerini herhangi bir sırada içerdiğini doğrular. Derinlemesine eşitlik kontrolü kullanılır. Tekrarlanan öğeler dikkate alınmaz.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'derinlemesine eşit üyeleri içerir'
  );
});

notIncludeDeepMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin üyelerini herhangi bir sırada içermediğini doğrular. Derinlemesine eşitlik kontrolü kullanılır. Tekrarlanan öğeler dikkate alınmaz.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'derinlemesine eşit üyeleri içermez'
  );
});

includeOrderedMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin başından başlayarak aynı sırada superset dizisinin üyelerini içerdiğini doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'sıralı üyeleri içerir');
});

notIncludeOrderedMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin başından başlayarak aynı sırada superset dizisinin üyelerini içermediğini doğrular. Katı eşitlik (===) kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 1], 'sıralı üyeleri içermez');
  assert.notIncludeOrderedMembers([1, 2, 3], [2, 3], 'sıralı üyeleri içermez');
});

includeDeepOrderedMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin başından başlayarak aynı sırada superset dizisinin derinlemesine eşit üyelerini içerdiğini doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'derinlemesine eşit sıralı üyeleri içerir'
  );
});

notIncludeDeepOrderedMembers

• Tür: <T>(superset: T[], subset: T[], message?: string) => void

subset dizisinin, superset dizisinin başından başlayarak aynı sırada superset dizisinin derinlemesine eşit üyelerini içermediğini doğrular. Derinlemesine eşitlik kontrolü kullanılır.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'derinlemesine eşit sıralı üyeleri içermez'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'derinlemesine eşit sıralı üyeleri içermez'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'derinlemesine eşit sıralı üyeleri içermez'
  );
});

oneOf

• Tür: <T>(inList: T, list: T[], message?: string) => void

inList değerinin (nesne veya dizi olmayan), list dizisi içinde bulunduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Listede bulunamadı');
});

changes

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, object nesnesinin property özelliğini değiştirdiğini doğrular.

import { assert, test } from 'vitest';

test('assert.changes', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 22;
  }
  assert.changes(fn, obj, 'val');
});

changesBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

modifier fonksiyonunun, object nesnesinin property özelliğini change miktarınca değiştirdiğini doğrular.

import { assert, test } from 'vitest';

test('assert.changesBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val += 2;
  }
  assert.changesBy(fn, obj, 'val', 2);
});

doesNotChange

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, object nesnesinin property özelliğini değiştirmediğini doğrular.

import { assert, test } from 'vitest';

test('assert.doesNotChange', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val += 2;
  }
  assert.doesNotChange(fn, obj, 'val', 2);
});

changesButNotBy

• Tür: <T>(modifier: Function, object: T, property: string, change:number, message?: string) => void

modifier fonksiyonunun, object nesnesinin property özelliğini değiştirdiğini, ancak belirtilen change miktarınca değiştirmediğini doğrular.

import { assert, test } from 'vitest';

test('assert.changesButNotBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val += 10;
  }
  assert.changesButNotBy(fn, obj, 'val', 5);
});

increases

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini artırdığını doğrular.

import { assert, test } from 'vitest';

test('assert.increases', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 13;
  }
  assert.increases(fn, obj, 'val');
});

increasesBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini belirtilen change miktarınca artırdığını doğrular.

import { assert, test } from 'vitest';

test('assert.increasesBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val += 10;
  }
  assert.increasesBy(fn, obj, 'val', 10);
});

doesNotIncrease

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini artırmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.doesNotIncrease', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 8;
  }
  assert.doesNotIncrease(fn, obj, 'val');
});

increasesButNotBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini artırdığını, ancak belirtilen change miktarınca artırmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.increasesButNotBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val += 15;
  }
  assert.increasesButNotBy(fn, obj, 'val', 10);
});

decreases

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini azalttığını doğrular.

import { assert, test } from 'vitest';

test('assert.decreases', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 5;
  }
  assert.decreases(fn, obj, 'val');
});

decreasesBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini belirtilen change miktarınca azalttığını doğrular.

import { assert, test } from 'vitest';

test('assert.decreasesBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val -= 5;
  }
  assert.decreasesBy(fn, obj, 'val', 5);
});

doesNotDecrease

• Tür: <T>(modifier: Function, object: T, property: string, message?: string) => void

modifier fonksiyonunun, sayısal bir object nesnesinin property özelliğini azaltmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.doesNotDecrease', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 15;
  }
  assert.doesNotDecrease(fn, obj, 'val');
});

doesNotDecreaseBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Bir modifier fonksiyonunun, sayısal bir nesnenin belirtilen property özelliğini veya dönüş değerini, belirtilen change miktarınca azaltmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.doesNotDecreaseBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 5;
  }
  assert.doesNotDecreaseBy(fn, obj, 'val', 1);
});

decreasesButNotBy

• Tür: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Bir modifier fonksiyonunun, sayısal bir nesnenin belirtilen property özelliğini veya dönüş değerini azalttığını, ancak belirtilen change miktarınca azaltmadığını doğrular.

import { assert, test } from 'vitest';

test('assert.decreasesButNotBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 5;
  }
  assert.decreasesButNotBy(fn, obj, 'val', 1);
});

ifError

• Tür: <T>(object: T, message?: string) => void

object'in false bir değer olup olmadığını doğrular. Eğer object true bir değer ise, bir hata fırlatır. Bu, chai'nin Node'un assert sınıfı için doğrudan bir karşılık olmasını sağlamak amacıyla eklenmiştir.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // hatayı tekrar fırlatır
});

isExtensible

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: extensible

object'in genişletilebilir (yeni özellikler eklenebilir) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isExtensible', () => {
  assert.isExtensible({});
});

isNotExtensible

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: notExtensible

object'in genişletilebilir olmadığını (yeni özellikler eklenemez) doğrular.

import { assert, test } from 'vitest';

test('assert.isNotExtensible', () => {
  const nonExtensibleObject = Object.preventExtensions({});
  const sealedObject = Object.seal({});
  const frozenObject = Object.freeze({});

  assert.isNotExtensible(nonExtensibleObject);
  assert.isNotExtensible(sealedObject);
  assert.isNotExtensible(frozenObject);
});

isSealed

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: sealed

object'in kilitlenmiş (üzerine yeni özellikler eklenemez ve mevcut özellikler silinemez) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isSealed', () => {
  const sealedObject = Object.seal({});
  const frozenObject = Object.seal({});

  assert.isSealed(sealedObject);
  assert.isSealed(frozenObject);
});

isNotSealed

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: notSealed

object'in kilitlenmemiş (üzerine yeni özellikler eklenebilir ve mevcut özellikler silinebilir) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isNotSealed', () => {
  assert.isNotSealed({});
});

isFrozen

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: frozen

object'in dondurulmuş (üzerine yeni özellikler eklenemez ve mevcut özellikler değiştirilemez) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isFrozen', () => {
  const frozenObject = Object.freeze({});
  assert.frozen(frozenObject);
});

isNotFrozen

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: notFrozen

object'in dondurulmamış (üzerine yeni özellikler eklenebilir ve mevcut özellikler değiştirilebilir) olduğunu doğrular.

import { assert, test } from 'vitest';

test('assert.isNotFrozen', () => {
  assert.isNotFrozen({});
});

isEmpty

• Tür: <T>(target: T, message?: string) => void
• Diğer Adı: empty

target'ın boş olduğunu, yani herhangi bir değer içermediğini doğrular. Diziler ve dizeler için length özelliğini, Map ve Set örnekleri için size özelliğini, fonksiyon olmayan nesneler için ise kendi numaralandırılabilir string özelliklerinin sayısını kontrol eder.

import { assert, test } from 'vitest';

test('assert.isEmpty', () => {
  assert.isEmpty([]);
  assert.isEmpty('');
  assert.isEmpty(new Map());
  assert.isEmpty({});
});

isNotEmpty

• Tür: <T>(object: T, message?: string) => void
• Diğer Adı: notEmpty

target'ın boş olmadığını, yani değerler içerdiğini doğrular. Diziler ve dizeler için length özelliğini, Map ve Set örnekleri için size özelliğini, fonksiyon olmayan nesneler için ise kendi numaralandırılabilir string özelliklerinin sayısını kontrol eder.

import { assert, test } from 'vitest';

test('assert.isNotEmpty', () => {
  assert.isNotEmpty([1, 2]);
  assert.isNotEmpty('34');
  assert.isNotEmpty(new Set([5, 6]));
  assert.isNotEmpty({ key: 7 });
});