Assert

[安定版: 2 - 安定版]

ソースコード: lib/assert.js

node:assert モジュールは、不変条件を検証するためのアサーション関数のセットを提供します。

厳密なアサーションモード

[履歴]

バージョン	変更
v15.0.0	`require('node:assert/strict')` として公開。
v13.9.0, v12.16.2	"厳密モード" を "厳密なアサーションモード" に、"レガシーモード" を "レガシーなアサーションモード" に変更しました。これは、より一般的な意味での "厳密モード" との混同を避けるためです。
v9.9.0	厳密なアサーションモードにエラー差分を追加。
v9.9.0	assert モジュールに厳密なアサーションモードを追加。
v9.9.0	追加: v9.9.0

厳密なアサーションモードでは、非厳密なメソッドは対応する厳密なメソッドのように動作します。例えば、assert.deepEqual() は assert.deepStrictEqual() のように動作します。

厳密なアサーションモードでは、オブジェクトのエラーメッセージに差分が表示されます。レガシーなアサーションモードでは、オブジェクトのエラーメッセージにはオブジェクトが表示され、多くの場合、切り詰められます。

厳密なアサーションモードを使用するには：

ESMCJS

import { strict as assert } from 'node:assert'

const assert = require('node:assert').strict

ESMCJS

import assert from 'node:assert/strict'

const assert = require('node:assert/strict')

エラー差分の例：

ESMCJS

import { strict as assert } from 'node:assert'

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

const assert = require('node:assert/strict')

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

色の表示を無効にするには、NO_COLOR または NODE_DISABLE_COLORS 環境変数を使用します。これにより、REPL の色も無効になります。ターミナル環境での色のサポートの詳細については、tty の getColorDepth() ドキュメントを参照してください。

レガシーアサーションモード

レガシーアサーションモードでは、以下の関数で==演算子を使用します。

レガシーアサーションモードを使用するには：

ESMCJS

import assert from 'node:assert'

const assert = require('node:assert')

レガシーアサーションモードでは、特にassert.deepEqual()を使用する場合、予期せぬ結果になる可能性があります。

// WARNING: レガシーアサーションモードでは、これはAssertionErrorをスローしません！
assert.deepEqual(/a/gi, new Date())

Class: assert.AssertionError

継承元: <errors.Error>

アサーションの失敗を示します。node:assertモジュールによってスローされるすべてのエラーは、AssertionErrorクラスのインスタンスになります。

`new assert.AssertionError(options)`

追加されたバージョン: v0.1.21

options <Object>
- message <string> 指定した場合、エラーメッセージはこの値に設定されます。
- actual <any> エラーインスタンスのactualプロパティ。
- expected <any> エラーインスタンスのexpectedプロパティ。
- operator <string> エラーインスタンスのoperatorプロパティ。
- stackStartFn <Function> 指定した場合、生成されたスタックトレースはこの関数より前のフレームを省略します。

Errorのサブクラスであり、アサーションの失敗を示します。

すべてのインスタンスには、組み込みのErrorプロパティ（messageとname）と以下が含まれます。

actual <any> assert.strictEqual()などのメソッドのactual引数に設定されます。
expected <any> assert.strictEqual()などのメソッドのexpected値に設定されます。
generatedMessage <boolean> メッセージが自動生成されたかどうかを示します（trueの場合）。
code <string> エラーがアサーションエラーであることを示すために、常にERR_ASSERTIONという値になります。
operator <string> 渡された演算子値に設定されます。

ESMCJS

import assert from 'node:assert'

// 後でエラーメッセージを比較するためにAssertionErrorを生成します。
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// エラー出力を検証します。
try {
  assert.strictEqual(1, 2)
} catch (err) {
  assert(err instanceof assert.AssertionError)
  assert.strictEqual(err.message, message)
  assert.strictEqual(err.name, 'AssertionError')
  assert.strictEqual(err.actual, 1)
  assert.strictEqual(err.expected, 2)
  assert.strictEqual(err.code, 'ERR_ASSERTION')
  assert.strictEqual(err.operator, 'strictEqual')
  assert.strictEqual(err.generatedMessage, true)
}

const assert = require('node:assert')

// 後でエラーメッセージを比較するためにAssertionErrorを生成します。
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// エラー出力を検証します。
try {
  assert.strictEqual(1, 2)
} catch (err) {
  assert(err instanceof assert.AssertionError)
  assert.strictEqual(err.message, message)
  assert.strictEqual(err.name, 'AssertionError')
  assert.strictEqual(err.actual, 1)
  assert.strictEqual(err.expected, 2)
  assert.strictEqual(err.code, 'ERR_ASSERTION')
  assert.strictEqual(err.operator, 'strictEqual')
  assert.strictEqual(err.generatedMessage, true)
}

クラス: `assert.CallTracker`

[履歴]

バージョン	変更点
v20.1.0	`assert.CallTracker`クラスは非推奨となり、将来のバージョンで削除されます。
v14.2.0, v12.19.0	追加: v14.2.0, v12.19.0

[安定性: 0 - 非推奨]

安定性: 0 安定性: 0 - 非推奨

この機能は非推奨であり、将来のバージョンで削除されます。mock ヘルパー関数などの代替案の使用を検討してください。

`new assert.CallTracker()`

追加: v14.2.0, v12.19.0

関数が特定の回数呼び出されたかどうかを追跡するために使用できる新しいCallTrackerオブジェクトを作成します。検証を行うには、tracker.verify()を呼び出す必要があります。通常の方法は、process.on('exit')ハンドラーで呼び出すことです。

ESMCJS

import assert from 'node:assert'
import process from 'node:process'

const tracker = new assert.CallTracker()

function func() {}

// callsfunc()はtracker.verify()の前に正確に1回呼び出される必要があります。
const callsfunc = tracker.calls(func, 1)

callsfunc()

// tracker.verify()を呼び出し、すべてのtracker.calls()関数が正確な回数呼び出されたかどうかを検証します。
process.on('exit', () => {
  tracker.verify()
})

const assert = require('node:assert')
const process = require('node:process')

const tracker = new assert.CallTracker()

function func() {}

// callsfunc()はtracker.verify()の前に正確に1回呼び出される必要があります。
const callsfunc = tracker.calls(func, 1)

callsfunc()

// tracker.verify()を呼び出し、すべてのtracker.calls()関数が正確な回数呼び出されたかどうかを検証します。
process.on('exit', () => {
  tracker.verify()
})

`tracker.calls([fn][, exact])`

追加: v14.2.0, v12.19.0

fn <Function> デフォルト: 何もしない関数。
exact <number> デフォルト: 1。
戻り値: <Function> fnをラップする関数。

ラッパー関数は正確にexact回呼び出されることが期待されます。tracker.verify()が呼び出された時点で関数が正確にexact回呼び出されていない場合、tracker.verify()はエラーをスローします。

ESMCJS

import assert from 'node:assert'

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify()の前に正確な回数呼び出される必要があるfunc()をラップする関数を返します。
const callsfunc = tracker.calls(func)

const assert = require('node:assert')

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify()の前に正確な回数呼び出される必要があるfunc()をラップする関数を返します。
const callsfunc = tracker.calls(func)

`tracker.getCalls(fn)`

追加されたバージョン: v18.8.0, v16.18.0

fn <Function>
戻り値: <Array> 追跡対象の関数へのすべての呼び出しを含む配列。
オブジェクト <Object>
- thisArg <Object>
- arguments <Array> 追跡対象の関数に渡された引数

ESMCJS

import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])

const assert = require('node:assert')

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])

`tracker.report()`

追加されたバージョン: v14.2.0, v12.19.0

戻り値: <Array> tracker.calls()によって返されたラッパー関数の情報を含むオブジェクトの配列。
オブジェクト <Object>
- message <string>
- actual <number> 関数が実際に呼び出された回数。
- expected <number> 関数が呼び出されることが期待された回数。
- operator <string> ラップされた関数の名前。
- stack <Object> 関数のスタックトレース。

期待された回数だけ呼び出されなかった関数の、期待値と実際の呼び出し回数に関する情報を含む配列です。

ESMCJS

import assert from 'node:assert'

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify()の前に正確な回数呼び出さなければならないfunc()をラップする関数を返します。
const callsfunc = tracker.calls(func, 2)

// callsfunc()に関する情報を含む配列を返します。
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

const assert = require('node:assert')

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify()の前に正確な回数呼び出さなければならないfunc()をラップする関数を返します。
const callsfunc = tracker.calls(func, 2)

// callsfunc()に関する情報を含む配列を返します。
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

`tracker.reset([fn])`

追加日時: v18.8.0, v16.18.0

fn <Function> 追跡する関数をリセットします。

コールトラッカーの呼び出しをリセットします。追跡対象の関数が引数として渡された場合、その関数の呼び出しがリセットされます。引数が渡されない場合、すべての追跡対象関数がリセットされます。

ESMCJS

import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Trackerは1回呼び出されました
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

const assert = require('node:assert')

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Trackerは1回呼び出されました
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

`tracker.verify()`

追加日時: v14.2.0, v12.19.0

tracker.calls() に渡された関数リストを反復処理し、期待される回数呼び出されていない関数に対してエラーをスローします。

ESMCJS

import assert from 'node:assert'

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() の前に正確な回数呼び出す必要がある func() をラップする関数を返します。
const callsfunc = tracker.calls(func, 2)

callsfunc()

// callsfunc() は1回しか呼び出されていないため、エラーが発生します。
tracker.verify()

const assert = require('node:assert')

// コールトラッカーを作成します。
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() の前に正確な回数呼び出す必要がある func() をラップする関数を返します。
const callsfunc = tracker.calls(func, 2)

callsfunc()

// callsfunc() は1回しか呼び出されていないため、エラーが発生します。
tracker.verify()

`assert(value[, message])`

追加日: v0.5.9

value <any> 真理値としてチェックされる入力。
message <string> | <Error>

assert.ok() のエイリアスです。

`assert.deepEqual(actual, expected[, message])`

[履歴]

バージョン	変更点
v22.2.0, v20.15.0	エラー原因とエラーのプロパティも比較されるようになりました。
v18.0.0	正規表現の lastIndex プロパティも比較されるようになりました。
v16.0.0, v14.18.0	レガシーアサーションモードでは、非推奨からレガシーに変更されました。
v14.0.0	両方が NaN の場合、NaN は同一とみなされるようになりました。
v12.0.0	型タグが適切に比較されるようになり、チェックをより分かりやすくするためのいくつかのマイナーな比較調整が行われました。
v9.0.0	`Error`の名前とメッセージが適切に比較されるようになりました。
v8.0.0	`Set`と`Map`の内容も比較されるようになりました。
v6.4.0, v4.7.1	型付き配列のスライスが正しく処理されるようになりました。
v6.1.0, v4.5.0	循環参照を持つオブジェクトを入力として使用できるようになりました。
v5.10.1, v4.4.3	`Uint8Array`以外の型付き配列を正しく処理します。
v0.1.21	追加日: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

厳格なアサーションモード

assert.deepStrictEqual() のエイリアスです。

レガシーアサーションモード

[安定版: 3 - レガシー]

安定版: 3 安定性: 3 - レガシー: 代わりにassert.deepStrictEqual() を使用してください。

actualパラメータとexpectedパラメータ間の深い等価性をテストします。代わりにassert.deepStrictEqual() を使用することを検討してください。assert.deepEqual() は予期しない結果になる可能性があります。

深い等価性とは、子オブジェクトの列挙可能な「独自の」プロパティも以下のルールに従って再帰的に評価されることを意味します。

比較の詳細

プリミティブ値はNaNを除き、==演算子を使用して比較されます。両辺がNaNの場合、同一とみなされます。
オブジェクトの型タグは同じである必要があります。
列挙可能な独自の属性のみが考慮されます。
Errorの名前、メッセージ、原因、およびエラーは、列挙可能なプロパティでなくても常に比較されます。
オブジェクトラッパーは、オブジェクトとアンラップされた値の両方として比較されます。
Objectのプロパティは順序なしで比較されます。
MapのキーとSetの項目は順序なしで比較されます。
両辺が異なるとき、または両辺が循環参照に遭遇したときに、再帰は停止します。
実装では、オブジェクトの[[Prototype]]はテストしません。
Symbolのプロパティは比較されません。
WeakMapとWeakSetの比較は、それらの値ではなく、インスタンスのみに依存します。
RegExpの lastIndex、flags、および source は、列挙可能なプロパティでなくても常に比較されます。

次の例は、プリミティブが==演算子を使用して比較されるため、AssertionErrorをスローしません。

ESMCJS

import assert from 'node:assert'
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false)

const assert = require('node:assert')
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false)

"深い"等価性とは、子オブジェクトの列挙可能な独自の属性も評価されることを意味します。

ESMCJS

import assert from 'node:assert'

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.deepEqual(obj1, obj1)
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

const assert = require('node:assert')

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.deepEqual(obj1, obj1)
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

値が等しくない場合、messageプロパティがmessageパラメーターの値に設定されたAssertionErrorがスローされます。messageパラメーターが未定義の場合、デフォルトのエラーメッセージが割り当てられます。messageパラメーターがErrorのインスタンスである場合、AssertionErrorの代わりにそれがスローされます。

`assert.deepStrictEqual(actual, expected[, message])`

[履歴]

バージョン	変更点
v22.2.0, v20.15.0	エラー原因とエラープロパティも比較されるようになりました。
v18.0.0	正規表現の lastIndex プロパティも比較されるようになりました。
v9.0.0	列挙可能なシンボルプロパティが比較されるようになりました。
v9.0.0	`NaN` は、SameValueZero 比較を使用して比較されるようになりました。
v8.5.0	`Error`の名前とメッセージが適切に比較されるようになりました。
v8.0.0	`Set`と`Map`の内容も比較されるようになりました。
v6.1.0	循環参照を持つオブジェクトが入力として使用できるようになりました。
v6.4.0, v4.7.1	型付き配列のスライスが正しく処理されるようになりました。
v5.10.1, v4.4.3	`Uint8Array`以外の型付き配列を正しく処理するようになりました。
v1.2.0	追加：v1.2.0

actual <any>
expected <any>
message <string> | <Error>

actualパラメータとexpectedパラメータ間の深い等価性をテストします。「深い」等価性とは、子オブジェクトの列挙可能な独自のプロパティも、以下のルールに従って再帰的に評価されることを意味します。

比較の詳細

プリミティブ値は、Object.is()を使用して比較されます。
オブジェクトの型タグは同じである必要があります。
オブジェクトの[[Prototype]]は、===演算子を使用して比較されます。
列挙可能な独自の"own"プロパティのみが考慮されます。
Errorの名前、メッセージ、原因、およびエラーは、列挙可能なプロパティでなくても常に比較されます。errorsも比較されます。
列挙可能な独自のSymbolプロパティも比較されます。
オブジェクトラッパーは、オブジェクトとアンラップされた値の両方として比較されます。
Objectのプロパティは順序なしで比較されます。
MapのキーとSetのアイテムは、順序なしで比較されます。
両方が異なる場合、または両方が循環参照に遭遇した場合、再帰は停止します。
WeakMapとWeakSetの比較は、それらの値に依存しません。詳細は下記を参照してください。
RegExpの lastIndex、フラグ、およびソースは、列挙可能なプロパティでなくても常に比較されます。

ESMCJS

import assert from 'node:assert/strict'

// これは、1 !== '1' なので失敗します。
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// 以下のオブジェクトは独自の属性を持っていません
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// 異なる [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// 異なる型タグ:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// Object.is(NaN, NaN) が true なので OK です。

// アンラップされた異なる数値:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// オブジェクトと文字列はアンラップされると同一なので OK です。

assert.deepStrictEqual(-0, -0)
// OK

// 異なるゼロ:
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK、両方のオブジェクトで同じシンボルだからです。

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK、エントリを比較することは不可能だからです

// weakMap3 に weakMap1 にないプロパティがあるため失敗します:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

const assert = require('node:assert/strict')

// これは、1 !== '1' なので失敗します。
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// 以下のオブジェクトは独自の属性を持っていません
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// 異なる [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// 異なる型タグ:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// Object.is(NaN, NaN) が true なので OK です。

// アンラップされた異なる数値:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// オブジェクトと文字列はアンラップされると同一なので OK です。

assert.deepStrictEqual(-0, -0)
// OK

// 異なるゼロ:
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK、両方のオブジェクトで同じシンボルだからです。

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK、エントリを比較することは不可能だからです

// weakMap3 に weakMap1 にないプロパティがあるため失敗します:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

値が等しくない場合、messageプロパティがmessageパラメータの値に設定されたAssertionErrorがスローされます。messageパラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。messageパラメータがErrorのインスタンスである場合、AssertionErrorではなく、それがスローされます。

`assert.doesNotMatch(string, regexp[, message])`

[履歴]

バージョン	変更
v16.0.0	この API は実験的なものではなくなりました。
v13.6.0, v12.16.0	追加: v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

string入力値が正規表現に一致しないことを期待します。

ESMCJS

import assert from 'node:assert/strict'

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/)
// OK

const assert = require('node:assert/strict')

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/)
// OK

値が一致する場合、またはstring引数の型がstring以外の場合、messageパラメータの値に等しいmessageプロパティが設定されたAssertionErrorがスローされます。messageパラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。messageパラメータがErrorのインスタンスである場合、AssertionErrorの代わりにそれがスローされます。

`assert.doesNotReject(asyncFn[, error][, message])`

追加: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function>
message <string>

asyncFnプロミスを待ちます。または、asyncFnが関数の場合、関数をすぐに呼び出し、返されたプロミスが完了するのを待ちます。その後、プロミスが拒否されていないことを確認します。

asyncFnが関数であり、同期的にエラーをスローした場合、assert.doesNotReject()はそのエラーを含む拒否されたPromiseを返します。関数がプロミスを返さない場合、assert.doesNotReject()はERR_INVALID_RETURN_VALUEエラーを含む拒否されたPromiseを返します。どちらの場合も、エラーハンドラはスキップされます。

assert.doesNotReject()を使用することは実際には役に立ちません。拒否をキャッチして再度拒否することにはほとんどメリットがないためです。代わりに、拒否するべきではない特定のコードパスにコメントを追加し、エラーメッセージをできるだけ明確にすることを検討してください。

指定されている場合、errorはClass、RegExp、または検証関数にすることができます。詳細はassert.throws()を参照してください。

非同期的な性質を除いて、完了を待つ動作はassert.doesNotThrow()と同一です。

ESMCJS

import assert from 'node:assert/strict'

await assert.doesNotReject(async () => {
  throw new TypeError('Wrong value')
}, SyntaxError)

const assert = require('node:assert/strict')

;(async () => {
  await assert.doesNotReject(async () => {
    throw new TypeError('Wrong value')
  }, SyntaxError)
})()

ESMCJS

import assert from 'node:assert/strict'

assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))).then(() => {
  // ...
})

const assert = require('node:assert/strict')

assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))).then(() => {
  // ...
})

`assert.doesNotThrow(fn[, error][, message])`

[履歴]

バージョン	変更
v5.11.0, v4.4.5	`message` パラメータが尊重されるようになりました。
v4.2.0	`error` パラメータにアロー関数を使用できるようになりました。
v0.1.21	追加: v0.1.21

fn <Function>
error <RegExp> | <Function>
message <string>

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

assert.doesNotThrow()は、エラーをキャッチして再スローしてもメリットがないため、実際には役に立ちません。代わりに、エラーをスローしないはずの特定のコードパスにコメントを追加し、エラーメッセージをできるだけ分かりやすくすることを検討してください。

assert.doesNotThrow()が呼び出されると、すぐにfn関数が呼び出されます。

エラーがスローされ、それがerrorパラメータで指定された型と同じ場合、AssertionErrorがスローされます。エラーの型が異なる場合、またはerrorパラメータが未定義の場合、エラーは呼び出し元に伝播されます。

指定されている場合、errorはClass、RegExp、または検証関数にすることができます。詳細はassert.throws()を参照してください。

例えば、以下のものは、アサーションに一致するエラー型がないため、TypeErrorをスローします。

ESMCJS

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, SyntaxError)

const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, SyntaxError)

しかし、以下はメッセージ'Got unwanted exception...'と共にAssertionErrorになります。

ESMCJS

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, TypeError)

const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, TypeError)

AssertionErrorがスローされ、messageパラメータに値が提供されている場合、messageの値はAssertionErrorメッセージに追加されます。

ESMCJS

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value')
  },
  /Wrong value/,
  'Whoops'
)
// Throws: AssertionError: Got unwanted exception: Whoops

const assert = require('node:assert/strict')

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value')
  },
  /Wrong value/,
  'Whoops'
)
// Throws: AssertionError: Got unwanted exception: Whoops

`assert.equal(actual, expected[, message])`

[履歴]

バージョン	変更内容
v16.0.0, v14.18.0	レガシーアサーションモードにおいて、状態が「非推奨」から「レガシー」に変更されました。
v14.0.0	両辺が NaN の場合、NaN は同一とみなされるようになりました。
v0.1.21	追加：v0.1.21

actual <any>
expected <any>
message <string> | <Error>

厳密アサーションモード

assert.strictEqual() のエイリアスです。

レガシーアサーションモード

[安定度: 3 - レガシー]

安定度: 3 安定度: 3 - レガシー: 代わりに assert.strictEqual() を使用してください。

== 演算子を使用して、actual パラメータと expected パラメータ間の浅い、強制的な等価性をテストします。NaN は特別に処理され、両辺が NaN の場合は同一とみなされます。

ESMCJS

import assert from 'node:assert'

assert.equal(1, 1)
// OK, 1 == 1
assert.equal(1, '1')
// OK, 1 == '1'
assert.equal(NaN, NaN)
// OK

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

const assert = require('node:assert')

assert.equal(1, 1)
// OK, 1 == 1
assert.equal(1, '1')
// OK, 1 == '1'
assert.equal(NaN, NaN)
// OK

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

値が等しくない場合、message プロパティが message パラメータの値に設定された AssertionError がスローされます。message パラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError の代わりにそれがスローされます。

`assert.fail([message])`

追加されたバージョン: v0.1.21

message <string> | <Error> デフォルト: 'Failed'

指定されたエラーメッセージ、またはデフォルトのエラーメッセージでAssertionErrorをスローします。messageパラメータがErrorのインスタンスである場合、AssertionErrorではなく、それがスローされます。

ESMCJS

import assert from 'node:assert/strict'

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array

const assert = require('node:assert/strict')

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array

assert.fail()に 2 つ以上の引数を渡して使用することは可能ですが、非推奨です。詳細は下記をご覧ください。

`assert.fail(actual, expected[, message[, operator[, stackStartFn]]])`

[履歴]

バージョン	変更
v10.0.0	`assert.fail()`に複数の引数を渡して呼び出すことは非推奨となり、警告が出力されます。
v0.1.21	追加されたバージョン: v0.1.21

[安定版: 0 - 非推奨]

安定版: 0 安定性: 0 - 非推奨: assert.fail([message])または他のアサート関数を使用してください。

actual <any>
expected <any>
message <string> | <Error>
operator <string> デフォルト: '!='
stackStartFn <Function> デフォルト: assert.fail

messageが偽の場合、エラーメッセージは、提供されたoperatorで区切られたactualとexpectedの値として設定されます。actualとexpectedの 2 つの引数のみが提供された場合、operatorは'!='にデフォルト設定されます。messageが 3 番目の引数として提供された場合、それはエラーメッセージとして使用され、他の引数はスローされたオブジェクトのプロパティとして格納されます。stackStartFnが提供された場合、その関数より上のすべてのスタックフレームはスタックトレースから削除されます（Error.captureStackTraceを参照）。引数が何も与えられない場合、デフォルトメッセージFailedが使用されます。

ESMCJS

import assert from 'node:assert/strict'

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array

const assert = require('node:assert/strict')

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array

最後の 3 つのケースでは、actual、expected、operatorはエラーメッセージに影響しません。

stackStartFnの例外のスタックトレースを切り詰めるための使用例：

ESMCJS

import assert from 'node:assert/strict'

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

const assert = require('node:assert/strict')

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

`assert.ifError(value)`

[履歴]

バージョン	変更
v10.0.0	元のエラーをスローする代わりに、完全なスタックトレースを含む[`AssertionError`][]にラップされるようになりました。
v10.0.0	値は`undefined`または`null`のみになります。それ以前は、すべての偽の値が`null`と同じように扱われ、スローされませんでした。
v0.1.97	追加：v0.1.97

value <any>

valueがundefinedまたはnullでない場合、valueをスローします。これは、コールバックのerror引数をテストする場合に便利です。スタックトレースには、ifError()自体に対する潜在的な新しいフレームを含む、ifError()に渡されたエラーからのすべてのフレームが含まれています。

ESMCJS

import assert from 'node:assert/strict'

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

const assert = require('node:assert/strict')

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

`assert.match(string, regexp[, message])`

[履歴]

バージョン	変更点
v16.0.0	この API は実験的なものでなくなりました。
v13.6.0, v12.16.0	追加：v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

string入力値が正規表現に一致することを期待します。

ESMCJS

import assert from 'node:assert/strict'

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/)
// OK

const assert = require('node:assert/strict')

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/)
// OK

値が一致しない場合、またはstring引数の型がstring以外の場合、messageパラメーターの値に等しいmessageプロパティが設定されたAssertionErrorがスローされます。messageパラメーターが未定義の場合、デフォルトのエラーメッセージが割り当てられます。messageパラメーターがErrorのインスタンスである場合、AssertionErrorの代わりにそれがスローされます。

`assert.notDeepEqual(actual, expected[, message])`

[履歴]

バージョン	変更点
v16.0.0, v14.18.0	レガシーアサーションモードで、非推奨からレガシーに変更されました。
v14.0.0	両方が NaN の場合、NaN は同一として扱われます。
v9.0.0	`Error`の名前とメッセージが正しく比較されるようになりました。
v8.0.0	`Set`と`Map`の内容も比較されるようになりました。
v6.4.0, v4.7.1	型付き配列のスライスが正しく処理されるようになりました。
v6.1.0, v4.5.0	循環参照を持つオブジェクトを入力として使用できるようになりました。
v5.10.1, v4.4.3	`Uint8Array`以外の型付き配列を正しく処理します。
v0.1.21	追加：v0.1.21

actual <any>
expected <any>
message <string> | <Error>

厳密なアサーションモード

assert.notDeepStrictEqual()のエイリアスです。

レガシーアサーションモード

[安定版: 3 - レガシー]

安定版: 3 安定性: 3 - レガシー: 代わりにassert.notDeepStrictEqual()を使用してください。

深い不等式をテストします。assert.deepEqual()の反対です。

ESMCJS

import assert from 'node:assert'

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK

const assert = require('node:assert')

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK

値が深く等しい場合、messageパラメーターの値に等しいmessageプロパティが設定されたAssertionErrorがスローされます。messageパラメーターが未定義の場合、デフォルトのエラーメッセージが割り当てられます。messageパラメーターがErrorのインスタンスである場合、AssertionErrorの代わりにそれがスローされます。

`assert.notDeepStrictEqual(actual, expected[, message])`

[履歴]

バージョン	変更内容
v9.0.0	`-0` と `+0` は同一と見なされなくなりました。
v9.0.0	`NaN` は、SameValueZero 比較を使用して比較されるようになりました。
v9.0.0	`Error` の名前とメッセージが正しく比較されるようになりました。
v8.0.0	`Set` と `Map` の内容も比較されるようになりました。
v6.1.0	循環参照を持つオブジェクトを入力として使用できるようになりました。
v6.4.0, v4.7.1	型付き配列のスライスが正しく処理されるようになりました。
v5.10.1, v4.4.3	`Uint8Array` 以外の型付き配列が正しく処理されるようになりました。
v1.2.0	追加: v1.2.0

actual <any>
expected <any>
message <string> | <Error>

厳密な深層不等価性をテストします。assert.deepStrictEqual() の逆です。

ESMCJS

import assert from 'node:assert/strict'

assert.notDeepStrictEqual({ a: 1 }, { a: '1' })
// OK

const assert = require('node:assert/strict')

assert.notDeepStrictEqual({ a: 1 }, { a: '1' })
// OK

値が厳密に深く等しい場合、message プロパティに message パラメータの値が設定された AssertionError がスローされます。message パラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError ではなく、それがスローされます。

`assert.notEqual(actual, expected[, message])`

[履歴]

バージョン	変更内容
v16.0.0, v14.18.0	従来のアサーションモードでは、非推奨からレガシーに変更されました。
v14.0.0	NaN は、両側が NaN の場合、同一と見なされるようになりました。
v0.1.21	追加: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

厳密アサーションモード

assert.notStrictEqual() のエイリアスです。

従来のアサーションモード

[安定度: 3 - レガシー]

安定度: 3 安定性: 3 - レガシー: 代わりに assert.notStrictEqual() を使用してください。

!= 演算子を使用した、浅い強制不等価性をテストします。NaN は特別に扱われ、両側が NaN の場合、同一と見なされます。

ESMCJS

import assert from 'node:assert'

assert.notEqual(1, 2)
// OK

assert.notEqual(1, 1)
// AssertionError: 1 != 1

assert.notEqual(1, '1')
// AssertionError: 1 != '1'

const assert = require('node:assert')

assert.notEqual(1, 2)
// OK

assert.notEqual(1, 1)
// AssertionError: 1 != 1

assert.notEqual(1, '1')
// AssertionError: 1 != '1'

値が等しい場合、message プロパティに message パラメータの値が設定された AssertionError がスローされます。message パラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError ではなく、それがスローされます。

`assert.notStrictEqual(actual, expected[, message])`

[履歴]

バージョン	変更点
v10.0.0	厳密等価比較が `Object.is()` に変更されました。
v0.1.21	追加: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Object.is() によって決定されるように、actual パラメータと expected パラメータの間の厳密な不等式をテストします。

ESMCJS

import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1')
// OK

const assert = require('node:assert/strict')

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1')
// OK

値が厳密に等しい場合、message パラメータの値に等しい message プロパティが設定された AssertionError がスローされます。message パラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError の代わりにそれがスローされます。

`assert.ok(value[, message])`

[履歴]

バージョン	変更点
v10.0.0	`assert.ok()`（引数なし）は、事前に定義されたエラーメッセージを使用するようになりました。
v0.1.21	追加: v0.1.21

value <any>
message <string> | <Error>

value が真であるかどうかをテストします。assert.equal(!!value, true, message) と同等です。

value が真でない場合、message パラメータの値に等しい message プロパティが設定された AssertionError がスローされます。message パラメータが undefined の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError の代わりにそれがスローされます。引数が全く渡されない場合、message は文字列 'No value argument passed to assert.ok()' に設定されます。

repl では、ファイルでスローされるものとは異なるエラーメッセージが表示されることに注意してください！詳細については下記を参照してください。

ESMCJS

import assert from 'node:assert/strict'

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

const assert = require('node:assert/strict')

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

ESMCJS

import assert from 'node:assert/strict'

// Using `assert()` works the same:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

const assert = require('node:assert')

// Using `assert()` works the same:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

`assert.rejects(asyncFn[, error][, message])`

追加: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function> | <Object> | <Error>
message <string>

asyncFnプロミス、またはasyncFnが関数であれば、関数をただちに呼び出して返されたプロミスの完了を待ちます。その後、プロミスが拒否されていることを確認します。

asyncFnが関数であり、同期的にエラーをスローした場合、assert.rejects()は、そのエラーを含む拒否されたPromiseを返します。関数がプロミスを返さない場合、assert.rejects()はERR_INVALID_RETURN_VALUEエラーを含む拒否されたPromiseを返します。どちらの場合も、エラーハンドラーはスキップされます。

完了を待つ非同期的な性質を除けば、assert.throws()とまったく同じ動作をします。

指定されている場合、errorはClass、RegExp、検証関数、各プロパティがテストされるオブジェクト、または列挙不可能なmessageおよびnameプロパティを含む各プロパティがテストされるエラーのインスタンスにすることができます。

指定されている場合、messageは、asyncFnが拒否に失敗した場合にAssertionErrorによって提供されるメッセージになります。

ESMCJS

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value')
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
  }
)

const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value')
    },
    {
      name: 'TypeError',
      message: 'Wrong value',
    }
  )
})()

ESMCJS

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value')
  },
  err => {
    assert.strictEqual(err.name, 'TypeError')
    assert.strictEqual(err.message, 'Wrong value')
    return true
  }
)

const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value')
    },
    err => {
      assert.strictEqual(err.name, 'TypeError')
      assert.strictEqual(err.message, 'Wrong value')
      return true
    }
  )
})()

ESMCJS

import assert from 'node:assert/strict'

assert.rejects(Promise.reject(new Error('Wrong value')), Error).then(() => {
  // ...
})

const assert = require('node:assert/strict')

assert.rejects(Promise.reject(new Error('Wrong value')), Error).then(() => {
  // ...
})

errorは文字列にはできません。2 番目の引数として文字列が提供された場合、errorは省略されたものとみなされ、文字列は代わりにmessageに使用されます。これは見落としやすいミスにつながる可能性があります。文字列を 2 番目の引数として使用することを検討している場合は、assert.throws()の例をよく読んでください。

`assert.strictEqual(actual, expected[, message])`

[履歴]

バージョン	変更
v10.0.0	厳密等価比較が `Object.is()` に変更されました。
v0.1.21	追加: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Object.is() によって決定されるように、actual パラメータと expected パラメータの厳密な等価性をテストします。

ESMCJS

import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`)
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical

const assert = require('node:assert/strict')

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`)
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical

値が厳密に等しくない場合、message プロパティが message パラメータの値に設定された AssertionError がスローされます。message パラメータが未定義の場合、デフォルトのエラーメッセージが割り当てられます。message パラメータが Error のインスタンスである場合、AssertionError ではなく、それがスローされます。

`assert.throws(fn[, error][, message])`

[履歴]

バージョン	変更
v10.2.0	`error` パラメータは、正規表現を含むオブジェクトを指定できるようになりました。
v9.9.0	`error` パラメータは、オブジェクトを指定できるようになりました。
v4.2.0	`error` パラメータは、アロー関数も指定できるようになりました。
v0.1.21	追加: v0.1.21

fn <Function>
error <RegExp> | <Function> | <Object> | <Error>
message <string>

関数 fn がエラーをスローすることを期待します。

指定されている場合、error はClass、RegExp、検証関数、各プロパティが厳密な深層等値でテストされる検証オブジェクト、または厳密な深層等値（列挙できない message および name プロパティを含む）でテストされるエラーのインスタンスにすることができます。オブジェクトを使用する場合、文字列プロパティに対して検証する際に正規表現を使用することも可能です。例については以下を参照してください。

指定されている場合、message は、fn の呼び出しがエラーをスローしない場合、またはエラーの検証に失敗した場合に、AssertionError が提供するメッセージに追加されます。

カスタム検証オブジェクト/エラーインスタンス:

ESMCJS

import assert from 'node:assert/strict'

const err = new TypeError('Wrong value')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // Only properties on the validation object will be tested for.
    // Using nested objects requires all properties to be present. Otherwise
    // the validation is going to fail.
  }
)

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err
  },
  {
    // The `name` and `message` properties are strings and using regular
    // expressions on those will match against the string. If they fail, an
    // error is thrown.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // It is not possible to use regular expressions for nested properties!
      baz: 'text',
    },
    // The `reg` property contains a regular expression and only if the
    // validation object contains an identical regular expression, it is going
    // to pass.
    reg: /abc/i,
  }
)

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found')
    // Copy all enumerable properties from `err` to `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // The error's `message` and `name` properties will also be checked when using
  // an error as validation object.
  err
)

const assert = require('node:assert/strict')

const err = new TypeError('Wrong value')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // Only properties on the validation object will be tested for.
    // Using nested objects requires all properties to be present. Otherwise
    // the validation is going to fail.
  }
)

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err
  },
  {
    // The `name` and `message` properties are strings and using regular
    // expressions on those will match against the string. If they fail, an
    // error is thrown.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // It is not possible to use regular expressions for nested properties!
      baz: 'text',
    },
    // The `reg` property contains a regular expression and only if the
    // validation object contains an identical regular expression, it is going
    // to pass.
    reg: /abc/i,
  }
)

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found')
    // Copy all enumerable properties from `err` to `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // The error's `message` and `name` properties will also be checked when using
  // an error as validation object.
  err
)

コンストラクタを使用した instanceof の検証:

ESMCJS

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Wrong value')
}, Error)

const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Wrong value')
}, Error)

RegExpを使用したエラーメッセージの検証:

正規表現を使用すると、エラーオブジェクトに対して .toString が実行され、そのためエラー名も含まれます。

ESMCJS

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Wrong value')
}, /^Error: Wrong value$/)

const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Wrong value')
}, /^Error: Wrong value$/)

カスタムエラー検証:

関数は、すべての内部検証が成功したことを示すために true を返す必要があります。そうでない場合は、AssertionErrorで失敗します。

ESMCJS

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Wrong value')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Avoid returning anything from validation functions besides `true`.
    // Otherwise, it's not clear what part of the validation failed. Instead,
    // throw an error about the specific validation that failed (as done in this
    // example) and add as much helpful debugging information to that error as
    // possible.
    return true
  },
  'unexpected error'
)

const assert = require('node:assert/strict')

assert.throws(
  () => {
    throw new Error('Wrong value')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Avoid returning anything from validation functions besides `true`.
    // Otherwise, it's not clear what part of the validation failed. Instead,
    // throw an error about the specific validation that failed (as done in this
    // example) and add as much helpful debugging information to that error as
    // possible.
    return true
  },
  'unexpected error'
)

error は文字列にできません。2 番目の引数として文字列が提供された場合、error は省略されたものとみなされ、文字列は代わりに message に使用されます。これは見落としやすいミスにつながる可能性があります。スローされたエラーメッセージと同じメッセージを使用すると、ERR_AMBIGUOUS_ARGUMENT エラーが発生します。2 番目の引数として文字列を使用することを検討する場合は、以下の例を注意深く読んでください。

ESMCJS

import assert from 'node:assert/strict'

function throwingFirst() {
  throw new Error('First')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second')
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/)

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

const assert = require('node:assert/strict')

function throwingFirst() {
  throw new Error('First')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second')
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/)

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

エラーが発生しやすい混乱を招く表記法のため、2 番目の引数として文字列を使用することは避けてください。

`assert.partialDeepStrictEqual(actual, expected[, message])`

追加: v23.4.0

[安定版: 1 - 試験的]

安定版: 1 安定性: 1.0 - 開発初期段階

actual <any>
expected <any>
message <string> | <Error>

assert.partialDeepStrictEqual() は、actual パラメータと expected パラメータの等価性を深層比較によってアサートします。expected パラメータ内のすべてのプロパティが、actual パラメータ内に同等の値で存在することを確認し、型強制は許可しません。assert.deepStrictEqual() との主な違いは、assert.partialDeepStrictEqual() では、actual パラメータ内のすべてのプロパティが expected パラメータに存在する必要がないことです。このメソッドは、常に assert.deepStrictEqual() と同じテストケースに合格する必要があり、その上位集合として動作します。

ESMCJS

import assert from 'node:assert'

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']))
// OK

assert.partialDeepStrictEqual(new Map([['key1', 'value1']]), new Map([['key1', 'value1']]))
// OK

assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))
// OK

assert.partialDeepStrictEqual(/abc/, /abc/)
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual(new Date(0), new Date(0))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError

const assert = require('node:assert')

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError

Assert ​

厳密なアサーションモード ​

レガシーアサーションモード ​

Class: assert.AssertionError ​

new assert.AssertionError(options) ​

クラス: assert.CallTracker ​

new assert.CallTracker() ​

tracker.calls([fn][, exact]) ​

tracker.getCalls(fn) ​

tracker.report() ​

tracker.reset([fn]) ​

tracker.verify() ​

assert(value[, message]) ​

assert.deepEqual(actual, expected[, message]) ​

比較の詳細 ​

assert.deepStrictEqual(actual, expected[, message]) ​

比較の詳細 ​

assert.doesNotMatch(string, regexp[, message]) ​

assert.doesNotReject(asyncFn[, error][, message]) ​

assert.doesNotThrow(fn[, error][, message]) ​

assert.equal(actual, expected[, message]) ​

assert.fail([message]) ​

assert.fail(actual, expected[, message[, operator[, stackStartFn]]]) ​

assert.ifError(value) ​

assert.match(string, regexp[, message]) ​

assert.notDeepEqual(actual, expected[, message]) ​

assert.notDeepStrictEqual(actual, expected[, message]) ​

assert.notEqual(actual, expected[, message]) ​

assert.notStrictEqual(actual, expected[, message]) ​

assert.ok(value[, message]) ​

assert.rejects(asyncFn[, error][, message]) ​

assert.strictEqual(actual, expected[, message]) ​

assert.throws(fn[, error][, message]) ​

assert.partialDeepStrictEqual(actual, expected[, message]) ​

Assert

厳密なアサーションモード

レガシーアサーションモード

Class: assert.AssertionError

`new assert.AssertionError(options)`

クラス: `assert.CallTracker`

`new assert.CallTracker()`

`tracker.calls([fn][, exact])`

`tracker.getCalls(fn)`

`tracker.report()`

`tracker.reset([fn])`

`tracker.verify()`

`assert(value[, message])`

`assert.deepEqual(actual, expected[, message])`

比較の詳細

`assert.deepStrictEqual(actual, expected[, message])`

比較の詳細

`assert.doesNotMatch(string, regexp[, message])`

`assert.doesNotReject(asyncFn[, error][, message])`

`assert.doesNotThrow(fn[, error][, message])`

`assert.equal(actual, expected[, message])`

`assert.fail([message])`

`assert.fail(actual, expected[, message[, operator[, stackStartFn]]])`

`assert.ifError(value)`

`assert.match(string, regexp[, message])`

`assert.notDeepEqual(actual, expected[, message])`

`assert.notDeepStrictEqual(actual, expected[, message])`

`assert.notEqual(actual, expected[, message])`

`assert.notStrictEqual(actual, expected[, message])`

`assert.ok(value[, message])`

`assert.rejects(asyncFn[, error][, message])`

`assert.strictEqual(actual, expected[, message])`

`assert.throws(fn[, error][, message])`

`assert.partialDeepStrictEqual(actual, expected[, message])`