assert

Vitest は、不変条件を検証するために、chaiのassertメソッドを再エクスポートしています。

assert

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

指定されたexpressionが真であることをアサートします。偽の場合、アサーションは失敗します。

import { assert, test } from 'vitest';

test('assert', () => {
  assert('foo' !== 'bar', 'foo は bar と等しくないはずです');
});

fail

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

アサーションを強制的に失敗させます。

import { assert, test } from 'vitest';

test('assert.fail', () => {
  assert.fail('失敗時のエラーメッセージ');
  assert.fail('foo', 'bar', 'foo は bar ではありません', '===');
});

isOk

• 型: <T>(value: T, message?: string) => void
• エイリアス: ok

指定されたvalueが truthy であることをアサートします。

import { assert, test } from 'vitest';

test('assert.isOk', () => {
  assert.isOk('foo', 'すべての truthy な値は ok です');
  assert.isOk(false, 'false は truthy ではないため、これは失敗します');
});

isNotOk

• 型: <T>(value: T, message?: string) => void
• エイリアス: notOk

指定されたvalueが falsy であることをアサートします。

import { assert, test } from 'vitest';

test('assert.isNotOk', () => {
  assert.isNotOk(
    'foo',
    'これは失敗します。すべての truthy な値は ok ではないため'
  );
  assert.isNotOk(false, 'false は falsy なので、これは成功します');
});

equal

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

actualとexpectedが非厳密に等しい (==) ことをアサートします。

import { assert, test } from 'vitest';

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

notEqual

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

actualとexpectedが非厳密に等しくない (!=) ことをアサートします。

import { assert, test } from 'vitest';

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

strictEqual

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

actualとexpectedが厳密に等しい (===) ことをアサートします。

import { assert, test } from 'vitest';

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

deepEqual

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

actualがexpectedと深く等しいことをアサートします。

import { assert, test } from 'vitest';

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

notDeepEqual

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

actualがexpectedと深く等しくないことをアサートします。

import { assert, test } from 'vitest';

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

isAbove

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

valueToCheckがvalueToBeAboveより大きい (>) ことをアサートします。

import { assert, test } from 'vitest';

test('assert.isAbove', () => {
  assert.isAbove(5, 2, '5 は 2 より大きいです');
});

isAtLeast

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

valueToCheckがvalueToBeAtLeast以上 (>=) であることをアサートします。

import { assert, test } from 'vitest';

test('assert.isAtLeast', () => {
  assert.isAtLeast(5, 2, '5 は 2 以上です');
  assert.isAtLeast(3, 3, '3 は 3 以上です');
});

isBelow

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

valueToCheckがvalueToBeBelowより小さい (<) ことをアサートします。

import { assert, test } from 'vitest';

test('assert.isBelow', () => {
  assert.isBelow(3, 6, '3 は 6 より小さいです');
});

isAtMost

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

valueToCheckがvalueToBeAtMost以下 (<=) であることをアサートします。

import { assert, test } from 'vitest';

test('assert.isAtMost', () => {
  assert.isAtMost(3, 6, '3 は 6 以下です');
  assert.isAtMost(4, 4, '4 は 4 以下です');
});

isTrue

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

valueが真 (true) であることをアサートします。

import { assert, test } from 'vitest';

const testPassed = true;

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

isNotTrue

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

valueが真 (true) でないことをアサートします。

import { assert, test } from 'vitest';

const testPassed = 'ok';

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

isFalse

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

valueが偽 (false) であることをアサートします。

import { assert, test } from 'vitest';

const testPassed = false;

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

isNotFalse

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

valueが偽 (false) でないことをアサートします。

import { assert, test } from 'vitest';

const testPassed = 'no';

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

isNull

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

valueが null であることをアサートします。

import { assert, test } from 'vitest';

const error = null;

test('assert.isNull', () => {
  assert.isNull(error, 'error は null です');
});

isNotNull

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

valueが null でないことをアサートします。

import { assert, test } from 'vitest';

const error = { message: 'error が発生しました' };

test('assert.isNotNull', () => {
  assert.isNotNull(error, 'error は null ではなくオブジェクトです');
});

isNaN

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

valueが NaN (非数) であることをアサートします。

import { assert, test } from 'vitest';

const calculation = 1 * 'vitest';

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

isNotNaN

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

valueが NaN (非数) でないことをアサートします。

import { assert, test } from 'vitest';

const calculation = 1 * 2;

test('assert.isNotNaN', () => {
  assert.isNotNaN(calculation, '1 * 2 は NaN ではなく 2 です');
});

exists

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

valueが null でも undefined でもないことをアサートします。

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.exists', () => {
  assert.exists(name, 'foo は null でも undefined でもありません');
});

notExists

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

valueが null または undefined のいずれかであることをアサートします。

import { assert, test } from 'vitest';

const foo = null;
const bar = undefined;

test('assert.notExists', () => {
  assert.notExists(foo, 'foo は null なので存在しません');
  assert.notExists(bar, 'bar は undefined なので存在しません');
});

isUndefined

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

valueが undefined であることをアサートします。

import { assert, test } from 'vitest';

const name = undefined;

test('assert.isUndefined', () => {
  assert.isUndefined(name, 'name は undefined です');
});

isDefined

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

valueが undefined でないことをアサートします。

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isDefined', () => {
  assert.isDefined(name, 'name は undefined ではありません');
});

isFunction

• 型: <T>(value: T, message?: string) => void
• エイリアス: isCallablevalueが関数であることをアサートします。

import { assert, test } from 'vitest';

function name() {
  return 'foo';
}

test('assert.isFunction', () => {
  assert.isFunction(name, 'name は関数です');
});

isNotFunction

• 型: <T>(value: T, message?: string) => void
• エイリアス: isNotCallable

valueが関数でないことをアサートします。

import { assert, test } from 'vitest';

const name = 'foo';

test('assert.isNotFunction', () => {
  assert.isNotFunction(name, 'name は関数ではなく文字列です');
});

isObject

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

valueが Object 型のオブジェクト (Object.prototype.toString によって判定される) であることをアサートします。このアサーションはサブクラスのオブジェクトにはマッチしません。

import { assert, test } from 'vitest';

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

test('assert.isObject', () => {
  assert.isObject(someThing, 'someThing はオブジェクトです');
});

isNotObject

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

value の型がオブジェクト型ではないことを表明します。Object.prototype.toString によって判定されます。このアサーションは、サブクラス化されたオブジェクトには適用されません。

import { assert, test } from 'vitest';

const someThing = 'redCircle';

test('assert.isNotObject', () => {
  assert.isNotObject(someThing, 'someThing はオブジェクトではなく文字列です');
});

isArray

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

value が配列であることを表明します。

import { assert, test } from 'vitest';

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

test('assert.isArray', () => {
  assert.isArray(color, 'color は配列です');
});

isNotArray

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

value が配列ではないことを表明します。

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isNotArray', () => {
  assert.isNotArray(color, 'color は配列ではなく文字列です');
});

isString

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

value が文字列であることを表明します。

import { assert, test } from 'vitest';

const color = 'red';

test('assert.isString', () => {
  assert.isString(color, 'color は文字列です');
});

isNotString

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

value が文字列ではないことを表明します。

import { assert, test } from 'vitest';

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

test('assert.isNotString', () => {
  assert.isNotString(color, 'color は文字列ではなく配列です');
});

isNumber

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

value が数値であることを表明します。

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isNumber', () => {
  assert.isNumber(colors, 'colors は数値です');
});

isNotNumber

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

value が数値ではないことを表明します。

import { assert, test } from 'vitest';

const colors = '3 colors';

test('assert.isNotNumber', () => {
  assert.isNotNumber(colors, 'colors は数値ではなく文字列です');
});

isFinite

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

value が有限数 (NaN、Infinity 以外) であることを表明します。

import { assert, test } from 'vitest';

const colors = 3;

test('assert.isFinite', () => {
  assert.isFinite(colors, 'colors は NaN または Infinity ではない数値です');
});

isBoolean

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

value がブール値であることを表明します。

import { assert, test } from 'vitest';

const isReady = true;

test('assert.isBoolean', () => {
  assert.isBoolean(isReady, 'isReady はブール値です');
});

isNotBoolean

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

value がブール値ではないことを表明します。

import { assert, test } from 'vitest';

const isReady = 'sure';

test('assert.isNotBoolean', () => {
  assert.isNotBoolean(isReady, 'isReady はブール値ではなく文字列です');
});

typeOf

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

value の型が name であることを表明します。Object.prototype.toString によって判定されます。

import { assert, test } from 'vitest';

test('assert.typeOf', () => {
  assert.typeOf({ color: 'red' }, 'object', 'オブジェクトです');
  assert.typeOf(['red', 'green'], 'array', '配列です');
  assert.typeOf('red', 'string', '文字列です');
  assert.typeOf(/red/, 'regexp', '正規表現です');
  assert.typeOf(null, 'null', 'null です');
  assert.typeOf(undefined, 'undefined', 'undefined です');
});

notTypeOf

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

value の型が name ではないことを表明します。Object.prototype.toString によって判定されます。

import { assert, test } from 'vitest';

test('assert.notTypeOf', () => {
  assert.notTypeOf('red', 'number', '"red" は数値ではありません');
});

instanceOf

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

value が 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 は Person のインスタンスです');
  assert.instanceOf(coffee, Tea, 'coffee は Tea のインスタンスです');
});

notInstanceOf

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

value が constructor のインスタンスではないことを表明します。

import { assert, test } from 'vitest';

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

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

test('assert.instanceOf', () => {
  assert.instanceOf(foo, Tea, 'foo は Tea のインスタンスではありません');
});

include

• Type:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: Partial<T>, message?: string) => void

haystack が needle を含むことを表明します。配列内の値、文字列内の部分文字列、またはオブジェクト内のプロパティのサブセットの包含を表明するために使用できます。

import { assert, test } from 'vitest';

test('assert.include', () => {
  assert.include([1, 2, 3], 2, '配列は値 2 を含む');
  assert.include('foobar', 'foo', '文字列 "foobar" は部分文字列 "foo" を含む');
  assert.include(
    { foo: 'bar', hello: 'universe' },
    { foo: 'bar' },
    'オブジェクトはプロパティ { foo: "bar" } を含む'
  );
});

notInclude

• Type:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: Partial<T>, message?: string) => void

haystack が needle を含まないことを表明します。配列内の値、文字列内の部分文字列、またはオブジェクト内のプロパティのサブセットの不在を表明するために使用できます。

import { assert, test } from 'vitest';

test('assert.notInclude', () => {
  assert.notInclude([1, 2, 3], 4, '配列に 4 は含まれていません');
  assert.notInclude(
    'foobar',
    'baz',
    '文字列 "foobar" に "baz" は含まれていません'
  );
  assert.notInclude(
    { foo: 'bar', hello: 'universe' },
    { foo: 'baz' },
    "オブジェクトにプロパティ { foo: 'baz' } は含まれていません"
  );
});

deepInclude

• Type:
• (haystack: string, needle: string, message?: string) => void
• <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
• <T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void

haystack が needle を含むことを表明します。配列内の値、またはオブジェクト内のプロパティのサブセットの包含を表明するために使用できます。厳密等価性 (===) が使用されます。

import { assert, test } from 'vitest';

const obj1 = { a: 1 };
const obj2 = { b: 2 };

test('assert.deepInclude', () => {
  assert.deepInclude([obj1, obj2], { a: 1 }, '配列は { a: 1 } を含む');
  assert.deepInclude(
    { foo: obj1, bar: obj2 },
    { foo: { a: 1 } },
    'オブジェクトは { foo: { a: 1 } } を含む'
  );
});

notDeepInclude

• Type:
  • (haystack: string, needle: string, message?: string) => void
  • <T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void
  • <T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void

haystack が needle を含まないことを表明します。配列内の値、またはオブジェクト内のプロパティのサブセットの不在を表明するために使用できます。厳密等価性 (===) が使用されます。

import { assert, test } from 'vitest';

const obj1 = { a: 1 };
const obj2 = { b: 2 };

test('assert.notDeepInclude', () => {
  assert.notDeepInclude([obj1, obj2], { a: 10 });
  assert.notDeepInclude({ foo: obj1, bar: obj2 }, { foo: { a: 10 } });
});

nestedInclude

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

haystack が needle を含むことを表明します。オブジェクト内のプロパティのサブセットの包含を表明するために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュ (\\) を使用してエスケープできます。

import { assert, test } from 'vitest';

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

notNestedInclude

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

haystack が needle を含まないことを表明します。オブジェクト内のプロパティのサブセットの不在を表明するために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュ (\\) を使用してエスケープできます。

import { assert, test } from 'vitest';

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

deepNestedInclude

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

haystack が needle を含むことを表明します。厳密等価性 (===) をチェックしながら、オブジェクト内のプロパティのサブセットの包含を表明するために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュ (\\) を使用してエスケープできます。

import { assert, test } from 'vitest';

test('assert.deepNestedInclude', () => {
  assert.deepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { x: 1 } });
  assert.deepNestedInclude(
    { '.a': { '[b]': { x: 1 } } },
    { '\\.a.\\[b\\]': { x: 1 } }
  );
});

notDeepNestedInclude

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

haystack が needle を含まないことを表明します。厳密等価性 (===) をチェックしながら、オブジェクト内のプロパティのサブセットの不在を表明するために使用できます。ネストされたプロパティを参照するために、ドット表記とブラケット表記を使用できます。プロパティ名内の「[]」と「.」は、二重バックスラッシュ (\\) を使用してエスケープできます。

import { assert, test } from 'vitest';

test('assert.notDeepNestedInclude', () => {
  assert.notDeepNestedInclude({ a: { b: [{ x: 1 }] } }, { 'a.b[0]': { y: 1 } });
  assert.notDeepNestedInclude(
    { '.a': { '[b]': { x: 1 } } },
    { '\\.a.\\[b\\]': { y: 2 } }
  );
});

ownInclude

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

haystack が needle を含むことを表明します。継承されたプロパティを無視しながら、オブジェクト自身のプロパティのサブセットの包含を表明するために使用できます。

import { assert, test } from 'vitest';

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

notOwnInclude

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

haystack が needle を含まないことを表明します。継承されたプロパティを無視しながら、オブジェクト自身のプロパティのサブセットの不在を表明するために使用できます。

import { assert, test } from 'vitest';

const obj1 = {
  b: 2,
};

const obj2 = Object.create(obj1);
obj2.a = 1;

test('assert.notOwnInclude', () => {
  assert.notOwnInclude(obj2, { b: 2 });
});

deepOwnInclude

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

haystack が needle を含んでいることを検証します。この関数は、継承されたプロパティを無視し、深い等価性チェックを行いながら、オブジェクトが指定されたプロパティのサブセットを自身のプロパティとして含んでいることを検証するために使用できます。

import { assert, test } from 'vitest';

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

notDeepOwnInclude

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

haystack が needle を含んでいないことを検証します。この関数は、継承されたプロパティを無視し、深い等価性チェックを行いながら、オブジェクトが指定されたプロパティのサブセットを自身のプロパティとして含んでいないことを検証するために使用できます。

import { assert, test } from 'vitest';

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

match

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

value が正規表現 regexp に一致することを検証します。

import { assert, test } from 'vitest';

test('assert.match', () => {
  assert.match('foobar', /^foo/, 'regexp matches'); // 正規表現に一致
});

notMatch

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

value が正規表現 regexp に一致しないことを検証します。

import { assert, test } from 'vitest';

test('assert.notMatch', () => {
  assert.notMatch('foobar', /^foo/, 'regexp does not match'); // 正規表現に不一致
});

property

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持つことを検証します。

import { assert, test } from 'vitest';

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

notProperty

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持たないことを検証します。

import { assert, test } from 'vitest';

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

propertyVal

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持ち、その値が value と厳密に等しいことを検証します。

import { assert, test } from 'vitest';

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

notPropertyVal

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持たないか、またはその値が value と厳密に等しくないことを検証します。

import { assert, test } from 'vitest';

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

deepPropertyVal

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持ち、その値が value と深く等しいことを検証します。

import { assert, test } from 'vitest';

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

notDeepPropertyVal

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持たないか、またはその値が value と深く等しくないことを検証します。

import { assert, test } from 'vitest';

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

nestedProperty

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持つことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表す文字列にすることができます。

import { assert, test } from 'vitest';

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

notNestedProperty

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

object が property で指定された名前のプロパティ（直接的または継承されたもの）を持たないことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表す文字列にすることができます。

import { assert, test } from 'vitest';

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

nestedPropertyVal

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

object が property で指定された名前のプロパティを持ち、その値が value と厳密に等しいことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表すことができます。

import { assert, test } from 'vitest';

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

notNestedPropertyVal

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

object が property で指定された名前のプロパティを持たないか、またはその値が value と厳密に等しくないことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表すことができます。

import { assert, test } from 'vitest';

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

deepNestedPropertyVal

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

object が property で指定された名前のプロパティを持ち、その値が value と深く等しいことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表すことができます。

import { assert, test } from 'vitest';

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

notDeepNestedPropertyVal

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

object が property で指定された名前のプロパティを持たないか、またはその値が value と深く等しくないことを検証します。property は、ドット記法またはブラケット記法を使用してネストされたプロパティへの参照を表すことができます。

import { assert, test } from 'vitest';

test('assert.notDeepNestedPropertyVal', () => {
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.green',
    { oolong: 'yum' }
  );
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.green',
    { matcha: 'yuck' }
  );
  assert.notDeepNestedPropertyVal(
    { tea: { green: { matcha: 'yum' } } },
    'tea.black',
    { matcha: 'yum' }
  );
});

lengthOf

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

object が、期待される長さ length またはサイズ size を持つことを検証します。

import { assert, test } from 'vitest';

test('assert.lengthOf', () => {
  assert.lengthOf([1, 2, 3], 3, 'array has length of 3'); // 配列の長さが3
  assert.lengthOf('foobar', 6, 'string has length of 6'); // 文字列の長さが6
  assert.lengthOf(new Set([1, 2, 3]), 3, 'set has size of 3'); // セットのサイズが3
  assert.lengthOf(
    new Map([
      ['a', 1],
      ['b', 2],
      ['c', 3],
    ]),
    3,
    'map has size of 3' // マップのサイズが3
  );
});

hasAnyKeys

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

object が、指定された keys の少なくとも 1 つをキーとして持つことを検証します。キーの配列の代わりにオブジェクトを渡すこともでき、そのオブジェクトのキーが期待されるキーのセットとして扱われます。

import { assert, test } from 'vitest';

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

hasAllKeys

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

object が、指定された keys をすべてキーとして持ち、それ以外のキーを持たないことを検証します。キーの配列の代わりにオブジェクトを渡すこともでき、そのオブジェクトのキーが期待されるキーのセットとして扱われます。

import { assert, test } from 'vitest';

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

containsAllKeys

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

object が、指定された keys をすべてキーとして持つことを検証します。リストにないキーがさらに存在しても構いません。キーの配列の代わりにオブジェクトを渡すこともでき、そのオブジェクトのキーが期待されるキーのセットとして扱われます。

import { assert, test } from 'vitest';

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

doesNotHaveAnyKeys

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

object が、指定された keys をいずれも持っていないことをアサートします。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

doesNotHaveAllKeys

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

object が、指定された keys のうち、少なくとも 1 つ持っていないことをアサートします。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

hasAnyDeepKeys

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

object が、指定された keys のうち、少なくとも 1 つをディープに持っていることをアサートします。Sets と Maps はキーとしてオブジェクトを持つことができるため、このアサーションを使用して深い比較を実行できます。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

hasAllDeepKeys

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

object が、指定された keys をすべてディープに持っていることをアサートします。Sets と Maps はキーとしてオブジェクトを持つことができるため、このアサーションを使用して深い比較を実行できます。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

containsAllDeepKeys

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

object が、指定された keys をすべてディープに含んでいることをアサートします。Sets と Maps はキーとしてオブジェクトを持つことができるため、このアサーションを使用して深い比較を実行できます。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

doesNotHaveAnyDeepKeys

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

object が、指定された keys をいずれもディープに持っていないことをアサートします。Sets と Maps はキーとしてオブジェクトを持つことができるため、このアサーションを使用して深い比較を実行できます。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

doesNotHaveAllDeepKeys

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

object が、指定された keys のうち、少なくとも 1 つをディープに持っていないことをアサートします。Sets と Maps はキーとしてオブジェクトを持つことができるため、このアサーションを使用して深い比較を実行できます。keys の配列の代わりに、キーのセットとして使用する単一のオブジェクトを提供することもできます。

import { assert, test } from 'vitest';

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

throws

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

fn がエラーをスローすることをアサートします。

errorLike が Error コンストラクタの場合、fn が errorLike のインスタンスであるエラーをスローすることをアサートします。errorLike が Error インスタンスの場合、スローされたエラーが errorLike と同一のインスタンスであることをアサートします。errMsgMatcher が指定されている場合、スローされたエラーのメッセージが 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

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

fn がエラーをスローしないことをアサートします。

errorLike が Error コンストラクタの場合、fn が errorLike のインスタンスであるエラーをスローしないことをアサートします。errorLike が Error インスタンスの場合、スローされたエラーが errorLike と同一のインスタンスでないことをアサートします。errMsgMatcher が指定されている場合、スローされたエラーのメッセージが 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

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

operator を使用して val1 と val2 を比較することをアサートします。

import { assert, test } from 'vitest';

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

closeTo

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

actual が expected の +/- delta の範囲内であることをアサートします。

import { assert, test } from 'vitest';

test('assert.closeTo', () => {
  assert.closeTo(1.5, 1, 0.5, 'numbers are close');
});

sameMembers

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

set1 と set2 が、順不同で同じメンバーを厳密に持っていることをアサートします (=== を使用)。

import { assert, test } from 'vitest';

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

notSameMembers

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

set1 と set2 が、順不同で同じメンバーを厳密に持っていないことをアサートします (=== を使用)。

import { assert, test } from 'vitest';

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

sameDeepMembers

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

set1 と set2 が、順不同で同じメンバーをディープに持っていることをアサートします。

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

notSameDeepMembers

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

set1 と set2 が、順不同で同じメンバーをディープに持っていないことをアサートします。

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

sameOrderedMembers

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

set1 と set2 が、同じ順序で同じメンバーを厳密に持っていることをアサートします (=== を使用)。

import { assert, test } from 'vitest';

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

notSameOrderedMembers

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

set1 と set2 が、同じ順序で同じメンバーを厳密に持っていないことをアサートします (=== を使用)。

import { assert, test } from 'vitest';

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

sameDeepOrderedMembers

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

set1 と set2 が、同じ順序で同じメンバーをディープに持っていることをアサートします。

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

notSameDeepOrderedMembers

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

set1 と set2 が、深い等価性において同じ順序の要素を持たないことをアサートします。深い等価性チェックが使用されます。

import { assert, test } from 'vitest';

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

includeMembers

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

subset のすべての要素が、任意の順序で superset に含まれることをアサートします。厳密等価性 (===) による比較を行います。重複は無視されます。

import { assert, test } from 'vitest';

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

notIncludeMembers

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

subset の少なくとも 1 つの要素が、superset に含まれないことをアサートします。厳密等価性 (===) による比較を行います。重複は無視されます。

import { assert, test } from 'vitest';

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

includeDeepMembers

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

subset のすべての要素が、任意の順序で superset に含まれることをアサートします。深い等価性チェックを使用します。重複は無視されます。

import { assert, test } from 'vitest';

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

notIncludeDeepMembers

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

subset の少なくとも 1 つの要素が、superset に含まれないことをアサートします。深い等価性チェックを使用します。重複は無視されます。

import { assert, test } from 'vitest';

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

includeOrderedMembers

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

subset が superset の先頭から始まる同じ順序で superset に含まれることをアサートします。厳密等価性 (===) による比較を行います。

import { assert, test } from 'vitest';

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

notIncludeOrderedMembers

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

subset が superset の先頭から始まる同じ順序で superset に含まれないことをアサートします。厳密等価性 (===) による比較を行います。

import { assert, test } from 'vitest';

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

includeDeepOrderedMembers

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

subset が superset の先頭から始まる同じ順序で superset に含まれることをアサートします。深い等価性チェックを使用します。

import { assert, test } from 'vitest';

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

notIncludeDeepOrderedMembers

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

subset が superset の先頭から始まる同じ順序で superset に含まれないことをアサートします。深い等価性チェックを使用します。

import { assert, test } from 'vitest';

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

oneOf

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

オブジェクトや配列でない値 inList が、配列 list のいずれかの要素と厳密に等しいことをアサートします。

import { assert, test } from 'vitest';

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

changes

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

関数 modifier の実行によって、object の property の値が変化することをアサートします。

import { assert, test } from 'vitest';

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

changesBy

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

関数 modifier の実行によって、object の property の値が 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

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

関数 modifier の実行によって、object の property の値が変化しないことをアサートします。

import { assert, test } from 'vitest';

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

changesButNotBy

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

関数 modifier の実行によって、object の property の値が変化するものの、その変化量が 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

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

関数 modifier の実行によって、数値型の object の property の値が増加することをアサートします。

import { assert, test } from 'vitest';

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

increasesBy

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

関数 modifier の実行によって、数値型の object の property の値が 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

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

関数 modifier の実行によって、数値型の object の property の値が増加しないことをアサートします。

import { assert, test } from 'vitest';

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

increasesButNotBy

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

関数 modifier の実行によって、数値型の object の property の値が増加するものの、その増加量が 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

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

関数 modifier の実行によって、数値型の object の property の値が減少することをアサートします。

import { assert, test } from 'vitest';

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

decreasesBy

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

関数 modifier の実行によって、数値型の object の property の値が 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

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

関数 modifier の実行によって、数値型の object の property の値が減少しないことをアサートします。

import { assert, test } from 'vitest';

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

doesNotDecreaseBy

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

modifierを実行した結果、数値型のobjectのpropertyの値、またはmodifierの戻り値がchangeだけ減少しないことを検証します。

import { assert, test } from 'vitest';

test('assert.doesNotDecreaseBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 5;
  }
  assert.doesNotDecreaseBy(fn, obj, 'val', 1); // fnを実行してもobj.valは1だけ減少するわけではないのでパスする
});

decreasesButNotBy

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

modifierを実行した結果、数値型のobjectのpropertyの値、またはmodifierの戻り値がchangeだけ減少するが、その減少幅がchangeと一致しないことを検証します。

import { assert, test } from 'vitest';

test('assert.decreasesButNotBy', () => {
  const obj = { val: 10 };
  function fn() {
    obj.val = 5;
  }
  assert.decreasesButNotBy(fn, obj, 'val', 1); // fnを実行するとobj.valは5減少するが、1ではないのでパスする
});

ifError

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

objectが falsy な値であることを検証し、truthy な値の場合は例外をスローします。これは、chai が Node.js のassertクラスのドロップイン置換として機能するように追加されました。

import { assert, test } from 'vitest';

test('assert.ifError', () => {
  const err = new Error('I am a custom error');
  assert.ifError(err); // errはtruthyな値なので、例外がスローされる
});

isExtensible

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

objectが拡張可能（新しいプロパティを追加できる）であることを検証します。

import { assert, test } from 'vitest';

test('assert.isExtensible', () => {
  assert.isExtensible({}); // 空のオブジェクトは拡張可能なのでパスする
});

isNotExtensible

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

objectが拡張不可能（新しいプロパティを追加できない）であることを検証します。

import { assert, test } from 'vitest';

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

  assert.isNotExtensible(nonExtensibleObject); // 拡張不可なのでパスする
  assert.isNotExtensible(sealedObject); // シールされているので拡張不可でパスする
  assert.isNotExtensible(frozenObject); // フリーズされているので拡張不可でパスする
});

isSealed

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

objectがシールされている（新しいプロパティを追加できず、既存のプロパティを削除できない）ことを検証します。

import { assert, test } from 'vitest';

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

  assert.isSealed(sealedObject); // シールされているのでパスする
  assert.isSealed(frozenObject); // フリーズされているのでシールされておりパスする
});

isNotSealed

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

objectがシールされていない（新しいプロパティを追加でき、既存のプロパティを削除できる）ことを検証します。

import { assert, test } from 'vitest';

test('assert.isNotSealed', () => {
  assert.isNotSealed({}); // 空のオブジェクトはシールされていないのでパスする
});

isFrozen

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

objectがフリーズされている（新しいプロパティを追加できず、既存のプロパティを変更できない）ことを検証します。

import { assert, test } from 'vitest';

test('assert.isFrozen', () => {
  const frozenObject = Object.freeze({});
  assert.isFrozen(frozenObject); // フリーズされているのでパスする
});

isNotFrozen

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

objectがフリーズされていない（新しいプロパティを追加でき、既存のプロパティを変更できる）ことを検証します。

import { assert, test } from 'vitest';

test('assert.isNotFrozen', () => {
  assert.isNotFrozen({}); // 空のオブジェクトはフリーズされていないのでパスする
});

isEmpty

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

targetが空であることを検証します。配列と文字列の場合は、lengthプロパティをチェックします。Map および Set インスタンスの場合は、sizeプロパティをチェックします。関数以外のオブジェクトの場合は、独自の列挙可能な文字列キーの数を取得します。

import { assert, test } from 'vitest';

test('assert.isEmpty', () => {
  assert.isEmpty([]); // 空の配列なのでパスする
  assert.isEmpty(''); // 空の文字列なのでパスする
  assert.isEmpty(new Map()); // 空のMapなのでパスする
  assert.isEmpty({}); // 空のオブジェクトなのでパスする
});

isNotEmpty

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

objectが空でないことを検証します。配列と文字列の場合は、lengthプロパティをチェックします。Map および Set インスタンスの場合は、sizeプロパティをチェックします。関数以外のオブジェクトの場合は、独自の列挙可能な文字列キーの数を取得します。

import { assert, test } from 'vitest';

test('assert.isNotEmpty', () => {
  assert.isNotEmpty([1, 2]); // 要素を持つ配列なのでパスする
  assert.isNotEmpty('34'); // 文字列なのでパスする
  assert.isNotEmpty(new Set([5, 6])); // 要素を持つSetなのでパスする
  assert.isNotEmpty({ key: 7 }); // プロパティを持つオブジェクトなのでパスする
});