assert

Vitest znovu exportuje metodu assert z chai pro ověřování invariantů.

assert

Typ: (expression: any, message?: string) => asserts expression

Ověří, zda je daný expression truthy. Pokud ne, test selže.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo by nemělo být rovno bar');
});

fail

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

Vynutí selhání testu.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('Chybová zpráva při selhání.');
  assert.fail('foo', 'bar', 'foo není bar', '===');
});

isOk

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

Ověří, zda je daná value truthy.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'Každá truthy hodnota je v pořádku.');
  assert.isOk(false, 'Toto selže, protože false není truthy hodnota.');
});

isNotOk

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

Ověří, zda je daná value falsy (vyhodnocuje se jako nepravdivá).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk(
    'foo',
    'Toto selže, protože každá truthy hodnota není v pořádku.'
  );
  assert.isNotOk(false, 'Toto projde, protože false je falsy.');
});

equal

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

Ověří nepřísnou rovnost (==) mezi actual a expected.

import { assert, test } from 'vitest';

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

notEqual

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

Ověří nepřísnou nerovnost (!=) mezi actual a expected.

import { assert, test } from 'vitest';

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

strictEqual

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

Ověří přísnou rovnost (===) mezi actual a expected.

import { assert, test } from 'vitest';

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

deepEqual

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

Ověří, zda je actual hluboce rovno expected. Porovnává rekurzivně všechny vlastnosti obou objektů.

import { assert, test } from 'vitest';

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

notDeepEqual

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

Ověří, zda se actual hluboce nerovná expected.

import { assert, test } from 'vitest';

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

isAbove

Typ: (valueToCheck: number, valueToBeAbove: number, message?: string) => void

Ověří, zda je valueToCheck přísně větší než (>) valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 je větší než 2');
});

isAtLeast

Typ: (valueToCheck: number, valueToBeAtLeast: number, message?: string) => void

Ověří, zda je valueToCheck větší nebo rovna (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 je větší nebo rovna 2');
  assert.isAtLeast(3, 3, '3 je větší nebo rovna 3');
});

isBelow

Typ: (valueToCheck: number, valueToBeBelow: number, message?: string) => void

Ověří, zda je valueToCheck přísně menší než (<) valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 je menší než 6');
});

isAtMost

Typ: (valueToCheck: number, valueToBeAtMost: number, message?: string) => void

Ověří, zda je valueToCheck menší nebo rovna (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 je menší nebo rovna 6');
  assert.isAtMost(4, 4, '4 je menší nebo rovna 4');
});

isTrue

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

Ověří, zda je value rovna true.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Ověří, zda value není rovna true.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Ověří, zda je value rovna false.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Ověří, zda value není rovna false.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Ověří, zda je value null (nulová hodnota).

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

Ověří, zda value není null (nulová hodnota).

import { assert, test } from 'vitest';

const error = { message: 'nastala chyba' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error není null, je to objekt');
});

isNaN

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

Ověří, zda je value NaN (Not a Number, není číslo).

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Ověří, zda value není NaN (není číslo).

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 není NaN, ale 2');
});

exists

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

Ověří, zda value není ani null, ani undefined (nedefinováno).

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo není ani null, ani undefined');
});

notExists

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

Ověří, zda je value buď null, nebo undefined (nedefinováno).

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo je null, proto neexistuje');
  assert.notExists(bar, 'bar je undefined, proto neexistuje');
});

isUndefined

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

Ověří, zda je value undefined (nedefinováno).

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Ověří, zda value není undefined (nedefinováno).

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name není undefined');
});

isFunction

Typ: <T>(value: T, message?: string) => void
Alias: isCallable Ověří, zda je value funkce.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name je funkce');
});

isNotFunction

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

Ověří, zda value není funkce.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name není funkce, je to řetězec');
});

isObject

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

Ověří, zda je value objektem typu Object (jak ukazuje Object.prototype.toString). Toto ověření se neshoduje s objekty odvozenými od Object.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing je objekt');
});

isNotObject

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

Ověří, že value není objekt typu Object (zjištěno pomocí Object.prototype.toString). Toto tvrzení selže i pro instance podtříd Object.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing není objekt, ale řetězec');
});

isArray

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

Ověří, že value je pole.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color je pole');
});

isNotArray

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

Ověří, že value není pole.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color není pole, ale řetězec');
});

isString

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

Ověří, že value je řetězec.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color je řetězec');
});

isNotString

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

Ověří, že value není řetězec.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color není řetězec, ale pole');
});

isNumber

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

Ověří, že value je číslo.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors je číslo');
});

isNotNumber

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

Ověří, že value není číslo.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors není číslo, ale řetězec');
});

isFinite

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

Ověří, že value je konečné číslo (tj. není NaN ani Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors je konečné číslo, není NaN nebo Infinity');
});

isBoolean

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

Ověří, že value je logická hodnota (boolean).

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady je logická hodnota');
});

isNotBoolean

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

Ověří, že value není logická hodnota (boolean).

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady není logická hodnota, ale řetězec');
});

typeOf

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

Ověří, že typ value odpovídá zadanému name, jak je určeno pomocí Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'máme objekt');
  assert.typeOf(['red', 'green'], 'array', 'máme pole');
  assert.typeOf('red', 'string', 'máme řetězec');
  assert.typeOf(/red/, 'regexp', 'máme regulární výraz');
  assert.typeOf(null, 'null', 'máme null');
  assert.typeOf(undefined, 'undefined', 'máme undefined');
});

notTypeOf

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

Ověří, že typ value neodpovídá zadanému name, jak je určeno pomocí Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" není číslo');
});

instanceOf

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

Ověří, že value je instance konstruktoru constructor.

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 je instance Person');
  assert.instanceOf(coffee, Tea, 'coffee je instance Tea');
});

notInstanceOf

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

Ověří, že value není instance konstruktoru constructor.

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, 'foo není instance Tea');
});

include

Typ:
- (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

Ověří, že haystack obsahuje needle. Lze použít k ověření přítomnosti hodnoty v poli, podřetězce v řetězci nebo podmnožiny vlastností v objektu.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'pole obsahuje hodnotu');
  assert.include('foobar', 'foo', 'řetězec obsahuje podřetězec');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'objekt obsahuje vlastnost'
  );
});

notInclude

Typ:
- (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

Ověří, že haystack neobsahuje needle. Lze použít k ověření absence hodnoty v poli, podřetězce v řetězci nebo podmnožiny vlastností v objektu.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'pole neobsahuje 4');
  assert.notInclude('foobar', 'baz', 'foobar neobsahuje baz');
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'objekt neobsahuje vlastnost'
  );
});

deepInclude

Typ:
(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

Ověří, že haystack obsahuje needle. Lze použít k ověření přítomnosti hodnoty v poli nebo podmnožiny vlastností v objektu. Používá hlubokou rovnost (deep equality).

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

Typ:
- (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

Ověří, že haystack neobsahuje needle. Lze použít k ověření absence hodnoty v poli nebo podmnožiny vlastností v objektu. Používá hlubokou rovnost (deep equality).

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack obsahuje needle. Lze použít k ověření přítomnosti podmnožiny vlastností ve vnořeném objektu. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky [] a . v názvech vlastností je nutné escapovat pomocí dvojitých zpětných lomítek.

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack neobsahuje needle. Lze použít k ověření absence podmnožiny vlastností ve vnořeném objektu. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky [] a . v názvech vlastností je nutné escapovat pomocí dvojitých zpětných lomítek.

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack obsahuje needle. Lze použít k ověření přítomnosti podmnožiny vlastností ve vnořeném objektu s použitím hluboké rovnosti (deep equality). Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky [] a . v názvech vlastností je nutné escapovat pomocí dvojitých zpětných lomítek.

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack neobsahuje needle. Lze použít k ověření absence podmnožiny vlastností ve vnořeném objektu s použitím hluboké rovnosti (deep equality). Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky [] a . v názvech vlastností je nutné escapovat pomocí dvojitých zpětných lomítek.

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack obsahuje needle jako vlastní vlastnost (tj. nezděděnou). Lze použít k ověření přítomnosti podmnožiny vlastností v objektu, přičemž se ignorují zděděné vlastnosti.

import { assert, test } from 'vitest';

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

notOwnInclude

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, že haystack neobsahuje needle jako vlastní vlastnost (tj. nezděděnou). Lze použít k ověření absence podmnožiny vlastností v objektu, přičemž se ignorují zděděné vlastnosti.

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

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, zda haystack obsahuje needle jako vlastní vlastnost (tj. nezděděnou). Používá se k ověření, zda objekt obsahuje podmnožinu vlastností, přičemž se kontroluje hloubková rovnost. Zděděné vlastnosti jsou ignorovány.

import { assert, test } from 'vitest';

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

notDeepOwnInclude

Typ: (haystack: any, needle: any, message?: string) => void

Ověří, zda haystack neobsahuje needle jako vlastní vlastnost (tj. nezděděnou). Používá se k ověření, zda objekt neobsahuje podmnožinu vlastností, přičemž se kontroluje hloubková rovnost. Zděděné vlastnosti jsou ignorovány.

import { assert, test } from 'vitest';

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

match

Typ: (value: string, regexp: RegExp, message?: string) => void

Ověří, zda řetězec value odpovídá regulárnímu výrazu regexp.

import { assert, test } from 'vitest';

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

notMatch

Typ: (value: string, regexp: RegExp, message?: string) => void

Ověří, zda řetězec value neodpovídá regulárnímu výrazu regexp.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'regexp does not match');
});

property

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

Ověří, zda object má vlastnost s názvem property, ať už přímou nebo zděděnou.

import { assert, test } from 'vitest';

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

notProperty

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

Ověří, zda object nemá vlastnost s názvem property, ať už přímou nebo zděděnou.

import { assert, test } from 'vitest';

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

propertyVal

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

Ověří, zda object má vlastnost s názvem property (ať už přímou nebo zděděnou) a zda má tato vlastnost hodnotu rovnou value. Používá striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Ověří, zda object nemá vlastnost s názvem property (ať už přímou nebo zděděnou) s hodnotou rovnou value. Používá striktní porovnání rovnosti (===).

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

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

Ověří, zda object má vlastnost s názvem property (ať už přímou nebo zděděnou) a zda má tato vlastnost hodnotu hloubkově rovnou value. Používá hloubkové porovnání rovnosti.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

Ověří, zda object nemá vlastnost s názvem property (ať už přímou nebo zděděnou) s hodnotou hloubkově rovnou value. Používá hloubkové porovnání rovnosti.

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

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

Ověří, zda object má vnořenou vlastnost s názvem property. property může být řetězec používající tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Ověří, zda object nemá vnořenou vlastnost s názvem property. property může být řetězec používající tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Ověří, zda object má vnořenou vlastnost s názvem property a zda má tato vlastnost hodnotu rovnou value. property může používat tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti. Používá striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

notNestedPropertyVal

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

Ověří, zda object nemá vnořenou vlastnost s názvem property s hodnotou rovnou value. property může používat tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti. Používá striktní porovnání rovnosti (===).

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

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

Ověří, zda object má vnořenou vlastnost s názvem property a zda má tato vlastnost hodnotu hloubkově rovnou value. property může používat tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti. Používá hloubkové porovnání rovnosti.

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

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

Ověří, zda object nemá vnořenou vlastnost s názvem property s hodnotou hloubkově rovnou value. property může používat tečkovou notaci (např. tea.green) nebo hranaté závorky (např. tea['green']) pro odkazování na vnořené vlastnosti. Používá hloubkové porovnání rovnosti.

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

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

Ověří, zda má object vlastnost length (pro pole, řetězce atd.) nebo size (pro Set, Map atd.) s hodnotou rovnou length.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'array has length of 3');
  assert.lengthOf('foobar', 6, 'string has length of 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'set has size of 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'map has size of 3'
  );
});

hasAnyKeys

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

Ověří, zda object má alespoň jeden z klíčů uvedených v keys. Argument keys může být buď pole klíčů, nebo objekt, jehož klíče se použijí jako sada očekávaných klíčů.

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

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

Ověří, zda object má všechny klíče uvedené v keys a pouze je. Argument keys může být buď pole klíčů, nebo objekt, jehož klíče se použijí jako sada očekávaných klíčů.

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

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

Ověří, zda object obsahuje všechny klíče uvedené v keys, a případně i další klíče. Argument keys může být buď pole klíčů, nebo objekt, jehož klíče se použijí jako sada očekávaných klíčů.

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

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

Ověří, že objekt object neobsahuje žádný z klíčů uvedených v keys. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object neobsahuje alespoň jeden z klíčů uvedených v keys. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object obsahuje alespoň jeden z klíčů uvedených v keys. Vzhledem k tomu, že Set a Map mohou mít objekty jako klíče, lze tuto aserci použít k provedení hloubkového porovnání klíčů. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object obsahuje všechny klíče uvedené v keys a pouze tyto klíče. Vzhledem k tomu, že Set a Map mohou mít objekty jako klíče, lze tuto aserci použít k provedení hloubkového porovnání klíčů. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object obsahuje všechny klíče uvedené v keys. Vzhledem k tomu, že Set a Map mohou mít objekty jako klíče, lze tuto aserci použít k provedení hloubkového porovnání klíčů. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object neobsahuje žádný z klíčů uvedených v keys. Vzhledem k tomu, že Set a Map mohou mít objekty jako klíče, lze tuto aserci použít k provedení hloubkového porovnání klíčů. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

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

Ověří, že objekt object neobsahuje alespoň jeden z klíčů uvedených v keys. Vzhledem k tomu, že Set a Map mohou mít objekty jako klíče, lze tuto aserci použít k provedení hloubkového porovnání klíčů. Místo pole klíčů lze zadat i objekt, jehož klíče budou použity jako sada očekávaných klíčů.

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

Typ:
- (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

Pokud je errorLike konstruktor chyby (ErrorConstructor), ověří, že funkce fn vyvolá chybu, která je instancí tohoto konstruktoru. Pokud je errorLike instance chyby (Error), ověří, že vyvolaná chyba je stejná instance jako errorLike. Pokud je zadán errMsgMatcher, ověří se také, že zpráva vyvolané chyby odpovídá regulárnímu výrazu nebo řetězci errMsgMatcher.

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

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

Pokud je errorLike konstruktor chyby (ErrorConstructor), ověří, že funkce fn nevyvolá chybu, která je instancí tohoto konstruktoru. Pokud je errorLike instance chyby (Error), ověří, že vyvolaná chyba není stejná instance jako errorLike. Pokud je zadán errMsgMatcher, ověří se také, že zpráva vyvolané chyby neodpovídá regulárnímu výrazu nebo řetězci errMsgMatcher.

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

Typ: (val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void

Porovná hodnoty val1 a val2 pomocí zadaného operatoru.

import { assert, test } from 'vitest';

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

closeTo

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

Ověří, že actual (skutečná hodnota) je přibližně rovna expected (očekávané hodnotě), s tolerancí +/- delta.

import { assert, test } from 'vitest';

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

sameMembers

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

Ověří, že set1 a set2 obsahují stejné prvky v libovolném pořadí. Používá se striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Ověří, že set1 a set2 neobsahují stejné prvky v libovolném pořadí. Používá se striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

sameDeepMembers

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

Ověří, že set1 a set2 obsahují stejné prvky v libovolném pořadí. Používá se hloubkové porovnání rovnosti.

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

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

Ověří, že set1 a set2 neobsahují stejné prvky v libovolném pořadí. Používá se hloubkové porovnání rovnosti.

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

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

Ověří, že set1 a set2 obsahují stejné prvky ve stejném pořadí. Používá se striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

notSameOrderedMembers

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

Ověří, že set1 a set2 neobsahují stejné prvky ve stejném pořadí. Používá se striktní porovnání rovnosti (===).

import { assert, test } from 'vitest';

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

sameDeepOrderedMembers

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

Ověří, že set1 a set2 obsahují stejné prvky ve stejném pořadí. Používá se hloubkové porovnání rovnosti.

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

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

Ověřuje, že set1 a set2 neobsahují stejné prvky ve stejném pořadí. Pro porovnání prvků se používá hloubková kontrola rovnosti.

import { assert, test } from 'vitest';

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

includeMembers

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

Ověřuje, že subset je podmnožinou superset bez ohledu na pořadí prvků. Pro porovnání prvků se používá striktní kontrola rovnosti (===). Duplicitní prvky v subset jsou ignorovány.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Ověřuje, že subset není podmnožinou superset bez ohledu na pořadí prvků. Pro porovnání prvků se používá striktní kontrola rovnosti (===). Duplicitní prvky v subset jsou ignorovány.

import { assert, test } from 'vitest';

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

includeDeepMembers

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

Ověřuje, že subset je podmnožinou superset bez ohledu na pořadí prvků. Pro porovnání prvků se používá hloubková kontrola rovnosti. Duplicitní prvky v subset jsou ignorovány.

import { assert, test } from 'vitest';

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

notIncludeDeepMembers

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

Ověřuje, že subset není podmnožinou superset bez ohledu na pořadí prvků. Pro porovnání prvků se používá hloubková kontrola rovnosti. Duplicitní prvky v subset jsou ignorovány.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'not include deep members'
  );
});

includeOrderedMembers

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

Ověřuje, že subset je obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Pro porovnání prvků se používá striktní kontrola rovnosti (===).

import { assert, test } from 'vitest';

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

notIncludeOrderedMembers

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

Ověřuje, že subset není obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Pro porovnání prvků se používá striktní kontrola rovnosti (===).

import { assert, test } from 'vitest';

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

includeDeepOrderedMembers

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

Ověřuje, že subset je obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Pro porovnání prvků se používá hloubková kontrola rovnosti.

import { assert, test } from 'vitest';

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

notIncludeDeepOrderedMembers

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

Ověřuje, že subset není obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Pro porovnání prvků se používá hloubková kontrola rovnosti.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'not include deep ordered members'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'not include deep ordered members'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'not include deep ordered members'
  );
});

oneOf

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

Ověřuje, že hodnota inList (která není objekt ani pole) se nachází v poli list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Not found in list');
});

changes

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

Ověřuje, že funkce modifier změní hodnotu vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

changesBy

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

Ověřuje, že funkce modifier změní hodnotu vlastnosti property objektu object o hodnotu change.

import { assert, test } from 'vitest';

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

doesNotChange

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

Ověřuje, že funkce modifier nezmění hodnotu vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Ověřuje, že funkce modifier změní hodnotu vlastnosti property objektu object, ale ne o hodnotu change.

import { assert, test } from 'vitest';

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

increases

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

Ověřuje, že funkce modifier zvýší hodnotu číselné vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

increasesBy

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

Ověřuje, že funkce modifier zvýší hodnotu číselné vlastnosti property objektu object o hodnotu change.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Ověřuje, že funkce modifier nezvýší hodnotu číselné vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Ověřuje, že funkce modifier zvýší hodnotu číselné vlastnosti property objektu object, ale ne o hodnotu change.

import { assert, test } from 'vitest';

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

decreases

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

Ověřuje, že funkce modifier sníží hodnotu číselné vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

decreasesBy

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

Ověřuje, že funkce modifier sníží hodnotu číselné vlastnosti property objektu object o hodnotu change.

import { assert, test } from 'vitest';

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

doesNotDecrease

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

Ověřuje, že funkce modifier nesníží hodnotu číselné vlastnosti property objektu object.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Ověří, že modifier nesníží číselnou hodnotu vlastnosti property objektu object ani návratovou hodnotu modifier o hodnotu change nebo více.

import { assert, test } from 'vitest';

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

decreasesButNotBy

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

Ověří, že modifier sníží číselnou hodnotu vlastnosti property objektu object nebo návratovou hodnotu modifier, ale ne o hodnotu change.

import { assert, test } from 'vitest';

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

ifError

Type: <T>(object: T, message?: string) => void

Ověří, zda je object nepravdivá hodnota (falsy). Pokud je object pravdivá hodnota (truthy), vyvolá výjimku. Tato funkce byla přidána, aby bylo možné použít chai jako přímou náhradu za Node.js assert class.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // Znovu vyvolá err!
});

isExtensible

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

Ověří, že object je rozšiřitelný (lze k němu přidávat nové vlastnosti).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Ověří, že object není rozšiřitelný (nelze k němu přidávat nové vlastnosti).

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

Type: <T>(object: T, message?: string) => void
Alias: sealed

Ověří, že object je zapečetěný (nelze k němu přidávat nové vlastnosti ani odstraňovat existující, ale hodnoty existujících vlastností lze měnit, pokud jsou zapisovatelné).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Ověří, že object není zapečetěný (mohou k němu být přidány nové vlastnosti a jeho existující vlastnosti mohou být odstraněny).

import { assert, test } from 'vitest';

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

isFrozen

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

Ověří, že object je zmrazený (nemohou k němu být přidány nové vlastnosti a jeho existující vlastnosti nemohou být měněny).

import { assert, test } from 'vitest';

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

isNotFrozen

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

Ověří, že object není zmrazený (mohou k němu být přidány nové vlastnosti a jeho existující vlastnosti mohou být měněny).

import { assert, test } from 'vitest';

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

isEmpty

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

Ověří, že target neobsahuje žádné hodnoty. Pro pole a řetězce kontroluje vlastnost length. Pro instance Map a Set kontroluje vlastnost size. Pro objekty kontroluje počet klíčů.

import { assert, test } from 'vitest';

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

isNotEmpty

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

Ověří, že target obsahuje hodnoty. Pro pole a řetězce kontroluje vlastnost length. Pro instance Map a Set kontroluje vlastnost size. Pro objekty kontroluje počet klíčů.

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