assert

A Vitest újraexportálja az assert metódust a chai könyvtárból az invariánsok ellenőrzéséhez.

assert

Típus: (expression: any, message?: string) => asserts expression

Azt állítja, hogy a megadott expression igaz (truthy), különben a feltétel meghiúsul.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo nem lehet egyenlő a bar-ral');
});

fail

Típus:
- (message?: string) => never
- <T>(actual: T, expected: T, message?: string, operator?: string) => never

Kikényszerít egy feltételhibát.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('hibaüzenet hiba esetén');
  assert.fail('foo', 'bar', 'foo nem bar', '===');
});

isOk

Típus: <T>(value: T, message?: string) => void
Alias: ok

Azt állítja, hogy a megadott value igaz értékű.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'minden igaz érték rendben van');
  assert.isOk(false, 'ez el fog bukni, mivel a false nem igaz értékű');
});

isNotOk

Típus: <T>(value: T, message?: string) => void
Alias: notOk

Azt állítja, hogy a megadott value hamis értékű.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'ez el fog bukni, minden igaz érték nem rendben van');
  assert.isNotOk(false, 'ez át fog menni, mivel a false hamis értékű');
});

equal

Típus: <T>(actual: T, expected: T, message?: string) => void

A actual és expected nem szigorú egyenlőségét (==) állítja.

import { assert, test } from 'vitest';

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

notEqual

Típus: <T>(actual: T, expected: T, message?: string) => void

A actual és expected nem szigorú egyenlőtlenségét (!=) állítja.

import { assert, test } from 'vitest';

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

strictEqual

Típus: <T>(actual: T, expected: T, message?: string) => void

A actual és expected szigorú egyenlőségét (===) állítja.

import { assert, test } from 'vitest';

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

deepEqual

Típus: <T>(actual: T, expected: T, message?: string) => void

Azt állítja, hogy az actual mélyen egyenlő az expected-del.

import { assert, test } from 'vitest';

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

notDeepEqual

Típus: <T>(actual: T, expected: T, message?: string) => void

Azt állítja, hogy az actual nem mélyen egyenlő az expected-del.

import { assert, test } from 'vitest';

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

isAbove

Típus: (valueToCheck: number, valueToBeAbove: number, message?: string) => void

Azt állítja, hogy a valueToCheck szigorúan nagyobb (>) a valueToBeAbove-nál.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 szigorúan nagyobb, mint 2');
});

isAtLeast

Típus: (valueToCheck: number, valueToBeAtLeast: number, message?: string) => void

Azt állítja, hogy a valueToCheck nagyobb vagy egyenlő (>=) a valueToBeAtLeast-tel.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 nagyobb vagy egyenlő 2-vel');
  assert.isAtLeast(3, 3, '3 nagyobb vagy egyenlő 3-mal');
});

isBelow

Típus: (valueToCheck: number, valueToBeBelow: number, message?: string) => void

Azt állítja, hogy a valueToCheck szigorúan kisebb (<) a valueToBeBelow-nál.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 szigorúan kisebb, mint 6');
});

isAtMost

Típus: (valueToCheck: number, valueToBeAtMost: number, message?: string) => void

Azt állítja, hogy a valueToCheck kisebb vagy egyenlő (<=) a valueToBeAtMost-tal.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 kisebb vagy egyenlő 6-tal');
  assert.isAtMost(4, 4, '4 kisebb vagy egyenlő 4-gyel');
});

isTrue

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value igaz.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem igaz.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value hamis.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem hamis.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value null.

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, 'az error null');
});

isNotNull

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem null.

import { assert, test } from 'vitest';

const error = { message: 'hiba történt' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'az error nem null, hanem objektum');
});

isNaN

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 nem NaN, hanem 2');
});

exists

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value sem null, sem undefined.

import { assert, test } from 'vitest';

const name = 'foo';

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

notExists

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value null vagy undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'a foo null, tehát nem létezik');
  assert.notExists(bar, 'a bar undefined, tehát nem létezik');
});

isUndefined

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value undefined.

import { assert, test } from 'vitest';

const name = undefined;

test('assert.isUndefined', () => {
  assert.isUndefined(name, 'a name undefined');
});

isDefined

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'a name nem undefined');
});

isFunction

Típus: <T>(value: T, message?: string) => void
Alias: isCallable Azt állítja, hogy a value egy függvény.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'a name függvény');
});

isNotFunction

Típus: <T>(value: T, message?: string) => void
Alias: isNotCallable

Azt állítja, hogy a value nem függvény.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'a name nem függvény, hanem string');
});

isObject

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy Object típusú objektum (az Object.prototype.toString szerint). A feltétel nem egyezik az alosztályozott objektumokkal.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'a someThing objektum');
});

isNotObject

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem Object típusú objektum (az Object.prototype.toString szerint). A feltétel nem egyezik az alosztályozott objektumokkal.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'a someThing nem objektum, hanem string');
});

isArray

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy tömb.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'a color tömb');
});

isNotArray

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem tömb.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'a color nem tömb, hanem string');
});

isString

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy string.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'a color string');
});

isNotString

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem string.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'a color nem string, hanem tömb');
});

isNumber

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy szám.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'a colors szám');
});

isNotNumber

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem szám.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'a colors nem szám, hanem string');
});

isFinite

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy véges szám (nem NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'a colors szám, nem NaN vagy Infinity');
});

isBoolean

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value egy logikai érték.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'az isReady egy logikai érték');
});

isNotBoolean

Típus: <T>(value: T, message?: string) => void

Azt állítja, hogy a value nem logikai érték.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'az isReady nem logikai érték, hanem string');
});

typeOf

Típus: <T>(value: T, name: string, message?: string) => void

Azt állítja, hogy a value típusa name, az Object.prototype.toString által meghatározva.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'van egy objektumunk');
  assert.typeOf(['red', 'green'], 'array', 'van egy tömbünk');
  assert.typeOf('red', 'string', 'van egy stringünk');
  assert.typeOf(/red/, 'regexp', 'van egy reguláris kifejezésünk');
  assert.typeOf(null, 'null', 'van egy null értékünk');
  assert.typeOf(undefined, 'undefined', 'van egy undefined értékünk');
});

notTypeOf

Típus: <T>(value: T, name: string, message?: string) => void

Azt állítja, hogy a value típusa nem name, az Object.prototype.toString által meghatározva.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" nem szám');
});

instanceOf

Típus: <T>(value: T, constructor: Function, message?: string) => void

Azt állítja, hogy a value a constructor egy példánya.

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, 'a foo a Person egy példánya');
  assert.instanceOf(coffee, Tea, 'a coffee a Tea egy példánya');
});

notInstanceOf

Típus: <T>(value: T, constructor: Function, message?: string) => void

Azt állítja, hogy a value nem a constructor egy példánya.

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.notInstanceOf', () => {
  assert.notInstanceOf(foo, Tea, 'a foo nem a Tea egy példánya');
});

include

Típus:
- (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

Azt állítja, hogy a haystack tartalmazza a needle-t. Használható egy érték tömbben való, egy részstring stringben való, vagy egy tulajdonság halmaz objektumban való szereplésének ellenőrzésére.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'a tömb tartalmazza az értéket');
  assert.include('foobar', 'foo', 'a string tartalmazza a részstringet');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'az objektum tartalmazza a tulajdonságot'
  );
});

notInclude

Típus:
- (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

Azt állítja, hogy a haystack nem tartalmazza a needle-t. Használható egy érték tömbben való hiányának, egy részstring stringben való hiányának, vagy egy tulajdonság halmaz objektumban való hiányának ellenőrzésére.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'a tömb nem tartalmazza a 4-et');
  assert.notInclude('foobar', 'baz', 'a foobar nem tartalmazza a baz-t');
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'az objektum nem tartalmazza a tulajdonságot'
  );
});

deepInclude

Típus:
(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

Azt állítja, hogy a haystack tartalmazza a needle-t. Használható egy érték tömbben való, vagy egy tulajdonság halmaz objektumban való szereplésének ellenőrzésére. Mély egyenlőséget használ.

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ípus:
- (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

Azt állítja, hogy a haystack nem tartalmazza a needle-t. Használható egy érték tömbben való hiányának, vagy egy tulajdonság halmaz objektumban való hiányának ellenőrzésére. Mély egyenlőséget használ.

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ípus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való szereplésének ellenőrzésére. Lehetővé teszi a pont- és zárójel-jelölés használatát a beágyazott tulajdonságok hivatkozására. A tulajdonságnevekben lévő „[]” és „.” dupla visszafelé perjelekkel elkerülhetők.

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ípus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack nem tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való hiányának ellenőrzésére. Lehetővé teszi a pont- és zárójel-jelölés használatát a beágyazott tulajdonságok hivatkozására. A tulajdonságnevekben lévő „[]” és „.” dupla visszafelé perjelekkel elkerülhetők.

import { assert, test } from 'vitest';

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

deepNestedInclude

Típus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való szereplésének ellenőrzésére, miközben mély egyenlőséget ellenőriz. Lehetővé teszi a pont- és zárójel-jelölés használatát a beágyazott tulajdonságok hivatkozására. A tulajdonságnevekben lévő „[]” és „.” dupla visszafelé perjelekkel elkerülhetők.

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ípus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack nem tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való hiányának ellenőrzésére, miközben mély egyenlőséget ellenőriz. Lehetővé teszi a pont- és zárójel-jelölés használatát a beágyazott tulajdonságok hivatkozására. A tulajdonságnevekben lévő „[]” és „.” dupla visszafelé perjelekkel elkerülhetők.

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ípus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való szereplésének ellenőrzésére, miközben figyelmen kívül hagyja az örökölt tulajdonságokat.

import { assert, test } from 'vitest';

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

notOwnInclude

Típus: (haystack: any, needle: any, message?: string) => void

Azt állítja, hogy a haystack nem tartalmazza a needle-t. Használható egy tulajdonság halmaz objektumban való hiányának ellenőrzésére, miközben figyelmen kívül hagyja az örökölt tulajdonságokat.

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ípus: (haystack: any, needle: any, message?: string) => void

import { assert, test } from 'vitest';

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

notDeepOwnInclude

Típus: (haystack: any, needle: any, message?: string) => void

import { assert, test } from 'vitest';

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

match

Típus: (value: string, regexp: RegExp, message?: string) => void

Azt állítja, hogy a value illeszkedik a regexp reguláris kifejezésre.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'a regexp illeszkedik');
});

notMatch

Típus: (value: string, regexp: RegExp, message?: string) => void

Azt állítja, hogy a value nem illeszkedik a regexp reguláris kifejezésre.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'a regexp nem illeszkedik');
});

property

Típus: <T>(object: T, property: string, message?: string) => void

Azt állítja, hogy az object rendelkezik egy közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg.

import { assert, test } from 'vitest';

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

notProperty

Típus: <T>(object: T, property: string, message?: string) => void

Azt állítja, hogy az object nem rendelkezik közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg.

import { assert, test } from 'vitest';

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

propertyVal

Típus: <T, V>(object: T, property: string, value: V, message?: string) => void

Azt állítja, hogy az object rendelkezik egy közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

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

notPropertyVal

Típus: <T, V>(object: T, property: string, value: V, message?: string) => void

Azt állítja, hogy az object nem rendelkezik közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. Szigorú egyenlőségellenőrzést (===) használ.

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ípus: <T, V>(object: T, property: string, value: V, message?: string) => void

Azt állítja, hogy az object rendelkezik egy közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

Típus: <T, V>(object: T, property: string, value: V, message?: string) => void

Azt állítja, hogy az object nem rendelkezik közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. Mély egyenlőségellenőrzést használ.

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ípus: <T>(object: T, property: string, message?: string) => void

Azt állítja, hogy az object rendelkezik egy közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amely egy string lehet pont- és zárójel-jelöléssel a beágyazott hivatkozáshoz.

import { assert, test } from 'vitest';

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

notNestedProperty

Típus: <T>(object: T, property: string, message?: string) => void

Azt állítja, hogy az object nem rendelkezik közvetlen vagy örökölt tulajdonsággal, amelyet a property nevez meg, és amely egy string lehet pont- és zárójel-jelöléssel a beágyazott hivatkozáshoz.

import { assert, test } from 'vitest';

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

nestedPropertyVal

Típus: <T>(object: T, property: string, value: any, message?: string) => void

Azt állítja, hogy az object rendelkezik egy tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. A property használhat pont- és zárójel-jelölést a beágyazott hivatkozáshoz. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

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

notNestedPropertyVal

Típus: <T>(object: T, property: string, value: any, message?: string) => void

Azt állítja, hogy az object nem rendelkezik egy tulajdonsággal, amelyet a property nevez meg, és amelynek értéke a value. A property használhat pont- és zárójel-jelölést a beágyazott hivatkozáshoz. Szigorú egyenlőségellenőrzést (===) használ.

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ípus: <T>(object: T, property: string, value: any, message?: string) => void

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ípus: <T>(object: T, property: string, value: any, message?: string) => void

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ípus: <T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void

Azt állítja, hogy az object rendelkezik egy length vagy size tulajdonsággal a várt értékkel.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'a tömb hossza 3');
  assert.lengthOf('foobar', 6, 'a string hossza 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'a halmaz mérete 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'a Map mérete 3'
  );
});

hasAnyKeys

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

Azt állítja, hogy az object rendelkezik legalább egyet a megadott keys közül. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object rendelkezik az összes megadott keys kulccsal, és csak azokkal. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object tartalmazza az összes megadott keys kulcsot, de lehetnek további, nem felsorolt kulcsai is. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object nem rendelkezik a megadott keys kulcsok egyikével sem. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object nem rendelkezik legalább egyet a megadott keys kulcsok közül. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

Azt állítja, hogy az object rendelkezik legalább egyet a megadott keys kulcsok közül. Mivel a Set-ek és Map-ek objektumokat is tartalmazhatnak kulcsként, ezt a feltételt használhatja mély összehasonlításra. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object rendelkezik az összes megadott keys kulccsal, és csak azokkal. Mivel a Set-ek és Map-ek objektumokat is tartalmazhatnak kulcsként, ezt a feltételt használhatja mély összehasonlításra. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object tartalmazza az összes megadott keys kulcsot. Mivel a Set-ek és Map-ek objektumokat is tartalmazhatnak kulcsként, ezt a feltételt használhatja mély összehasonlításra. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object nem rendelkezik a megadott keys kulcsok egyikével sem. Mivel a Set-ek és Map-ek objektumokat is tartalmazhatnak kulcsként, ezt a feltételt használhatja mély összehasonlításra. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus: <T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void

Azt állítja, hogy az object nem rendelkezik legalább egyet a megadott keys kulcsok közül. Mivel a Set-ek és Map-ek objektumokat is tartalmazhatnak kulcsként, ezt a feltételt használhatja mély összehasonlításra. Egyetlen objektumot is megadhat a kulcsok tömbje helyett, és annak kulcsai lesznek a várt kulcshalmaz.

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ípus:
- (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
- (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void
Alias:
- throw
- Throw

Ha az errorLike egy Error konstruktor, azt állítja, hogy az fn egy errorLike példányú hibát fog dobni. Ha az errorLike egy Error példány, azt állítja, hogy a dobott hiba ugyanaz a példány, mint az errorLike. Ha az errMsgMatcher meg van adva, azt is állítja, hogy a dobott hiba üzenete illeszkedik az errMsgMatcher-re.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'A dobott hibának tartalmaznia kell ezt az üzenetet');
  assert.throws(fn, /A dobott hibának tartalmaznia kell egy üzenetet, amely illeszkedik erre/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'A dobott hibának ReferenceError-nak kell lennie, és tartalmaznia kell ezt az üzenetet'
  );
  assert.throws(
    fn,
    errorInstance,
    'A dobott hibának ugyanannak az errorInstance-nak kell lennie, és tartalmaznia kell ezt az üzenetet'
  );
  assert.throws(
    fn,
    ReferenceError,
    /A dobott hibának ReferenceError-nak kell lennie, és illeszkednie kell erre/
  );
  assert.throws(
    fn,
    errorInstance,
    /A dobott hibának ugyanannak az errorInstance-nak kell lennie, és illeszkednie kell erre/
  );
});

doesNotThrow

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

Ha az errorLike egy Error konstruktor, azt állítja, hogy az fn nem fog errorLike példányú hibát dobni. Ha az errorLike egy Error példány, azt állítja, hogy a dobott hiba nem ugyanaz a példány, mint az errorLike. Ha az errMsgMatcher meg van adva, azt is állítja, hogy a dobott hiba üzenete nem illeszkedik az errMsgMatcher-re.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Bármely dobott hibának nem szabad tartalmaznia ezt az üzenetet');
  assert.doesNotThrow(fn, /Bármely dobott hibának nem szabad illeszkednie erre/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'A hibának nem szabad tartalmaznia ezt az üzenetet');
  assert.doesNotThrow(fn, errorInstance, 'A hibának nem szabad tartalmaznia ezt az üzenetet');
  assert.doesNotThrow(fn, Error, /A hibának nem szabad illeszkednie erre/);
  assert.doesNotThrow(fn, errorInstance, /A hibának nem szabad illeszkednie erre/);
});

operator

Típus: (val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void

Összehasonlítja a val1 és val2 értékeket az operator segítségével.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'minden rendben van');
});

closeTo

Típus: (actual: number, expected: number, delta: number, message?: string) => void
Alias: approximately

Azt állítja, hogy az actual egyenlő az expected-del, egy +/- delta tartományon belül.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'a számok közel vannak');
});

sameMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 ugyanazokat az elemeket tartalmazzák, bármilyen sorrendben. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'ugyanazok az elemek');
});

notSameMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 nem ugyanazokat az elemeket tartalmazzák, bármilyen sorrendben. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'nem ugyanazok az elemek');
});

sameDeepMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 ugyanazokat az elemeket tartalmazzák, bármilyen sorrendben. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'ugyanazok a mély elemek'
  );
});

notSameDeepMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 nem ugyanazokat az elemeket tartalmazzák, bármilyen sorrendben. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nem ugyanazok a mély elemek'
  );
});

sameOrderedMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 ugyanazokat az elemeket tartalmazzák, ugyanabban a sorrendben. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'ugyanazok a rendezett elemek');
});

notSameOrderedMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 nem ugyanazokat az elemeket tartalmazzák, ugyanabban a sorrendben. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'nem ugyanazok a rendezett elemek'
  );
});

sameDeepOrderedMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 ugyanazokat az elemeket tartalmazzák, ugyanabban a sorrendben. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'ugyanazok a mélyen rendezett elemek'
  );
});

notSameDeepOrderedMembers

Típus: <T>(set1: T[], set2: T[], message?: string) => void

Azt állítja, hogy a set1 és set2 nem ugyanazokat az elemeket tartalmazzák, ugyanabban a sorrendben. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'nem ugyanazok a mélyen rendezett elemek'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nem ugyanazok a mélyen rendezett elemek'
  );
});

includeMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset benne van a superset-ben, bármilyen sorrendben. Szigorú egyenlőségellenőrzést (===) használ. A duplikátumokat figyelmen kívül hagyja.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'tagokat tartalmaz');
});

notIncludeMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset nincs benne a superset-ben, bármilyen sorrendben. Szigorú egyenlőségellenőrzést (===) használ. A duplikátumokat figyelmen kívül hagyja.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'nem tartalmaz tagokat');
});

includeDeepMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset benne van a superset-ben, bármilyen sorrendben. Mély egyenlőségellenőrzést használ. A duplikátumokat figyelmen kívül hagyja.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'mély tagokat tartalmaz'
  );
});

notIncludeDeepMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset nincs benne a superset-ben, bármilyen sorrendben. Mély egyenlőségellenőrzést használ. A duplikátumokat figyelmen kívül hagyja.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'nem tartalmaz mély tagokat'
  );
});

includeOrderedMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset benne van a superset-ben, ugyanabban a sorrendben, a superset első elemével kezdve. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'rendezett tagokat tartalmaz');
});

notIncludeOrderedMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset nincs benne a superset-ben, ugyanabban a sorrendben, a superset első elemével kezdve. Szigorú egyenlőségellenőrzést (===) használ.

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'nem tartalmaz rendezett tagokat'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'nem tartalmaz rendezett tagokat'
  );
});

includeDeepOrderedMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset benne van a superset-ben, ugyanabban a sorrendben, a superset első elemével kezdve. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'mélyen rendezett tagokat tartalmaz'
  );
});

notIncludeDeepOrderedMembers

Típus: <T>(superset: T[], subset: T[], message?: string) => void

Azt állítja, hogy a subset nincs benne a superset-ben, ugyanabban a sorrendben, a superset első elemével kezdve. Mély egyenlőségellenőrzést használ.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'nem tartalmaz mélyen rendezett tagokat'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'nem tartalmaz mélyen rendezett tagokat'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'nem tartalmaz mélyen rendezett tagokat'
  );
});

oneOf

Típus: <T>(inList: T, list: T[], message?: string) => void

Azt állítja, hogy a nem objektum, nem tömb inList érték megjelenik a lapos list tömbben.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Nem található a listában');
});

changes

Típus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier megváltoztatja egy object property tulajdonságát.

import { assert, test } from 'vitest';

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

changesBy

Típus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier egy change értékkel megváltoztatja egy object property tulajdonságát.

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ípus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier nem változtatja meg egy object property tulajdonságát.

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ípus: <T>(modifier: Function, object: T, property: string, change:number, message?: string) => void

Azt állítja, hogy egy modifier megváltoztatja egy object property tulajdonságát, de nem a megadott change értékkel.

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ípus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier növeli egy numerikus object property tulajdonságát.

import { assert, test } from 'vitest';

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

increasesBy

Típus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier egy change értékkel növeli egy numerikus object property tulajdonságát, vagy egy modifier visszatérési értékét.

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ípus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier nem növeli egy numerikus object property tulajdonságát.

import { assert, test } from 'vitest';

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

increasesButNotBy

Típus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier növeli egy numerikus object property tulajdonságát, de nem a megadott change értékkel.

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ípus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier csökkenti egy numerikus object property tulajdonságát.

import { assert, test } from 'vitest';

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

decreasesBy

Típus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier egy change értékkel csökkenti egy numerikus object property tulajdonságát, vagy egy modifier visszatérési értékét.

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ípus: <T>(modifier: Function, object: T, property: string, message?: string) => void

Azt állítja, hogy egy modifier nem csökkenti egy numerikus object property tulajdonságát.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

Típus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier nem csökkenti egy numerikus object property tulajdonságát, vagy egy modifier visszatérési értékét egy change értékkel.

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ípus: <T>(modifier: Function, object: T, property: string, change: number, message?: string) => void

Azt állítja, hogy egy modifier csökkenti egy numerikus object property tulajdonságát, de nem a megadott change értékkel.

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ípus: <T>(object: T, message?: string) => void

Azt állítja, hogy ha az object nem hamis érték, akkor hibát dob, ha igaz érték. Ez azért került hozzáadásra, hogy a chai helyettesíthesse a Node assert osztályát.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('Én egy egyedi hiba vagyok');
  assert.ifError(err); // Újra dobja az err-t!
});

isExtensible

Típus: <T>(object: T, message?: string) => void
Alias: extensible

Azt állítja, hogy az object bővíthető (új tulajdonságok adhatók hozzá).

import { assert, test } from 'vitest';

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

isNotExtensible

Típus: <T>(object: T, message?: string) => void
Alias: notExtensible

Azt állítja, hogy az object nem bővíthető (nem adhatók hozzá új tulajdonságok).

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ípus: <T>(object: T, message?: string) => void
Alias: sealed

Azt állítja, hogy az object le van zárva (nem adhatók hozzá új tulajdonságok, és a meglévő tulajdonságai nem távolíthatók el).

import { assert, test } from 'vitest';

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

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

isNotSealed

Típus: <T>(object: T, message?: string) => void
Alias: notSealed

Azt állítja, hogy az object nincs lezárva (új tulajdonságok adhatók hozzá, és a meglévő tulajdonságai eltávolíthatók).

import { assert, test } from 'vitest';

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

isFrozen

Típus: <T>(object: T, message?: string) => void
Alias: frozen

Azt állítja, hogy az objektum fagyasztva van (nem adhatók hozzá új tulajdonságok, és a meglévő tulajdonságai nem módosíthatók).

import { assert, test } from 'vitest';

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

isNotFrozen

Típus: <T>(object: T, message?: string) => void
Alias: notFrozen

Azt állítja, hogy az object nincs fagyasztva (új tulajdonságok adhatók hozzá, és a meglévő tulajdonságai módosíthatók).

import { assert, test } from 'vitest';

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

isEmpty

Típus: <T>(target: T, message?: string) => void
Alias: empty

Azt állítja, hogy a target nem tartalmaz semmilyen értéket. Tömbök és stringek esetén a length tulajdonságot ellenőrzi. Map és Set példányok esetén a size tulajdonságot ellenőrzi. Nem függvény objektumok esetén a saját számozható string kulcsainak számát kapja meg.

import { assert, test } from 'vitest';

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

isNotEmpty

Típus: <T>(object: T, message?: string) => void
Alias: notEmpty

Azt állítja, hogy a target tartalmaz értékeket. Tömbök és stringek esetén a length tulajdonságot ellenőrzi. Map és Set példányok esetén a size tulajdonságot ellenőrzi. Nem függvény objektumok esetén a saját számozható string kulcsainak számát kapja meg.

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 });
});

assert ​

assert ​

fail ​

isOk ​

isNotOk ​

equal ​

notEqual ​

strictEqual ​

deepEqual ​

notDeepEqual ​

isAbove ​

isAtLeast ​

isBelow ​

isAtMost ​

isTrue ​

isNotTrue ​

isFalse ​

isNotFalse ​

isNull ​

isNotNull ​

isNaN ​

isNotNaN ​

exists ​

notExists ​

isUndefined ​

isDefined ​

isFunction ​

isNotFunction ​

isObject ​

isNotObject ​

isArray ​

isNotArray ​

isString ​

isNotString ​

isNumber ​

isNotNumber ​

isFinite ​

isBoolean ​

isNotBoolean ​

typeOf ​

notTypeOf ​

instanceOf ​

notInstanceOf ​

include ​

notInclude ​

deepInclude ​

notDeepInclude ​

nestedInclude ​

notNestedInclude ​

deepNestedInclude ​

notDeepNestedInclude ​

ownInclude ​

notOwnInclude ​

deepOwnInclude ​

notDeepOwnInclude ​

match ​

notMatch ​

property ​

notProperty ​

propertyVal ​

notPropertyVal ​

deepPropertyVal ​

notDeepPropertyVal ​

nestedProperty ​

notNestedProperty ​

nestedPropertyVal ​

notNestedPropertyVal ​

deepNestedPropertyVal ​

notDeepNestedPropertyVal ​

lengthOf ​

hasAnyKeys ​

hasAllKeys ​

containsAllKeys ​

doesNotHaveAnyKeys ​

doesNotHaveAllKeys ​

hasAnyDeepKeys ​

hasAllDeepKeys ​

containsAllDeepKeys ​

doesNotHaveAnyDeepKeys ​

doesNotHaveAllDeepKeys ​

assert

assert

fail

isOk

isNotOk

equal

notEqual

strictEqual

deepEqual

notDeepEqual

isAbove

isAtLeast

isBelow

isAtMost

isTrue

isNotTrue

isFalse

isNotFalse

isNull

isNotNull

isNaN

isNotNaN

exists

notExists

isUndefined

isDefined

isFunction

isNotFunction

isObject

isNotObject

isArray

isNotArray

isString

isNotString

isNumber

isNotNumber

isFinite

isBoolean

isNotBoolean

typeOf

notTypeOf

instanceOf

notInstanceOf

include

notInclude

deepInclude

notDeepInclude

nestedInclude

notNestedInclude

deepNestedInclude

notDeepNestedInclude

ownInclude

notOwnInclude

deepOwnInclude

notDeepOwnInclude

match

notMatch

property

notProperty

propertyVal

notPropertyVal

deepPropertyVal

notDeepPropertyVal

nestedProperty

notNestedProperty

nestedPropertyVal

notNestedPropertyVal

deepNestedPropertyVal

notDeepNestedPropertyVal

lengthOf

hasAnyKeys

hasAllKeys

containsAllKeys

doesNotHaveAnyKeys

doesNotHaveAllKeys

hasAnyDeepKeys

hasAllDeepKeys

containsAllDeepKeys

doesNotHaveAnyDeepKeys

doesNotHaveAllDeepKeys