assert

Vitest réexporte la méthode assert de chai pour la vérification des invariants.

assert

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

Affirme que l'expression donnée est vraie, sinon l'assertion échouera.

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

Provoque un échec d'assertion.

import { assert, test } from 'vitest';

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

isOk

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

Affirme que la value donnée est une valeur vraie (truthy).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'toute valeur truthy est ok');
  assert.isOk(false, 'ceci échouera car false n\'est pas truthy');
});

isNotOk

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

Affirme que la value donnée est une valeur fausse (falsy).

import { assert, test } from 'vitest';

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

equal

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

Affirme l'égalité non stricte (==) de 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

Affirme l'inégalité non stricte (!=) de actual et expected.

import { assert, test } from 'vitest';

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

strictEqual

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

Affirme l'égalité stricte (===) de 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

Affirme 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

Affirme 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

Affirme 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

Affirme 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

Affirme 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

Affirme 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

Affirme que value est true.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Affirme que value n'est pas true.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Affirme que value est false.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Affirme que value n'est pas false.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Affirme que value est null.

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, 'l\'erreur est nulle');
});

isNotNull

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

Affirme que value n'est pas null.

import { assert, test } from 'vitest';

const error = { message: 'une erreur s\'est produite' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'l\'erreur n\'est pas nulle mais un objet');
});

isNaN

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

Affirme que value est NaN (Not a Number).

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Affirme que value n'est pas NaN.

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

Affirme 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

Affirme 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

Affirme que value est undefined.

import { assert, test } from 'vitest';

const name = undefined;

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

isDefined

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

Affirme que value n'est pas undefined.

import { assert, test } from 'vitest';

const name = 'foo';

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

isFunction

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

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

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

isNotFunction

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

Affirme que value n'est pas une fonction.

import { assert, test } from 'vitest';

const name = 'foo';

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

isObject

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

Affirme que value est un objet de type Object (tel que révélé 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

Affirme que value n'est pas un objet de type Object (tel que révélé par Object.prototype.toString). L'assertion ne correspond pas aux objets sous-classés.

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

Affirme que value est un tableau.

import { assert, test } from 'vitest';

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

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

isNotArray

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

Affirme que value n'est pas un tableau.

import { assert, test } from 'vitest';

const color = 'red';

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

isString

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

Affirme que value est une chaîne de caractères.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'la couleur est une chaîne de caractères');
});

isNotString

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

Affirme 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, 'la couleur n\'est pas une chaîne de caractères mais un tableau');
});

isNumber

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

Affirme 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

Affirme 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

Affirme que value est un nombre fini (ni NaN, ni Infinity).

import { assert, test } from 'vitest';

const colors = 3;

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

isBoolean

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

Affirme 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

Affirme 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

Affirme que le type de value est 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 de caractères');
  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

Affirme que le type de value n'est 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

Affirme 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

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

Affirme que haystack inclut needle. Peut être utilisé pour affirmer l'inclusion d'une valeur dans un tableau, d'une sous-chaîne dans une chaîne, 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 la valeur');
  assert.include('foobar', 'foo', 'la chaîne 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

Affirme que haystack n'inclut pas needle. Peut être utilisé pour affirmer l'absence d'une valeur dans un tableau, d'une sous-chaîne dans une chaîne, 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 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

Affirme que haystack inclut needle. Peut être utilisé pour affirmer l'inclusion d'une valeur dans un tableau ou d'un sous-ensemble de propriétés dans un objet. L'égalité profonde est utilisée.

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

Affirme que haystack n'inclut pas needle. Peut être utilisé pour affirmer l'absence d'une valeur dans un tableau ou d'un sous-ensemble de propriétés dans un objet. L'égalité profonde est utilisée.

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

Affirme que haystack inclut needle. Peut être utilisé pour affirmer l'inclusion d'un sous-ensemble de propriétés dans un objet. Permet l'utilisation de la notation par points et crochets 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 en utilisant des doubles barres obliques inverses.

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

Affirme que haystack n'inclut pas needle. Peut être utilisé pour affirmer l'absence d'un sous-ensemble de propriétés dans un objet. Permet l'utilisation de la notation par points et crochets 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 en utilisant des doubles barres obliques inverses.

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

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

Affirme que haystack inclut needle. Peut être utilisé pour affirmer l'inclusion d'un sous-ensemble de propriétés dans un objet tout en vérifiant l'égalité profonde. Permet l'utilisation de la notation par points et crochets 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 en utilisant des doubles barres obliques inverses.

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

Affirme que haystack n'inclut pas needle. Peut être utilisé pour affirmer l'absence d'un sous-ensemble de propriétés dans un objet tout en vérifiant l'égalité profonde. Permet l'utilisation de la notation par points et crochets 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 en utilisant des doubles barres obliques inverses.

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

Affirme que haystack inclut needle. Peut être utilisé pour affirmer l'inclusion d'un sous-ensemble de propriétés dans un objet tout 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

Affirme que haystack n'inclut pas needle. Peut être utilisé pour affirmer l'absence d'un sous-ensemble de propriétés dans un objet tout 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. Peut être utilisé pour affirmer l'inclusion d'un sous-ensemble de propriétés dans un objet tout en ignorant les propriétés héritées et en vérifiant l'égalité profonde.

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. Peut être utilisé pour affirmer l'absence d'un sous-ensemble de propriétés dans un objet tout en ignorant les propriétés héritées et en vérifiant l'égalité profonde.

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 value correspond à l'expression régulière regexp.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'l\'expression régulière correspond');
});

notMatch

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

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

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'l\'expression régulière ne correspond pas');
});

property

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

Affirme que object a une propriété directe ou héritée nommée par 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 n'a pas de propriété directe ou héritée nommée par 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 a une propriété directe ou héritée nommée par property avec une valeur donnée par value. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Affirme que object n'a pas de propriété directe ou héritée nommée par property avec une valeur donnée par value. Utilise une vérification d'égalité stricte (===).

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 a une propriété directe ou héritée nommée par property avec une valeur donnée par value. Utilise une vérification d'égalité profonde.

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 n'a pas de propriété directe ou héritée nommée par property avec une valeur donnée par value. Utilise une vérification d'égalité profonde.

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

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

Affirme que object a une propriété directe ou héritée nommée par property, qui peut être une chaîne de caractères utilisant la notation par points et crochets pour une référence imbriquée.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Affirme que object n'a pas de propriété directe ou héritée nommée par property, qui peut être une chaîne de caractères utilisant la notation par points et crochets pour une référence imbriquée.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Affirme que object a une propriété nommée par property avec la valeur donnée par value. property peut utiliser la notation par points et crochets pour une référence imbriquée. Utilise une vérification d'égalité stricte (===).

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 n'a pas de propriété nommée par property avec la valeur donnée par value. property peut utiliser la notation par points et crochets pour une référence imbriquée. Utilise une vérification d'égalité stricte (===).

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 a une propriété nommée par property avec une valeur donnée par value. property peut utiliser la notation par points et crochets pour une référence imbriquée. Utilise une vérification d'égalité profonde.

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

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

Affirme que object n'a pas de propriété nommée par property avec la valeur donnée par value. property peut utiliser la notation par points et crochets pour une référence imbriquée. Utilise une vérification d'égalité profonde.

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 a une length ou size avec la valeur attendue.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'le tableau a une longueur de 3');
  assert.lengthOf('foobar', 6, 'la chaîne a une longueur de 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'l\'ensemble a une taille de 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'la carte a une taille de 3'
  );
});

hasAnyKeys

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

Affirme que object a au moins une des keys fournies. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et ses 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 a toutes les keys fournies, et seulement celles-ci. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et ses 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 a toutes les keys fournies, mais peut avoir des clés supplémentaires non listées. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et ses 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

Affirme que object n'a aucune des keys fournies. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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

Affirme que object n'a pas au moins une des keys fournies. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et ses clés seront utilisées comme ensemble de clés attendu.

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

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

Affirme que object a au moins une des keys fournies. Étant donné que les ensembles (Set) et les cartes (Map) peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison profonde. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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

Affirme que object a toutes les keys fournies, et seulement celles-ci. Étant donné que les ensembles (Set) et les cartes (Map) peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison profonde. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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

Affirme que object contient toutes les keys fournies. Étant donné que les ensembles (Set) et les cartes (Map) peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison profonde. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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

Affirme que object n'a aucune des keys fournies. Étant donné que les ensembles (Set) et les cartes (Map) peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison profonde. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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

Affirme que object n'a pas au moins une des keys fournies. Étant donné que les ensembles (Set) et les cartes (Map) peuvent avoir des objets comme clés, vous pouvez utiliser cette assertion pour effectuer une comparaison profonde. Vous pouvez également fournir un seul objet au lieu d'un tableau de clés, et 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, affirme que fn lancera une erreur qui est une instance de errorLike. Si errorLike est une instance d'erreur, affirme que l'erreur lancée est la même instance que errorLike. Si errMsgMatcher est fourni, il affirme également que l'erreur lancée aura un message correspondant à errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'L\'erreur lancée doit avoir ce message');
  assert.throws(fn, /L\'erreur lancée doit avoir un message qui correspond à ceci/);
  assert.throws(fn, ReferenceError);
  assert.throws(fn, errorInstance);
  assert.throws(
    fn,
    ReferenceError,
    'L\'erreur lancée doit être une ReferenceError et avoir ce message'
  );
  assert.throws(
    fn,
    errorInstance,
    'L\'erreur lancée doit être la même instance d\'erreur et avoir ce message'
  );
  assert.throws(
    fn,
    ReferenceError,
    /L\'erreur lancée doit être une ReferenceError et correspondre à ceci/
  );
  assert.throws(
    fn,
    errorInstance,
    /L\'erreur lancé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, affirme que fn ne lancera pas d'erreur qui est une instance de errorLike. Si errorLike est une instance d'erreur, affirme que l'erreur lancée n'est pas la même instance que errorLike. Si errMsgMatcher est fourni, il affirme également que l'erreur lancée n'aura pas de message correspondant à errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Toute erreur lancée ne doit pas avoir ce message');
  assert.doesNotThrow(fn, /Toute erreur lancée ne doit pas correspondre à ceci/);
  assert.doesNotThrow(fn, Error);
  assert.doesNotThrow(fn, errorInstance);
  assert.doesNotThrow(fn, Error, 'L\'erreur ne doit pas avoir ce message');
  assert.doesNotThrow(fn, errorInstance, 'L\'erreur ne doit pas avoir ce message');
  assert.doesNotThrow(fn, Error, /L\'erreur ne doit pas correspondre à ceci/);
  assert.doesNotThrow(fn, errorInstance, /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.

import { assert, test } from 'vitest';

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

closeTo

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

Affirme que actual est égal à expected, à une plage de +/- delta près.

import { assert, test } from 'vitest';

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

sameMembers

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

Affirme que set1 et set2 ont les mêmes membres dans n'importe quel ordre. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Affirme que set1 et set2 n'ont pas les mêmes membres dans n'importe quel ordre. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'pas les mêmes membres');
});

sameDeepMembers

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

Affirme que set1 et set2 ont les mêmes membres dans n'importe quel ordre. Utilise une vérification d'égalité profonde.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'mêmes membres profonds'
  );
});

notSameDeepMembers

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

Affirme que set1 et set2 n'ont pas les mêmes membres dans n'importe quel ordre. Utilise une vérification d'égalité profonde.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'pas les mêmes membres profonds'
  );
});

sameOrderedMembers

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

Affirme que set1 et set2 ont les mêmes membres dans le même ordre. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

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

notSameOrderedMembers

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

Affirme que set1 et set2 n'ont pas les mêmes membres dans le même ordre. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'pas les mêmes membres ordonnés'
  );
});

sameDeepOrderedMembers

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

Affirme que set1 et set2 ont les mêmes membres dans le même ordre. Utilise une vérification d'égalité profonde.

import { assert, test } from 'vitest';

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

notSameDeepOrderedMembers

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

Affirme que set1 et set2 n'ont pas les mêmes membres dans le même ordre. Utilise une vérification 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 }],
    'pas les mêmes membres ordonnés profonds'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'pas les mêmes membres ordonnés profonds'
  );
});

includeMembers

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

Affirme que subset est inclus dans superset dans n'importe quel ordre. Utilise une vérification d'égalité stricte (===). Les doublons sont ignorés.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'inclure les membres');
});

notIncludeMembers

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

Affirme que subset n'est pas inclus dans superset dans n'importe quel ordre. Utilise une vérification d'égalité stricte (===). Les doublons sont ignorés.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'ne pas inclure les membres');
});

includeDeepMembers

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

Affirme que subset est inclus dans superset dans n'importe quel ordre. Utilise une vérification d'égalité profonde. Les doublons 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 }],
    'inclure les membres profonds'
  );
});

notIncludeDeepMembers

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

Affirme que subset n'est pas inclus dans superset dans n'importe quel ordre. Utilise une vérification d'égalité profonde. Les doublons sont ignorés.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'ne pas inclure les membres profonds'
  );
});

includeOrderedMembers

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

Affirme que subset est inclus dans superset dans le même ordre, en commençant par le premier élément de superset. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'inclure les membres ordonnés');
});

notIncludeOrderedMembers

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

Affirme que subset n'est pas inclus dans superset dans le même ordre, en commençant par le premier élément de superset. Utilise une vérification d'égalité stricte (===).

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'ne pas inclure les membres ordonnés'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'ne pas inclure les membres ordonnés'
  );
});

includeDeepOrderedMembers

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

Affirme que subset est inclus dans superset dans le même ordre, en commençant par le premier élément de superset. Utilise une vérification d'égalité profonde.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'inclure les membres ordonnés profonds'
  );
});

notIncludeDeepOrderedMembers

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

Affirme que subset n'est pas inclus dans superset dans le même ordre, en commençant par le premier élément de superset. Utilise une vérification d'égalité profonde.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'ne pas inclure les membres ordonnés profonds'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'ne pas inclure les membres ordonnés profonds'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'ne pas inclure les membres ordonnés profonds'
  );
});

oneOf

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

Affirme que la valeur non-objet, non-tableau inList apparaît dans le tableau plat list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'Non trouvé dans la liste');
});

changes

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

Affirme qu'un modifier modifie la property d'un object.

import { assert, test } from 'vitest';

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

changesBy

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

Affirme qu'un modifier modifie la property d'un object d'une change spécifique.

import { assert, test } from 'vitest';

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

doesNotChange

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

Affirme qu'un modifier ne modifie pas la property d'un object.

import { assert, test } from 'vitest';

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

changesButNotBy

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

Affirme qu'un modifier modifie la property d'un object ou la valeur de retour d'un modifier, mais pas d'une change spécifique.

import { assert, test } from 'vitest';

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

increases

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

Affirme qu'un modifier augmente la property numérique d'un object.

import { assert, test } from 'vitest';

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

increasesBy

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

Affirme qu'un modifier augmente la property numérique d'un object ou la valeur de retour d'un modifier d'une change spécifique.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Affirme qu'un modifier n'augmente pas la property numérique d'un object.

import { assert, test } from 'vitest';

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

increasesButNotBy

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

Affirme qu'un modifier augmente la property numérique d'un object ou la valeur de retour d'un modifier, mais pas d'une change spécifique.

import { assert, test } from 'vitest';

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

decreases

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

Affirme qu'un modifier diminue la property numérique d'un object.

import { assert, test } from 'vitest';

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

decreasesBy

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

Affirme qu'un modifier diminue la property numérique d'un object ou la valeur de retour d'un modifier d'une change spécifique.

import { assert, test } from 'vitest';

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

doesNotDecrease

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

Affirme qu'un modifier ne diminue pas la property numérique d'un object.

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

Affirme qu'un modifier ne diminue pas la property numérique d'un object ou la valeur de retour d'un modifier d'une change spécifique.

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

Affirme qu'un modifier diminue la property numérique d'un object ou la valeur de retour d'un modifier, mais pas de la quantité spécifiée.

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

Affirme si object n'est pas une valeur fausse (falsy), et lance une erreur si c'est une valeur vraie (truthy). Ceci est ajouté pour permettre à Chai d'être un remplacement direct de la classe assert de Node.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('Je suis une erreur personnalisée');
  assert.ifError(err); // Relance l'erreur !
});

isExtensible

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

Affirme 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

Affirme 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

Affirme que object est scellé (de nouvelles propriétés ne peuvent pas lui être ajoutées et ses 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.freeze({});

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

isNotSealed

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

Affirme que object n'est pas scellé (de nouvelles propriétés peuvent lui être ajoutées ou ses 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

Affirme que l'objet est gelé (de nouvelles propriétés ne peuvent pas lui être ajoutées et ses 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

Affirme que object n'est pas gelé (de nouvelles propriétés peuvent lui être ajoutées ou ses 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

Affirme que la 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 de Map et Set, elle vérifie la propriété size. Pour les objets non-fonctionnels, elle obtient le nombre de leurs propres clés de chaîne énumérables.

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

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

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