assert

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

assert

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

Ověří, že daný výraz je pravdivý, jinak ověření 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ěří, že daná hodnota je pravdivá.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'všechny pravdivé hodnoty jsou platné');
  assert.isOk(false, 'toto selže, protože false není pravdivé');
});

isNotOk

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

Ověří, že daná hodnota je nepravdivá.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'toto selže, každá pravdivá hodnota není ok');
  assert.isNotOk(false, 'toto projde, protože false je nepravdivé');
});

equal

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

Ověří nestriktní 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ěří nestriktní 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ěří striktní 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ěří, že actual je hluboce rovno expected.

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ěří, že actual není hluboce rovno 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ěří, že valueToCheck je striktně větší než (>) valueToBeAbove.

import { assert, test } from 'vitest';

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

isAtLeast

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

Ověří, že valueToCheck je větší nebo rovno (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

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

isBelow

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

Ověří, že valueToCheck je striktně menší než (<) valueToBeBelow.

import { assert, test } from 'vitest';

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

isAtMost

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

Ověří, že valueToCheck je menší nebo rovno (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

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

isTrue

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

Ověří, že value je true.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

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

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Ověří, že value je false.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

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

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Ověří, že value je null.

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ěří, že value není null.

import { assert, test } from 'vitest';

const error = { message: 'error was occurred' };

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

isNaN

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

Ověří, že value je NaN.

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ěří, že value není NaN.

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ěří, že value není ani null, ani undefined.

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ěří, že value je buď null, nebo undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

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

isUndefined

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

Ověří, že value je undefined.

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ěří, že value není undefined.

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ěří, že value je 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ěří, že value není funkce.

import { assert, test } from 'vitest';

const name = 'foo';

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

isObject

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

Ověří, že value je objekt typu Object (jak odhalí Object.prototype.toString). Ověření neodpovídá podtřídám objektů.

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 (jak odhalí Object.prototype.toString). Ověření neodpovídá podtřídám objektů.

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 (ne NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

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

isBoolean

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

Ověří, že value je boolean.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady je boolean');
});

isNotBoolean

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

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

import { assert, test } from 'vitest';

const isReady = 'sure';

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

typeOf

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

Ověří, že typ value je name, jak je určeno 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 není name, jak je určeno 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 instancí 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 instancí Person');
  assert.instanceOf(coffee, Tea, 'coffee je instancí Tea');
});

notInstanceOf

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

Ověří, že value není instancí 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í instancí 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í zahrnutí 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í zahrnutí hodnoty v poli nebo podmnožiny vlastností v objektu. Používá se hluboká rovnost.

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á se hluboká rovnost.

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í zahrnutí podmnožiny vlastností v objektu. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky '[]' a '.' v názvech vlastností lze 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í zahrnutí podmnožiny vlastností v objektu. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky '[]' a '.' v názvech vlastností lze 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í zahrnutí podmnožiny vlastností v objektu s kontrolou hluboké rovnosti. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky '[]' a '.' v názvech vlastností lze 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í v objektu s kontrolou hluboké rovnosti. Umožňuje použití tečkové a závorkové notace pro odkazování na vnořené vlastnosti. Znaky '[]' a '.' v názvech vlastností lze 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. Lze použít k ověření zahrnutí podmnožiny vlastních (nezděděných) vlastností v objektu.

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. Lze použít k ověření absence podmnožiny vlastních (nezděděných) vlastností v objektu.

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ěří, že haystack obsahuje needle. Lze použít k ověření zahrnutí podmnožiny vlastních (nezděděných) vlastností v objektu s kontrolou hluboké rovnosti.

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ěří, že haystack neobsahuje needle. Lze použít k ověření absence podmnožiny vlastních (nezděděných) vlastností v objektu s kontrolou hluboké rovnosti.

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ěří, že value odpovídá regulárnímu výrazu regexp.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'regexp odpovídá');
});

notMatch

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

Ověří, že value neodpovídá regulárnímu výrazu regexp.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'regexp neodpovídá');
});

property

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

Ověří, že object má přímou nebo zděděnou vlastnost pojmenovanou property.

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ěří, že object nemá přímou nebo zděděnou vlastnost pojmenovanou property.

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ěří, že object má přímou nebo zděděnou vlastnost pojmenovanou property s hodnotou danou value. Používá striktní kontrolu 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ěří, že object nemá přímou nebo zděděnou vlastnost pojmenovanou property s hodnotou danou value. Používá striktní kontrolu 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ěří, že object má přímou nebo zděděnou vlastnost pojmenovanou property s hodnotou danou value. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

Ověří, že object nemá přímou nebo zděděnou vlastnost pojmenovanou property s hodnotou danou value. Používá hlubokou kontrolu 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ěří, že object má přímou nebo zděděnou vlastnost pojmenovanou property, která může být řetězec používající tečkovou a závorkovou notaci pro vnořený odkaz.

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ěří, že object nemá přímou nebo zděděnou vlastnost pojmenovanou property, která může být řetězec používající tečkovou a závorkovou notaci pro vnořený odkaz.

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ěří, že object má vlastnost pojmenovanou property s hodnotou danou value. property může používat tečkovou a závorkovou notaci pro vnořený odkaz. Používá striktní kontrolu 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ěří, že object nemá vlastnost pojmenovanou property s hodnotou danou value. property může používat tečkovou a závorkovou notaci pro vnořený odkaz. Používá striktní kontrolu 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ěří, že object má vlastnost pojmenovanou property s hodnotou danou value. property může používat tečkovou a závorkovou notaci pro vnořený odkaz. Používá hlubokou kontrolu 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ěří, že object nemá vlastnost pojmenovanou property s hodnotou danou value. property může používat tečkovou a závorkovou notaci pro vnořený odkaz. Používá hlubokou kontrolu 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ěří, že object má length nebo size s očekávanou hodnotou.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'pole má délku 3');
  assert.lengthOf('foobar', 6, 'řetězec má délku 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'set má velikost 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'mapa má velikost 3'
  );
});

hasAnyKeys

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

Ověří, že object má alespoň jeden z poskytnutých keys. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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ěří, že object má všechny a pouze všechny poskytnuté keys. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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ěří, že object má všechny poskytnuté keys, ale může mít i další klíče, které nejsou uvedeny. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object nemá žádný z poskytnutých keys. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object nemá alespoň jeden z poskytnutých keys. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada klíčů.

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

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

Ověří, že object má alespoň jeden z poskytnutých keys. Jelikož Sety a Mapy mohou mít objekty jako klíče, můžete toto ověření použít k provedení hlubokého porovnání. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object má všechny a pouze všechny poskytnuté keys. Jelikož Sety a Mapy mohou mít objekty jako klíče, můžete toto ověření použít k provedení hlubokého porovnání. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object obsahuje všechny poskytnuté keys. Jelikož Sety a Mapy mohou mít objekty jako klíče, můžete toto ověření použít k provedení hlubokého porovnání. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object nemá žádný z poskytnutých keys. Jelikož Sety a Mapy mohou mít objekty jako klíče, můžete toto ověření použít k provedení hlubokého porovnání. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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 object nemá alespoň jeden z poskytnutých keys. Jelikož Sety a Mapy mohou mít objekty jako klíče, můžete toto ověření použít k provedení hlubokého porovnání. Můžete také poskytnout jeden objekt namísto pole klíčů a jeho klíče budou použity jako očekávaná sada 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, ověří, že fn vyhodí chybu, která je instancí errorLike. Pokud je errorLike instance chyby, ověří, že vyhozená chyba je stejná instance jako errorLike. Pokud je errMsgMatcher poskytnut, ověří také, že vyhozená chyba bude mít zprávu odpovídající errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Chyba musí obsahovat tuto zprávu');
  assert.throws(fn, /Chyba musí obsahovat zprávu, která odpovídá tomuto/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Chyba musí být ReferenceError a obsahovat tuto zprávu'
  );
  assert.throws(
    fn,
    errorInstance,
    'Chyba musí být stejná instance chyby a obsahovat tuto zprávu'
  );
  assert.throws(
    fn,
    ReferenceError,
    /Chyba musí být ReferenceError a odpovídat tomuto/
  );
  assert.throws(
    fn,
    errorInstance,
    /Chyba musí být stejná instance chyby a odpovídat tomuto/
  );
});

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, ověří, že fn nevyhodí chybu, která je instancí errorLike. Pokud je errorLike instance chyby, ověří, že vyhozená chyba není stejná instance jako errorLike. Pokud je errMsgMatcher poskytnut, ověří také, že vyhozená chyba nebude mít zprávu odpovídající errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Žádná vyhozená chyba nesmí mít tuto zprávu');
  assert.doesNotThrow(fn, /Žádná vyhozená chyba nesmí odpovídat tomuto/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Chyba nesmí mít tuto zprávu');
  assert.doesNotThrow(fn, errorInstance, 'Chyba nesmí mít tuto zprávu');
  assert.doesNotThrow(fn, Error, /Chyba nesmí odpovídat tomuto/);
  assert.doesNotThrow(fn, errorInstance, /Chyba nesmí odpovídat tomuto/);
});

operator

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

Porovná val1 a val2 pomocí operator.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'hodnoty jsou v pořádku');
});

closeTo

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

Ověří, že actual je rovno expected s přesností na rozsah +/- delta.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'hodnoty jsou dostatečně blízké');
});

sameMembers

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

Ověří, že set1 a set2 mají stejné členy v libovolném pořadí. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'stejné členy');
});

notSameMembers

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

Ověří, že set1 a set2 nemají stejné členy v libovolném pořadí. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'ne stejné členy');
});

sameDeepMembers

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

Ověří, že set1 a set2 mají stejné členy v libovolném pořadí. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'stejné hluboké členy'
  );
});

notSameDeepMembers

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

Ověří, že set1 a set2 nemají stejné členy v libovolném pořadí. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'ne stejné hluboké členy'
  );
});

sameOrderedMembers

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

Ověří, že set1 a set2 mají stejné členy ve stejném pořadí. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'stejné uspořádané členy');
});

notSameOrderedMembers

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

Ověří, že set1 a set2 nemají stejné členy ve stejném pořadí. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'ne stejné uspořádané členy'
  );
});

sameDeepOrderedMembers

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

Ověří, že set1 a set2 mají stejné členy ve stejném pořadí. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'stejné hluboké uspořádané členy'
  );
});

notSameDeepOrderedMembers

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

Ověří, že set1 a set2 nemají stejné členy ve stejném pořadí. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'ne stejné hluboké uspořádané členy'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'ne stejné hluboké uspořádané členy'
  );
});

includeMembers

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

Ověří, že subset je obsažen v superset v libovolném pořadí. Používá striktní kontrolu rovnosti (===). Duplikáty jsou ignorovány.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'zahrnuje členy');
});

notIncludeMembers

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

Ověří, že subset není obsažen v superset v libovolném pořadí. Používá striktní kontrolu rovnosti (===). Duplikáty jsou ignorovány.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'nezahrnuje členy');
});

includeDeepMembers

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

Ověří, že subset je obsažen v superset v libovolném pořadí. Používá hlubokou kontrolu rovnosti. Duplikáty 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 }],
    'zahrnuje hluboké členy'
  );
});

notIncludeDeepMembers

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

Ověří, že subset není obsažen v superset v libovolném pořadí. Používá hlubokou kontrolu rovnosti. Duplikáty jsou ignorovány.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'nezahrnuje hluboké členy'
  );
});

includeOrderedMembers

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

Ověří, že subset je obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'zahrnuje uspořádané členy');
});

notIncludeOrderedMembers

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

Ověří, že subset není obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Používá striktní kontrolu rovnosti (===).

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'nezahrnuje uspořádané členy'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'nezahrnuje uspořádané členy'
  );
});

includeDeepOrderedMembers

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

Ověří, že subset je obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'zahrnuje hluboké uspořádané členy'
  );
});

notIncludeDeepOrderedMembers

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

Ověří, že subset není obsažen v superset ve stejném pořadí, počínaje prvním prvkem v superset. Používá hlubokou kontrolu rovnosti.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'nezahrnuje hluboké uspořádané členy'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'nezahrnuje hluboké uspořádané členy'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'nezahrnuje hluboké uspořádané členy'
  );
});

oneOf

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

Ověří, že neobjektová, nepolová hodnota inList se objeví v plochém poli list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Nenalezeno v seznamu');
});

changes

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

Ověří, že modifier změní vlastnost property objectu.

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ěří, že modifier změní vlastnost property objectu o 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ěří, že modifier nezmění vlastnost property objectu.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Ověří, že modifier změní vlastnost property objectu nebo návratovou hodnotu modifier, ale ne o přesně 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ěří, že modifier zvýší číselnou vlastnost property objectu.

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ěří, že modifier zvýší číselnou vlastnost property objectu nebo návratovou hodnotu modifier o 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ěří, že modifier nezvýší číselnou vlastnost property objectu.

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ěří, že modifier nezvýší číselnou vlastnost property objectu nebo návratovou hodnotu modifier o 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ěří, že modifier sníží číselnou vlastnost property objectu.

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ěří, že modifier sníží číselnou vlastnost property objectu nebo návratovou hodnotu modifier o 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ěří, že modifier nesníží číselnou vlastnost property objectu.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Ověří, že modifier nesníží číselnou vlastnost property objectu nebo návratovou hodnotu modifier o change.

import { assert, test } from 'vitest';

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

decreasesButNotBy

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

Ověří, že modifier sníží číselnou vlastnost property objectu nebo návratovou hodnotu modifier, ale ne o přesně 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

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

Ověří, zda object není nepravdivá hodnota, a vyhodí chybu, pokud je to pravdivá hodnota. Toto je přidáno, aby Chai mohl být přímou náhradou za třídu assert z Node.js.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('Vlastní chyba');
  assert.ifError(err); // Znovu vyhodí chybu!
});

isExtensible

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

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

import { assert, test } from 'vitest';

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

isNotExtensible

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

Ověří, že object není rozšiřitelný (nelze do něj 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

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

Ověří, že object je zapečetěný (nelze do něj přidávat nové vlastnosti a jeho stávající vlastnosti nelze odebírat).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Ověří, že object není zapečetěný (lze do něj přidávat nové vlastnosti a jeho stávající vlastnosti lze odebírat).

import { assert, test } from 'vitest';

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

isFrozen

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

Ověří, že objekt je zmrazený (nelze do něj přidávat nové vlastnosti a jeho stávající vlastnosti nelze upravovat).

import { assert, test } from 'vitest';

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

isNotFrozen

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

Ověří, že object není zmrazený (lze do něj přidávat nové vlastnosti a jeho stávající vlastnosti lze upravovat).

import { assert, test } from 'vitest';

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

isEmpty

• Typ: <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 ne-funkční objekty získá počet jejich vlastních vyčíslitelných řetězcových klíčů.

import { assert, test } from 'vitest';

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

isNotEmpty

• Typ: <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 ne-funkční objekty získá počet jejich vlastních vyčíslitelných řetězcových 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 });
});