assert

Vitest reexporta el método assert desde chai para realizar verificaciones de invariantes.

assert

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

Afirma que la expression dada es verdadera. Si la expresión es falsa, la aserción fallará.

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo no debe 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 igual a bar', '===');
});

isOk

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

Afirma que el value dado es "truthy" (verdadero según la coerción de JavaScript).

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'Cualquier valor truthy es ok');
  assert.isOk(false, 'Esto fallará porque false no es truthy');
});

isNotOk

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

Afirma que el value dado es "falsy" (falso según la coerción de JavaScript).

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk('foo', 'Esto fallará, cualquier valor truthy no es ok');
  assert.isNotOk(false, 'Esto pasará porque false es falsy');
});

equal

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

Afirma que actual y expected son iguales utilizando el operador de igualdad no estricta (==).

import { assert, test } from 'vitest';

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

notEqual

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

Afirma que actual y expected no son iguales utilizando el operador de desigualdad no estricta (!=).

import { assert, test } from 'vitest';

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

strictEqual

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

Afirma la igualdad estricta (===) entre 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. Compara recursivamente las propiedades de los objetos.

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 ( valueToCheck > 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 ( valueToCheck >= 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 ( valueToCheck < valueToBeBelow).

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 es estrictamente menor que 6');
});

isAtMost

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

Afirma que valueToCheck es menor o igual que valueToBeAtMost ( valueToCheck <= 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 estrictamente verdadero (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 estrictamente verdadero (true). Es decir, no es igual a 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 estrictamente falso (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 estrictamente falso (false). Es decir, no es igual a 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 nulo (null).

import { assert, test } from 'vitest';

const error = null;

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

isNotNull

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

Afirma que value no es nulo (null).

import { assert, test } from 'vitest';

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

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

isNaN

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

Afirma que value es NaN (No es un Número).

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 (No es un Número).

import { assert, test } from 'vitest';

const calculation = 1 * 2;

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

exists

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

Afirma que value no es ni nulo (null) ni indefinido (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 nulo (null) o indefinido (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 indefinido (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 indefinido (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, es una cadena');
});

isObject

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

Afirma que value es un objeto del tipo Object (determinado por Object.prototype.toString). Esta aserción no se cumple para instancias de subclases de Object.

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 lo determinado por Object.prototype.toString). Esta afirmación no considera objetos de subclases.

import { assert, test } from 'vitest';

const someThing = 'redCircle';

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

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

isString

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

Afirma que value es una cadena de texto.

import { assert, test } from 'vitest';

const color = 'red';

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

isNotString

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

Afirma que value no es una cadena de texto.

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color no es una cadena de texto, 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 de texto'
  );
});

isFinite

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

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

import { assert, test } from 'vitest';

const colors = 3;

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

isBoolean

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

Afirma que value es un valor 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 valor booleano.

import { assert, test } from 'vitest';

const isReady = 'sure';

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

typeOf

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

Afirma que el tipo de value es name, según 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 de texto');
  assert.typeOf(/red/, 'regexp', 'tenemos una expresión regular');
  assert.typeOf(null, 'null', 'tenemos un valor nulo');
  assert.typeOf(undefined, 'undefined', 'tenemos un valor indefinido');
});

notTypeOf

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

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

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" no es un valor numérico');
});

instanceOf

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

Afirma que value es una instancia de la clase 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 la clase 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.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. Se utiliza para verificar la inclusión de un valor en un array, una subcadena en una cadena de texto, o un subconjunto de propiedades en un objeto.

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, 'array contiene value');
  assert.include('foobar', 'foo', 'string contiene substring');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'object contains property'
  );
});

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. Se utiliza para verificar la ausencia de un valor en un array, una subcadena en una cadena de texto, o un subconjunto de propiedades en un objeto.

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, "array doesn't contain 4");
  assert.notInclude('foobar', 'baz', "foobar doesn't contain baz");
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    "object doesn't contain property"
  );
});

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. Se utiliza para verificar la inclusión de un valor en un array o un subconjunto de propiedades en un objeto, utilizando 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. Se utiliza para verificar la ausencia de un valor en un array o un subconjunto de propiedades en un objeto, utilizando 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. Se utiliza para verificar la inclusión de un subconjunto de propiedades en un objeto. Permite usar notación de puntos y corchetes para hacer referencia a propiedades anidadas. Los caracteres ‘[]’ y ‘.’ en los nombres de las propiedades se pueden escapar utilizando 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. Se utiliza para verificar la ausencia de un subconjunto de propiedades en un objeto. Permite usar notación de puntos y corchetes para hacer referencia a propiedades anidadas. Los caracteres ‘[]’ y ‘.’ en los nombres de las propiedades se pueden escapar utilizando 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. Se utiliza para verificar la inclusión de un subconjunto de propiedades en un objeto, comprobando la igualdad profunda. Permite usar notación de puntos y corchetes para hacer referencia a propiedades anidadas. Los caracteres ‘[]’ y ‘.’ en los nombres de las propiedades se pueden escapar utilizando 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. Se utiliza para verificar la ausencia de un subconjunto de propiedades en un objeto, comprobando la igualdad profunda. Permite usar notación de puntos y corchetes para hacer referencia a propiedades anidadas. Los caracteres ‘[]’ y ‘.’ en los nombres de las propiedades se pueden escapar utilizando 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. Se utiliza para verificar que existe 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. Se utiliza para verificar 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. Se utiliza para verificar si un objeto contiene un subconjunto de propiedades, ignorando las propiedades heredadas y realizando una comparación profunda para la igualdad.

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. Se utiliza para verificar si un objeto no contiene un subconjunto de propiedades, ignorando las propiedades heredadas y realizando una comparación profunda para la igualdad.

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) llamada 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) llamada 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) llamada property con un valor igual a value. Utiliza una comparación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notPropertyVal', () => {
  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) llamada property con un valor igual a value. Utiliza una comparació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) llamada property con un valor igual a value. Utiliza una comparació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) llamada property con un valor igual a value. Utiliza una comparación de igualdad profunda.

import { assert, test } from 'vitest';

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

nestedProperty

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

Afirma que object tiene una propiedad (directa o heredada) llamada property, que puede ser una cadena que utiliza la notación de puntos o corchetes para acceder a propiedades anidadas.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  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) llamada property, que puede ser una cadena que utiliza la notación de puntos o corchetes para acceder a propiedades anidadas.

import { assert, test } from 'vitest';

test('assert.deepPropertyVal', () => {
  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 nombrada por property con un valor igual a value. property puede usar la notación de puntos o corchetes para acceder a propiedades anidadas. Utiliza una comparació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 nombrada por property con un valor igual a value. property puede usar la notación de puntos o corchetes para acceder a propiedades anidadas. Utiliza una comparació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

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

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

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 propiedad length o size 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 keys proporcionadas. También acepta un objeto en lugar de un array de claves, utilizando las claves de este objeto 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 las keys proporcionadas y solamente esas. También acepta un objeto en lugar de un array de claves, utilizando las claves de este objeto 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 keys proporcionadas, pero puede tener claves adicionales. También acepta un objeto en lugar de un array de claves, utilizando las claves de este objeto 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']));
  assert.containsAllKeys(new Set([{ foo: 'bar' }, 'anotherKey']));
});

doesNotHaveAnyKeys

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

Afirma que object no posee ninguna de las claves proporcionadas. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 posee al menos una de las claves proporcionadas. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 posee al menos una de las claves proporcionadas. Dado que los Set y Map pueden tener objetos como claves, esta afirmación permite realizar una comparación en profundidad. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 posee todas las claves proporcionadas y solo esas. Dado que los Set y Map pueden tener objetos como claves, esta afirmación permite realizar una comparación en profundidad. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 Set y Map pueden tener objetos como claves, esta afirmación permite realizar una comparación en profundidad. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 posee ninguna de las claves proporcionadas. Dado que los Set y Map pueden tener objetos como claves, esta afirmación permite realizar una comparación en profundidad. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 posee al menos una de las claves proporcionadas. Dado que los Set y Map pueden tener objetos como claves, esta afirmación permite realizar una comparación en profundidad. Se puede proporcionar un objeto individual en lugar de un array de claves, utilizando sus claves como el conjunto de claves a verificar.

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 mensaje del error lanzado coincide con errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.throws', () => {
  assert.throws(fn, 'Error thrown must have this msg'); // El error lanzado debe tener este mensaje
  assert.throws(fn, /Error thrown must have a msg that matches this/); // El error lanzado debe tener un mensaje que coincida con esta expresión regular
  assert.throws(fn, ReferenceError); // El error lanzado debe ser una instancia de ReferenceError
  assert.throws(fn, errorInstance); // El error lanzado debe ser la misma instancia de error que errorInstance
  assert.throws(
    fn,
    ReferenceError,
    'Error thrown must be a ReferenceError and have this msg' // El error lanzado debe ser una instancia de ReferenceError y tener este mensaje
  );
  assert.throws(
    fn,
    errorInstance,
    'Error thrown must be the same errorInstance and have this msg' // El error lanzado debe ser la misma instancia de error que errorInstance y tener este mensaje
  );
  assert.throws(
    fn,
    ReferenceError,
    /Error thrown must be a ReferenceError and match this/ // El error lanzado debe ser una instancia de ReferenceError y su mensaje debe coincidir con esta expresión regular
  );
  assert.throws(
    fn,
    errorInstance,
    /Error thrown must be the same errorInstance and match this/ // El error lanzado debe ser la misma instancia de error que errorInstance y su mensaje debe coincidir con esta expresión regular
  );
});

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 mensaje del error lanzado no coincide con errMsgMatcher.

import { assert, test } from 'vitest';

test('assert.doesNotThrow', () => {
  assert.doesNotThrow(fn, 'Any Error thrown must not have this message'); // Ningún error lanzado debe tener este mensaje
  assert.doesNotThrow(fn, /Any Error thrown must not match this/); // Ningún error lanzado debe tener un mensaje que coincida con esta expresión regular
  assert.doesNotThrow(fn, Error); // No debe lanzar ningún error que sea una instancia de Error
  assert.doesNotThrow(fn, errorInstance); // No debe lanzar la misma instancia de error que errorInstance
  assert.doesNotThrow(fn, Error, 'Error must not have this message'); // No debe lanzar ningún error que sea una instancia de Error y tenga este mensaje
  assert.doesNotThrow(fn, errorInstance, 'Error must not have this message'); // No debe lanzar la misma instancia de error que errorInstance y tenga este mensaje
  assert.doesNotThrow(fn, Error, /Error must not match this/); // No debe lanzar ningún error que sea una instancia de Error y su mensaje coincida con esta expresión regular
  assert.doesNotThrow(fn, errorInstance, /Error must not match this/); // No debe lanzar la misma instancia de error que errorInstance y su mensaje coincida con esta expresión regular
});

operator

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

Compara val1 y val2 utilizando el operator especificado.

import { assert, test } from 'vitest';

test('assert.operator', () => {
  assert.operator(1, '<', 2, 'everything is ok'); // Todo está correcto
});

closeTo

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

Afirma que actual es numéricamente igual a expected, dentro de una tolerancia de +/- delta.

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'numbers are close'); // Los números son cercanos
});

sameMembers

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

Afirma que set1 y set2 contienen los mismos elementos, sin importar el orden. Utiliza una comparación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.sameMembers', () => {
  assert.sameMembers([1, 2, 3], [2, 1, 3], 'same members'); // Mismos elementos
});

notSameMembers

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

Afirma que set1 y set2 no contienen los mismos elementos, sin importar el orden. Utiliza una comparación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notSameMembers', () => {
  assert.notSameMembers([1, 2, 3], [5, 1, 3], 'not same members'); // No son los mismos elementos
});

sameDeepMembers

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

Afirma que set1 y set2 contienen los mismos elementos, sin importar el orden. Utiliza una comprobación de igualdad profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.sameDeepMembers', () => {
  assert.sameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'same deep members' // Mismos elementos (comparación profunda)
  );
});

notSameDeepMembers

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

Afirma que set1 y set2 no contienen los mismos elementos, sin importar el orden. Utiliza una comprobación de igualdad profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.notSameDeepMembers', () => {
  assert.notSameDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'same deep members' // Mismos elementos profundos
  );
});

sameOrderedMembers

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

Afirma que set1 y set2 contienen los mismos elementos en el mismo orden. Utiliza una comparación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.sameOrderedMembers', () => {
  assert.sameOrderedMembers([1, 2, 3], [1, 2, 3], 'same ordered members'); // Mismos elementos ordenados
});

notSameOrderedMembers

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

Afirma que set1 y set2 no contienen los mismos elementos en el mismo orden. Utiliza una comparación de igualdad estricta (===).

import { assert, test } from 'vitest';

test('assert.notSameOrderedMembers', () => {
  assert.notSameOrderedMembers(
    [1, 2, 3],
    [2, 1, 3],
    'not same ordered members' // No son los mismos elementos ordenados
  );
});

sameDeepOrderedMembers

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

Afirma que set1 y set2 contienen los mismos elementos en el mismo orden. Utiliza una comprobación de igualdad profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.sameDeepOrderedMembers', () => {
  assert.sameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    'same deep ordered members' // Mismos elementos ordenados (comparación profunda)
  );
});

notSameDeepOrderedMembers

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

Afirma que set1 y set2 no contienen los mismos elementos en el mismo orden, utilizando una comparación profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.notSameDeepOrderedMembers', () => {
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }, { z: 5 }],
    'no tienen los mismos elementos en el mismo orden'
  );
  assert.notSameDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { c: 3 }],
    'no tienen los mismos elementos en el mismo orden'
  );
});

includeMembers

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

Afirma que todos los elementos de subset están presentes en superset, sin importar el orden. Utiliza una comparación estricta (===). Los duplicados en subset se ignoran.

import { assert, test } from 'vitest';

test('assert.includeMembers', () => {
  assert.includeMembers([1, 2, 3], [2, 1, 2], 'incluye los elementos');
});

notIncludeMembers

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

Afirma que no todos los elementos de subset están presentes en superset, sin importar el orden. Utiliza una comparación estricta (===). Los duplicados en subset se ignoran.

import { assert, test } from 'vitest';

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

includeDeepMembers

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

Afirma que todos los elementos de subset están presentes en superset, sin importar el orden. Utiliza una comparación profunda (deep equality check). Los duplicados en subset se ignoran.

import { assert, test } from 'vitest';

test('assert.includeDeepMembers', () => {
  assert.includeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }, { b: 2 }],
    'incluye los elementos en profundidad'
  );
});

notIncludeDeepMembers

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

Afirma que no todos los elementos de subset están presentes en superset, sin importar el orden. Utiliza una comparación profunda (deep equality check). Los duplicados en subset se ignoran.

import { assert, test } from 'vitest';

test('assert.notIncludeDeepMembers', () => {
  assert.notIncludeDeepMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { f: 5 }],
    'no incluye los elementos en profundidad'
  );
});

includeOrderedMembers

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

Afirma que subset está contenido en superset en el mismo orden, comenzando desde el primer elemento de superset. Utiliza una comparación estricta (===).

import { assert, test } from 'vitest';

test('assert.includeOrderedMembers', () => {
  assert.includeOrderedMembers(
    [1, 2, 3],
    [1, 2],
    'incluye los elementos ordenados'
  );
});

notIncludeOrderedMembers

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

Afirma que subset no está contenido en superset en el mismo orden, comenzando desde el primer elemento de superset. Utiliza una comparación estricta (===).

import { assert, test } from 'vitest';

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

includeDeepOrderedMembers

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

Afirma que subset está contenido en superset en el mismo orden, comenzando desde el primer elemento de superset. Utiliza una comparación profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.includeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { b: 2 }],
    'incluye los elementos ordenados en profundidad'
  );
});

notIncludeDeepOrderedMembers

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

Afirma que subset no está contenido en superset en el mismo orden, comenzando desde el primer elemento de superset. Utiliza una comparación profunda (deep equality check).

import { assert, test } from 'vitest';

test('assert.includeDeepOrderedMembers', () => {
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ a: 1 }, { f: 5 }],
    'no incluye los elementos ordenados en profundidad'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { a: 1 }],
    'no incluye los elementos ordenados en profundidad'
  );
  assert.notIncludeDeepOrderedMembers(
    [{ a: 1 }, { b: 2 }, { c: 3 }],
    [{ b: 2 }, { c: 3 }],
    'no incluye los elementos ordenados en profundidad'
  );
});

oneOf

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

Afirma que el valor inList (que no debe ser un objeto ni un array) está presente en el array list.

import { assert, test } from 'vitest';

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

changes

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

Afirma que la ejecución de la función modifier modifica la propiedad property del objeto 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 la ejecución de la función modifier modifica la propiedad property del objeto object en la cantidad especificada por 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 la ejecución de la función modifier no modifica la propiedad property del objeto 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 la ejecución de la función modifier modifica la propiedad property del objeto object, pero no en la cantidad especificada por change.

import { assert, test } from 'vitest';

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

increases

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

Afirma que la ejecución de la función modifier incrementa el valor numérico de la propiedad property del objeto 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 la ejecución de la función modifier incrementa el valor numérico de la propiedad property del objeto object en la cantidad especificada por change.

import { assert, test } from 'vitest';

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

doesNotIncrease

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

Afirma que la ejecución de la función modifier no incrementa el valor numérico de la propiedad property del objeto 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 la ejecución de la función modifier incrementa el valor numérico de la propiedad property del objeto object, pero no en la cantidad especificada por change.

import { assert, test } from 'vitest';

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

decreases

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

Afirma que la ejecución de la función modifier disminuye el valor numérico de la propiedad property del objeto 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 la ejecución de la función modifier disminuye el valor numérico de la propiedad property del objeto object en la cantidad especificada por 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 la ejecución de la función modifier no disminuye el valor numérico de la propiedad property del objeto 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 la ejecución de modifier no reduce la propiedad numérica property del objeto object (o su valor de retorno) en la 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 la ejecución de modifier reduce la propiedad numérica property del objeto object (o su valor de retorno), pero no exactamente en la cantidad change.

import { assert, test } from 'vitest';

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

ifError

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

Verifica que object sea un valor falso (falsy). Si object es un valor verdadero (truthy), lanza una excepción. Esto se añade para permitir que chai sea un reemplazo directo para la clase assert de Node.js.

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // ¡Vuelve a lanzar 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 permite añadir nuevas propiedades ni eliminar las existentes).

import { assert, test } from 'vitest';

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

  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 y 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 object 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.isFrozen(frozenObject);
});

isNotFrozen

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

Afirma que object no está congelado (se le pueden añadir nuevas propiedades y 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 está vacío, es decir, no contiene valores. Para arrays y strings, comprueba la propiedad length. Para instancias de Map y Set, comprueba la propiedad size. Para objetos que no son funciones, cuenta sus propias claves enumerables de tipo string.

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 no está vacío, es decir, contiene algún valor. Para arrays y strings, comprueba la propiedad length. Para instancias de Map y Set, comprueba la propiedad size. Para objetos que no son funciones, cuenta sus propias claves enumerables de tipo string.

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

assert ​

assert ​

fail ​

isOk ​

isNotOk ​

equal ​

notEqual ​

strictEqual ​

deepEqual ​

notDeepEqual ​

isAbove ​

isAtLeast ​

isBelow ​

isAtMost ​

isTrue ​

isNotTrue ​

isFalse ​

isNotFalse ​

isNull ​

isNotNull ​

isNaN ​

isNotNaN ​

exists ​

notExists ​

isUndefined ​

isDefined ​

isFunction ​

isNotFunction ​

isObject ​

isNotObject ​

isArray ​

isNotArray ​

isString ​

isNotString ​

isNumber ​

isNotNumber ​

isFinite ​

isBoolean ​

isNotBoolean ​

typeOf ​

notTypeOf ​

instanceOf ​

notInstanceOf ​

include ​

notInclude ​

deepInclude ​

notDeepInclude ​

nestedInclude ​

notNestedInclude ​

deepNestedInclude ​

notDeepNestedInclude ​

ownInclude ​

notOwnInclude ​

deepOwnInclude ​

notDeepOwnInclude ​

match ​

notMatch ​

property ​

notProperty ​

propertyVal ​

notPropertyVal ​

deepPropertyVal ​

notDeepPropertyVal ​

nestedProperty ​

notNestedProperty ​

nestedPropertyVal ​

notNestedPropertyVal ​

deepNestedPropertyVal ​

notDeepNestedPropertyVal ​

lengthOf ​

hasAnyKeys ​

hasAllKeys ​

containsAllKeys ​

doesNotHaveAnyKeys ​

doesNotHaveAllKeys ​

hasAnyDeepKeys ​

hasAllDeepKeys ​

containsAllDeepKeys ​

doesNotHaveAnyDeepKeys ​

doesNotHaveAllDeepKeys ​

assert

assert

fail

isOk

isNotOk

equal

notEqual

strictEqual

deepEqual

notDeepEqual

isAbove

isAtLeast

isBelow

isAtMost

isTrue

isNotTrue

isFalse

isNotFalse

isNull

isNotNull

isNaN

isNotNaN

exists

notExists

isUndefined

isDefined

isFunction

isNotFunction

isObject

isNotObject

isArray

isNotArray

isString

isNotString

isNumber

isNotNumber

isFinite

isBoolean

isNotBoolean

typeOf

notTypeOf

instanceOf

notInstanceOf

include

notInclude

deepInclude

notDeepInclude

nestedInclude

notNestedInclude

deepNestedInclude

notDeepNestedInclude

ownInclude

notOwnInclude

deepOwnInclude

notDeepOwnInclude

match

notMatch

property

notProperty

propertyVal

notPropertyVal

deepPropertyVal

notDeepPropertyVal

nestedProperty

notNestedProperty

nestedPropertyVal

notNestedPropertyVal

deepNestedPropertyVal

notDeepNestedPropertyVal

lengthOf

hasAnyKeys

hasAllKeys

containsAllKeys

doesNotHaveAnyKeys

doesNotHaveAllKeys

hasAnyDeepKeys

hasAllDeepKeys

containsAllDeepKeys

doesNotHaveAnyDeepKeys

doesNotHaveAllDeepKeys