assert

Vitest ponownie eksportuje metodę assert z biblioteki chai do weryfikacji niezmienników.

assert

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

Sprawdza, czy dana expression jest wartością prawdziwą (truthy). Jeśli nie, 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 w przypadku niepowodzenia');
  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 ok');
  assert.isOk(
    false,
    'to zakończy się niepowodzeniem, ponieważ false nie jest truthy'
  );
});

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, każda wartość truthy nie jest ok'
  );
  assert.isNotOk(false, 'to się powiedzie, ponieważ false jest falsy');
});

equal

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

Sprawdza równość nietypową (==) 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 nierówność nietypową (!=) actual i expected.

import { assert, test } from 'vitest';

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

strictEqual

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

Sprawdza równość ścisłą (===) 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. Porównuje rekurencyjnie wszystkie właściwości.

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 większe niż (>) valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 jest większe niż 2');
});

isAtLeast

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

Sprawdza, czy valueToCheck jest większe lub równe (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

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

isBelow

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

Sprawdza, czy valueToCheck jest mniejsze niż (<) valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 jest mniejsze niż 6');
});

isAtMost

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

Sprawdza, czy valueToCheck jest mniejsze lub równe (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

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

isTrue

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

Sprawdza, czy value jest prawdą (ściśle równe 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 prawdą (ściśle różne od 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 fałszem (ściśle równe 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 fałszem (ściśle różne od 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 równe null.

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, 'error ma wartość null');
});

isNotNull

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

Sprawdza, czy value nie jest równe null.

import { assert, test } from 'vitest';

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

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

isNaN

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

Sprawdza, czy value to NaN (Not a Number - nie jest liczbą).

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Sprawdza, czy value to nie NaN (nie jest liczbą).

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 nie jest NaN, ale 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 nullem, ani niezdefiniowane');
});

notExists

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

Sprawdza, czy value jest albo null, albo undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo jest nullem, więc nie istnieje');
  assert.notExists(bar, 'bar jest niezdefiniowane, więc nie istnieje');
});

isUndefined

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

Sprawdza, czy value jest równe undefined.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Sprawdza, czy value nie jest równe undefined.

import { assert, test } from 'vitest';

const name = 'foo';

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

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 to funkcja');
});

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ą, ale stringiem');
});

isObject

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

Sprawdza, czy value jest obiektem (typu object). Asercja nie przechodzi dla wartości null.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing to obiekt');
});

isNotObject

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

Sprawdza, czy value nie jest obiektem (w rozumieniu Object.prototype.toString). Asercja nie przechodzi dla obiektów będących instancjami podklas.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(
    someThing,
    'someThing nie jest obiektem, lecz ciągiem znaków'
  );
});

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 ciągiem znaków');
});

isString

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

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

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color jest stringiem');
});

isNotString

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

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

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ą (inną niż NaN lub 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ą (boolean).

import { assert, test } from 'vitest';

const isReady = true;

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

isNotBoolean

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

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

import { assert, test } from 'vitest';

const isReady = 'sure';

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

typeOf

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

Sprawdza, czy typ value zgadza się z name, zgodnie z tym, co zwraca Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'mamy obiekt');
  assert.typeOf(['red', 'green'], 'array', 'mamy tablicę');
  assert.typeOf('red', 'string', 'mamy string');
  assert.typeOf(/red/, 'regexp', 'mamy wyrażenie regularne');
  assert.typeOf(null, 'null', 'mamy null');
  assert.typeOf(undefined, 'undefined', 'mamy undefined');
});

notTypeOf

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

Sprawdza, czy typ value jest różny od name, zgodnie z tym, co zwraca 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 element, ciąg znaków zawiera podciąg, lub 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 elementu, ciąg znaków nie zawiera podciągu, lub 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, czy tablica zawiera element lub obiekt zawiera podzbiór właściwości. Używane jest głębokie porównanie równości.

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, czy tablica nie zawiera elementu lub obiekt nie zawiera podzbioru właściwości. Używane jest głębokie porównanie równości.

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, czy obiekt zawiera podzbiór właściwości. 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 można uniknąć 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, czy obiekt nie zawiera podzbioru właściwości. 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 można uniknąć za pomocą podwójnych ukośników wstecznych (\).

import { assert, test } from 'vitest';

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

deepNestedInclude

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

Sprawdza, czy haystack zawiera needle. Może być użyte do sprawdzenia, czy obiekt zawiera podzbiór właściwości, sprawdzając 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 można uniknąć 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, czy obiekt nie zawiera podzbioru właściwości, sprawdzając 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 można uniknąć 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, czy obiekt zawiera podzbiór własnych właściwości (ignorując dziedziczone).

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, czy obiekt nie zawiera podzbioru własnych właściwości (ignorując dziedziczone).

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 },
    'obj2 nie zawiera *własnej* właściwości b: 2'
  );
});

deepOwnInclude

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

Sprawdza, czy haystack głęboko zawiera needle. Może być użyte do sprawdzenia, czy obiekt zawiera podzbiór właściwości innego obiektu, ignorując właściwości dziedziczone 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 głęboko nie zawiera needle. Może być użyte do sprawdzenia, czy obiekt nie zawiera podzbioru właściwości innego obiektu, ignorując właściwości dziedziczone 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 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 nie pasuje');
});

property

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

Sprawdza, czy object posiada właściwość o nazwie property, bezpośrednio lub dziedziczoną.

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 posiada właściwości o nazwie property, bezpośrednio ani dziedziczonej.

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 posiada właściwość o nazwie property o wartości value, bezpośrednio lub dziedziczoną. Używa ścisłego porównania równości (===).

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 posiada właściwości o nazwie property o wartości value, bezpośrednio ani dziedziczonej. Używa ścisłego porównania równości (===).

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 posiada właściwość o nazwie property o wartości value, bezpośrednio lub dziedziczoną. Używa głębokiego porównania 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 posiada właściwości o nazwie property o wartości value, bezpośrednio ani dziedziczonej. Używa głębokiego porównania 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 posiada zagnieżdżoną właściwość o nazwie property, używając notacji kropkowej lub nawiasowej do odwoływania się do zagnieżdżonych właściwości.

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 posiada zagnieżdżonej właściwości o nazwie property, używając notacji kropkowej lub nawiasowej do odwoływania się do zagnieżdżonych właściwości.

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 posiada zagnieżdżoną właściwość o nazwie property o wartości value. property może używać notacji kropkowej lub nawiasowej do odwoływania się do zagnieżdżonych właściwości. Używa ścisłego porównania równości (===).

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 posiada zagnieżdżonej właściwości o nazwie property o wartości value. property może używać notacji kropkowej lub nawiasowej do odwoływania się do zagnieżdżonych właściwości. Używa ścisłego porównania równości (===).

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

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

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

import { assert, test } from 'vitest';

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

lengthOf

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

Sprawdza, czy object posiada właściwość length (długość) lub size (rozmiar) o wartości równej length.

import { assert, test } from 'vitest';

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

hasAnyKeys

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

Sprawdza, czy object posiada co najmniej jeden z kluczy zawartych w keys. Zamiast tablicy kluczy można podać obiekt, którego klucze zostaną użyte jako oczekiwany zestaw 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 posiada wszystkie klucze zawarte w keys i tylko te klucze. Zamiast tablicy kluczy można podać obiekt, którego klucze zostaną użyte jako oczekiwany zestaw 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 posiada wszystkie klucze zawarte w keys, ale może posiadać również inne, niewymienione klucze. Zamiast tablicy kluczy można podać obiekt, którego klucze zostaną użyte jako oczekiwany zestaw 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 zawiera żadnego z podanych kluczy keys. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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 zawiera wszystkich z podanych kluczy keys. Innymi słowy, sprawdza, czy brakuje przynajmniej jednego z podanych kluczy. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych kluczy.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

Sprawdza, czy object zawiera przynajmniej jeden z podanych kluczy keys, porównując je głęboko. Jest to szczególnie przydatne dla Set i Map, które mogą mieć obiekty jako klucze. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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 zawiera wszystkie z podanych kluczy keys, porównując je głęboko. Jest to szczególnie przydatne dla Set i Map, które mogą mieć obiekty jako klucze. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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 z podanych kluczy keys, porównując je głęboko. object może zawierać również inne klucze. Jest to szczególnie przydatne dla Set i Map, które mogą mieć obiekty jako klucze. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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 zawiera żadnego z podanych kluczy keys, porównując je głęboko. Jest to szczególnie przydatne dla Set i Map, które mogą mieć obiekty jako klucze. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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 zawiera wszystkich z podanych kluczy keys, porównując je głęboko. Innymi słowy, sprawdza, czy brakuje przynajmniej jednego z podanych kluczy. Jest to szczególnie przydatne dla Set i Map, które mogą mieć obiekty jako klucze. Zamiast tablicy kluczy można podać obiekt, a jego klucze zostaną użyte jako zestaw oczekiwanych 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

Sprawdza, czy funkcja fn zgłasza błąd.

Jeśli errorLike jest konstruktorem błędu (np. ReferenceError), sprawdza, czy zgłoszony błąd jest instancją tego konstruktora.
Jeśli errorLike jest instancją błędu, sprawdza, czy zgłoszony błąd jest tą samą instancją.
Jeśli podano errMsgMatcher, sprawdza, czy komunikat zgłoszonego błędu pasuje do errMsgMatcher (może to być ciąg znaków lub wyrażenie regularne).

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Error thrown must have this msg');
  assert.throws(fn, /Error thrown must have a msg that matches this/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Error thrown must be a ReferenceError and have this msg'
  );
  assert.throws(
    fn,
    errorInstance,
    'Error thrown must be the same errorInstance and have this msg'
  );
  assert.throws(
    fn,
    ReferenceError,
    /Error thrown must be a ReferenceError and match this/
  );
  assert.throws(
    fn,
    errorInstance,
    /Error thrown must be the same errorInstance and match this/
  );
});

doesNotThrow

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

Sprawdza, czy funkcja fn nie zgłasza błędu.

Jeśli errorLike jest konstruktorem błędu (np. ReferenceError), sprawdza, czy nie jest zgłaszany błąd będący instancją tego konstruktora.
Jeśli errorLike jest instancją błędu, sprawdza, czy zgłoszony błąd nie jest tą samą instancją.
Jeśli podano errMsgMatcher, sprawdza, czy komunikat zgłoszonego błędu nie pasuje do errMsgMatcher (może to być ciąg znaków lub wyrażenie regularne).

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Any Error thrown must not have this message');
  assert.doesNotThrow(fn, /Any Error thrown must not match this/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Error must not have this message');
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');
  assert.doesNotThrow(fn, Error, /Error must not match this/);
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/);
});

operator

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

Porównuje val1 i val2 za pomocą podanego operatora operator.

import { assert, test } from 'vitest';

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

closeTo

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

Sprawdza, czy wartość actual jest bliska wartości expected w zakresie +/- delta.

import { assert, test } from 'vitest';

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

sameMembers

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

Sprawdza, czy set1 i set2 zawierają te same elementy, niezależnie od kolejności. Używa porównania ścisłego (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Sprawdza, czy set1 i set2 nie zawierają tych samych elementów, niezależnie od kolejności. Używa porównania ścisłego (===).

import { assert, test } from 'vitest';

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

sameDeepMembers

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

Sprawdza, czy set1 i set2 zawierają te same elementy, niezależnie od kolejności. Używa porównania głębokiego.

import { assert, test } from 'vitest';

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

notSameDeepMembers

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

Sprawdza, czy set1 i set2 nie zawierają tych samych elementów, niezależnie od kolejności. Używa porównania głębokiego.

import { assert, test } from 'vitest';

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

sameOrderedMembers

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

Sprawdza, czy set1 i set2 zawierają te same elementy w tej samej kolejności. Używa porównania ścisłego (===).

import { assert, test } from 'vitest';

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

notSameOrderedMembers

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

Sprawdza, czy set1 i set2 nie zawierają tych samych elementów w tej samej kolejności. Używa porównania ścisłego (===).

import { assert, test } from 'vitest';

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

sameDeepOrderedMembers

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

Sprawdza, czy set1 i set2 zawierają te same elementy w tej samej kolejności. Używa porównania głębokiego.

import { assert, test } from 'vitest';

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

notSameDeepOrderedMembers

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

Sprawdza, czy set1 i set2 nie zawierają identycznych elementów w tej samej kolejności, porównując je głęboko.

import { assert, test } from 'vitest';

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

includeMembers

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

Sprawdza, czy wszystkie elementy subset znajdują się w superset, niezależnie od kolejności. Używa porównania ścisłej równości (===). Duplikaty w subset są ignorowane.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Sprawdza, czy przynajmniej jeden element subset nie znajduje się w superset. Używa porównania ścisłej równości (===). Duplikaty w subset są ignorowane.

import { assert, test } from 'vitest';

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

includeDeepMembers

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

Sprawdza, czy wszystkie elementy subset znajdują się w superset, niezależnie od kolejności. Używa głębokiego porównania równości. Duplikaty w subset są ignorowane.

import { assert, test } from 'vitest';

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

notIncludeDeepMembers

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

Sprawdza, czy przynajmniej jeden element subset nie znajduje się w superset. Używa głębokiego porównania równości. Duplikaty w subset są ignorowane.

import { assert, test } from 'vitest';

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

includeOrderedMembers

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

Sprawdza, czy subset jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu superset. Używa porównania ścisłej równości (===).

import { assert, test } from 'vitest';

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

notIncludeOrderedMembers

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

Sprawdza, czy subset nie jest zawarty w superset w tej samej kolejności, zaczynając od pierwszego elementu superset. Używa porównania ścisłej równości (===).

import { assert, test } from 'vitest';

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

includeDeepOrderedMembers

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

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

import { assert, test } from 'vitest';

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

notIncludeDeepOrderedMembers

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

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

import { assert, test } from 'vitest';

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

oneOf

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

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

import { assert, test } from 'vitest';

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

changes

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

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

import { assert, test } from 'vitest';

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

doesNotIncrease

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

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

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

Sprawdza, czy wywołanie funkcji modifier nie powoduje zmniejszenia wartości numerycznej właściwości property obiektu object (lub wartości zwracanej przez modifier) o wartość 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

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

Sprawdza, czy wywołanie funkcji modifier powoduje zmniejszenie wartości numerycznej właściwości property obiektu object (lub wartości zwracanej przez modifier), ale nie dokładnie o 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

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

Sprawdza, czy object jest wartością fałszywą (falsy value). Jeśli object jest wartością prawdziwą (truthy value), zgłasza wyjątek. Metoda ta została dodana, aby umożliwić zastąpienie klasy assert z Node.js biblioteką Chai.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // Ponownie zgłasza err!
});

isExtensible

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

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

import { assert, test } from 'vitest';

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

isNotExtensible

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

Sprawdza, czy obiekt object nie jest rozszerzalny (czy 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

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

Sprawdza, czy obiekt object jest zapieczętowany (nie można do niego dodawać nowych właściwości ani usuwać istniejących).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Sprawdza, czy obiekt object nie jest zapieczętowany (można do niego dodawać nowe właściwości lub usuwać istniejące).

import { assert, test } from 'vitest';

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

isFrozen

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

Sprawdza, czy obiekt object jest zamrożony (nie można do niego dodawać nowych właściwości ani modyfikować istniejących).

import { assert, test } from 'vitest';

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

isNotFrozen

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

Sprawdza, czy obiekt object nie jest zamrożony (można do niego dodawać nowe właściwości lub modyfikować istniejące).

import { assert, test } from 'vitest';

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

isEmpty

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

Sprawdza, czy target jest puste. 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 (które nie są funkcjami) sprawdza liczbę ich własnych, wyliczalnych kluczy łańcuchowych.

import { assert, test } from 'vitest';

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

isNotEmpty

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

Sprawdza, czy target nie jest puste. 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 (które nie są funkcjami) sprawdza liczbę ich własnych, wyliczalnych kluczy łańcuchowych.

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