[nodejs] 断言

assert

主要用于判断两个变量是否一致（官方语言：assert 模块提供了一组用于验证不变量的断言函数。）
下文test case使用版本为node 16.14.0

// 代码示例为严格模式
const assert = require('assert/strict');
assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]); // 其中3是有所不同的，第一个是数字，第二个是字符串

当我们运行时，会发现，node会给出错误提示，并告知是哪个元素不同

可以看到，node会抛出一个错误，这个错误是assert.AssertionError类的，继承自<errors.Error>；

AssertionError

创建assertionError类时，可以携带部分参数，具体参数如下：

• option<object>：
  • message <string> 如果提供，则错误消息将设置为此值。
  • actual <any> 错误实例上的 actual 属性。
  • expected <any> 错误实例上的 expected 属性。
  • operator <string> 错误实例上的 operator 属性。
  • stackStartFn <Function> 如果提供，则生成的堆栈跟踪将省略此函数之前的帧

所有实例都包含内置的 Error 属性（message 和 name），以及：

• actual 对于 assert.strictEqual() 等方法，设置为 actual 参数。
• expected 对于 assert.strictEqual() 等方法，设置为 expected 值。
• generatedMessage 指示消息是否是自动生成的 (true)。
• code 值始终为 ERR_ASSERTION，以表明该错误是断言错误。
• operator 设置为传入的运算符值。

ps：可以看上图对应实例中的参数具体内容

创建AssertionError类，我们输入1，预期是2，使用strictEqual方法比较：

const assert = require('assert');
// 生成 AssertionError，以便稍后比较错误信息：
const {
    message } = new assert.AssertionError({
   
  actual: 1,
  expected: 2,
  operator: 'strictEqual'
});
console.log('=========message start==========');
console.log(message);
console.log('=========message end==========');
console.log('=========AssertionError start==========');
console.log(new assert.AssertionError({
   
   actual: 1,
   expected: 2,
   operator: 'strictEqual'
}));
console.log('=========AssertionError end==========');

我们运行后的结果为

=========message start==========
Expected values to be strictly equal:

1 !== 2

=========message end==========
=========AssertionError start==========
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:

1 !== 2

    at new AssertionError (node:internal/assert/assertion_error:466:5)
    at Object.<anonymous> (/Users/work/node_test/app.js:12:13)
    at Module._compile (node:internal/modules/cjs/loader:1103:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1155:10)
    at Module.load (node:internal/modules/cjs/loader:981:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
    at node:internal/main/run_main_module:17:47 {
   
  generatedMessage: true,
  code: 'ERR_ASSERTION',
  actual: 1,
  expected: 2,
  operator: 'strictEqual'
}
=========AssertionError end==========

验证assert中的错误输出结果与我们预期是否一致

const assert = require('assert');
// 生成 AssertionError，以便稍后比较错误信息：
const {
    message } = new assert.AssertionError({
   
  actual: 1,
  expected: 2,
  operator: 'strictEqual'
});
// 验证错误的输出：
try {
   
  assert.strictEqual(1, 2);
} catch (err) {
   
  // 修改下边的任意比较值，都会有响应比较错误的报错，try~
  assert(err instanceof assert.AssertionError); // 错误类型为assert.AssertionError这个类
  assert.strictEqual(err.message, message); // 错误的消息是上个实验的消息
  assert.strictEqual(err.name, 'AssertionError'); // 错误名字是AssertionError
  assert.strictEqual(err.actual, 1); // 输入的是1
  assert.strictEqual(err.expected, 2); // 预期数值是2
  assert.strictEqual(err.code, 'ERR_ASSERTION'); // code值始终为 ERR_ASSERTION，以表明该错误是断言错误。
  assert.strictEqual(err.operator, 'strictEqual'); // 使用的是strictEqual方法
  assert.strictEqual(err.generatedMessage, true); // 是否为自动生成的消息
}

运行此段代码时，程序不会报错，说明，strictEqual传递的两个参数是一致的，尝试修改上述配置的任意值，都将有新的错误出现，可以试试~

assert.CallTracker类

新增v14.2.0, v12.19.0，该api目前处在实验阶段

官方语言：可用于跟踪函数是否被调用了特定次数。 必须调用 tracker.verify() 才能进行验证。 通常的模式是在 process.on(‘exit’) 句柄中调用。如果是和预期相符的，不会报错，如果是不相符的就会报错，多说无益，上code

const assert = require('assert');
const  process = require('process');

const tracker = new assert.CallTracker();

function func() {
   
    console.log('enter the function');
}

// 官方注释：callfunc() 必须在 tracker.verify() 之前恰好被调用 1 次。
// 拟调用callsfunc一次，如果多次调用就会报错
const runNum = 1;
const callsfunc = tracker.calls(func, runNum);

callsfunc();
// callsfunc(); // 本函数注释掉不会有任何报错，解除注释后会有报错

// 调用 tracker.verify() 并验证是否所有 tracker.calls() 函数都已被准确调用。
process.on('exit', () => {
   
  tracker.verify();
});

如果callsfunc只调用一次，运行上述函数不会有任何问题，如果把注释删除，调用2次函数会报AssertionError错误，错误如下：

enter the function
enter the function
node:internal/assert/calltracker:88
      throw new AssertionError({
   
      ^

AssertionError [ERR_ASSERTION]: Function(s) were not called the expected number of times
    at new AssertionError (node:internal/assert/assertion_error:466:5)
    at CallTracker.verify (node:internal/assert/calltracker:88:13)
    at process.<anonymous> (/Users/work/node_test/app.js:18:11)
    at process.emit (node:events:520:28) {
   
  generatedMessage: false,
  code: 'ERR_ASSERTION',
  actual: undefined,
  expected: undefined,
  operator: undefined,
  'message 0': 'Expected the func function to be executed 1 time(s) but was executed 2 time(s).',
  'actual 0': 2, // 实际调用了2次
  'expected 0': 1, // 预期是1次
  'operator 0': 'func',
  'stack trace 0': Error
      at CallTracker.calls (node:internal/assert/calltracker:43:19)
      at Object.<anonymous> (/Users/work/node_test/app.js:11:27)
      at Module._compile (node:internal/modules/cjs/loader:1103:14)
      at Object.Module._extensions..js (node:internal/modules/cjs/loader:1155:10)
      at Module.load (node:internal/modules/cjs/loader:981:32)
      at Function.Module._load (node:internal/modules/cjs/loader:822:12)
      at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
      at node:internal/main/run_main_module:17:47
}

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

新增于: v14.2.0, v12.19.0

• fn <Function> 默认值: 无操作的函数。
• exact <number> 默认值: 1。
• 返回: <Function> 封装 fn。

预计封装函数将被精确调用 exact 次。 如果在调用 tracker.verify() 时函数没有被精确调用 exact 次，那么 tracker.verify() 将抛出错误。

使用方法和测试例子可以看上面的例子，报错和使用方式一致。

tracker.report()

新增于: v14.2.0, v12.19.0

• 返回: <Array> 包含有关 tracker.calls() 返回的封装函数的信息的对象的数组。
• 对象 <Object>
• message <string>
• actual <number> 函数被调用的实际次数。
• expected <number> 函数预期被调用的次数。
• operator <string> 被封装的函数的名称。
• stack <Object> 函数的堆栈跟踪。

数组包含有关未调用预期次数的函数的预期和实际调用次数的信息。

const assert = require('assert');
// 创建调用跟踪器。
const tracker = new assert.CallTracker();

function func() {
   }

function foo() {
   }

// 返回封装 func() 的函数，其必须在 tracker.verify() 之前调用准确次数。
const callsfunc = tracker.calls(func, 2);

callsfunc(); // 此函数为封装了func的函数，可以统计到调用的次数

// 返回包含 callfunc() 信息的数组()
const report = tracker.report();
console.log(report);
// 打印后的内容
// [
//  {
   
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 1,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]