assert

Vitest réexporte la méthode assert de chai afin de vérifier les invariants.

assert

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

Vérifie que l'expression donnée est truthy (s'évalue à vrai) ; sinon, l'assertion échoue.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo ne doit pas être égal à bar');
});

fail

• Type:
  • (message?: string) => never
  • <T>(actual: T, expected: T, message?: string, operator?: string) => never

Force l'échec d'une assertion.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail("message d'erreur en cas d'échec de l'assertion");
  assert.fail('foo', 'bar', "foo n'est pas bar", '===');
});

isOk

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

Vérifie que la value donnée est truthy (s'évalue à vrai).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'tout truthy est ok');
  assert.isOk(false, "cette assertion échouera car false n'est pas truthy");
});

isNotOk

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

Vérifie que la value donnée est falsy (s'évalue à faux).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', "ceci échouera, tout truthy n'est pas ok");
  assert.isNotOk(false, 'ceci passera car false est falsy');
});

equal

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

Vérifie l'égalité non stricte (==) entre actual et expected.

import { assert, test } from 'vitest';

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

notEqual

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

Vérifie l'inégalité non stricte (!=) entre actual et expected.

import { assert, test } from 'vitest';

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

strictEqual

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

Vérifie l'égalité stricte (===) entre actual et expected.

import { assert, test } from 'vitest';

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

deepEqual

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

Vérifie que actual est profondément égal à expected.

import { assert, test } from 'vitest';

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

notDeepEqual

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

Vérifie que actual n'est pas profondément égal à expected.

import { assert, test } from 'vitest';

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

isAbove

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

Vérifie que valueToCheck est strictement supérieur (>) à valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 est strictement supérieur à 2');
});

isAtLeast

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

Vérifie que valueToCheck est supérieur ou égal (>=) à valueToBeAtLeast.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 est supérieur ou égal à 2');
  assert.isAtLeast(3, 3, '3 est supérieur ou égal à 3');
});

isBelow

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

Vérifie que valueToCheck est strictement inférieur (<) à valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 est strictement inférieur à 6');
});

isAtMost

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

Vérifie que valueToCheck est inférieur ou égal (<=) à valueToBeAtMost.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 est inférieur ou égal à 6');
  assert.isAtMost(4, 4, '4 est inférieur ou égal à 4');
});

isTrue

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

Vérifie que value est true (vrai).

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Vérifie que value n'est pas true (vrai).

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Vérifie que value est false (faux).

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Vérifie que value n'est pas false (faux).

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Vérifie que value est null.

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

Vérifie que value n'est pas null.

import { assert, test } from 'vitest';

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

test('assert.isNotNull', () => {
  assert.isNotNull(error, "error n'est pas null mais un objet");
});

isNaN

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

Vérifie que value est NaN (Not a Number - Pas un Nombre).

import { assert, test } from 'vitest';

const calculation = 1 * 'viitest';

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

isNotNaN

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

Vérifie que value n'est pas NaN (Not a Number - Pas un Nombre).

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, "1 * 2 n'est pas NaN mais 2");
});

exists

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

Vérifie que value n'est ni null ni undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, "foo n'est ni null ni undefined");
});

notExists

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

Vérifie que value est soit null, soit undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, "foo est null donc n'existe pas");
  assert.notExists(bar, "bar est undefined donc n'existe pas");
});

isUndefined

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

Vérifie que value est undefined.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Vérifie que value n'est pas undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, "name n'est pas undefined");
});

isFunction

• Type: <T>(value: T, message?: string) => void
• Alias: isCallable Vérifie que value est une fonction.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name est une fonction');
});

isNotFunction

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

Vérifie que value n'est pas une fonction.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(
    name,
    "name n'est pas une fonction, mais une chaîne de caractères"
  );
});

isObject

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

Vérifie que value est un objet de type Object (tel que déterminé par Object.prototype.toString). L'assertion ne correspond pas aux objets sous-classés.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing est un objet');
});

isNotObject

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

Vérifie que value n'est pas un objet de type Object (tel que déterminé par Object.prototype.toString). Cette assertion ne s'applique pas aux objets héritant de Object.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(
    someThing,
    "someThing n'est pas un objet, mais une chaîne de caractères"
  );
});

isArray

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

Vérifie que value est un tableau.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color est un tableau');
});

isNotArray

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

Vérifie que value n'est pas un tableau.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(
    color,
    "color n'est pas un tableau, mais une chaîne de caractères"
  );
});

isString

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

Vérifie que value est une chaîne de caractères.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color est une chaîne');
});

isNotString

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

Vérifie que value n'est pas une chaîne de caractères.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, "color n'est pas une chaîne, mais un tableau");
});

isNumber

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

Vérifie que value est un nombre.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors est un nombre');
});

isNotNumber

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

Vérifie que value n'est pas un nombre.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(
    colors,
    "colors n'est pas un nombre, mais une chaîne de caractères"
  );
});

isFinite

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

Vérifie que value est un nombre fini (c'est-à-dire, ni NaN, ni Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors est un nombre, ni NaN, ni Infinity');
});

isBoolean

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

Vérifie que value est un booléen.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady est un booléen');
});

isNotBoolean

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

Vérifie que value n'est pas un booléen.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(
    isReady,
    "isReady n'est pas un booléen, mais une chaîne de caractères"
  );
});

typeOf

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

Vérifie que le type de value correspond à name, tel que déterminé par Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'nous avons un objet');
  assert.typeOf(['red', 'green'], 'array', 'nous avons un tableau');
  assert.typeOf('red', 'string', 'nous avons une chaîne');
  assert.typeOf(/red/, 'regexp', 'nous avons une expression régulière');
  assert.typeOf(null, 'null', 'nous avons un null');
  assert.typeOf(undefined, 'undefined', 'nous avons un undefined');
});

notTypeOf

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

Vérifie que le type de value ne correspond pas à name, tel que déterminé par Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" n’est pas un nombre.');
});

instanceOf

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

Vérifie que value est une instance de constructor.

import { assert, test } from 'vitest';

function Person(name) {
  this.name = name;
}
const foo = new Person('foo');

class Tea {
  constructor(name) {
    this.name = name;
  }
}
const coffee = new Tea('coffee');

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Person, 'foo est une instance de Person');
  assert.instanceOf(coffee, Tea, 'coffee est une instance de Tea');
});

notInstanceOf

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

Vérifie que value n'est pas une instance de constructor.

import { assert, test } from 'vitest';

function Person(name) {
  this.name = name;
}
const foo = new Person('foo');

class Tea {
  constructor(name) {
    this.name = name;
  }
}
const coffee = new Tea('coffee');

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Tea, 'foo n’est pas une instance de Tea');
});

include

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

Peut être utilisé pour vérifier l'inclusion d'une valeur dans un tableau, d'une sous-chaîne dans une chaîne de caractères ou d'un sous-ensemble de propriétés dans un objet.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'le tableau contient cette valeur');
  assert.include(
    'foobar',
    'foo',
    'la chaîne de caractères contient la sous-chaîne'
  );
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'l’objet contient la propriété'
  );
});

notInclude

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

Peut être utilisé pour vérifier l'absence d'une valeur dans un tableau, d'une sous-chaîne dans une chaîne de caractères ou d'un sous-ensemble de propriétés dans un objet.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'le tableau ne contient pas le nombre 4');
  assert.notInclude('foobar', 'baz', 'foobar ne contient pas baz');
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'l’objet ne contient pas la propriété'
  );
});

deepInclude

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

Vérifie que haystack inclut needle en utilisant une comparaison profonde (deep equality). Peut être utilisé pour vérifier l'inclusion d'une valeur dans un tableau ou d'un sous-ensemble de propriétés dans un objet.

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

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

Vérifie que haystack n'inclut pas needle en utilisant une comparaison profonde (deep equality). Peut être utilisé pour vérifier l'absence d'une valeur dans un tableau ou d'un sous-ensemble de propriétés dans un objet.

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

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

Vérifie que haystack inclut needle. Peut être utilisé pour vérifier l'inclusion d'un sous-ensemble de propriétés dans un objet. Permet l'utilisation de la notation point et crochet pour référencer les propriétés imbriquées. Les caractères '[]' et '.' dans les noms de propriétés peuvent être échappés à l'aide de doubles antislashs.

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

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

Vérifie que haystack n'inclut pas needle. Peut être utilisé pour vérifier l'absence d'un sous-ensemble de propriétés dans un objet. Permet l'utilisation de la notation point et crochet pour référencer les propriétés imbriquées. Les caractères '[]' et '.' dans les noms de propriétés peuvent être échappés à l'aide de doubles antislashs.

import { assert, test } from 'vitest';

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

deepNestedInclude

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

Vérifie que haystack inclut needle. Peut être utilisé pour vérifier l'inclusion d'un sous-ensemble de propriétés dans un objet en utilisant une comparaison profonde (deep equality). Permet l'utilisation de la notation point et crochet pour référencer les propriétés imbriquées. Les caractères '[]' et '.' dans les noms de propriétés peuvent être échappés à l'aide de doubles antislashs.

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

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

Vérifie que haystack n'inclut pas needle. Peut être utilisé pour vérifier l'absence d'un sous-ensemble de propriétés dans un objet en utilisant une comparaison profonde (deep equality). Permet l'utilisation de la notation point et crochet pour référencer les propriétés imbriquées. Les caractères '[]' et '.' dans les noms de propriétés peuvent être échappés à l'aide de doubles antislashs.

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

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

Vérifie que haystack inclut needle. Peut être utilisé pour vérifier l'inclusion d'un sous-ensemble de propriétés dans un objet, en ignorant les propriétés héritées.

import { assert, test } from 'vitest';

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

notOwnInclude

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

Vérifie que haystack n'inclut pas needle. Peut être utilisé pour vérifier l'absence d'un sous-ensemble de propriétés dans un objet, en ignorant les propriétés héritées.

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

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

Affirme que haystack inclut needle, en effectuant une comparaison profonde et en ignorant les propriétés héritées. Utile pour vérifier la présence d'un sous-ensemble de propriétés dans un objet.

import { assert, test } from 'vitest';

test('assert.deepOwnInclude', () => {
  assert.deepOwnInclude({ a: { b: 2 } }, { a: { b: 2 } });
});

notDeepOwnInclude

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

Affirme que haystack n'inclut pas needle, en effectuant une comparaison profonde et en ignorant les propriétés héritées. Utile pour vérifier l'absence d'un sous-ensemble de propriétés dans un objet.

import { assert, test } from 'vitest';

test('assert.notDeepOwnInclude', () => {
  assert.notDeepOwnInclude({ a: { b: 2 } }, { a: { c: 3 } });
});

match

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

Affirme que la chaîne value correspond à l'expression régulière regexp.

import { assert, test } from 'vitest';

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

notMatch

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

Affirme que la chaîne value ne correspond pas à l'expression régulière regexp.

import { assert, test } from 'vitest';

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

property

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

Affirme que object possède une propriété (directe ou héritée) nommée property.

import { assert, test } from 'vitest';

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

notProperty

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

Affirme que object ne possède pas de propriété (directe ou héritée) nommée property.

import { assert, test } from 'vitest';

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

propertyVal

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

Affirme que object possède une propriété (directe ou héritée) nommée property dont la valeur est strictement égale (===) à value.

import { assert, test } from 'vitest';

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

notPropertyVal

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

Affirme que object ne possède pas de propriété (directe ou héritée) nommée property dont la valeur est strictement égale (===) à value.

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

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

Affirme que object possède une propriété (directe ou héritée) nommée property dont la valeur est profondément égale à value.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

Affirme que object ne possède pas de propriété (directe ou héritée) nommée property dont la valeur est profondément égale à value.

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

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

Affirme que object possède une propriété (directe ou héritée) nommée property, où property peut être une chaîne utilisant la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Affirme que object ne possède pas de propriété (directe ou héritée) nommée property, où property peut être une chaîne utilisant la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Affirme que object possède une propriété nommée property dont la valeur est strictement égale (===) à value. property peut utiliser la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

import { assert, test } from 'vitest';

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

notNestedPropertyVal

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

Affirme que object ne possède pas de propriété nommée property dont la valeur est strictement égale (===) à value. property peut utiliser la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

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

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

Affirme que object possède une propriété nommée property dont la valeur est profondément égale à value. property peut utiliser la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

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

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

Affirme que object ne possède pas de propriété nommée property dont la valeur est profondément égale à value. property peut utiliser la notation pointée (par exemple, tea.green) ou entre crochets pour une référence imbriquée.

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

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

Affirme que object possède une propriété length ou size dont la valeur est égale à length.

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

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

Affirme que object possède au moins une des clés spécifiées dans keys. keys peut être un tableau de clés ou un objet dont les clés seront utilisées comme ensemble de clés attendu.

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

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

Affirme que object possède toutes les clés spécifiées dans keys et uniquement celles-ci. keys peut être un tableau de clés ou un objet dont les clés seront utilisées comme ensemble de clés attendu.

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

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

Affirme que object possède toutes les clés spécifiées dans keys, mais peut également contenir d'autres clés. keys peut être un tableau de clés ou un objet dont les clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object ne contient aucune des clés spécifiées. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object ne contient pas toutes les clés spécifiées. Autrement dit, elle vérifie qu'au moins une des clés fournies est absente de l'objet. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object contient au moins une des clés spécifiées. Étant donné que les Set et les Map peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison en profondeur des clés. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object contient toutes les clés spécifiées et uniquement celles-ci. Étant donné que les Set et les Map peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison en profondeur des clés. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object contient toutes les clés spécifiées. Contrairement à hasAllDeepKeys, l'objet peut contenir d'autres clés en plus de celles spécifiées. Étant donné que les Set et les Map peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison en profondeur des clés. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object ne contient aucune des clés spécifiées. Étant donné que les Set et les Map peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison en profondeur des clés. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Vérifie que object ne contient pas toutes les clés spécifiées. Autrement dit, elle vérifie qu'au moins une des clés fournies est absente de l'objet. Étant donné que les Set et les Map peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison en profondeur des clés. Vous pouvez également fournir un objet unique au lieu d'un tableau de clés ; dans ce cas, ses clés seront utilisées comme ensemble de clés attendu.

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

Si errorLike est un constructeur d'erreur (ErrorConstructor), vérifie que fn lève une erreur qui est une instance de errorLike. Si errorLike est une instance d'erreur (Error), vérifie que l'erreur levée est la même instance que errorLike. Si errMsgMatcher est fourni, vérifie également que le message de l'erreur levée correspond à errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, "Le message d'erreur doit correspondre à");
  assert.throws(fn, /Error thrown must have a msg that matches this/); // Le message d'erreur doit correspondre à ceci
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(fn, ReferenceError, "Le message d'erreur doit correspondre à");
  assert.throws(fn, errorInstance, "Le message d'erreur doit correspondre à");
  assert.throws(
    fn,
    ReferenceError,
    /Error thrown must be a ReferenceError and match this/ // L'erreur levée doit être une ReferenceError et correspondre à ceci
  );
  assert.throws(
    fn,
    errorInstance,
    /Error thrown must be the same errorInstance and match this/ // L'erreur levée doit être la même instance d'erreur et correspondre à ceci
  );
});

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

Si errorLike est un constructeur d'erreur (ErrorConstructor), vérifie que fn ne lève pas une erreur qui est une instance de errorLike. Si errorLike est une instance d'erreur (Error), vérifie que l'erreur levée n'est pas la même instance que errorLike. Si errMsgMatcher est fourni, vérifie également qu'aucune erreur levée ne contient un message correspondant à errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Aucune erreur levée ne doit contenir ce message');
  assert.doesNotThrow(fn, /Any Error thrown must not match this/); // Toute erreur levée ne doit pas correspondre à ceci
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'Error must not have this message'); // L'erreur ne doit pas avoir ce message
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message'); // L'erreur ne doit pas avoir ce message
  assert.doesNotThrow(fn, Error, /Error must not match this/); // L'erreur ne doit pas correspondre à ceci
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/); // L'erreur ne doit pas correspondre à ceci
});

operator

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

Compare val1 et val2 en utilisant l'operator spécifié.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'tout est correct');
});

closeTo

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

Vérifie que actual est égal à expected, à +/- delta près (marge d'erreur).

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'les valeurs sont proches');
});

sameMembers

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

Vérifie que set1 et set2 contiennent les mêmes éléments, quel que soit leur ordre. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'mêmes éléments');
});

notSameMembers

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

Vérifie que set1 et set2 ne contiennent pas les mêmes éléments, quel que soit leur ordre. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'éléments différents');
});

sameDeepMembers

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

Vérifie que set1 et set2 contiennent les mêmes éléments, quel que soit leur ordre. Utilise une comparaison d'égalité en profondeur.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'membres identiques en comparaison approfondie'
  );
});

notSameDeepMembers

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

Vérifie que set1 et set2 ne contiennent pas les mêmes éléments, quel que soit leur ordre. Utilise une comparaison d'égalité en profondeur.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'éléments différents (comparaison profonde)'
  );
});

sameOrderedMembers

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

Vérifie que set1 et set2 contiennent les mêmes éléments dans le même ordre. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'mêmes éléments ordonnés');
});

notSameOrderedMembers

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

Vérifie que set1 et set2 ne contiennent pas les mêmes éléments dans le même ordre. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'membres non identiques dans le même ordre'
  );
});

sameDeepOrderedMembers

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

Vérifie que set1 et set2 contiennent les mêmes éléments dans le même ordre. Utilise une comparaison d'égalité en profondeur.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'mêmes éléments ordonnés (comparaison profonde)'
  );
});

notSameDeepOrderedMembers

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

Vérifie que set1 et set2 ne contiennent pas les mêmes éléments dans le même ordre, en utilisant une comparaison d'égalité profonde.

import { assert, test } from 'vitest';

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

includeMembers

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

Vérifie que tous les éléments de subset sont présents dans superset, quel que soit l'ordre. Utilise une comparaison d'égalité stricte (===). Les doublons dans subset sont ignorés.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Vérifie qu'au moins un élément de subset n'est pas présent dans superset, quel que soit l'ordre. Utilise une comparaison d'égalité stricte (===). Les doublons dans subset sont ignorés.

import { assert, test } from 'vitest';

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

includeDeepMembers

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

Vérifie que tous les éléments de subset sont présents dans superset, quel que soit l'ordre. Utilise une comparaison d'égalité profonde. Les doublons dans subset sont ignorés.

import { assert, test } from 'vitest';

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

notIncludeDeepMembers

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

Vérifie qu'au moins un élément de subset n'est pas présent dans superset, quel que soit l'ordre. Utilise une comparaison d'égalité profonde. Les doublons dans subset sont ignorés.

import { assert, test } from 'vitest';

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

includeOrderedMembers

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

Vérifie que subset est une sous-séquence de superset, en respectant l'ordre des éléments et en commençant par le premier élément de superset. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

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

notIncludeOrderedMembers

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

Vérifie que subset n'est pas une sous-séquence de superset, en respectant l'ordre des éléments et en commençant par le premier élément de superset. Utilise une comparaison d'égalité stricte (===).

import { assert, test } from 'vitest';

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

includeDeepOrderedMembers

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

Vérifie que subset est une sous-séquence de superset, en respectant l'ordre des éléments et en commençant par le premier élément de superset. Utilise une comparaison d'égalité profonde.

import { assert, test } from 'vitest';

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

notIncludeDeepOrderedMembers

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

Vérifie que subset n'est pas une sous-séquence de superset, en respectant l'ordre des éléments et en commençant par le premier élément de superset. Utilise une comparaison d'égalité profonde.

import { assert, test } from 'vitest';

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

oneOf

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

Vérifie que la valeur inList (qui ne doit pas être un objet ou un tableau) est présente dans le tableau list.

import { assert, test } from 'vitest';

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

changes

• Type: <T>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur modifie la valeur de la propriété de l'objet.

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>(modificateur: Function, objet: T, propriété: string, changement: number, message?: string) => void

Vérifie que l'exécution de la fonction modificateur modifie la valeur de la propriété de l'objet d'une valeur égale à changement.

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>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur ne modifie pas la valeur de la propriété de l'objet.

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>(modificateur: Function, objet: T, propriété: string, changement:number, message?: string) => void

Vérifie que l'exécution de la fonction modificateur modifie la valeur de la propriété de l'objet, mais pas d'une valeur égale à changement.

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>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur augmente la valeur numérique de la propriété de l'objet.

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>(modificateur: Function, objet: T, propriété: string, changement: number, message?: string) => void

Vérifie que l'exécution de la fonction modificateur augmente la valeur numérique de la propriété de l'objet d'une valeur égale à changement.

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>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur n'augmente pas la valeur numérique de la propriété de l'objet.

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>(modificateur: Function, objet: T, propriété: string, changement: number, message?: string) => void

Vérifie que l'exécution de la fonction modificateur augmente la valeur numérique de la propriété de l'objet, mais pas d'une valeur égale à changement.

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>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur diminue la valeur numérique de la propriété de l'objet.

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>(modificateur: Function, objet: T, propriété: string, changement: number, message?: string) => void

Vérifie que l'exécution de la fonction modificateur diminue la valeur numérique de la propriété de l'objet d'une valeur égale à changement.

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>(modificateur: Function, objet: T, propriété: string, message?: string) => void

Vérifie que l'exécution de la fonction modificateur ne diminue pas la valeur numérique de la propriété de l'objet.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Vérifie qu'un modifier ne diminue pas la valeur d'une property numérique d'un object, ou la valeur retournée par un modifier, d'un montant change spécifié.

import { assert, test } from 'vitest';

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

decreasesButNotBy

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

Vérifie qu'un modifier diminue la valeur d'une property numérique d'un object, ou la valeur retournée par un modifier, mais pas d'un montant change spécifié.

import { assert, test } from 'vitest';

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

ifError

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

Vérifie que object n'est pas une valeur "truthy" (évaluant à vrai), et lance une erreur si c'est le cas. Ceci a été ajouté pour permettre à chai d'être un remplacement immédiat de la classe assert de Node.

import { assert, test } from 'vitest';

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

isExtensible

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

Vérifie que object est extensible (de nouvelles propriétés peuvent lui être ajoutées).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Vérifie que object n'est pas extensible (de nouvelles propriétés ne peuvent pas lui être ajoutées).

import { assert, test } from 'vitest';

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

  assert.isNotExtensible(nonExtensibleObject);
  assert.isNotExtensible(sealedObject);
  assert.isNotExtensible(frozenObject);
});

isSealed

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

Vérifie que object est scellé (de nouvelles propriétés ne peuvent pas lui être ajoutées et les propriétés existantes ne peuvent pas être supprimées).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Vérifie que object n'est pas scellé (de nouvelles propriétés peuvent lui être ajoutées et les propriétés existantes peuvent être supprimées).

import { assert, test } from 'vitest';

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

isFrozen

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

Vérifie que object est gelé (de nouvelles propriétés ne peuvent pas lui être ajoutées et les propriétés existantes ne peuvent pas être modifiées).

import { assert, test } from 'vitest';

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

isNotFrozen

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

Vérifie que object n'est pas gelé (de nouvelles propriétés peuvent lui être ajoutées et les propriétés existantes peuvent être modifiées).

import { assert, test } from 'vitest';

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

isEmpty

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

Vérifie que target ne contient aucune valeur. Pour les tableaux et les chaînes de caractères, elle vérifie la propriété length. Pour les instances Map et Set, elle vérifie la propriété size. Pour les objets non-fonction, elle compte le nombre de propriétés propres énumérables (clés de type chaîne de caractères).

import { assert, test } from 'vitest';

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

isNotEmpty

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

Vérifie que target contient des valeurs. Pour les tableaux et les chaînes de caractères, elle vérifie la propriété length. Pour les instances Map et Set, elle vérifie la propriété size. Pour les objets non-fonction, elle compte le nombre de propriétés propres énumérables (clés de type chaîne de caractères).

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