assert

Vitest reeksportuje metodę assert z chai do weryfikacji niezmienników.

assert

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

Sprawdza, czy podane expression jest wartością prawdziwą (truthy). W przeciwnym razie asercja zakończy się niepowodzeniem.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo nie powinno być równe bar');
});

fail

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

Wymusza niepowodzenie asercji.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('komunikat błędu przy niepowodzeniu');
  assert.fail('foo', 'bar', 'foo nie jest bar', '===');
});

isOk

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

Sprawdza, czy dana value jest wartością prawdziwą (truthy).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'każda wartość truthy jest poprawna');
  assert.isOk(false, 'to się nie powiedzie, ponieważ false jest wartością fałszywą (falsy)');
});

isNotOk

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

Sprawdza, czy dana value jest wartością fałszywą (falsy).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'to się nie powiedzie, ponieważ foo jest wartością prawdziwą (truthy)');
  assert.isNotOk(false, 'to się powiedzie, ponieważ false jest wartością fałszywą (falsy)');
});

equal

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

Sprawdza luźną równość (==) actual i 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

Sprawdza luźną nierówność (!=) actual i 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

Sprawdza dokładne porównanie (===) actual i 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

Sprawdza, czy actual jest głęboko równe 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

Sprawdza, czy actual nie jest głęboko równe expected.

import { assert, test } from 'vitest';

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

isAbove

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

Sprawdza, czy valueToCheck jest ściśle większe od (>) valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 jest ściśle większe od 2');
});

isAtLeast

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

Sprawdza, czy valueToCheck jest większe bądź równe (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 jest większe bądź równe 2');
  assert.isAtLeast(3, 3, '3 jest większe bądź równe 3');
});

isBelow

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

Sprawdza, czy valueToCheck jest ściśle mniejsze od (<) valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 jest ściśle mniejsze od 6');
});

isAtMost

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

Sprawdza, czy valueToCheck jest mniejsze bądź równe (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 jest mniejsze bądź równe 6');
  assert.isAtMost(4, 4, '4 jest mniejsze bądź równe 4');
});

isTrue

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

Sprawdza, czy value jest wartością true.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Sprawdza, czy value nie jest wartością true.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Sprawdza, czy value jest wartością false.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Sprawdza, czy value nie jest wartością false.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Sprawdza, czy value jest null.

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

Sprawdza, czy value nie jest null.

import { assert, test } from 'vitest';

const error = { message: 'wystąpił błąd' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error nie jest null, lecz obiektem');
});

isNaN

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

Sprawdza, czy value jest NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Sprawdza, czy value nie jest NaN.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 nie jest NaN, lecz wynosi 2');
});

exists

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

Sprawdza, czy value nie jest ani null, ani undefined.

import { assert, test } from 'vitest';

const name = 'foo';

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

notExists

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

Sprawdza, czy value jest null lub undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo jest null, więc nie ma wartości');
  assert.notExists(bar, 'bar jest undefined, więc nie ma wartości');
});

isUndefined

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

Sprawdza, czy value jest undefined.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Sprawdza, czy value nie jest undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name nie jest undefined');
});

isFunction

Typ: <T>(value: T, message?: string) => void
Alias: isCallable Sprawdza, czy value jest funkcją.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name jest funkcją');
});

isNotFunction

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

Sprawdza, czy value nie jest funkcją.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name nie jest funkcją, lecz stringiem');
});

isObject

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

Sprawdza, czy value jest obiektem typu Object (jak ujawnia Object.prototype.toString). Asercja nie pasuje do obiektów podklas.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing jest obiektem');
});

isNotObject

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

Sprawdza, czy value nie jest obiektem typu Object (jak ujawnia Object.prototype.toString). Asercja nie pasuje do obiektów podklas.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing nie jest obiektem, lecz stringiem');
});

isArray

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

Sprawdza, czy value jest tablicą.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color jest tablicą');
});

isNotArray

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

Sprawdza, czy value nie jest tablicą.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color nie jest tablicą, lecz stringiem');
});

isString

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

Sprawdza, czy value jest ciągiem znaków.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color jest ciągiem znaków');
});

isNotString

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

Sprawdza, czy value nie jest ciągiem znaków.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color nie jest ciągiem znaków, lecz tablicą');
});

isNumber

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

Sprawdza, czy value jest liczbą.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors jest liczbą');
});

isNotNumber

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

Sprawdza, czy value nie jest liczbą.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors nie jest liczbą, lecz ciągiem znaków');
});

isFinite

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

Sprawdza, czy value jest liczbą skończoną (nie NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors jest liczbą skończoną (nie NaN ani Infinity)');
});

isBoolean

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

Sprawdza, czy value jest wartością logiczną.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady jest wartością logiczną');
});

isNotBoolean

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

Sprawdza, czy value nie jest wartością logiczną.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady nie jest wartością logiczną, lecz ciągiem znaków');
});

typeOf

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

Sprawdza, czy typ value to name, określony przez Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'jest to obiekt');
  assert.typeOf(['red', 'green'], 'array', 'jest to tablica');
  assert.typeOf('red', 'string', 'jest to ciąg znaków');
  assert.typeOf(/red/, 'regexp', 'jest to wyrażenie regularne');
  assert.typeOf(null, 'null', 'jest to null');
  assert.typeOf(undefined, 'undefined', 'jest to undefined');
});

notTypeOf

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

Sprawdza, czy typ value nie jest name, określony przez Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" nie jest liczbą');
});

instanceOf

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

Sprawdza, czy value jest instancją 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 jest instancją Person');
  assert.instanceOf(coffee, Tea, 'coffee jest instancją Tea');
});

notInstanceOf

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

Sprawdza, czy value nie jest instancją 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 nie jest instancją 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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia, czy tablica zawiera wartość, czy ciąg znaków zawiera podciąg, lub czy obiekt zawiera podzbiór właściwości.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'tablica zawiera wartość');
  assert.include('foobar', 'foo', 'ciąg znaków zawiera podciąg');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'obiekt zawiera właściwość'
  );
});

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia, czy tablica nie zawiera wartości, czy ciąg znaków nie zawiera podciągu, lub czy obiekt nie zawiera podzbioru właściwości.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, "tablica nie zawiera 4");
  assert.notInclude('foobar', 'baz', "foobar nie zawiera baz");
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    "obiekt nie zawiera właściwości"
  );
});

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia włączenia wartości w tablicy lub podzbioru właściwości w obiekcie. Wykorzystywana jest głęboka równość.

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia braku wartości w tablicy lub podzbioru właściwości w obiekcie. Wykorzystywana jest głęboka równość.

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia włączenia podzbioru właściwości w obiekcie. Umożliwia użycie notacji kropkowej i nawiasowej do odwoływania się do zagnieżdżonych właściwości. Znaki „[]” i „.” w nazwach właściwości mogą być escapowane za pomocą podwójnych ukośników wstecznych.

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia włączenia podzbioru właściwości w obiekcie. Umożliwia użycie notacji kropkowej i nawiasowej do odwoływania się do zagnieżdżonych właściwości. Znaki „[]” i „.” w nazwach właściwości mogą być escapowane za pomocą podwójnych ukośników wstecznych.

import { assert, test } from 'vitest';

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

deepNestedInclude

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia włączenia podzbioru właściwości w obiekcie, sprawdzając jednocześnie głęboką równość. Umożliwia użycie notacji kropkowej i nawiasowej do odwoływania się do zagnieżdżonych właściwości. Znaki „[]” i „.” w nazwach właściwości mogą być escapowane za pomocą podwójnych ukośników wstecznych.

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia braku podzbioru właściwości w obiekcie, sprawdzając jednocześnie głęboką równość. Umożliwia użycie notacji kropkowej i nawiasowej do odwoływania się do zagnieżdżonych właściwości. Znaki „[]” i „.” w nazwach właściwości mogą być escapowane za pomocą podwójnych ukośników wstecznych.

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia włączenia podzbioru właściwości w obiekcie, ignorując dziedziczone właściwości.

import { assert, test } from 'vitest';

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

notOwnInclude

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia braku podzbioru właściwości w obiekcie, ignorując dziedziczone właściwości.

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia włączenia podzbioru właściwości w obiekcie, ignorując dziedziczone właściwości i sprawdzając głęboką równość.

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

Sprawdza, czy haystack nie zawiera needle. Może być użyte do sprawdzenia braku podzbioru właściwości w obiekcie, ignorując dziedziczone właściwości i sprawdzając głęboką równość.

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

Sprawdza, czy value pasuje do wyrażenia regularnego regexp.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'wyrażenie regularne pasuje');
});

notMatch

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

Sprawdza, czy value nie pasuje do wyrażenia regularnego regexp.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'wyrażenie regularne nie pasuje do');
});

property

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

Sprawdza, czy object ma bezpośrednią lub dziedziczoną właściwość o nazwie 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

Sprawdza, czy object nie ma bezpośredniej ani dziedziczonej właściwości o nazwie 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

Sprawdza, czy object ma bezpośrednią lub dziedziczoną właściwość o nazwie property z wartością value. Wykorzystuje dokładne porównanie (===).

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

Sprawdza, czy object nie ma bezpośredniej ani dziedziczonej właściwości o nazwie property z wartością value. Wykorzystuje dokładne porównanie (===).

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

Sprawdza, czy object ma bezpośrednią lub dziedziczoną właściwość o nazwie property z wartością value. Używa głębokiego sprawdzania równości.

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

Sprawdza, czy object nie ma bezpośredniej ani dziedziczonej właściwości o nazwie property z wartością value. Używa głębokiego sprawdzania równości.

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

Sprawdza, czy object ma bezpośrednią lub dziedziczoną właściwość o nazwie property, która może być ciągiem znaków używającym notacji kropkowej i nawiasowej do zagnieżdżonego odwołania.

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

Sprawdza, czy object nie ma bezpośredniej ani dziedziczonej właściwości o nazwie property, która może być ciągiem znaków używającym notacji kropkowej i nawiasowej do zagnieżdżonego odwołania.

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

Sprawdza, czy object ma właściwość o nazwie property z wartością value. property może używać notacji kropkowej i nawiasowej do zagnieżdżonego odwołania. Wykorzystuje dokładne porównanie (===).

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

Sprawdza, czy object nie ma właściwości o nazwie property z wartością value. property może używać notacji kropkowej i nawiasowej do zagnieżdżonego odwołania. Wykorzystuje dokładne porównanie (===).

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

Sprawdza, czy object ma właściwość o nazwie property z wartością value. property może używać notacji kropkowej i nawiasowej do zagnieżdżonego odwołania. Używa głębokiego sprawdzania równości.

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

Sprawdza, czy object nie ma właściwości o nazwie property z wartością value. property może używać notacji kropkowej i nawiasowej do zagnieżdżonego odwołania. Używa głębokiego sprawdzania równości.

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

Sprawdza, czy object ma length lub size o oczekiwanej wartości.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'tablica ma długość równą 3');
  assert.lengthOf('foobar', 6, 'ciąg znaków ma długość równą 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'zbiór ma rozmiar równy 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'mapa ma rozmiar równy 3'
  );
});

hasAnyKeys

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

Sprawdza, czy object ma co najmniej jeden z podanych keys. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object ma dokładnie wszystkie podane keys. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object ma wszystkie podane keys, ale może mieć więcej kluczy, które nie są wymienione. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object nie ma żadnego z podanych keys. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object nie ma co najmniej jednego z podanych keys. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object ma co najmniej jeden z podanych keys. Ponieważ zbiory i mapy mogą mieć obiekty jako klucze, możesz użyć tej asercji do wykonania głębokiego porównania. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object ma dokładnie wszystkie podane keys. Ponieważ zbiory i mapy mogą mieć obiekty jako klucze, możesz użyć tej asercji do wykonania głębokiego porównania. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object zawiera wszystkie podane keys. Ponieważ zbiory i mapy mogą mieć obiekty jako klucze, możesz użyć tej asercji do wykonania głębokiego porównania. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object nie ma żadnego z podanych keys. Ponieważ zbiory i mapy mogą mieć obiekty jako klucze, możesz użyć tej asercji do wykonania głębokiego porównania. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Sprawdza, czy object nie ma co najmniej jednego z podanych keys. Ponieważ zbiory i mapy mogą mieć obiekty jako klucze, możesz użyć tej asercji do wykonania głębokiego porównania. Możesz również podać pojedynczy obiekt zamiast tablicy kluczy, a jego klucze zostaną użyte jako oczekiwany zbiór kluczy.

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

Jeśli errorLike jest konstruktorem błędu, sprawdza, czy fn zgłosi błąd będący instancją errorLike. Jeśli errorLike jest instancją błędu, sprawdza, czy zgłoszony błąd jest tą samą instancją co errorLike. Jeśli podano errMsgMatcher, sprawdza również, czy zgłoszony błąd będzie miał komunikat pasujący do errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Zgłoszony błąd musi zawierać ten komunikat');
  assert.throws(fn, /Zgłoszony błąd musi pasować do tego wyrażenia regularnego/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Zgłoszony błąd musi być ReferenceError i zawierać ten komunikat'
  );
  assert.throws(
    fn,
    errorInstance,
    'Zgłoszony błąd musi być tą samą instancją errorInstance i zawierać ten komunikat'
  );
  assert.throws(
    fn,
    ReferenceError,
    /Zgłoszony błąd musi być ReferenceError i pasować do tego wyrażenia regularnego/
  );
  assert.throws(
    fn,
    errorInstance,
    /Zgłoszony błąd musi być tą samą instancją errorInstance i pasować do tego wyrażenia regularnego/
  );
});

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

Jeśli errorLike jest konstruktorem błędu, sprawdza, czy fn nie zgłosi błędu, który jest instancją errorLike. Jeśli errorLike jest instancją błędu, sprawdza, czy zgłoszony błąd nie jest tą samą instancją co errorLike. Jeśli podano errMsgMatcher, sprawdza również, czy zgłoszony błąd nie będzie miał komunikatu pasującego do errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Żaden zgłoszony błąd nie może zawierać tego komunikatu');
  assert.doesNotThrow(fn, /Żaden zgłoszony błąd nie może pasować do tego wyrażenia regularnego/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Błąd nie może zawierać tego komunikatu');
  assert.doesNotThrow(fn, errorInstance, 'Błąd nie może zawierać tego komunikatu');
  assert.doesNotThrow(fn, Error, /Błąd nie może pasować do tego wyrażenia regularnego/);
  assert.doesNotThrow(fn, errorInstance, /Błąd nie może pasować do tego wyrażenia regularnego/);
});

operator

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

Porównuje val1 i val2 za pomocą operator.

import { assert, test } from 'vitest';

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

closeTo

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

Sprawdza, czy actual jest równe expected w zakresie +/- delta.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'liczby są blisko');
});

sameMembers

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

Sprawdza, czy set1 i set2 mają takie same elementy w dowolnej kolejności. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Sprawdza, czy set1 i set2 nie mają tych samych elementów w dowolnej kolejności. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'różne elementy');
});

sameDeepMembers

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

Sprawdza, czy set1 i set2 mają te same elementy w dowolnej kolejności. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'te same głębokie elementy'
  );
});

notSameDeepMembers

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

Sprawdza, czy set1 i set2 nie mają tych samych elementów w dowolnej kolejności. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nie te same głębokie elementy'
  );
});

sameOrderedMembers

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

Sprawdza, czy set1 i set2 mają te same elementy w tej samej kolejności. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'te same uporządkowane elementy');
});

notSameOrderedMembers

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

Sprawdza, czy set1 i set2 nie mają tych samych elementów w tej samej kolejności. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'nie te same uporządkowane elementy'
  );
});

sameDeepOrderedMembers

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

Sprawdza, czy set1 i set2 mają te same elementy w tej samej kolejności. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'te same głęboko uporządkowane elementy'
  );
});

notSameDeepOrderedMembers

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

Sprawdza, czy set1 i set2 nie mają tych samych elementów w tej samej kolejności. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'nie te same głęboko uporządkowane elementy'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nie te same głęboko uporządkowane elementy'
  );
});

includeMembers

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

Sprawdza, czy subset jest zawarty w superset w dowolnej kolejności. Wykorzystuje dokładne porównanie (===). Duplikaty są ignorowane.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Sprawdza, czy subset nie jest zawarty w superset w dowolnej kolejności. Wykorzystuje dokładne porównanie (===). Duplikaty są ignorowane.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'nie zawiera tych elementów');
});

includeDeepMembers

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

Sprawdza, czy subset jest zawarty w superset w dowolnej kolejności. Używa głębokiego sprawdzania równości. Duplikaty są ignorowane.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'zawiera głębokie elementy'
  );
});

notIncludeDeepMembers

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

Sprawdza, czy subset nie jest zawarty w superset w dowolnej kolejności. Używa głębokiego sprawdzania równości. Duplikaty są ignorowane.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'nie zawiera tych głębokich elementów'
  );
});

includeOrderedMembers

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

Sprawdza, czy subset jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu w superset. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'zawiera uporządkowane elementy');
});

notIncludeOrderedMembers

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

Sprawdza, czy subset nie jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu w superset. Wykorzystuje dokładne porównanie (===).

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'nie zawiera tych uporządkowanych elementów'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'nie zawiera tych uporządkowanych elementów'
  );
});

includeDeepOrderedMembers

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

Sprawdza, czy subset jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu w superset. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'zawiera głęboko uporządkowane elementy'
  );
});

notIncludeDeepOrderedMembers

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

Sprawdza, czy subset nie jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu w superset. Używa głębokiego sprawdzania równości.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'nie zawiera tych głęboko uporządkowanych elementów'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'nie zawiera tych głęboko uporządkowanych elementów'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'nie zawiera tych głęboko uporządkowanych elementów'
  );
});

oneOf

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

Sprawdza, czy wartość inList (która nie jest obiektem ani tablicą) pojawia się w płaskiej tablicy list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Wartości nie znaleziono na liście');
});

changes

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

Sprawdza, czy modifier zmienia wartość właściwości property obiektu object.

import { assert, test } from 'vitest';

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

changesBy

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

Sprawdza, czy modifier zmienia wartość właściwości property obiektu object 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

Sprawdza, czy modifier nie zmienia wartości właściwości property obiektu 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

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

Sprawdza, czy modifier zmienia wartość właściwości property obiektu object, ale nie o podaną wartość 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

Sprawdza, czy modifier zwiększa wartość numerycznej właściwości property obiektu object.

import { assert, test } from 'vitest';

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

increasesBy

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

Sprawdza, czy modifier zwiększa wartość numerycznej właściwości property obiektu object lub wartość zwracaną przez 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

Sprawdza, czy modifier nie zwiększa wartości numerycznej właściwości property obiektu object.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Sprawdza, czy modifier zwiększa wartość numerycznej właściwości property obiektu object, ale nie o podaną wartość 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

Sprawdza, czy modifier zmniejsza wartość numerycznej właściwości property obiektu object.

import { assert, test } from 'vitest';

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

decreasesBy

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

Sprawdza, czy modifier zmniejsza wartość numerycznej właściwości property obiektu object lub wartość zwracaną przez 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

Sprawdza, czy modifier nie zmniejsza wartości numerycznej właściwości property obiektu object.

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

Sprawdza, czy modifier nie zmniejsza wartości numerycznej właściwości property obiektu object lub wartości zwracanej przez 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

Sprawdza, czy modifier zmniejsza wartość numerycznej właściwości property obiektu object, ale nie o podaną wartość 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

Sprawdza, czy object nie jest wartością fałszywą, i rzuca wyjątek, jeśli jest wartością prawdziwą. Jest to dodane, aby chai mogło służyć jako zamiennik dla klasy assert Node.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('Jestem własnym błędem');
  assert.ifError(err); // Ponownie rzuca wyjątek!
});

isExtensible

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

Sprawdza, czy object jest rozszerzalny (tj. można do niego dodawać nowe właściwości).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Sprawdza, czy object nie jest rozszerzalny (tj. nie można do niego dodawać nowych właściwości).

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

Sprawdza, czy object jest zablokowany (tj. nie można do niego dodawać nowych właściwości, a istniejące nie mogą być usuwane).

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

Sprawdza, czy object nie jest zablokowany (tj. można do niego dodawać nowe właściwości, a istniejące mogą być usuwane).

import { assert, test } from 'vitest';

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

isFrozen

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

Sprawdza, czy obiekt jest zablokowany do modyfikacji (tj. nie można do niego dodawać nowych właściwości, a istniejące nie mogą być modyfikowane).

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

Sprawdza, czy object nie jest zablokowany do modyfikacji (tj. można do niego dodawać nowe właściwości, a istniejące mogą być modyfikowane).

import { assert, test } from 'vitest';

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

isEmpty

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

Sprawdza, czy target jest pusty. Dla tablic i ciągów znaków sprawdza właściwość length. Dla instancji Map i Set sprawdza właściwość size. Dla obiektów niebędących funkcjami, pobiera liczbę ich własnych wyliczalnych kluczy typu string.

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

Sprawdza, czy target nie jest pusty. Dla tablic i ciągów znaków sprawdza właściwość length. Dla instancji Map i Set sprawdza właściwość size. Dla obiektów niebędących funkcjami, pobiera liczbę ich własnych wyliczalnych kluczy typu string.

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