assert

Vitest reexportiert die assert-Methode von chai zur Validierung von Invarianten.

assert

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

Stellt sicher, dass der gegebene expression einen Wahrheitswert hat (truthy 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 einen Assertionsfehler.

import { assert, test } from 'vitest';

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

isOk

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

Stellt sicher, dass der gegebene value einen Wahrheitswert hat (truthy ist).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'Jeder truthy Wert ist ok');
  assert.isOk(false, 'Dies wird fehlschlagen, da false nicht truthy ist');
});

isNotOk

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

Stellt sicher, dass der gegebene value einen Falschwert hat (falsy ist).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'Dies wird fehlschlagen, da ein truthy Wert nicht "not ok" ist');
  assert.isNotOk(false, 'Dies wird erfolgreich sein, da false falsy ist');
});

equal

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

Stellt die nicht-strikte Gleichheit (==) von actual und expected sicher.

import { assert, test } from 'vitest';

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

notEqual

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

Stellt die nicht-strikte Ungleichheit (!=) von actual und expected sicher.

import { assert, test } from 'vitest';

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

strictEqual

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

Stellt die strikte Gleichheit (===) von actual und expected sicher.

import { assert, test } from 'vitest';

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

deepEqual

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

Stellt sicher, dass actual tief 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

Stellt sicher, dass actual und expected nicht tief gleich sind.

import { assert, test } from 'vitest';

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

isAbove

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

Stellt sicher, dass valueToCheck strikt größer als (>) valueToBeAbove ist.

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

Stellt sicher, 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

Stellt sicher, dass valueToCheck strikt kleiner als (<) valueToBeBelow ist.

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

Stellt sicher, 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

Stellt sicher, dass value true ist.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Stellt sicher, dass value nicht true ist.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Stellt sicher, dass value false ist.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Stellt sicher, dass value nicht false ist.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Stellt sicher, dass value null ist.

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

Stellt sicher, dass value nicht null ist.

import { assert, test } from 'vitest';

const error = { message: 'Es ist ein Fehler aufgetreten' };

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

isNaN

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

Stellt sicher, dass value NaN ist.

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Stellt sicher, dass value nicht NaN ist.

import { assert, test } from 'vitest';

const calculation = 1 * 2;

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

exists

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

Stellt sicher, 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 undefined');
});

notExists

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

Stellt sicher, 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, existiert also nicht');
  assert.notExists(bar, 'bar ist undefined, existiert also nicht');
});

isUndefined

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

Stellt sicher, dass value undefined ist.

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

Stellt sicher, dass value nicht undefined ist.

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 Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, dass value ein Objekt vom Typ Object ist (wie durch Object.prototype.toString offenbart). Die Assertion trifft nicht auf untergeordnete Objekte 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

Stellt sicher, dass value kein Objekt vom Typ Object ist (wie durch Object.prototype.toString offenbart). Die Assertion trifft nicht auf untergeordnete Objekte zu.

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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, dass value eine endliche Zahl ist (nicht NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors ist eine Zahl, nicht NaN oder Infinity');
});

isBoolean

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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, dass der Typ von value name ist, wie durch Object.prototype.toString bestimmt.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'wir haben ein Objekt');
  assert.typeOf(['red', 'green'], 'array', 'wir haben ein Array');
  assert.typeOf('red', 'string', 'wir haben einen String');
  assert.typeOf(/red/, 'regexp', 'wir haben einen regulären Ausdruck');
  assert.typeOf(null, 'null', 'wir haben null');
  assert.typeOf(undefined, 'undefined', 'wir haben undefined');
});

notTypeOf

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

Stellt sicher, dass der Typ von value nicht name ist, wie durch Object.prototype.toString bestimmt.

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

Stellt sicher, 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

Stellt sicher, 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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um das Enthaltensein eines Wertes in einem Array, eines Teilstrings in einem String oder einer Untermenge von Eigenschaften in einem Objekt zu bestätigen.

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 Teilstring');
  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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um das Fehlen eines Wertes in einem Array, eines Teilstrings in einem String oder einer Untermenge von Eigenschaften in einem Objekt zu bestätigen.

import { assert, test } from 'vitest';

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

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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um die Aufnahme eines Wertes in ein Array oder einer Untermenge von Eigenschaften in einem Objekt zu bestätigen. Es wird eine tiefe Gleichheitsprüfung verwendet.

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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um die Abwesenheit eines Wertes in einem Array oder einer Untermenge von Eigenschaften in einem Objekt zu bestätigen. Es wird eine tiefe Gleichheitsprüfung verwendet.

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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um die Aufnahme einer Untermenge von Eigenschaften in einem Objekt zu bestätigen. Ermöglicht die Verwendung von 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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um die Abwesenheit einer Untermenge von Eigenschaften in einem Objekt zu bestätigen. Ermöglicht die Verwendung von 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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um die Aufnahme einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während auf tiefe Gleichheit geprüft wird. Ermöglicht die Verwendung von 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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um die Abwesenheit einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während auf tiefe Gleichheit geprüft wird. Ermöglicht die Verwendung von 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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um die Aufnahme einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während geerbte 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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um die Abwesenheit einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während geerbte 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

Stellt sicher, dass haystack needle enthält. Kann verwendet werden, um die Aufnahme einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während geerbte Eigenschaften ignoriert und auf tiefe Gleichheit geprüft 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

Stellt sicher, dass haystack needle nicht enthält. Kann verwendet werden, um die Abwesenheit einer Untermenge von Eigenschaften in einem Objekt zu bestätigen, während geerbte Eigenschaften ignoriert und auf tiefe Gleichheit geprüft 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

Stellt sicher, dass value dem regulären Ausdruck regexp entspricht.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'Regulärer Ausdruck stimmt überein');
});

notMatch

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

Stellt sicher, dass value dem regulären Ausdruck regexp nicht entspricht.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /baz/, 'Regulärer Ausdruck stimmt nicht überein');
});

property

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

Stellt sicher, dass object eine direkte oder geerbte Eigenschaft mit dem Namen property hat.

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

Stellt sicher, dass object keine direkte oder geerbte Eigenschaft mit dem Namen property hat.

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

Stellt sicher, dass object eine direkte oder geerbte Eigenschaft mit dem Namen property und dem Wert value hat. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Stellt sicher, dass object keine direkte oder geerbte Eigenschaft mit dem Namen property und dem Wert value hat. 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

Stellt sicher, dass object eine direkte oder geerbte Eigenschaft mit dem Namen property und dem Wert value hat. 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

Stellt sicher, dass object keine direkte oder geerbte Eigenschaft mit dem Namen property und dem Wert value hat. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

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

nestedProperty

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

Stellt sicher, dass object eine direkte oder geerbte Eigenschaft mit dem Namen property hat, die ein String sein kann, der Punkt- und Klammernotation für verschachtelte Referenzen verwendet.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Stellt sicher, dass object keine direkte oder geerbte Eigenschaft mit dem Namen property hat, die ein String sein kann, der Punkt- und Klammernotation für verschachtelte Referenzen verwendet.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Stellt sicher, dass object eine Eigenschaft mit dem Namen property und dem Wert value hat. property kann 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

Stellt sicher, dass object keine Eigenschaft mit dem Namen property und dem Wert value hat. property kann 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

Stellt sicher, dass object eine Eigenschaft mit dem Namen property und dem Wert value hat. property kann Punkt- und Klammernotation für verschachtelte Referenzen verwenden. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

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

Stellt sicher, dass object keine Eigenschaft mit dem Namen property und dem Wert value hat. property kann 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

Stellt sicher, dass object eine length oder size mit dem erwarteten Wert hat.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'Array hat Länge 3');
  assert.lengthOf('foobar', 6, 'String hat Länge 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'Set hat Größe 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'Map hat Größe 3'
  );
});

hasAnyKeys

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

Stellt sicher, dass object mindestens einen der angegebenen Schlüssel hat. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

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

Stellt sicher, dass object alle der angegebenen Schlüssel hat und keine weiteren. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

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

Stellt sicher, dass object alle der angegebenen Schlüssel hat, aber möglicherweise weitere nicht aufgelistete Schlüssel. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

doesNotHaveAnyKeys

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

Stellt sicher, dass object keinen der angegebenen Schlüssel hat. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

doesNotHaveAllKeys

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

Stellt sicher, dass object nicht alle der angegebenen Schlüssel hat. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

Stellt sicher, dass object mindestens einen der angegebenen Schlüssel hat. Da Sets und Maps Objekte als Schlüssel haben können, können Sie diese Assertion verwenden, um einen tiefen Vergleich durchzuführen. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

hasAllDeepKeys

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

Stellt sicher, dass object alle der angegebenen Schlüssel hat und keine weiteren. Da Sets und Maps Objekte als Schlüssel haben können, können Sie diese Assertion verwenden, um einen tiefen Vergleich durchzuführen. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

containsAllDeepKeys

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

Stellt sicher, dass object alle der angegebenen Schlüssel enthält. Da Sets und Maps Objekte als Schlüssel haben können, können Sie diese Assertion verwenden, um einen tiefen Vergleich durchzuführen. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

doesNotHaveAnyDeepKeys

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

Stellt sicher, dass object keinen der angegebenen Schlüssel hat. Da Sets und Maps Objekte als Schlüssel haben können, können Sie diese Assertion verwenden, um einen tiefen Vergleich durchzuführen. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

doesNotHaveAllDeepKeys

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

Stellt sicher, dass object nicht alle der angegebenen Schlüssel hat. Da Sets und Maps Objekte als Schlüssel haben können, können Sie diese Assertion verwenden, um einen tiefen Vergleich durchzuführen. Sie können auch ein einzelnes Objekt anstelle eines Schlüssel-Arrays angeben, und dessen Schlüssel werden als erwarteter Satz von Schlüsseln verwendet.

import { assert, test } from 'vitest';

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

throws

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

Wenn errorLike ein Error-Konstruktor ist, prüft dies, dass fn einen Fehler auslöst, der eine Instanz von errorLike ist. Wenn errorLike eine Error-Instanz ist, prüft dies, dass der ausgelöste Fehler dieselbe Instanz wie errorLike ist. Wenn errMsgMatcher angegeben ist, prüft dies auch, dass der ausgelöste Fehler eine Nachricht hat, die errMsgMatcher entspricht.

import { assert, test } from 'vitest';

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

doesNotThrow

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

Wenn errorLike ein Error-Konstruktor ist, prüft dies, dass fn keinen Fehler auslöst, der eine Instanz von errorLike ist. Wenn errorLike eine Error-Instanz ist, prüft dies, dass der ausgelöste Fehler nicht dieselbe Instanz wie errorLike ist. Wenn errMsgMatcher angegeben ist, prüft dies auch, dass der ausgelöste Fehler keine Nachricht hat, die errMsgMatcher entspricht.

import { assert, test } from 'vitest';

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

operator

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

Vergleicht val1 und val2 mit dem operator.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'alles ist in Ordnung');
});

closeTo

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

Stellt sicher, dass der actual-Wert gleich dem expected-Wert ist, innerhalb eines +/- delta-Bereichs.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'Zahlen sind nah beieinander');
});

sameMembers

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

Stellt sicher, dass set1 und set2 die gleichen Elemente in beliebiger Reihenfolge haben. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Stellt sicher, dass set1 und set2 nicht die gleichen Elemente in beliebiger Reihenfolge haben. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'nicht gleiche Elemente');
});

sameDeepMembers

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

Stellt sicher, dass set1 und set2 die gleichen Elemente in beliebiger Reihenfolge haben. 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 }],
    'gleiche tiefe Elemente'
  );
});

notSameDeepMembers

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

Stellt sicher, dass set1 und set2 nicht die gleichen Elemente in beliebiger Reihenfolge haben. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nicht gleiche tiefe Elemente'
  );
});

sameOrderedMembers

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

Stellt sicher, dass set1 und set2 die gleichen Elemente in der gleichen Reihenfolge haben. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'gleiche geordnete Elemente');
});

notSameOrderedMembers

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

Stellt sicher, dass set1 und set2 nicht die gleichen Elemente in der gleichen Reihenfolge haben. Verwendet eine strikte Gleichheitsprüfung (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'nicht gleiche geordnete Elemente'
  );
});

sameDeepOrderedMembers

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

Stellt sicher, dass set1 und set2 die gleichen Elemente in der gleichen Reihenfolge haben. 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 }],
    'gleiche tiefe geordnete Elemente'
  );
});

notSameDeepOrderedMembers

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

Stellt sicher, dass set1 und set2 nicht die gleichen Elemente in der gleichen Reihenfolge haben. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'nicht gleiche tiefe geordnete Elemente'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'nicht gleiche tiefe geordnete Elemente'
  );
});

includeMembers

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

Stellt sicher, dass das subset im superset in beliebiger Reihenfolge enthalten ist. Verwendet eine strikte Gleichheitsprüfung (===). Duplikate werden ignoriert.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Stellt sicher, dass das subset nicht im superset in beliebiger Reihenfolge enthalten ist. Verwendet eine strikte Gleichheitsprüfung (===). Duplikate werden ignoriert.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'Elemente nicht enthalten');
});

includeDeepMembers

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

Stellt sicher, dass das subset im superset in beliebiger Reihenfolge enthalten ist. Verwendet eine tiefe Gleichheitsprüfung. Duplikate werden ignoriert.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'tiefe Elemente enthalten'
  );
});

notIncludeDeepMembers

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

Stellt sicher, dass das subset nicht im superset in beliebiger Reihenfolge enthalten ist. Verwendet eine tiefe Gleichheitsprüfung. Duplikate werden ignoriert.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'tiefe Elemente nicht enthalten'
  );
});

includeOrderedMembers

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

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

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'geordnete Elemente enthalten');
});

notIncludeOrderedMembers

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

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

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'geordnete Elemente nicht enthalten'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'geordnete Elemente nicht enthalten'
  );
});

includeDeepOrderedMembers

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

Stellt sicher, dass das subset im superset in der gleichen Reihenfolge, beginnend mit dem ersten Element im superset, enthalten ist. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'tiefe geordnete Elemente enthalten'
  );
});

notIncludeDeepOrderedMembers

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

Stellt sicher, dass das subset nicht im superset in der gleichen Reihenfolge, beginnend mit dem ersten Element im superset, enthalten ist. Verwendet eine tiefe Gleichheitsprüfung.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'tiefe geordnete Elemente nicht enthalten'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'tiefe geordnete Elemente nicht enthalten'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'tiefe geordnete Elemente nicht enthalten'
  );
});

oneOf

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

Stellt sicher, dass der Nicht-Objekt-, Nicht-Array-Wert inList im flachen Array list vorkommt.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Wert in Liste gefunden'); // Nachricht angepasst
});

changes

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

Stellt sicher, dass ein modifier die property des object ändert.

import { assert, test } from 'vitest';

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

changesBy

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

Stellt sicher, dass ein modifier die property des object um einen change-Wert ä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

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

Stellt sicher, dass ein modifier die property des object nicht ä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

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

Stellt sicher, dass ein modifier die property des object oder einen Rückgabewert des modifier ändert, aber nicht um einen change-Wert.

import { assert, test } from 'vitest';

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

increases

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

Stellt sicher, dass ein modifier die numerische property eines 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

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

Stellt sicher, dass ein modifier die numerische property eines object oder einen Rückgabewert des modifier um einen change-Wert erhöht.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Stellt sicher, dass ein modifier die numerische property eines 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

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

Stellt sicher, dass ein modifier die numerische property eines object oder einen Rückgabewert des modifier erhöht, aber nicht um einen change-Wert.

import { assert, test } from 'vitest';

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

decreases

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

Stellt sicher, dass ein modifier die numerische property eines 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

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

Stellt sicher, dass ein modifier die numerische property eines object oder einen Rückgabewert des modifier um einen change-Wert 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

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

Stellt sicher, dass ein modifier die numerische property eines 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 ein modifier die numerische property eines object oder einen Rückgabewert des modifier nicht um einen change-Wert 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 ein modifier die numerische property eines object oder einen Rückgabewert des modifier verringert, aber nicht um einen change-Wert.

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

Stellt sicher, ob object kein falsy Wert ist, und wirft einen Fehler, wenn es ein truthy Wert ist. Dies wurde hinzugefügt, um Chai als direkten Ersatz für die Node-Assert-Klasse zu ermöglichen.

import { assert, test } from 'vitest';

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

isExtensible

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

Stellt sicher, dass object erweiterbar ist (neue Eigenschaften können hinzugefügt werden).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Stellt sicher, dass object nicht erweiterbar ist (neue Eigenschaften können nicht 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

Stellt sicher, dass object versiegelt ist (es können keine neuen Eigenschaften hinzugefügt und bestehende Eigenschaften nicht entfernt werden).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Stellt sicher, dass object nicht versiegelt ist (es können neue Eigenschaften hinzugefügt und bestehende Eigenschaften entfernt werden).

import { assert, test } from 'vitest';

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

isFrozen

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

Stellt sicher, dass object eingefroren ist (es können keine neuen Eigenschaften hinzugefügt und bestehende Eigenschaften nicht geändert werden).

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

Stellt sicher, dass object nicht eingefroren ist (es können neue Eigenschaften hinzugefügt und bestehende Eigenschaften geändert werden).

import { assert, test } from 'vitest';

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

isEmpty

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

Stellt sicher, dass das target keine Werte enthält. Bei Arrays und Strings wird die length-Eigenschaft überprüft. Bei Map- und Set-Instanzen wird die size-Eigenschaft überprüft. Bei Nicht-Funktionsobjekten wird die Anzahl der eigenen aufzählbaren String-Schlüssel ermittelt.

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

Stellt sicher, dass das target Werte enthält. Bei Arrays und Strings wird die length-Eigenschaft überprüft. Bei Map- und Set-Instanzen wird die size-Eigenschaft überprüft. Bei Nicht-Funktionsobjekten wird die Anzahl der eigenen aufzählbaren String-Schlüssel ermittelt.

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