어설션

[안정됨: 2 - 안정됨]

안정됨: 2 안정성: 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	어설트 모듈에 엄격 어설션 모드를 추가함.
v9.9.0	추가됨: v9.9.0

엄격 어설션 모드에서 비엄격 메서드는 해당 엄격 메서드처럼 동작합니다. 예를 들어, assert.deepEqual()은 assert.deepStrictEqual()처럼 동작합니다.

엄격 어설션 모드에서 객체에 대한 오류 메시지는 차이점을 표시합니다. 레거시 어설션 모드에서 객체에 대한 오류 메시지는 객체를 표시하며, 종종 잘립니다.

엄격 어설션 모드를 사용하려면:

ESM

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

CJS

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

ESM

import assert from 'node:assert/strict';

CJS

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

오류 차이점 예시:

ESM

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
//   ]

CJS

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() 문서를 참조하십시오.

레거시 어설션 모드

레거시 어설션 모드는 다음에서 == 연산자를 사용합니다.

• assert.deepEqual()
• assert.equal()
• assert.notDeepEqual()
• assert.notEqual()

레거시 어설션 모드를 사용하려면:

ESM

import assert from 'node:assert';

CJS

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

레거시 어설션 모드는 특히 assert.deepEqual()을 사용할 때 놀라운 결과를 초래할 수 있습니다.

// 경고: 레거시 어설션 모드에서는 AssertionError가 발생하지 않습니다!
assert.deepEqual(/a/gi, new Date());

클래스: assert.AssertionError

• 확장: <errors.Error>

어설션 실패를 나타냅니다. node:assert 모듈에서 throw되는 모든 오류는 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> 전달된 연산자 값으로 설정됩니다.

ESM

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

CJS

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') 핸들러에서 호출하는 것입니다.

ESM

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

CJS

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()는 오류를 발생시킵니다.

ESM

import assert from 'node:assert';

// 호출 추적기를 만듭니다.
const tracker = new assert.CallTracker();

function func() {}

// tracker.verify() 전에 정확한 횟수만큼 호출해야 하는 func()를 래핑하는 함수를
// 반환합니다.
const callsfunc = tracker.calls(func);

CJS

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> 추적된 함수에 전달된 인수

ESM

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

CJS

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

// Creates call tracker.
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> 함수의 스택 추적입니다.

배열에는 예상 횟수만큼 호출되지 않은 함수의 예상 및 실제 호출 횟수에 대한 정보가 포함되어 있습니다.

ESM

import assert from 'node:assert';

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on 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
//  }
// ]

CJS

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

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on 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])

Added in: v18.8.0, v16.18.0

• fn <Function> 재설정할 추적된 함수입니다.

호출 트래커의 호출을 재설정합니다. 추적된 함수가 인수로 전달되면 해당 함수에 대한 호출이 재설정됩니다. 인수가 전달되지 않으면 추적된 모든 함수가 재설정됩니다.

ESM

import assert from 'node:assert';

const tracker = new assert.CallTracker();

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

callsfunc();
// 트래커가 한 번 호출되었습니다.
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);

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

CJS

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

const tracker = new assert.CallTracker();

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

callsfunc();
// 트래커가 한 번 호출되었습니다.
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);

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

tracker.verify()

Added in: v14.2.0, v12.19.0

tracker.calls()에 전달된 함수 목록을 반복하고 예상 횟수만큼 호출되지 않은 함수에 대해 오류를 발생시킵니다.

ESM

import assert from 'node:assert';

// 호출 트래커를 만듭니다.
const tracker = new assert.CallTracker();

function func() {}

// tracker.verify() 전에 정확한 횟수만큼 호출해야 하는 func()을 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2);

callsfunc();

// callsfunc()가 한 번만 호출되었으므로 오류를 발생시킵니다.
tracker.verify();

CJS

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

// 호출 트래커를 만듭니다.
const tracker = new assert.CallTracker();

function func() {}

// tracker.verify() 전에 정확한 횟수만큼 호출해야 하는 func()을 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2);

callsfunc();

// callsfunc()가 한 번만 호출되었으므로 오류를 발생시킵니다.
tracker.verify();

assert(value[, message])

Added in: v0.5.9

• value <any> 참인지 확인되는 입력.
• message <string> | <Error>

assert.ok()의 별칭입니다.

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

[History]

Version	Changes
v22.2.0, v20.15.0	오류 원인과 errors 속성도 이제 비교됩니다.
v18.0.0	정규 표현식 lastIndex 속성도 이제 비교됩니다.
v16.0.0, v14.18.0	레거시 어설션 모드에서, 상태가 Deprecated에서 Legacy로 변경되었습니다.
v14.0.0	NaN은 이제 양쪽 모두 NaN인 경우 동일한 것으로 간주됩니다.
v12.0.0	이제 타입 태그가 올바르게 비교되며, 확인이 덜 놀랍도록 몇 가지 사소한 비교 조정이 있습니다.
v9.0.0	이제 Error 이름과 메시지가 올바르게 비교됩니다.
v8.0.0	이제 Set 및 Map 콘텐츠도 비교됩니다.
v6.4.0, v4.7.1	이제 Typed 배열 슬라이스가 올바르게 처리됩니다.
v6.1.0, v4.5.0	이제 순환 참조가 있는 객체를 입력으로 사용할 수 있습니다.
v5.10.1, v4.4.3	비-Uint8Array Typed 배열을 올바르게 처리합니다.
v0.1.21	Added in: v0.1.21

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

엄격한 어설션 모드

assert.deepStrictEqual()의 별칭입니다.

레거시 어설션 모드

[Stable: 3 - Legacy]

Stable: 3 Stability: 3 - Legacy: 대신 assert.deepStrictEqual()을 사용하십시오.

actual 및 expected 매개변수 간의 깊은 동등성을 테스트합니다. 대신 assert.deepStrictEqual()을 사용하는 것을 고려하십시오. assert.deepEqual()은 놀라운 결과를 가져올 수 있습니다.

깊은 동등성은 하위 객체의 열거 가능한 "자체" 속성도 다음 규칙에 따라 재귀적으로 평가됨을 의미합니다.

비교 세부 사항

• 기본값은 NaN을 제외하고 == 연산자로 비교됩니다. 양쪽 모두 NaN인 경우 동일한 것으로 취급됩니다.
• 객체의 타입 태그는 동일해야 합니다.
• 열거 가능한 "own" 속성만 고려됩니다.
• Error 이름, 메시지, 원인 및 오류는 열거 가능한 속성이 아니더라도 항상 비교됩니다.
• 객체 래퍼는 객체 및 래핑 해제된 값으로 모두 비교됩니다.
• Object 속성은 순서 없이 비교됩니다.
• Map 키와 Set 항목은 순서 없이 비교됩니다.
• 재귀는 양쪽이 다르거나 양쪽 모두 순환 참조를 만날 때 중지됩니다.
• 구현은 객체의 [[Prototype]]을 테스트하지 않습니다.
• Symbol 속성은 비교되지 않습니다.
• WeakMap 및 WeakSet 비교는 값에 의존하지 않고 인스턴스에만 의존합니다.
• RegExp lastIndex, flags 및 source는 열거 가능한 속성이 아니더라도 항상 비교됩니다.

다음 예제는 기본값이 == 연산자를 사용하여 비교되기 때문에 AssertionError를 발생시키지 않습니다.

ESM

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

assert.deepEqual('+00000000', false);

CJS

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

assert.deepEqual('+00000000', false);

"Deep" equality는 자식 객체의 열거 가능한 "own" 속성도 평가된다는 의미입니다.

ESM

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 {}

CJS

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	오류 원인 및 errors 속성도 비교됩니다.
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]]은 === 연산자를 사용하여 비교됩니다.
• 열거 가능한 "자체" 속성만 고려됩니다.
• Error 이름, 메시지, 원인 및 오류는 열거 가능한 속성이 아니더라도 항상 비교됩니다. errors도 비교됩니다.
• 열거 가능한 자체 Symbol 속성도 비교됩니다.
• 객체 래퍼는 객체와 언래핑된 값으로 모두 비교됩니다.
• Object 속성은 순서 없이 비교됩니다.
• Map 키와 Set 항목은 순서 없이 비교됩니다.
• 재귀는 양쪽 모두 다르거나 양쪽 모두 순환 참조를 만날 때 중지됩니다.
• WeakMap 및 WeakSet 비교는 해당 값에 의존하지 않습니다. 자세한 내용은 아래를 참조하세요.
• RegExp lastIndex, flags 및 source는 열거 가능한 속성이 아니더라도 항상 비교됩니다.

ESM

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

// 다른 0:
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
//   }

CJS

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

// 다른 0:
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가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

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 입력이 정규 표현식과 일치하지 않을 것으로 예상합니다.

ESM

import assert from 'node:assert/strict';

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: 입력이 일치하지 않을 것으로 예상되었습니다. ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: "string" 인수는 string 유형이어야 합니다.

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

CJS

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

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: 입력이 일치하지 않을 것으로 예상되었습니다. ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: "string" 인수는 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()와 동일하게 작동합니다.

ESM

import assert from 'node:assert/strict';

await assert.doesNotReject(
  async () => {
    throw new TypeError('잘못된 값');
  },
  SyntaxError,
);

CJS

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

(async () => {
  await assert.doesNotReject(
    async () => {
      throw new TypeError('잘못된 값');
    },
    SyntaxError,
  );
})();

ESM

import assert from 'node:assert/strict';

assert.doesNotReject(Promise.reject(new TypeError('잘못된 값')))
  .then(() => {
    // ...
  });

CJS

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

assert.doesNotReject(Promise.reject(new TypeError('잘못된 값')))
  .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를 발생시킵니다.

ESM

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  SyntaxError,
);

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  SyntaxError,
);

그러나 다음은 '원치 않는 예외가 발생했습니다...'라는 메시지와 함께 AssertionError를 발생시킵니다.

ESM

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  TypeError,
);

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  TypeError,
);

AssertionError가 발생하고 message 매개변수에 값이 제공되면 message 값이 AssertionError 메시지에 추가됩니다.

ESM

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  /잘못된 값/,
  '이런',
);
// 발생: AssertionError: 원치 않는 예외가 발생했습니다: 이런

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('잘못된 값');
  },
  /잘못된 값/,
  '이런',
);
// 발생: AssertionError: 원치 않는 예외가 발생했습니다: 이런

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인 경우 동일한 것으로 취급됩니다.

ESM

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

CJS

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])

Added in: v0.1.21

• message <string> | <Error> 기본: 'Failed'

제공된 오류 메시지 또는 기본 오류 메시지와 함께 AssertionError를 발생시킵니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 발생합니다.

ESM

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

CJS

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()을 사용하는 것은 가능하지만 더 이상 사용되지 않습니다. 자세한 내용은 아래를 참조하십시오.

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

[History]

Version	Changes
v10.0.0	둘 이상의 인수로 assert.fail()을 호출하는 것은 더 이상 사용되지 않으며 경고를 발생시킵니다.
v0.1.21	Added in: v0.1.21

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - 더 이상 사용되지 않음: 대신 assert.fail([message]) 또는 다른 assert 함수를 사용하십시오.

• actual <any>
• expected <any>
• message <string> | <Error>
• operator <string> 기본: '!='
• stackStartFn <Function> 기본: assert.fail

message가 falsy인 경우 오류 메시지는 제공된 operator로 구분된 actual 및 expected 값으로 설정됩니다. 두 개의 actual 및 expected 인수만 제공되는 경우 operator는 기본적으로 '!='가 됩니다. message가 세 번째 인수로 제공되면 오류 메시지로 사용되고 다른 인수는 throw된 객체의 속성으로 저장됩니다. stackStartFn이 제공되면 해당 함수 위의 모든 스택 프레임이 스택 추적에서 제거됩니다 (/api/errors#errorcapturestacktracetargetobject-constructoropt 참조). 인수가 제공되지 않으면 기본 메시지 Failed가 사용됩니다.

ESM

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

CJS

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

마지막 세 가지 경우에서 actual, expected 및 operator는 오류 메시지에 영향을 미치지 않습니다.

예외의 스택 추적을 잘라내기 위한 stackStartFn의 사용 예:

ESM

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)
//     ...

CJS

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	이제 value는 undefined 또는 null만 가능합니다. 이전에는 모든 거짓 값이 null과 동일하게 처리되었고 오류가 발생하지 않았습니다.
v0.1.97	다음에서 추가됨: v0.1.97

• value <any>

value가 undefined 또는 null이 아니면 value를 발생시킵니다. 이는 콜백에서 error 인수를 테스트할 때 유용합니다. 스택 추적에는 ifError() 자체에 대한 잠재적인 새 프레임을 포함하여 ifError()에 전달된 오류의 모든 프레임이 포함됩니다.

ESM

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

CJS

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 입력이 정규 표현식과 일치할 것으로 예상합니다.

ESM

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

CJS

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 유형이 아닌 경우, AssertionError가 발생하고 message 속성이 message 매개 변수의 값과 같게 설정됩니다. 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	Typed array 슬라이스가 이제 올바르게 처리됩니다.
v6.1.0, v4.5.0	순환 참조가 있는 객체를 이제 입력으로 사용할 수 있습니다.
v5.10.1, v4.4.3	non-Uint8Array typed array를 올바르게 처리합니다.
v0.1.21	추가됨: v0.1.21

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

엄격한 어설션 모드

assert.notDeepStrictEqual()의 별칭입니다.

레거시 어설션 모드

[안정성: 3 - 레거시]

안정성: 3 안정성: 3 - 레거시: 대신 assert.notDeepStrictEqual()을 사용하세요.

모든 깊은 불평등을 테스트합니다. assert.deepEqual()의 반대입니다.

ESM

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

CJS

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

값이 깊이 동일한 경우, AssertionError가 발생하고 message 속성이 message 매개 변수의 값과 같게 설정됩니다. 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()의 반대입니다.

ESM

import assert from 'node:assert/strict';

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

CJS

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

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

값이 깊고 엄격하게 동일하면 message 속성이 message 매개변수의 값과 같게 설정된 AssertionError가 발생합니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

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인 경우 동일한 것으로 취급됩니다.

ESM

import assert from 'node:assert';

assert.notEqual(1, 2);
// OK

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

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

CJS

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 대신 throw됩니다.

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 매개변수 간의 엄격한 부등식을 테스트합니다.

ESM

import assert from 'node:assert/strict';

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: "actual"이 엄격하게 같지 않을 것으로 예상됨:
//
// 1

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

CJS

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

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: "actual"이 엄격하게 같지 않을 것으로 예상됨:
//
// 1

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

값이 엄격하게 같으면 message 속성이 message 매개변수의 값과 같게 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

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가 throw됩니다. message 매개변수가 undefined이면 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다. 인수가 전혀 전달되지 않으면 message는 문자열 'No value argument passed to assert.ok()'로 설정됩니다.

repl에서 오류 메시지가 파일에서 throw되는 오류 메시지와 다를 수 있다는 점에 유의하십시오! 자세한 내용은 아래를 참조하십시오.

ESM

import assert from 'node:assert/strict';

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

assert.ok();
// AssertionError: `assert.ok()`에 값 인수가 전달되지 않았습니다.

assert.ok(false, '거짓입니다.');
// AssertionError: 거짓입니다.

// repl에서:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// 파일에서 (예: test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(0)

CJS

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

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

assert.ok();
// AssertionError: `assert.ok()`에 값 인수가 전달되지 않았습니다.

assert.ok(false, '거짓입니다.');
// AssertionError: 거짓입니다.

// repl에서:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// 파일에서 (예: test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert.ok(0)

ESM

import assert from 'node:assert/strict';

// `assert()`를 사용하는 것도 동일하게 작동합니다.
assert(0);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert(0)

CJS

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

// `assert()`를 사용하는 것도 동일하게 작동합니다.
assert(0);
// AssertionError: 표현식이 거짓 같은 값으로 평가되었습니다.
//
//   assert(0)

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

추가된 버전: v10.0.0

• asyncFn <함수> | <Promise>
• error <RegExp> | <함수> | <객체> | <오류>
• message <string>

asyncFn 프로미스를 대기하거나, asyncFn이 함수인 경우 즉시 함수를 호출하고 반환된 프로미스가 완료될 때까지 기다립니다. 그런 다음 프로미스가 거부되는지 확인합니다.

asyncFn이 함수이고 오류를 동기적으로 발생시키는 경우 assert.rejects()는 해당 오류와 함께 거부된 Promise를 반환합니다. 함수가 프로미스를 반환하지 않으면 assert.rejects()는 ERR_INVALID_RETURN_VALUE 오류와 함께 거부된 Promise를 반환합니다. 두 경우 모두 오류 처리기가 건너뜁니다.

완료를 기다리는 비동기적 특성 외에는 assert.throws()와 동일하게 동작합니다.

지정된 경우 error는 클래스, RegExp, 유효성 검사 함수, 각 속성이 테스트될 객체 또는 열거할 수 없는 message 및 name 속성을 포함하여 각 속성이 테스트될 오류의 인스턴스일 수 있습니다.

지정된 경우 asyncFn이 거부되지 못할 경우 message는 AssertionError에서 제공하는 메시지가 됩니다.

ESM

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('잘못된 값');
  },
  {
    name: 'TypeError',
    message: '잘못된 값',
  },
);

CJS

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

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('잘못된 값');
    },
    {
      name: 'TypeError',
      message: '잘못된 값',
    },
  );
})();

ESM

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('잘못된 값');
  },
  (err) => {
    assert.strictEqual(err.name, 'TypeError');
    assert.strictEqual(err.message, '잘못된 값');
    return true;
  },
);

CJS

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

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('잘못된 값');
    },
    (err) => {
      assert.strictEqual(err.name, 'TypeError');
      assert.strictEqual(err.message, '잘못된 값');
      return true;
    },
  );
})();

ESM

import assert from 'node:assert/strict';

assert.rejects(
  Promise.reject(new Error('잘못된 값')),
  Error,
).then(() => {
  // ...
});

CJS

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

assert.rejects(
  Promise.reject(new Error('잘못된 값')),
  Error,
).then(() => {
  // ...
});

error는 문자열일 수 없습니다. 문자열이 두 번째 인수로 제공되면 error는 생략된 것으로 간주되고 문자열은 대신 message에 사용됩니다. 이로 인해 쉽게 놓칠 수 있는 실수가 발생할 수 있습니다. 두 번째 인수로 문자열을 사용하는 것이 고려되는 경우 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 매개변수 간의 엄격한 동일성을 테스트합니다.

ESM

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

CJS

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에서 제공하는 메시지에 추가됩니다.

사용자 지정 유효성 검사 객체/오류 인스턴스:

ESM

import assert from 'node:assert/strict';

const err = new TypeError('잘못된 값');
err.code = 404;
err.foo = 'bar';
err.info = {
  nested: true,
  baz: 'text',
};
err.reg = /abc/i;

assert.throws(
  () => {
    throw err;
  },
  {
    name: 'TypeError',
    message: '잘못된 값',
    info: {
      nested: true,
      baz: 'text',
    },
    // 유효성 검사 객체의 속성만 테스트됩니다.
    // 중첩된 객체를 사용하려면 모든 속성이 있어야 합니다. 그렇지 않으면
    // 유효성 검사가 실패합니다.
  },
);

// 정규식을 사용하여 오류 속성 유효성 검사:
assert.throws(
  () => {
    throw err;
  },
  {
    // `name` 및 `message` 속성은 문자열이며 정규식을 사용하여 해당 속성을
    // 검사하면 문자열과 일치합니다. 실패하면 오류가 발생합니다.
    name: /^TypeError$/,
    message: /잘못된/,
    foo: 'bar',
    info: {
      nested: true,
      // 중첩된 속성에 정규식을 사용할 수 없습니다!
      baz: 'text',
    },
    // `reg` 속성은 정규식을 포함하며 유효성 검사 객체에 동일한 정규식이 포함된 경우에만
    // 통과합니다.
    reg: /abc/i,
  },
);

// 다른 `message` 및 `name` 속성으로 인해 실패합니다.
assert.throws(
  () => {
    const otherErr = new Error('찾을 수 없음');
    // `err`의 모든 열거 가능한 속성을 `otherErr`에 복사합니다.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value;
    }
    throw otherErr;
  },
  // 오류의 `message` 및 `name` 속성은 유효성 검사 객체로 오류를 사용할 때도 확인됩니다.
  err,
);

CJS

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

const err = new TypeError('잘못된 값');
err.code = 404;
err.foo = 'bar';
err.info = {
  nested: true,
  baz: 'text',
};
err.reg = /abc/i;

assert.throws(
  () => {
    throw err;
  },
  {
    name: 'TypeError',
    message: '잘못된 값',
    info: {
      nested: true,
      baz: 'text',
    },
    // 유효성 검사 객체의 속성만 테스트됩니다.
    // 중첩된 객체를 사용하려면 모든 속성이 있어야 합니다. 그렇지 않으면
    // 유효성 검사가 실패합니다.
  },
);

// 정규식을 사용하여 오류 속성 유효성 검사:
assert.throws(
  () => {
    throw err;
  },
  {
    // `name` 및 `message` 속성은 문자열이며 정규식을 사용하여 해당 속성을
    // 검사하면 문자열과 일치합니다. 실패하면 오류가 발생합니다.
    name: /^TypeError$/,
    message: /잘못된/,
    foo: 'bar',
    info: {
      nested: true,
      // 중첩된 속성에 정규식을 사용할 수 없습니다!
      baz: 'text',
    },
    // `reg` 속성은 정규식을 포함하며 유효성 검사 객체에 동일한 정규식이 포함된 경우에만
    // 통과합니다.
    reg: /abc/i,
  },
);

// 다른 `message` 및 `name` 속성으로 인해 실패합니다.
assert.throws(
  () => {
    const otherErr = new Error('찾을 수 없음');
    // `err`의 모든 열거 가능한 속성을 `otherErr`에 복사합니다.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value;
    }
    throw otherErr;
  },
  // 오류의 `message` 및 `name` 속성은 유효성 검사 객체로 오류를 사용할 때도 확인됩니다.
  err,
);

생성자를 사용하여 instanceof 유효성 검사:

ESM

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  Error,
);

CJS

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

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  Error,
);

RegExp를 사용하여 오류 메시지 유효성 검사:

정규식을 사용하면 오류 객체에서 .toString이 실행되므로 오류 이름도 포함됩니다.

ESM

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  /^Error: 잘못된 값$/,
);

CJS

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

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  /^Error: 잘못된 값$/,
);

사용자 지정 오류 유효성 검사:

함수는 모든 내부 유효성 검사가 통과되었음을 나타내기 위해 true를 반환해야 합니다. 그렇지 않으면 AssertionError로 실패합니다.

ESM

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  (err) => {
    assert(err instanceof Error);
    assert(/value/.test(err));
    // 유효성 검사 함수에서 `true` 이외의 다른 것을 반환하지 마십시오.
    // 그렇지 않으면 유효성 검사의 어느 부분이 실패했는지 명확하지 않습니다. 대신
    // 실패한 특정 유효성 검사에 대한 오류를 발생시키고 (이 예에서 수행된 것처럼) 해당 오류에
    // 최대한 많은 유용한 디버깅 정보를 추가하십시오.
    return true;
  },
  '예상치 못한 오류',
);

CJS

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

assert.throws(
  () => {
    throw new Error('잘못된 값');
  },
  (err) => {
    assert(err instanceof Error);
    assert(/value/.test(err));
    // 유효성 검사 함수에서 `true` 이외의 다른 것을 반환하지 마십시오.
    // 그렇지 않으면 유효성 검사의 어느 부분이 실패했는지 명확하지 않습니다. 대신
    // 실패한 특정 유효성 검사에 대한 오류를 발생시키고 (이 예에서 수행된 것처럼) 해당 오류에
    // 최대한 많은 유용한 디버깅 정보를 추가하십시오.
    return true;
  },
  '예상치 못한 오류',
);

error는 문자열일 수 없습니다. 문자열이 두 번째 인수로 제공되면 error는 생략된 것으로 간주되고 문자열은 message에 사용됩니다. 이로 인해 쉽게 놓칠 수 있는 실수가 발생할 수 있습니다. 발생된 오류 메시지와 동일한 메시지를 사용하면 ERR_AMBIGUOUS_ARGUMENT 오류가 발생합니다. 문자열을 두 번째 인수로 사용하는 것을 고려하는 경우 아래 예제를 주의 깊게 읽으십시오.

ESM

import assert from 'node:assert/strict';

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

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

function notThrowing() {}

// 두 번째 인수는 문자열이고 입력 함수가 Error를 발생시켰습니다.
// 첫 번째 경우는 입력 함수에서 발생한 오류 메시지와 일치하지 않으므로 발생하지 않습니다!
assert.throws(throwingFirst, 'Second');
// 다음 예제에서 메시지는 오류의 메시지보다 이점이 없으며 사용자가 실제로
// 오류 메시지와 일치시키려고 했는지 명확하지 않으므로 Node.js는 `ERR_AMBIGUOUS_ARGUMENT` 오류를 발생시킵니다.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// 문자열은 함수가 오류를 발생시키지 않는 경우에만 (메시지로) 사용됩니다.
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// 오류 메시지와 일치시키려는 경우 대신 이렇게 하십시오.
// 오류 메시지가 일치하므로 발생하지 않습니다.
assert.throws(throwingSecond, /Second$/);

// 오류 메시지가 일치하지 않으면 AssertionError가 발생합니다.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]

CJS

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

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

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

function notThrowing() {}

// 두 번째 인수는 문자열이고 입력 함수가 Error를 발생시켰습니다.
// 첫 번째 경우는 입력 함수에서 발생한 오류 메시지와 일치하지 않으므로 발생하지 않습니다!
assert.throws(throwingFirst, 'Second');
// 다음 예제에서 메시지는 오류의 메시지보다 이점이 없으며 사용자가 실제로
// 오류 메시지와 일치시키려고 했는지 명확하지 않으므로 Node.js는 `ERR_AMBIGUOUS_ARGUMENT` 오류를 발생시킵니다.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// 문자열은 함수가 오류를 발생시키지 않는 경우에만 (메시지로) 사용됩니다.
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// 오류 메시지와 일치시키려는 경우 대신 이렇게 하십시오.
// 오류 메시지가 일치하므로 발생하지 않습니다.
assert.throws(throwingSecond, /Second$/);

// 오류 메시지가 일치하지 않으면 AssertionError가 발생합니다.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]

혼란스럽고 오류가 발생하기 쉬운 표기법 때문에 문자열을 두 번째 인수로 사용하지 마십시오.

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

추가됨: v23.4.0

[Stable: 1 - 실험적]

Stable: 1 안정성: 1.0 - 초기 개발

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

assert.partialDeepStrictEqual()은 actual 및 expected 매개변수 간의 동등성을 깊은 비교를 통해 단언하여 expected 매개변수의 모든 속성이 타입 강제 변환 없이 동등한 값을 가진 actual 매개변수에 있는지 확인합니다. assert.deepStrictEqual()과의 주요 차이점은 assert.partialDeepStrictEqual()은 actual 매개변수의 모든 속성이 expected 매개변수에 있을 필요가 없다는 것입니다. 이 메서드는 항상 assert.deepStrictEqual()과 동일한 테스트 케이스를 통과해야 하며, 슈퍼 세트처럼 동작합니다.

ESM

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

CJS

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