assert

Vitest reexporta el método assert de chai para verificar invariantes.

assert

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

Afirma que la expression dada es verdadera; de lo contrario, la aserción falla.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo no debería ser igual a bar');
});

fail

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

Fuerza un fallo en la aserción.

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('mensaje de error en caso de fallo');
  assert.fail('foo', 'bar', 'foo no es bar', '===');
});

isOk

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

Afirma que el value dado es un valor verdadero (truthy).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'cualquier valor verdadero es ok');
  assert.isOk(false, 'esto fallará ya que false no es un valor verdadero');
});

isNotOk

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

Afirma que el value dado es un valor falso (falsy).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'esto fallará, ya que "foo" es un valor verdadero');
  assert.isNotOk(false, 'esto pasará ya que false es un valor falso');
});

equal

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

Afirma la igualdad no estricta (==) de actual y expected.

import { assert, test } from 'vitest';

test('assert.equal', () => {
  assert.equal(Math.sqrt(4), '2', 'la raíz cuadrada de 4 es 2');
});

notEqual

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

Afirma la desigualdad no estricta (!=) de actual y expected.

import { assert, test } from 'vitest';

test('assert.notEqual', () => {
  assert.notEqual(Math.sqrt(4), 3, 'la raíz cuadrada de 4 no es 3');
});

strictEqual

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

Afirma la igualdad estricta (===) de actual y expected.

import { assert, test } from 'vitest';

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

deepEqual

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

Afirma que actual es profundamente igual a expected.

import { assert, test } from 'vitest';

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

notDeepEqual

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

Afirma que actual no es profundamente igual a expected.

import { assert, test } from 'vitest';

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

isAbove

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

Afirma que valueToCheck es estrictamente mayor que (>) valueToBeAbove.

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 es estrictamente mayor que 2');
});

isAtLeast

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

Afirma que valueToCheck es mayor o igual que (>=) valueToBeAtLeast.

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 es mayor o igual que 2');
  assert.isAtLeast(3, 3, '3 es mayor o igual que 3');
});

isBelow

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

Afirma que valueToCheck es estrictamente menor que (<) valueToBeBelow.

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 is strictly less than 6');
});

isAtMost

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

Afirma que valueToCheck es menor o igual que (<=) valueToBeAtMost.

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 es menor o igual que 6');
  assert.isAtMost(4, 4, '4 es menor o igual que 4');
});

isTrue

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

Afirma que value es true.

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

Afirma que value no es true.

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

Afirma que value es false.

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

Afirma que value no es false.

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

Afirma que value es null.

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, 'el error es nulo');
});

isNotNull

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

Afirma que value no es null.

import { assert, test } from 'vitest';

const error = { message: 'se produjo un error' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'el error no es nulo, sino un objeto');
});

isNaN

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

Afirma que value es NaN (Not-a-Number).

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

Afirma que value no es NaN (Not-a-Number).

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 no es NaN, sino 2');
});

exists

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

Afirma que value no es ni null ni undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo no es ni nulo ni indefinido');
});

notExists

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

Afirma que value es null o undefined.

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo es nulo, por lo tanto no existe');
  assert.notExists(bar, 'bar es indefinido, por lo tanto no existe');
});

isUndefined

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

Afirma que value es undefined.

import { assert, test } from 'vitest';

const name = undefined;

test('assert.isUndefined', () => {
  assert.isUndefined(name, 'name es indefinido');
});

isDefined

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

Afirma que value no es undefined.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name no es indefinido');
});

isFunction

• Tipo: <T>(value: T, message?: string) => void
• Alias: isCallable Afirma que value es una función.

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name es una función');
});

isNotFunction

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

Afirma que value no es una función.

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name no es una función, sino una cadena');
});

isObject

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

Afirma que value es un objeto de tipo Object (según Object.prototype.toString). Esta aserción no coincide con objetos de subclase.

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing es un objeto');
});

isNotObject

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

Afirma que value no es un objeto de tipo Object (según Object.prototype.toString). Esta aserción no coincide con objetos de subclase.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing no es un objeto, sino una cadena');
});

isArray

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

Afirma que value es un array.

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color es un array');
});

isNotArray

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

Afirma que value no es un array.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color no es un array, sino una cadena');
});

isString

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

Afirma que value es una cadena.

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color es una cadena');
});

isNotString

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

Afirma que value no es una cadena.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color no es una cadena, sino un array');
});

isNumber

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

Afirma que value es un número.

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors es un número');
});

isNotNumber

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

Afirma que value no es un número.

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors no es un número, sino una cadena');
});

isFinite

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

Afirma que value es un número finito (no NaN, Infinity).

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors es un número, no NaN o Infinity');
});

isBoolean

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

Afirma que value es un booleano.

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady es un booleano');
});

isNotBoolean

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

Afirma que value no es un booleano.

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady no es un booleano, sino una cadena');
});

typeOf

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

Afirma que el tipo de value es name, según lo determinado por Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'tenemos un objeto');
  assert.typeOf(['red', 'green'], 'array', 'tenemos un array');
  assert.typeOf('red', 'string', 'tenemos una cadena');
  assert.typeOf(/red/, 'regexp', 'tenemos una expresión regular');
  assert.typeOf(null, 'null', 'tenemos un nulo');
  assert.typeOf(undefined, 'undefined', 'tenemos un indefinido');
});

notTypeOf

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

Afirma que el tipo de value no es name, según lo determinado por Object.prototype.toString.

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" no es un número');
});

instanceOf

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

Afirma que value es una instancia 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 es una instancia de Person');
  assert.instanceOf(coffee, Tea, 'coffee es una instancia de Tea');
});

notInstanceOf

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

Afirma que value no es una instancia 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 no es una instancia de Tea');
});

include

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un valor en un array, una subcadena en una cadena o un subconjunto de propiedades en un objeto.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'el array contiene el valor');
  assert.include('foobar', 'foo', 'la cadena contiene la subcadena');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'el objeto contiene la propiedad'
  );
});

notInclude

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un valor en un array, una subcadena en una cadena o un subconjunto de propiedades en un objeto.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, 'el array no contiene 4');
  assert.notInclude('foobar', 'baz', 'foobar no contiene baz');
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    'el objeto no contiene la propiedad'
  );
});

deepInclude

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un valor en un array o un subconjunto de propiedades en un objeto. Se utiliza la igualdad profunda.

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

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un valor en un array o un subconjunto de propiedades en un objeto. Se utiliza la igualdad profunda.

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

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un subconjunto de propiedades en un objeto. Permite el uso de notación de puntos y corchetes para referenciar propiedades anidadas. Los caracteres '[]' y '.' en los nombres de las propiedades pueden escaparse usando doble barra invertida (\\).

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

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un subconjunto de propiedades en un objeto. Permite el uso de notación de puntos y corchetes para referenciar propiedades anidadas. Los caracteres '[]' y '.' en los nombres de las propiedades pueden escaparse usando doble barra invertida (\\).

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

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un subconjunto de propiedades en un objeto mientras se verifica la igualdad profunda. Permite el uso de notación de puntos y corchetes para referenciar propiedades anidadas. Los caracteres '[]' y '.' en los nombres de las propiedades pueden escaparse usando doble barra invertida (\\).

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

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un subconjunto de propiedades en un objeto mientras se verifica la igualdad profunda. Permite el uso de notación de puntos y corchetes para referenciar propiedades anidadas. Los caracteres '[]' y '.' en los nombres de las propiedades pueden escaparse usando doble barra invertida (\\).

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

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un subconjunto de propiedades en un objeto ignorando las propiedades heredadas.

import { assert, test } from 'vitest';

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

notOwnInclude

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un subconjunto de propiedades en un objeto ignorando las propiedades heredadas.

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

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

Afirma que haystack incluye needle. Puede usarse para afirmar la inclusión de un subconjunto de propiedades en un objeto ignorando las propiedades heredadas y verificando la igualdad profunda.

import { assert, test } from 'vitest';

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

notDeepOwnInclude

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

Afirma que haystack no incluye needle. Puede usarse para afirmar la ausencia de un subconjunto de propiedades en un objeto ignorando las propiedades heredadas y verificando la igualdad profunda.

import { assert, test } from 'vitest';

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

match

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

Afirma que value coincide con la expresión regular regexp.

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'la expresión regular coincide');
});

notMatch

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

Afirma que value no coincide con la expresión regular regexp.

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'la expresión regular no coincide');
});

property

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

Afirma que object tiene una propiedad directa o heredada con el nombre property.

import { assert, test } from 'vitest';

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

notProperty

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

Afirma que object no tiene una propiedad directa o heredada con el nombre property.

import { assert, test } from 'vitest';

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

propertyVal

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

Afirma que object tiene una propiedad directa o heredada con el nombre property y un valor dado por value. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

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

notPropertyVal

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

Afirma que object no tiene una propiedad directa o heredada con el nombre property y un valor dado por value. Utiliza una comprobación de igualdad estricta (===).

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

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

Afirma que object tiene una propiedad directa o heredada con el nombre property y un valor dado por value. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

Afirma que object no tiene una propiedad directa o heredada con el nombre property y un valor dado por value. Utiliza una comprobación de igualdad profunda.

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

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

Afirma que object tiene una propiedad directa o heredada con el nombre property, que puede ser una cadena usando notación de puntos y corchetes para referencia anidada.

import { assert, test } from 'vitest';

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

notNestedProperty

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

Afirma que object no tiene una propiedad directa o heredada con el nombre property, que puede ser una cadena usando notación de puntos y corchetes para referencia anidada.

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

Afirma que object tiene una propiedad con el nombre property y un valor dado por value. property puede usar notación de puntos y corchetes para referencia anidada. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

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

notNestedPropertyVal

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

Afirma que object no tiene una propiedad con el nombre property y un valor dado por value. property puede usar notación de puntos y corchetes para referencia anidada. Utiliza una comprobación de igualdad estricta (===).

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

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

Afirma que object tiene una propiedad con el nombre property y un valor dado por value. property puede usar notación de puntos y corchetes para referencia anidada. Utiliza una comprobación de igualdad profunda.

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

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

Afirma que object no tiene una propiedad con el nombre property y un valor dado por value. property puede usar notación de puntos y corchetes para referencia anidada. Utiliza una comprobación de igualdad profunda.

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

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

Afirma que object tiene una longitud o un tamaño con el valor esperado.

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'el array tiene una longitud de 3');
  assert.lengthOf('foobar', 6, 'la cadena tiene una longitud de 6');
  assert.lengthOf(new Set([1, 2, 3]), 3, 'el conjunto tiene un tamaño de 3');
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'el mapa tiene un tamaño de 3'
  );
});

hasAnyKeys

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

Afirma que object tiene al menos una de las claves proporcionadas. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object tiene todas y solo todas las claves proporcionadas. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object tiene todas las claves proporcionadas, pero puede tener claves adicionales no listadas. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object no tiene ninguna de las claves proporcionadas. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object no tiene al menos una de las claves proporcionadas. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object tiene al menos una de las claves proporcionadas. Dado que los Sets y Maps pueden tener objetos como claves, puedes usar esta aserción para realizar una comparación profunda. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object tiene todas y solo todas las claves proporcionadas. Dado que los Sets y Maps pueden tener objetos como claves, puedes usar esta aserción para realizar una comparación profunda. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object contiene todas las claves proporcionadas. Dado que los Sets y Maps pueden tener objetos como claves, puedes usar esta aserción para realizar una comparación profunda. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object no tiene ninguna de las claves proporcionadas. Dado que los Sets y Maps pueden tener objetos como claves, puedes usar esta aserción para realizar una comparación profunda. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

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

Afirma que object no tiene al menos una de las claves proporcionadas. Dado que los Sets y Maps pueden tener objetos como claves, puedes usar esta aserción para realizar una comparación profunda. También puedes proporcionar un solo objeto en lugar de un array de claves, y sus claves se usarán como el conjunto esperado de claves.

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

• Tipo:
  • (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 es un constructor de Error, afirma que fn lanzará un error que es una instancia de errorLike. Si errorLike es una instancia de Error, afirma que el error lanzado es la misma instancia que errorLike. Si se proporciona errMsgMatcher, también afirma que el error lanzado tendrá un mensaje que coincida con errMsgMatcher.

import { assert, test } from 'vitest';

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

doesNotThrow

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

Si errorLike es un constructor de Error, afirma que fn no lanzará un error que sea una instancia de errorLike. Si errorLike es una instancia de Error, afirma que el error lanzado no es la misma instancia que errorLike. Si se proporciona errMsgMatcher, también afirma que el error lanzado no tendrá un mensaje que coincida con errMsgMatcher.

import { assert, test } from 'vitest';

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

operator

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

Compara val1 y val2 usando operator.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'todo está bien');
});

closeTo

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

Afirma que actual es igual a expected, dentro de un rango de +/- delta.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'los números están cerca');
});

sameMembers

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

Afirma que set1 y set2 tienen los mismos miembros en cualquier orden. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

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

notSameMembers

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

Afirma que set1 y set2 no tienen los mismos miembros en ningún orden. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'no son los mismos miembros');
});

sameDeepMembers

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

Afirma que set1 y set2 tienen los mismos miembros en cualquier orden. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'mismos miembros profundos'
  );
});

notSameDeepMembers

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

Afirma que set1 y set2 no tienen los mismos miembros en ningún orden. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'no son los mismos miembros profundos'
  );
});

sameOrderedMembers

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

Afirma que set1 y set2 tienen los mismos miembros en el mismo orden. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'mismos miembros ordenados');
});

notSameOrderedMembers

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

Afirma que set1 y set2 no tienen los mismos miembros en el mismo orden. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'no son los mismos miembros ordenados'
  );
});

sameDeepOrderedMembers

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

Afirma que set1 y set2 tienen los mismos miembros en el mismo orden. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'mismos miembros ordenados profundamente'
  );
});

notSameDeepOrderedMembers

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

Afirma que set1 y set2 no tienen los mismos miembros en el mismo orden. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'no son los mismos miembros ordenados profundamente'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'no son los mismos miembros ordenados profundamente'
  );
});

includeMembers

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

Afirma que subset está incluido en superset en cualquier orden. Utiliza una comprobación de igualdad estricta (===). Los duplicados se ignoran.

import { assert, test } from 'vitest';

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

notIncludeMembers

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

Afirma que subset no está incluido en superset en ningún orden. Utiliza una comprobación de igualdad estricta (===). Los duplicados se ignoran.

import { assert, test } from 'vitest';

test('assert.notIncludeMembers', () => {
  assert.notIncludeMembers([1, 2, 3], [5, 1], 'no incluir miembros');
});

includeDeepMembers

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

Afirma que subset está incluido en superset en cualquier orden. Utiliza una comprobación de igualdad profunda. Los duplicados se ignoran.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'incluir miembros profundos'
  );
});

notIncludeDeepMembers

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

Afirma que subset no está incluido en superset en ningún orden. Utiliza una comprobación de igualdad profunda. Los duplicados se ignoran.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'no incluir miembros profundos'
  );
});

includeOrderedMembers

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

Afirma que subset está incluido en superset en el mismo orden, comenzando con el primer elemento en superset. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers([1, 2, 3], [1, 2], 'incluir miembros ordenados');
});

notIncludeOrderedMembers

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

Afirma que subset no está incluido en superset en el mismo orden, comenzando con el primer elemento en superset. Utiliza una comprobación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notIncludeOrderedMembers', () => {
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 1],
    'no incluir miembros ordenados'
  );
  assert.notIncludeOrderedMembers(
    [1, 2, 3],
    [2, 3],
    'no incluir miembros ordenados'
  );
});

includeDeepOrderedMembers

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

Afirma que subset está incluido en superset en el mismo orden, comenzando con el primer elemento en superset. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'incluir miembros ordenados profundamente'
  );
});

notIncludeDeepOrderedMembers

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

Afirma que subset no está incluido en superset en el mismo orden, comenzando con el primer elemento en superset. Utiliza una comprobación de igualdad profunda.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'no incluir miembros ordenados profundamente'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'no incluir miembros ordenados profundamente'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'no incluir miembros ordenados profundamente'
  );
});

oneOf

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

Afirma que el valor no-objeto, no-array inList aparece en el array plano list.

import { assert, test } from 'vitest';

test('assert.oneOf', () => {
  assert.oneOf(1, [2, 1], 'No encontrado en la lista');
});

changes

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

Afirma que un modifier cambia la propiedad de 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

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

Afirma que un modifier cambia la propiedad de un object en una cantidad change.

import { assert, test } from 'vitest';

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

doesNotChange

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

Afirma que un modifier no cambia la propiedad de 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

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

Afirma que un modifier cambia la propiedad de un object o el valor de retorno de un modifier, pero no en la cantidad change especificada.

import { assert, test } from 'vitest';

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

increases

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

Afirma que un modifier aumenta la propiedad numérica de 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

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

Afirma que un modifier aumenta la propiedad numérica de un object o el valor de retorno de un modifier en una cantidad change.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Afirma que un modifier no aumenta la propiedad numérica de 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

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

Afirma que un modifier aumenta la propiedad numérica de un object o el valor de retorno de un modifier, pero no en la cantidad change especificada.

import { assert, test } from 'vitest';

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

decreases

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

Afirma que un modifier disminuye la propiedad numérica de 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

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

Afirma que un modifier disminuye la propiedad numérica de un object o el valor de retorno de un modifier en una cantidad change.

import { assert, test } from 'vitest';

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

doesNotDecrease

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

Afirma que un modifier no disminuye la propiedad numérica de 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

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

Afirma que un modifier no disminuye la propiedad numérica de un object o el valor de retorno de un modifier en una cantidad change.

import { assert, test } from 'vitest';

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

decreasesButNotBy

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

Afirma que un modifier disminuye la propiedad numérica de un object o el valor de retorno de un modifier, pero no en la cantidad change especificada.

import { assert, test } from 'vitest';

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

ifError

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

Afirma si object no es un valor falso (falsy), y lanza un error si es un valor verdadero (truthy). Esto se añade para permitir que Chai sea un reemplazo directo de la clase assert de Node.

import { assert, test } from 'vitest';

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

isExtensible

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

Afirma que object es extensible (se le pueden añadir nuevas propiedades).

import { assert, test } from 'vitest';

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

isNotExtensible

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

Afirma que object no es extensible (no se le pueden añadir nuevas propiedades).

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

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

Afirma que object está sellado (no se le pueden añadir nuevas propiedades y sus propiedades existentes no se pueden eliminar).

import { assert, test } from 'vitest';

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

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

isNotSealed

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

Afirma que object no está sellado (se le pueden añadir nuevas propiedades o sus propiedades existentes se pueden eliminar).

import { assert, test } from 'vitest';

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

isFrozen

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

Afirma que el objeto está congelado (no se le pueden añadir nuevas propiedades y sus propiedades existentes no se pueden modificar).

import { assert, test } from 'vitest';

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

isNotFrozen

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

Afirma que object no está congelado (se le pueden añadir nuevas propiedades o sus propiedades existentes se pueden modificar).

import { assert, test } from 'vitest';

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

isEmpty

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

Afirma que target no contiene ningún valor. Para arrays y cadenas, comprueba la propiedad length. Para instancias de Map y Set, comprueba la propiedad size. Para objetos que no son funciones, obtiene el recuento de sus propias claves de cadena enumerables.

import { assert, test } from 'vitest';

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

isNotEmpty

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

Afirma que target contiene valores. Para arrays y cadenas, comprueba la propiedad length. Para instancias de Map y Set, comprueba la propiedad size. Para objetos que no son funciones, obtiene el recuento de sus propias claves de cadena enumerables.

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