assert

Vitest повторно экспортирует метод assert из chai для проверки инвариантов.

assert

Тип: (expression: any, message?: string) => asserts expression

Утверждает, что данное expression является истинным. В противном случае утверждение завершается неудачей.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo не должно быть равно bar');
});

fail

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

Принудительно вызывает сбой утверждения.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('сообщение об ошибке при сбое');
  assert.fail('foo', 'bar', 'foo не равно bar', '===');
});

isOk

Тип: <T>(value: T, message?: string) => void
Псевдоним: ok

Утверждает, что данное value является истинным.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'любое истинное значение является корректным');
  assert.isOk(false, 'это завершится неудачей, так как false не является истинным');
});

isNotOk

Тип: <T>(value: T, message?: string) => void
Псевдоним: notOk

Утверждает, что данное value является ложным.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'это завершится неудачей, любое истинное значение не является корректным');
  assert.isNotOk(false, 'это пройдет, так как false является ложным');
});

equal

Тип: <T>(actual: T, expected: T, message?: string) => void

Утверждает нестрогое равенство (==) actual и expected.

import { assert, test } from 'vitest';

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

notEqual

Тип: <T>(actual: T, expected: T, message?: string) => void

Утверждает нестрогое неравенство (!=) actual и expected.

import { assert, test } from 'vitest';

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

strictEqual

Тип: <T>(actual: T, expected: T, message?: string) => void

Утверждает строгое равенство (===) actual и expected.

import { assert, test } from 'vitest';

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

deepEqual

Тип: <T>(actual: T, expected: T, message?: string) => void

Утверждает, что actual глубоко равно expected.

import { assert, test } from 'vitest';

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

notDeepEqual

Тип: <T>(actual: T, expected: T, message?: string) => void

Утверждает, что actual не глубоко равно expected.

import { assert, test } from 'vitest';

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

isAbove

Тип: (valueToCheck: number, valueToBeAbove: number, message?: string) => void

Утверждает, что valueToCheck строго больше (>) valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 строго больше, чем 2');
});

isAtLeast

Тип: (valueToCheck: number, valueToBeAtLeast: number, message?: string) => void

Утверждает, что valueToCheck больше или равно (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 больше или равно 2');
  assert.isAtLeast(3, 3, '3 больше или равно 3');
});

isBelow

Тип: (valueToCheck: number, valueToBeBelow: number, message?: string) => void

Утверждает, что valueToCheck строго меньше (<) valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 строго меньше, чем 6');
});

isAtMost

Тип: (valueToCheck: number, valueToBeAtMost: number, message?: string) => void

Утверждает, что valueToCheck меньше или равно (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 меньше или равно 6');
  assert.isAtMost(4, 4, '4 меньше или равно 4');
});

isTrue

Тип: <T>(value: T, message?: string) => void

Утверждает, что value истинно.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не истинно.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

Тип: <T>(value: T, message?: string) => void

Утверждает, что value ложно.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не ложно.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

Тип: <T>(value: T, message?: string) => void

Утверждает, что value равно null.

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не равно null.

import { assert, test } from 'vitest';

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

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error is not null but object');
});

isNaN

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 это не NaN, а 2');
});

exists

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является ни null, ни undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo не является ни null, ни undefined');
});

notExists

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является либо null, либо undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo равно null, поэтому не существует');
  assert.notExists(bar, 'bar равно undefined, поэтому не существует');
});

isUndefined

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является undefined.

import { assert, test } from 'vitest';

const name = undefined;

test('assert.isUndefined', () => {
  assert.isUndefined(name, 'name является undefined');
});

isDefined

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name не является undefined');
});

isFunction

Тип: <T>(value: T, message?: string) => void
Псевдоним: isCallable Утверждает, что value является функцией.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name является функцией');
});

isNotFunction

Тип: <T>(value: T, message?: string) => void
Псевдоним: isNotCallable

Утверждает, что value не является функцией.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name не является функцией, а является строкой');
});

isObject

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является объектом типа Object (как показано Object.prototype.toString). Утверждение не соответствует объектам подклассов.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing является объектом');
});

isNotObject

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является объектом типа Object (как показано Object.prototype.toString). Утверждение не соответствует объектам подклассов.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing не является объектом, а является строкой');
});

isArray

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является массивом.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color является массивом');
});

isNotArray

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является массивом.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color не является массивом, а является строкой');
});

isString

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является строкой.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color является строкой');
});

isNotString

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является строкой.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color не является строкой, а является массивом');
});

isNumber

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является числом.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors является числом');
});

isNotNumber

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является числом.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors не является числом, а является строкой');
});

isFinite

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является конечным числом (не NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors является конечным числом (не NaN или Infinity)');
});

isBoolean

Тип: <T>(value: T, message?: string) => void

Утверждает, что value является булевым значением.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady является булевым значением');
});

isNotBoolean

Тип: <T>(value: T, message?: string) => void

Утверждает, что value не является булевым значением.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady не является булевым значением, а является строкой');
});

typeOf

Тип: <T>(value: T, name: string, message?: string) => void

Утверждает, что тип value равен name, как определено Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'это объект');
  assert.typeOf(['red', 'green'], 'array', 'это массив');
  assert.typeOf('red', 'string', 'это строка');
  assert.typeOf(/red/, 'regexp', 'это регулярное выражение');
  assert.typeOf(null, 'null', 'это null');
  assert.typeOf(undefined, 'undefined', 'это undefined');
});

notTypeOf

Тип: <T>(value: T, name: string, message?: string) => void

Утверждает, что тип value не равен name, как определено Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" не является числом');
});

instanceOf

Тип: <T>(value: T, constructor: Function, message?: string) => void

Утверждает, что value является экземпляром 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 является экземпляром `Person`');
  assert.instanceOf(coffee, Tea, 'coffee является экземпляром `Tea`');
});

notInstanceOf

Тип: <T>(value: T, constructor: Function, message?: string) => void

Утверждает, что value не является экземпляром 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 не является экземпляром `Tea`');
});

include

Тип:
- (haystack: string, needle: string, message?: string) => void
- <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
- <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
- <T>(haystack: T, needle: Partial<T>, message?: string) => void

Утверждает, что haystack включает needle. Может использоваться для утверждения включения значения в массив, подстроки в строку или подмножества свойств в объект.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'массив содержит значение');
  assert.include('foobar', 'foo', 'строка содержит подстроку');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'объект содержит свойство'
  );
});

notInclude

Тип:
- (haystack: string, needle: string, message?: string) => void
- <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
- <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
- <T>(haystack: T, needle: Partial<T>, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения отсутствия значения в массиве, подстроки в строке или подмножества свойств в объекте.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, "массив не содержит 4");
  assert.notInclude('foobar', 'baz', "foobar не содержит baz");
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    "объект не содержит свойство"
  );
});

deepInclude

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

Утверждает, что haystack включает needle. Может использоваться для утверждения включения значения в массив или подмножества свойств в объект. Используется глубокое равенство.

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

Тип:
- (haystack: string, needle: string, message?: string) => void
- <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
- <T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения отсутствия значения в массиве или подмножества свойств в объекте. Используется глубокое равенство.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack включает needle. Может использоваться для утверждения включения подмножества свойств в объект. Позволяет использовать точечную и скобочную нотацию для ссылки на вложенные свойства. Символы [] и . в именах свойств могут быть экранированы с помощью двойных обратных слешей.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения включения подмножества свойств в объект. Позволяет использовать точечную и скобочную нотацию для ссылки на вложенные свойства. Символы [] и . в именах свойств могут быть экранированы с помощью двойных обратных слешей.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack включает needle. Может использоваться для утверждения включения подмножества свойств в объект с проверкой глубокого равенства. Позволяет использовать точечную и скобочную нотацию для ссылки на вложенные свойства. Символы [] и . в именах свойств могут быть экранированы с помощью двойных обратных слешей.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения отсутствия подмножества свойств в объекте с проверкой глубокого равенства. Позволяет использовать точечную и скобочную нотацию для ссылки на вложенные свойства. Символы [] и . в именах свойств могут быть экранированы с помощью двойных обратных слешей.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack включает needle. Может использоваться для утверждения включения подмножества свойств в объект, игнорируя унаследованные свойства.

import { assert, test } from 'vitest';

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

notOwnInclude

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения отсутствия подмножества свойств в объекте, игнорируя унаследованные свойства.

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

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack включает needle. Может использоваться для утверждения включения подмножества свойств в объект, игнорируя унаследованные свойства и проверяя глубокое равенство.

import { assert, test } from 'vitest';

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

notDeepOwnInclude

Тип: (haystack: any, needle: any, message?: string) => void

Утверждает, что haystack не включает needle. Может использоваться для утверждения отсутствия подмножества свойств в объекте, игнорируя унаследованные свойства и проверяя глубокое равенство.

import { assert, test } from 'vitest';

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

match

Тип: (value: string, regexp: RegExp, message?: string) => void

Утверждает, что value соответствует регулярному выражению regexp.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'регулярное выражение совпадает');
});

notMatch

Тип: (value: string, regexp: RegExp, message?: string) => void

Утверждает, что value не соответствует регулярному выражению regexp.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'регулярное выражение не совпадает');
});

property

Тип: <T>(object: T, property: string, message?: string) => void

Утверждает, что object имеет прямое или унаследованное свойство с именем property.

import { assert, test } from 'vitest';

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

notProperty

Тип: <T>(object: T, property: string, message?: string) => void

Утверждает, что object не имеет прямого или унаследованного свойства с именем property.

import { assert, test } from 'vitest';

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

propertyVal

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

Утверждает, что object имеет прямое или унаследованное свойство с именем property со значением value. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Утверждает, что object не имеет прямого или унаследованного свойства с именем property со значением value. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

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

deepPropertyVal

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

Утверждает, что object имеет прямое или унаследованное свойство с именем property со значением value. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

Утверждает, что object не имеет прямого или унаследованного свойства с именем property со значением value. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

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

nestedProperty

Тип: <T>(object: T, property: string, message?: string) => void

Утверждает, что object имеет прямое или унаследованное свойство с именем property, которое может быть строкой, использующей точечную и скобочную нотацию для вложенной ссылки.

import { assert, test } from 'vitest';

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

notNestedProperty

Тип: <T>(object: T, property: string, message?: string) => void

Утверждает, что object не имеет прямого или унаследованного свойства с именем property, которое может быть строкой, использующей точечную и скобочную нотацию для вложенной ссылки.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Утверждает, что object имеет свойство с именем property со значением value. property может использовать точечную и скобочную нотацию для вложенной ссылки. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

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

notNestedPropertyVal

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

Утверждает, что object не имеет свойства с именем property со значением value. property может использовать точечную и скобочную нотацию для вложенной ссылки. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

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

deepNestedPropertyVal

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

Утверждает, что object имеет свойство с именем property со значением value. property может использовать точечную и скобочную нотацию для вложенной ссылки. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

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

Утверждает, что object не имеет свойства с именем property со значением value. property может использовать точечную и скобочную нотацию для вложенной ссылки. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

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

lengthOf

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

Утверждает, что object имеет свойство length или size с ожидаемым значением.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'длина массива равна 3');
  assert.lengthOf('foobar', 6, 'длина строки равна 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'размер `Set` равен 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'размер `Map` равен 3'
  );
});

hasAnyKeys

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

Утверждает, что object имеет хотя бы один из предоставленных keys. Вы также можете предоставить один объект вместо массива ключей; его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

hasAllKeys

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

Утверждает, что object имеет все предоставленные keys и только их. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

containsAllKeys

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

Утверждает, что object имеет все предоставленные keys, но может содержать и другие, не перечисленные ключи. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

doesNotHaveAnyKeys

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

Утверждает, что object не имеет ни одного из указанных keys. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

doesNotHaveAllKeys

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

Утверждает, что object не имеет хотя бы одного из указанных keys. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

Утверждает, что object имеет хотя бы один из предоставленных keys. Поскольку Set и Map могут иметь объекты в качестве ключей, вы можете использовать это утверждение для выполнения глубокого сравнения. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

hasAllDeepKeys

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

Утверждает, что object имеет все и только все предоставленные keys. Поскольку Set и Map могут иметь объекты в качестве ключей, вы можете использовать это утверждение для выполнения глубокого сравнения. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

containsAllDeepKeys

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

Утверждает, что object содержит все предоставленные keys. Поскольку Set и Map могут иметь объекты в качестве ключей, вы можете использовать это утверждение для выполнения глубокого сравнения. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

doesNotHaveAnyDeepKeys

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

Утверждает, что object не имеет ни одного из предоставленных keys. Поскольку Set и Map могут иметь объекты в качестве ключей, вы можете использовать это утверждение для выполнения глубокого сравнения. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

import { assert, test } from 'vitest';

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

doesNotHaveAllDeepKeys

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

Утверждает, что object не имеет хотя бы одного из предоставленных keys. Поскольку Set и Map могут иметь объекты в качестве ключей, вы можете использовать это утверждение для выполнения глубокого сравнения. Вы также можете предоставить один объект вместо массива ключей, и его ключи будут использоваться в качестве ожидаемого набора ключей.

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

Тип:
- (fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void
- (fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void
Псевдоним:
- throw
- Throw

Если errorLike является конструктором Error, утверждает, что fn выбросит ошибку, которая является экземпляром errorLike. Если errorLike является экземпляром Error, утверждает, что выброшенная ошибка является тем же экземпляром, что и errorLike. Если errMsgMatcher предоставлен, он также утверждает, что выброшенная ошибка будет иметь сообщение, содержащее errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Выброшенная ошибка должна содержать это сообщение');
  assert.throws(fn, /Выброшенная ошибка должна содержать сообщение, соответствующее этому/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Выброшенная ошибка должна быть `ReferenceError` и содержать это сообщение'
  );
  assert.throws(
    fn,
    errorInstance,
    'Выброшенная ошибка должна быть тем же экземпляром `errorInstance` и содержать это сообщение'
  );
  assert.throws(
    fn,
    ReferenceError,
    /Выброшенная ошибка должна быть `ReferenceError` и соответствовать этому/
  );
  assert.throws(
    fn,
    errorInstance,
    /Выброшенная ошибка должна быть тем же экземпляром `errorInstance` и соответствовать этому/
  );
});

doesNotThrow

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

Если errorLike является конструктором Error, утверждает, что fn не выбросит ошибку, которая является экземпляром errorLike. Если errorLike является экземпляром Error, утверждает, что выброшенная ошибка не является тем же экземпляром, что и errorLike. Если errMsgMatcher предоставлен, он также утверждает, что выброшенная ошибка не будет иметь сообщение, соответствующее errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Любая выброшенная ошибка не должна содержать это сообщение');
  assert.doesNotThrow(fn, /Любая выброшенная ошибка не должна соответствовать этому/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Ошибка не должна содержать это сообщение');
  assert.doesNotThrow(fn, errorInstance, 'Ошибка не должна содержать это сообщение');
  assert.doesNotThrow(fn, Error, /Ошибка не должна соответствовать этому/);
  assert.doesNotThrow(fn, errorInstance, /Ошибка не должна соответствовать этому/);
});

operator

Тип: (val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void

Сравнивает val1 и val2 с использованием operator.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'все в порядке');
});

closeTo

Тип: (actual: number, expected: number, delta: number, message?: string) => void
Псевдоним: approximately

Утверждает, что actual равно expected с точностью до диапазона +/- delta.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'числа находятся в пределах допустимого отклонения');
});

sameMembers

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

Утверждает, что set1 и set2 имеют одинаковые элементы в любом порядке. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'элементы совпадают');
});

notSameMembers

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

Утверждает, что set1 и set2 не имеют одинаковых элементов в любом порядке. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'элементы не совпадают');
});

sameDeepMembers

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

Утверждает, что set1 и set2 имеют одинаковые элементы в любом порядке. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'глубоко совпадающие элементы'
  );
});

notSameDeepMembers

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

Утверждает, что set1 и set2 не имеют одинаковых элементов в любом порядке. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'глубоко не совпадающие элементы'
  );
});

sameOrderedMembers

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

Утверждает, что set1 и set2 имеют одинаковые элементы в том же порядке. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'упорядоченные элементы совпадают');
});

notSameOrderedMembers

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

Утверждает, что set1 и set2 не имеют одинаковых элементов в том же порядке. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'упорядоченные элементы не совпадают'
  );
});

sameDeepOrderedMembers

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

Утверждает, что set1 и set2 имеют одинаковые элементы в том же порядке. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'глубоко упорядоченные элементы совпадают'
  );
});

notSameDeepOrderedMembers

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

Утверждает, что set1 и set2 не имеют одинаковых элементов в том же порядке. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'глубоко упорядоченные элементы не совпадают'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'глубоко упорядоченные элементы не совпадают'
  );
});

includeMembers

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

Утверждает, что subset включен в superset в любом порядке. Используется строгая проверка равенства (===). Дубликаты игнорируются.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'включает элементы');
});

notIncludeMembers

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

Утверждает, что subset не включен в superset в любом порядке. Используется строгая проверка равенства (===). Дубликаты игнорируются.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'не включает элементы');
});

includeDeepMembers

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

Утверждает, что subset включен в superset в любом порядке. Используется глубокая проверка равенства. Дубликаты игнорируются.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'включает глубокие элементы'
  );
});

notIncludeDeepMembers

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

Утверждает, что subset не включен в superset в любом порядке. Используется глубокая проверка равенства. Дубликаты игнорируются.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'не включает глубокие элементы'
  );
});

includeOrderedMembers

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

Утверждает, что subset включен в superset в том же порядке, начиная с первого элемента в superset. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'включает упорядоченные элементы');
});

notIncludeOrderedMembers

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

Утверждает, что subset не включен в superset в том же порядке, начиная с первого элемента в superset. Используется строгая проверка равенства (===).

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'не включает упорядоченные элементы'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'не включает упорядоченные элементы'
  );
});

includeDeepOrderedMembers

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

Утверждает, что subset включен в superset в том же порядке, начиная с первого элемента в superset. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'включает глубокие упорядоченные элементы'
  );
});

notIncludeDeepOrderedMembers

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

Утверждает, что subset не включен в superset в том же порядке, начиная с первого элемента в superset. Используется глубокая проверка равенства.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'не включает глубокие упорядоченные элементы'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'не включает глубокие упорядоченные элементы'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'не включает глубокие упорядоченные элементы'
  );
});

oneOf

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

Утверждает, что не-объектное, не-массивное значение inList появляется в плоском массиве list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Значение отсутствует в списке');
});

changes

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

Утверждает, что modifier изменяет свойство property объекта object.

import { assert, test } from 'vitest';

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

changesBy

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

Утверждает, что modifier изменяет свойство property объекта object на 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

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

Утверждает, что modifier не изменяет свойство property объекта object.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Утверждает, что modifier изменяет свойство property объекта object, но не на 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

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

Утверждает, что modifier увеличивает числовое свойство property объекта object.

import { assert, test } from 'vitest';

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

increasesBy

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

Утверждает, что modifier увеличивает числовое свойство property объекта object или возвращаемое значение modifier на 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

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

Утверждает, что modifier не увеличивает числовое свойство property объекта object.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Утверждает, что modifier увеличивает числовое свойство property объекта object или возвращаемое значение modifier, но не на 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

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

Утверждает, что modifier уменьшает числовое свойство property объекта object.

import { assert, test } from 'vitest';

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

decreasesBy

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

Утверждает, что modifier уменьшает числовое свойство property объекта object или возвращаемое значение modifier на 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

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

Утверждает, что modifier не уменьшает числовое свойство property объекта object.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Утверждает, что modifier не уменьшает числовое свойство property объекта object или возвращаемое значение modifier на 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

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

Утверждает, что modifier уменьшает числовое свойство property объекта object или возвращаемое значение modifier, но не на 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

Тип: <T>(object: T, message?: string) => void

Утверждает, что object не является ложным значением. Если object является истинным значением, выбрасывает ошибку. Это добавлено для того, чтобы chai мог быть заменой класса assert Node.js.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('Это пользовательская ошибка');
  assert.ifError(err); // Перебрасывает err!
});

isExtensible

Тип: <T>(object: T, message?: string) => void
Псевдоним: extensible

Утверждает, что object является расширяемым (к нему можно добавлять новые свойства).

import { assert, test } from 'vitest';

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

isNotExtensible

Тип: <T>(object: T, message?: string) => void
Псевдоним: notExtensible

Утверждает, что object не является расширяемым (к нему нельзя добавлять новые свойства).

import { assert, test } from 'vitest';

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

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

isSealed

Тип: <T>(object: T, message?: string) => void
Псевдоним: sealed

Утверждает, что object является запечатанным (к нему нельзя добавлять новые свойства, а существующие свойства нельзя удалять).

import { assert, test } from 'vitest';

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

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

isNotSealed

Тип: <T>(object: T, message?: string) => void
Псевдоним: notSealed

Утверждает, что object не является запечатанным (к нему можно добавлять новые свойства, а существующие свойства можно удалять).

import { assert, test } from 'vitest';

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

isFrozen

Тип: <T>(object: T, message?: string) => void
Псевдоним: frozen

Утверждает, что object является замороженным (к нему нельзя добавлять новые свойства, а существующие свойства нельзя изменять).

import { assert, test } from 'vitest';

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

isNotFrozen

Тип: <T>(object: T, message?: string) => void
Псевдоним: notFrozen

Утверждает, что object не является замороженным (к нему можно добавлять новые свойства, а существующие свойства можно изменять).

import { assert, test } from 'vitest';

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

isEmpty

Тип: <T>(target: T, message?: string) => void
Псевдоним: empty

Утверждает, что target не содержит никаких значений. Для массивов и строк проверяется свойство length. Для экземпляров Map и Set проверяется свойство size. Для объектов, не являющихся функциями, подсчитывается количество их собственных перечисляемых строковых ключей.

import { assert, test } from 'vitest';

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

isNotEmpty

Тип: <T>(object: T, message?: string) => void
Псевдоним: notEmpty

Утверждает, что target содержит значения. Для массивов и строк проверяется свойство length. Для экземпляров Map и Set проверяется свойство size. Для объектов, не являющихся функциями, подсчитывается количество их собственных перечисляемых строковых ключей.

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