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

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

notDeepNestedPropertyVal

• 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 tiefe Gleichheitsprüfung.

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 });
});