assert

Vitest re-exportiert die assert-Methode von chai zur Überprüfung von Invarianten.

assert

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

Bestätigt, dass der gegebene Ausdruck truthy (als wahr bewertbar) ist; andernfalls schlägt die Assertion fehl.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo sollte nicht gleich bar sein');
});

fail

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

Erzwingt das Fehlschlagen einer Assertion.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('Fehlermeldung im Fehlerfall');
  assert.fail('foo', 'bar', 'foo ist nicht bar', '===');
});

isOk

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

Bestätigt, dass der gegebene value ein Truthy-Wert ist.

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'Jeder Truthy-Wert ist in Ordnung');
  assert.isOk(false, 'Dies wird fehlschlagen, da false kein Truthy-Wert ist');
});

isNotOk

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

Bestätigt, dass der gegebene value ein Falsy-Wert ist.

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk(
    'foo',
    'Dies wird fehlschlagen, da jeder Truthy-Wert nicht ok ist'
  );
  assert.isNotOk(
    false,
    'Dies wird erfolgreich sein, da false ein Falsy-Wert ist'
  );
});

equal

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

Bestätigt die nicht-strikte Gleichheit (==) von actual und 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

Bestätigt die nicht-strikte Ungleichheit (!=) von actual und 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

Bestätigt die strikte Gleichheit (===) von actual und 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

Bestätigt, dass actual tiefgehend gleich expected ist.

import { assert, test } from 'vitest';

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

notDeepEqual

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

Bestätigt, dass actual nicht tiefgehend gleich expected ist.

import { assert, test } from 'vitest';

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

isAbove

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

Bestätigt, dass valueToCheck strikt größer ist als valueToBeAbove (>).

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 ist strikt größer als 2');
});

isAtLeast

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

Bestätigt, dass valueToCheck größer oder gleich valueToBeAtLeast ist (>=).

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 ist größer oder gleich 2');
  assert.isAtLeast(3, 3, '3 ist größer oder gleich 3');
});

isBelow

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

Bestätigt, dass valueToCheck strikt kleiner ist als valueToBeBelow (<).

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 ist strikt kleiner als 6');
});

isAtMost

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

Bestätigt, dass valueToCheck kleiner oder gleich valueToBeAtMost ist (<=).

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 ist kleiner oder gleich 6');
  assert.isAtMost(4, 4, '4 ist kleiner oder gleich 4');
});

isTrue

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

Bestätigt, dass value den Wert true hat.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Bestätigt, dass value nicht den Wert true hat.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Bestätigt, dass value den Wert false hat.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Bestätigt, dass value nicht den Wert false hat.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Bestätigt, dass value den Wert null hat.

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

Bestätigt, dass value nicht den Wert null hat.

import { assert, test } from 'vitest';

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

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error ist nicht null, sondern ein Objekt');
});

isNaN

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

Bestätigt, dass value NaN (Not a Number, keine Zahl) ist.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

test('assert.isNaN', () => {
  assert.isNaN(
    calculation,
    '1 * "vitest" ergibt NaN (Not a Number, keine Zahl)'
  );
});

isNotNaN

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

Bestätigt, dass value nicht NaN (Not a Number, keine Zahl) ist.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(
    calculation,
    '1 * 2 ist nicht NaN (Not a Number, keine Zahl), sondern 2'
  );
});

exists

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

Bestätigt, dass value weder null noch undefined ist.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo ist weder null noch undefiniert');
});

notExists

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

Bestätigt, dass value entweder null oder undefined ist.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo ist null und existiert daher nicht');
  assert.notExists(bar, 'bar ist undefined und existiert daher nicht');
});

isUndefined

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

Bestätigt, dass value den Wert undefined hat.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Bestätigt, dass value nicht den Wert undefined hat.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name ist nicht undefined');
});

isFunction

Typ: <T>(value: T, message?: string) => void
Alias: isCallable Bestätigt, dass value eine Funktion ist.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name ist eine Funktion');
});

isNotFunction

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

Bestätigt, dass value keine Funktion ist.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name ist keine Funktion, sondern ein String');
});

isObject

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

Bestätigt, dass value ein Objekt vom Typ Object ist (wie durch Object.prototype.toString ermittelt). Die Assertion trifft nicht auf Objekte von Subklassen zu.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing ist ein Objekt');
});

isNotObject

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

Bestätigt, dass value kein Objekt vom Typ Object ist (ermittelt durch Object.prototype.toString). Die Assertion schlägt fehl, wenn value eine Instanz einer Unterklasse von Object ist.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(
    someThing,
    'someThing ist kein Objekt, sondern ein String.'
  );
});

isArray

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

Bestätigt, dass value ein Array ist.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color ist ein Array.');
});

isNotArray

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

Bestätigt, dass value kein Array ist.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color ist kein Array, sondern ein String.');
});

isString

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

Bestätigt, dass value ein String ist.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color ist ein String.');
});

isNotString

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

Bestätigt, dass value kein String ist.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color ist kein String, sondern ein Array.');
});

isNumber

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

Bestätigt, dass value eine Zahl ist.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors ist eine Zahl.');
});

isNotNumber

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

Bestätigt, dass value keine Zahl ist.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors ist keine Zahl, sondern ein String.');
});

isFinite

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

Bestätigt, dass value eine endliche Zahl ist (weder NaN noch Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(
    colors,
    'colors ist eine endliche Zahl (weder NaN noch Infinity).'
  );
});

isBoolean

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

Bestätigt, dass value ein Boolean ist.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady ist ein Boolean.');
});

isNotBoolean

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

Bestätigt, dass value kein Boolean ist.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady ist kein Boolean, sondern ein String.');
});

typeOf

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

Bestätigt, dass der Typ von value name entspricht, ermittelt durch Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'Es handelt sich um ein Objekt.');
  assert.typeOf(['red', 'green'], 'array', 'Es handelt sich um ein Array.');
  assert.typeOf('red', 'string', 'Es handelt sich um einen String.');
  assert.typeOf(
    /red/,
    'regexp',
    'Es handelt sich um einen regulären Ausdruck.'
  );
  assert.typeOf(null, 'null', 'Es handelt sich um einen Nullwert.');
  assert.typeOf(
    undefined,
    'undefined',
    'Es handelt sich um einen undefinierten Wert.'
  );
});

notTypeOf

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

Bestätigt, dass der Typ von value nicht name entspricht, ermittelt durch Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" ist keine Zahl.');
});

instanceOf

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

Bestätigt, dass value eine Instanz von constructor ist.

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 ist eine Instanz von Person.');
  assert.instanceOf(coffee, Tea, 'coffee ist eine Instanz von Tea.');
});

notInstanceOf

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

Bestätigt, dass value keine Instanz von constructor ist.

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 ist keine Instanz von 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

Bestätigt, dass haystack needle enthält. Kann verwendet werden, um das Vorhandensein eines Wertes in einem Array, einer Teilzeichenkette in einem String oder einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'Array enthält Wert.');
  assert.include('foobar', 'foo', 'String enthält Teilzeichenkette.');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'Objekt enthält Eigenschaft.'
  );
});

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

Bestätigt, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen eines Wertes in einem Array, einer Teilzeichenkette in einem String oder einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'Array enthält nicht 4.');
  assert.notInclude('foobar', 'baz', 'foobar enthält nicht baz.');
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'Objekt enthält nicht die Eigenschaft.'
  );
});

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

Bestätigt, dass haystack needle enthält. Kann verwendet werden, um das Vorhandensein eines Wertes in einem Array oder einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen. Es wird eine tiefe Gleichheitsprüfung (deep equality) durchgeführt.

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

Bestätigt, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen eines Wertes in einem Array oder einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen. Es wird eine tiefe Gleichheitsprüfung (deep equality) durchgeführt.

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

Bestätigt, dass haystack needle enthält. Kann verwendet werden, um das Vorhandensein einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen. Ermöglicht die Verwendung der Punkt- und Klammernotation zum Referenzieren verschachtelter Eigenschaften. ‘[]’ und ‘.’ in Eigenschaftsnamen können mit doppelten Backslashes (\\) maskiert werden.

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

Bestätigt, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen. Ermöglicht die Verwendung der Punkt- und Klammernotation zum Referenzieren verschachtelter Eigenschaften. ‘[]’ und ‘.’ in Eigenschaftsnamen können mit doppelten Backslashes (\\) maskiert werden.

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

Bestätigt, dass haystack needle enthält. Kann verwendet werden, um das Vorhandensein einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen, wobei eine tiefe Gleichheitsprüfung (deep equality) durchgeführt wird. Ermöglicht die Verwendung der Punkt- und Klammernotation zum Referenzieren verschachtelter Eigenschaften. ‘[]’ und ‘.’ in Eigenschaftsnamen können mit doppelten Backslashes (\\) maskiert werden.

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

Bestätigt, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen, wobei eine tiefe Gleichheitsprüfung (deep equality) durchgeführt wird. Ermöglicht die Verwendung der Punkt- und Klammernotation zum Referenzieren verschachtelter Eigenschaften. ‘[]’ und ‘.’ in Eigenschaftsnamen können mit doppelten Backslashes (\\) maskiert werden.

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

Bestätigt, dass haystack needle enthält. Kann verwendet werden, um das Vorhandensein einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen, wobei vererbte Eigenschaften ignoriert werden.

import { assert, test } from 'vitest';

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

notOwnInclude

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

Bestätigt, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen, wobei vererbte Eigenschaften ignoriert werden.

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

Bestätigt, dass haystack die needle tiefgehend enthält. Dies kann verwendet werden, um zu überprüfen, ob ein Objekt bestimmte Eigenschaften besitzt, wobei geerbte Eigenschaften ignoriert und eine tiefe Gleichheitsprüfung durchgeführt wird.

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

Bestätigt, dass haystack die needle nicht tiefgehend enthält. Dies kann verwendet werden, um das Fehlen einer Teilmenge von Eigenschaften in einem Objekt zu überprüfen, wobei geerbte Eigenschaften ignoriert und eine tiefe Gleichheitsprüfung durchgeführt wird.

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

Bestätigt, dass value mit dem regulären Ausdruck regexp übereinstimmt.

import { assert, test } from 'vitest';

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

notMatch

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

Bestätigt, dass value nicht mit dem regulären Ausdruck regexp übereinstimmt.

import { assert, test } from 'vitest';

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

property

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

Bestätigt, dass object eine Eigenschaft namens property besitzt (direkt oder geerbt).

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

Bestätigt, dass object keine Eigenschaft namens property besitzt (weder direkt noch geerbt).

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

Bestätigt, dass object eine Eigenschaft namens property mit dem Wert value besitzt (direkt oder geerbt). Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Bestätigt, dass object keine Eigenschaft namens property mit dem Wert value besitzt (weder direkt noch geerbt). Verwendet eine strikte Gleichheitsprüfung (===).

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

Bestätigt, dass object eine Eigenschaft namens property mit dem Wert value besitzt (direkt oder geerbt). Verwendet eine tiefe Gleichheitsprüfung.

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

Bestätigt, dass object keine Eigenschaft namens property mit dem Wert value besitzt (weder direkt noch geerbt). Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  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

Bestätigt, dass object eine Eigenschaft namens property besitzt (direkt oder geerbt), wobei die Punkt- und Klammernotation für verschachtelte Referenzen verwendet werden kann.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Bestätigt, dass object keine Eigenschaft namens property besitzt (weder direkt noch geerbt), wobei die Punkt- und Klammernotation für verschachtelte Referenzen verwendet werden kann.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Bestätigt, dass object eine Eigenschaft namens property mit dem Wert value besitzt. property kann die Punkt- und Klammernotation für verschachtelte Referenzen verwenden. Verwendet eine strikte Gleichheitsprüfung (===).

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

Bestätigt, dass object keine Eigenschaft namens property mit dem Wert value besitzt. property kann die Punkt- und Klammernotation für verschachtelte Referenzen verwenden. Verwendet eine strikte Gleichheitsprüfung (===).

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.notNestedPropertyVal', () => {
  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

Bestätigt, dass object eine Länge (length) oder Größe (size) mit dem erwarteten Wert hat.

import { assert, test } from 'vitest';

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

hasAnyKeys

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

Bestätigt, dass object mindestens einen der angegebenen keys besitzt. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt angegeben werden, dessen Eigenschaften als die erwarteten Schlüssel interpretiert werden.

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

Bestätigt, dass object alle angegebenen keys besitzt. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt angegeben werden, dessen Eigenschaften als die erwarteten Schlüssel interpretiert werden.

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

Bestätigt, dass object alle angegebenen keys besitzt, aber möglicherweise zusätzliche Schlüssel enthält. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt angegeben werden, dessen Eigenschaften als die erwarteten Schlüssel interpretiert werden.

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

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

Prüft, ob das object keine der angegebenen keys enthält. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Prüft, ob das object mindestens einen der angegebenen keys nicht enthält. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

Prüft, ob das object mindestens einen der angegebenen keys besitzt. Da Set und Map Objekte als Schlüssel verwenden können, kann diese Überprüfung für einen Deep Comparison verwendet werden. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Prüft, ob das object alle angegebenen keys besitzt. Da Set und Map Objekte als Schlüssel verwenden können, kann diese Überprüfung für einen Deep Comparison verwendet werden. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Prüft, ob das object alle angegebenen keys enthält. Da Set und Map Objekte als Schlüssel verwenden können, kann diese Überprüfung für einen Deep Comparison verwendet werden. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Prüft, ob das object keinen der angegebenen keys besitzt. Da Set und Map Objekte als Schlüssel verwenden können, kann diese Überprüfung für einen Deep Comparison verwendet werden. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Prüft, ob das object nicht alle der angegebenen keys besitzt. Das bedeutet, dass mindestens einer der angegebenen Schlüssel nicht vorhanden sein darf. Da Set und Map Objekte als Schlüssel verwenden können, kann diese Überprüfung für einen Deep Comparison verwendet werden. Anstelle eines Arrays von Schlüsseln kann auch ein einzelnes Objekt übergeben werden, dessen Schlüssel dann als die zu prüfenden Schlüssel verwendet werden.

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

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

Wenn errorLike ein Error-Konstruktor ist, wird geprüft, dass fn einen Fehler auslöst, der eine Instanz von errorLike ist. Wenn errorLike eine Error-Instanz ist, wird geprüft, dass der ausgelöste Fehler die gleiche Instanz wie errorLike ist. Wenn errMsgMatcher angegeben ist, wird zusätzlich geprüft, dass der ausgelöste Fehler eine Meldung enthält, die mit errMsgMatcher übereinstimmt.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Error thrown must have this msg'); // Der ausgelöste Fehler muss diese Meldung haben
  assert.throws(fn, /Error thrown must have a msg that matches this/); // Der ausgelöste Fehler muss eine Meldung haben, die dazu passt
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'Error thrown must be a ReferenceError and have this msg' // Der ausgelöste Fehler muss ein ReferenceError sein und diese Meldung haben
  );
  assert.throws(
    fn,
    errorInstance,
    'Error thrown must be the same errorInstance and have this msg' // Der ausgelöste Fehler muss die gleiche errorInstance sein und diese Meldung haben
  );
  assert.throws(
    fn,
    ReferenceError,
    /Error thrown must be a ReferenceError and match this/ // Der ausgelöste Fehler muss ein ReferenceError sein und dazu passen
  );
  assert.throws(
    fn,
    errorInstance,
    /Error thrown must be the same errorInstance and match this/ // Der ausgelöste Fehler muss die gleiche errorInstance sein und dazu passen
  );
});

doesNotThrow

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

Wenn errorLike ein Error-Konstruktor ist, wird geprüft, dass fn keinen Fehler auslöst, der eine Instanz von errorLike ist. Wenn errorLike eine Error-Instanz ist, wird geprüft, dass der ausgelöste Fehler nicht die gleiche Instanz wie errorLike ist. Wenn errMsgMatcher angegeben ist, wird zusätzlich geprüft, dass der ausgelöste Fehler keine Meldung enthält, die mit errMsgMatcher übereinstimmt.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Any Error thrown must not have this message'); // Es darf kein Fehler mit dieser Meldung ausgelöst werden
  assert.doesNotThrow(fn, /Any Error thrown must not match this/); // Es darf kein Fehler ausgelöst werden, dessen Meldung dazu passt
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Error must not have this message'); // Es darf kein Fehler mit dieser Meldung ausgelöst werden
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message'); // Es darf kein Fehler mit dieser Meldung ausgelöst werden
  assert.doesNotThrow(fn, Error, /Error must not match this/); // Es darf kein Fehler ausgelöst werden, dessen Meldung dazu passt
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/); // Es darf kein Fehler ausgelöst werden, dessen Meldung dazu passt
});

operator

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

Vergleicht val1 und val2 mithilfe des operator.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'everything is ok'); // Alles ist in Ordnung
});

closeTo

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

Prüft, ob actual innerhalb eines Bereichs von +/- delta gleich expected ist.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'numbers are close'); // Die Zahlen liegen nahe beieinander
});

sameMembers

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

Prüft, ob set1 und set2 die gleichen Elemente in beliebiger Reihenfolge enthalten. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Prüft, ob set1 und set2 nicht die gleichen Elemente in beliebiger Reihenfolge enthalten. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

sameDeepMembers

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

Prüft, ob set1 und set2 die gleichen Elemente in beliebiger Reihenfolge enthalten. Verwendet eine tiefe Gleichheitsprüfung.

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' // Gleiche Elemente (tiefer Vergleich)
  );
});

notSameDeepMembers

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

Prüft, ob set1 und set2 nicht die gleichen Elemente in beliebiger Reihenfolge enthalten. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'not same deep members' // Nicht die gleichen Elemente (tiefer Vergleich)
  );
});

sameOrderedMembers

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

Prüft, ob set1 und set2 die gleichen Elemente in der gleichen Reihenfolge enthalten. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

notSameOrderedMembers

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

Prüft, ob set1 und set2 nicht die gleichen Elemente in der gleichen Reihenfolge enthalten. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'not same ordered members' // Nicht die gleichen geordneten Elemente
  );
});

sameDeepOrderedMembers

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

Prüft, ob set1 und set2 die gleichen Elemente in der gleichen Reihenfolge enthalten. Verwendet eine tiefe Gleichheitsprüfung.

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' // Gleiche tief geordnete Elemente
  );
});

notSameDeepOrderedMembers

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

Stellt sicher, dass set1 und set2 nicht die gleichen Elemente in derselben Reihenfolge enthalten. Es wird eine Deep-Equality-Prüfung (tiefer Vergleich) verwendet.

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' // Die Arrays enthalten nicht die gleichen tief geordneten Elemente.
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'not same deep ordered members' // Die Arrays enthalten nicht die gleichen tief geordneten Elemente.
  );
});

includeMembers

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

Stellt sicher, dass subset in superset in beliebiger Reihenfolge enthalten ist. Es wird eine strikte Gleichheitsprüfung (===) verwendet. Duplikate in subset werden ignoriert.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'include members'); // Das Superset enthält alle Elemente des Subsets.
});

notIncludeMembers

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

Stellt sicher, dass subset nicht vollständig in superset in beliebiger Reihenfolge enthalten ist. Es wird eine strikte Gleichheitsprüfung (===) verwendet. Duplikate in subset werden ignoriert.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'not include members'); // Das Superset enthält nicht alle Elemente des Subsets.
});

includeDeepMembers

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

Stellt sicher, dass subset in superset in beliebiger Reihenfolge enthalten ist. Es wird eine Deep-Equality-Prüfung (tiefer Vergleich) verwendet. Duplikate in subset werden ignoriert.

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' // Das Superset enthält alle tiefen Elemente des Subsets.
  );
});

notIncludeDeepMembers

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

Stellt sicher, dass subset nicht vollständig in superset in beliebiger Reihenfolge enthalten ist. Es wird eine Deep-Equality-Prüfung (tiefer Vergleich) verwendet. Duplikate in subset werden ignoriert.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'not include deep members' // Das Superset enthält nicht alle tiefen Elemente des Subsets.
  );
});

includeOrderedMembers

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

Stellt sicher, dass subset in superset in der gleichen Reihenfolge enthalten ist, beginnend mit dem ersten Element in superset. Es wird eine strikte Gleichheitsprüfung (===) verwendet.

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'include ordered members'); // Das Superset enthält die geordneten Elemente des Subsets.
});

notIncludeOrderedMembers

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

Stellt sicher, dass subset nicht in superset in der gleichen Reihenfolge enthalten ist, beginnend mit dem ersten Element in superset. Es wird eine strikte Gleichheitsprüfung (===) verwendet.

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'not include ordered members' // Das Superset enthält die Elemente des Subsets nicht in der gleichen Reihenfolge.
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'not include ordered members' // Das Superset enthält die Elemente des Subsets nicht in der gleichen Reihenfolge, beginnend mit dem ersten Element.
  );
});

includeDeepOrderedMembers

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

Stellt sicher, dass subset in superset in der gleichen Reihenfolge enthalten ist, beginnend mit dem ersten Element in superset. Es wird eine Deep-Equality-Prüfung (tiefer Vergleich) verwendet.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'include deep ordered members' // Das Superset enthält die tief geordneten Elemente des Subsets.
  );
});

notIncludeDeepOrderedMembers

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

Stellt sicher, dass subset nicht in superset in der gleichen Reihenfolge enthalten ist, beginnend mit dem ersten Element in superset. Es wird eine Deep-Equality-Prüfung (tiefer Vergleich) verwendet.

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' // Das Superset enthält die tief geordneten Elemente des Subsets nicht.
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'not include deep ordered members' // Das Superset enthält die tief geordneten Elemente des Subsets nicht in der gleichen Reihenfolge.
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'not include deep ordered members' // Das Superset enthält die tief geordneten Elemente des Subsets nicht in der gleichen Reihenfolge, beginnend mit dem ersten Element.
  );
});

oneOf

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

Stellt sicher, dass ein Wert inList (der kein Objekt oder Array sein darf) in dem Array list enthalten ist.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Not found in list'); // Der Wert ist in der Liste enthalten.
});

changes

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der Eigenschaft property des Objekts object verändert.

import { assert, test } from 'vitest';

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

changesBy

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der Eigenschaft property des Objekts object um den Wert change verändert.

import { assert, test } from 'vitest';

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

doesNotChange

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der Eigenschaft property des Objekts object nicht verändert.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der Eigenschaft property des Objekts object verändert, aber nicht um den Wert 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

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object erhöht.

import { assert, test } from 'vitest';

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

increasesBy

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object um den Wert change erhöht.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object nicht erhöht.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object erhöht, aber nicht um den Wert 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

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object verringert.

import { assert, test } from 'vitest';

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

decreasesBy

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object um den Wert change verringert.

import { assert, test } from 'vitest';

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

doesNotDecrease

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

Stellt sicher, dass die Ausführung der Funktion modifier den Wert der numerischen Eigenschaft property des Objekts object nicht verringert.

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

Stellt sicher, dass die Ausführung von modifier den numerischen Wert der property des object oder den Rückgabewert von modifier nicht um den Wert change verringert.

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

Stellt sicher, dass die Ausführung von modifier den numerischen Wert der property des object oder den Rückgabewert von modifier zwar verringert, aber nicht um den Wert 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

Überprüft, ob object ein Falschwert ist. Wenn object ein Wahrheitswert ist (truthy), wird ein Fehler ausgelöst. Dies ermöglicht die Verwendung von Chai als direkten Ersatz für die Assert-Klasse von Node.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // Löst err erneut aus!
});

isExtensible

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

Bestätigt, dass object erweiterbar ist (ihm können neue Eigenschaften hinzugefügt werden).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Bestätigt, dass object nicht erweiterbar ist (ihm können keine neuen Eigenschaften hinzugefügt werden).

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

Bestätigt, dass object versiegelt ist (ihm können keine neuen Eigenschaften hinzugefügt und vorhandene Eigenschaften nicht entfernt werden können).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Bestätigt, dass object nicht versiegelt ist (ihm können neue Eigenschaften hinzugefügt und vorhandene Eigenschaften entfernt werden können).

import { assert, test } from 'vitest';

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

isFrozen

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

Bestätigt, dass das object eingefroren ist (ihm können keine neuen Eigenschaften hinzugefügt und vorhandene Eigenschaften nicht verändert werden können).

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

Bestätigt, dass object nicht eingefroren ist (ihm können neue Eigenschaften hinzugefügt und vorhandene Eigenschaften verändert werden können).

import { assert, test } from 'vitest';

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

isEmpty

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

Überprüft, ob target keine Werte enthält. Für Arrays und Strings wird die length-Eigenschaft überprüft. Für Map- und Set-Instanzen wird die size-Eigenschaft überprüft. Für Objekte, die keine Funktionen sind, wird die Anzahl der eigenen, aufzählbaren String-Schlüssel überprüft.

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

Überprüft, ob target Werte enthält. Für Arrays und Strings wird die length-Eigenschaft überprüft. Für Map- und Set-Instanzen wird die size-Eigenschaft überprüft. Für Objekte, die keine Funktionen sind, wird die Anzahl der eigenen, aufzählbaren String-Schlüssel überprüft.

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