1. //  assertion [əˈsɜːʃn] assert [əˈsɜː]
    4. // http://nodejs.cn/api/assert.html 当前参考版本 node v12.13.1
    5. /*
    6. // assert 模块抛出的所有错误都将是 AssertionError 类的实例。
    7. new assert.AssertionError(options: {
    8.   message: string; // 如果提供，则将错误消息设置为此值。
    9.   actual: any; // 错误实例上的 actual 属性将包含此值。
    10.   expected: any; // 错误实例上的 expected 属性将包含此值。
    11.   operator: string; // 错误实例上的 operator 属性将包含此值。
    12.   stackStartFn: Function; // 如果提供，则生成的堆栈跟踪将移除所有帧直到提供的函数。
    13. })
    16. assert.deepEqual(actual: any, expected: any[, message:string| Error]); 已废弃，应改为 assert.deepStrictEqual() 
    17.   // 深比较
    18.   // 使用抽象的相等性比较来比较原始值。
    19.   // 对象的类型标签应该相同。
    20.   // 只考虑可枚举的自身属性。
    21.   // 始终比较 Error 的名称和消息，即使这些不是可枚举的属性。
    22.   // 对象封装器作为对象和解封装后的值都进行比较。
    23.   // Object 属性的比较是无序的。
    24.   // Map 键名与 Set 子项的比较是无序的。
    25.   // 当两边的值不相同或遇到循环引用时，递归停止。
    26.   // 不测试对象的 [[Prototype]]。
    27.   // 可枚举的自身 Symbol 属性也会比较。
    28.   // WeakMap 和 WeakSet 的比较不依赖于它们的值。
    29.   // 以下示例不会抛出 AssertionError，因为抽象的相等性比较（==）会将原始类型视为相等。
    30.   // 不会抛出 AssertionError。
    31.   assert.deepEqual('+00000000', false);
    32.   const obj1 = {a: {b: 1}}; const obj2 = {a: {b: 1}}; const obj3 = Object.create(obj1);
    33.   assert.deepEqual(obj1, obj2); // 通过
    34.   // 原型会被忽略：
    35.   assert.deepEqual(obj1, obj4);
    36.   // 抛出 AssertionError: { a: { b: 1 } } deepEqual {}
    38. assert.notDeepEqual(actual, expected[, message]) 已废弃 与assert.deepEqual结果相反 应改为 assert.notDeepStrictEqual(actual, expected[, message])
    40. assert.strictEqual(ctual: any, expected: any[, message:string| Error]) （assert.equal 已废弃, assert.notEqual 已废弃）
    41.   // 浅比较
    42. assert.notStrictEqual(actual, expected[, message]) 与assert.strictEqual结果相反
    45. assert(value: any[, message:string|Error])
    46.   // assert.ok() 的别名。
    47.   检测值是否为真值
    48.   assert(0) 抛出异常
    49.   assert(typeof 123 === 'string') 抛出异常
    51. assert.ifError(value);
    52.   如果 value 不为 undefined 或 null，则抛出 value。
    53.   assert.ifError(0); 抛出异常
    54.   assert.ifError(undefined);
    55.   assert.ifError(null);
    56. */
    60. // const assert = require("assert"); // 普通模式(Legacy | 遗留模式)
    61. /* 
    62. 请注意，如果使用上面那条语句的话，抽象的相等性比较可能会导致意外的结果。 特别是对于 assert.deepEqual()，其中的比较规则是松散的：
    63. 使用 Legacy Mode 会使下面的语句不抛出错误
    64. assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]); 
    65. 遗留模式在以下方法中使用抽象的相等性比较：
    67. assert.deepEqual()
    68. assert.equal()
    69. assert.notDeepEqual()
    70. assert.notEqual()  
    71. */
    73. const assert = require('assert').strict; // 使用严格模式
    75. // 生成 AssertionError 以便稍后比较错误的消息：
    76. const { message } = new assert.AssertionError({
    77.   // message: '666', // 写上 message就使用写上的值，不写使用预设
    78.   actual: 1,
    79.   expected: 2,
    80.   operator: 'strictEqual'
    81. });
    83. /*
    84. // console.log(`测试开始`, message);
    85. // Input A expected to strictly equal input B: 属于A应该严格等于输入B
    86. // 下面的内容是 console.log(`测试开始`, message); 的输出内容
    88. 测试开始 Input A expected to strictly equal input B:
    89. + expected - actual
    91. - 1
    92. + 2
    93. */
    94. console.log(`测试开始========================================`);
    95. console.log(` `)
    96. try {
    97.   assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
    98. } catch(err) {
    99.   console.log(err);
    100.   // Input A expected to strictly deep-equal input B: 输入A应严格地深等于输入B：
    101.   // 下面是console.log(err);的内容
    102.   /*
    103.   assert.js:85
    104.   throw new AssertionError(obj);
    105.   ^
    107.   AssertionError [ERR_ASSERTION]: Input A expected to strictly deep-equal input B:
    108.   + expected - actual ... Lines skipped
    110.     [
    111.       [
    112.   ...
    113.           2,
    114.   -       3
    115.   +       '3'
    116.         ]
    117.   ...
    118.       5
    119.     ]
    120.     at Object.<anonymous> (/Users/lijunyang/project/sinon-demo/assert.js:42:8)
    121.     at Module._compile (internal/modules/cjs/loader.js:689:30)
    122.     at Object.Module._extensions..js (internal/modules/cjs/loader.js:700:10)
    123.     at Module.load (internal/modules/cjs/loader.js:599:32)
    124.     at tryModuleLoad (internal/modules/cjs/loader.js:538:12)
    125.     at Function.Module._load (internal/modules/cjs/loader.js:530:3)
    126.     at Function.Module.runMain (internal/modules/cjs/loader.js:742:12)
    127.     at startup (internal/bootstrap/node.js:282:19)
    128.     at bootstrapNodeJSCore (internal/bootstrap/node.js:743:3)
    129.   */
    130. }
    134. try {
    135.   assert.strictEqual(1, 2); // 断言失败会抛出异常
    136. } catch (err) {
    137.   // console.log(err);
    138.   /* 下面是console.log(err)的输出内容
    139.   { AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
    140.     + expected - actual
    142.     - 1
    143.     + 2
    144.     at Object.<anonymous> (/Users/lijunyang/project/sinon-demo/assert.js:39:10)
    145.     at Module._compile (internal/modules/cjs/loader.js:689:30)
    146.     at Object.Module._extensions..js (internal/modules/cjs/loader.js:700:10)
    147.     at Module.load (internal/modules/cjs/loader.js:599:32)
    148.     at tryModuleLoad (internal/modules/cjs/loader.js:538:12)
    149.     at Function.Module._load (internal/modules/cjs/loader.js:530:3)
    150.     at Function.Module.runMain (internal/modules/cjs/loader.js:742:12)
    151.     at startup (internal/bootstrap/node.js:282:19)
    152.     at bootstrapNodeJSCore (internal/bootstrap/node.js:743:3)
    153.   generatedMessage: true,
    154.   name: 'AssertionError [ERR_ASSERTION]',
    155.   code: 'ERR_ASSERTION',
    156.   actual: 1,
    157.   expected: 2,
    158.   operator: 'strictEqual' }
    159.   */
    160.  try {
    161.   assert(err instanceof assert.AssertionError); // 断言成功没有任何返回，没有任何提示
    162.   /*
    163.   assert.strictEqual(1, 2); // 断言失败会抛出异常 // 断言失败就不会执行后面的语句了
    164.   console.log('失败1')
    165.   assert.strictEqual(1, 2); // 断言失败会抛出异常
    166.   console.log('失败2')
    167.   */
    168.   assert.strictEqual(err.message, message);
    169.   assert.strictEqual(err.actual, 1);
    170.   assert.strictEqual(err.expected, 2);
    171.   assert.strictEqual(err.code, 'ERR_ASSERTION');
    172.   assert.strictEqual(err.operator, 'strictEqual');
    173.   assert.strictEqual(err.generatedMessage, true);
    174.   assert.strictEqual(err.name, 'AssertionError [ERR_ASSERTION]');
    175.   } catch (err) {
    176.     console.log(`err`, err);
    177.   }
    178. }
    180. console.log(` `)
    181. console.log(`测试结束========================================`);
    1. /*
    2. assert.throws(fn[, error][, message])
    3.   // 检测fn是否抛出异常
    4.   如果指定，则 error 可以是 Class、RegExp、验证函数，每个属性将被测试严格的深度相等的验证对象、或每个属性（包括不可枚举的 message 和 name 属性）将被测试严格的深度相等的错误实例。 使用对象时，还可以在对字符串属性进行验证时使用正则表达式。 请参阅下面的示例。
    6.   如果指定 message，则当 fn 调用无法抛出或错误验证失败时， message 将附加到 AssertionError 提供的消息。
    8. assert.doesNotThrow(fn[, error:  Error | <RegExp> | <Function>][, message])
    9.   断言 fn 函数不会抛出错误。
    10. */
    11. const assert = require('assert').strict;
    13. const err = new TypeError('错误值');
    14. err.code = 404;
    15. err.foo = 'bar';
    16. err.info = {
    17.   nested: true,
    18.   baz: 'text'
    19. };
    20. err.reg = /abc/i;
    22. // err.info.a = 2; // 使用嵌套对象需要存在所有属性。
    23. // 当上一条语句注释时,下面的assert通过，不然不通过
    24. assert.throws(
    25.   () => {
    26.     throw err;
    27.   },
    28.   { // 这个是验证对象
    29.     name: 'TypeError',
    30.     message: '错误值',
    31.     info: {
    32.       nested: true,
    33.       baz: 'text',
    34.     }
    35.     // 仅测试验证对象上的属性。
    36.     // 使用嵌套对象需要存在所有属性。
    37.     // 否则验证将失败。
    38.   }
    39. );
    41. // 使用正则表达式验证错误属性：
    42. assert.throws(
    43.   () => {
    44.     throw err;
    45.   },
    46.   {
    47.     // `name` 和 `message` 属性是字符串，使用正则表达式将匹配字符串。 
    48.     // 如果失败，则会抛出错误。
    49.     name: /^TypeError$/,
    50.     message: /错误/,
    51.     foo: 'bar',
    52.     info: {
    53.       nested: true,
    54.       // 无法对嵌套属性使用正则表达式！
    55.       baz: 'text'
    56.     },
    57.     // `reg` 属性包含一个正则表达式，
    58.     // 并且只有当验证对象包含相同的正则表达式时，
    59.     // 它才会通过。
    60.     reg: /abc/i
    61.   }
    62. );
    63. try {
    64.   assert.throws(
    65.     () => {
    66.       const otherErr = new Error('未找到');
    67.       otherErr.code = 404;
    68.       throw otherErr;
    69.     },
    70.     err // 测试 `message`、 `name` 和 `code`。
    71.   );
    72. } catch (err) {
    73.   console.log(err);
    74. }
    75. // 由于 `message` 和 `name` 属性不同而失败：
    76. /* 下面是上一条语句的输出内容
    77. AssertionError [ERR_ASSERTION]: Input A expected to strictly deep-equal input B:
    78. + expected - actual
    80.   Comparison {
    81.     code: 404,
    82. -   message: '未找到',
    83. -   name: 'Error'
    84. +   foo: 'bar',
    85. +   info: {
    86. +     baz: 'text',
    87. +     nested: true
    88. +   },
    89. +   message: '错误值',
    90. +   name: 'TypeError',
    91. +   reg: /abc/i
    92.   }
    93.     at Object.<anonymous> (/Users/lijunyang/project/sinon-demo/assert2.js:62:8)
    94.     at Module._compile (internal/modules/cjs/loader.js:689:30)
    95.     at Object.Module._extensions..js (internal/modules/cjs/loader.js:700:10)
    96.     at Module.load (internal/modules/cjs/loader.js:599:32)
    97.     at tryModuleLoad (internal/modules/cjs/loader.js:538:12)
    98.     at Function.Module._load (internal/modules/cjs/loader.js:530:3)
    99.     at Function.Module.runMain (internal/modules/cjs/loader.js:742:12)
    100.     at startup (internal/bootstrap/node.js:282:19)
    101.     at bootstrapNodeJSCore (internal/bootstrap/node.js:743:3)
    102. */
    105. // 使用构造函数验证 instanceof： 下面这条通过
    106. assert.throws(
    107.   () => {
    108.     throw new Error('错误值');
    109.   },
    110.   Error
    111. );
    113. // 使用 RegExp 验证错误消息： 使用正则表达式在错误对象上运行 .toString，因此也将包含错误名称。
    114. assert.throws(
    115.   () => {
    116.     const error = new Error('错误值');
    117.     // console.log(error.toString()); // 返回 "Error: 错误值"
    118.     throw error;
    119.   },
    120.   /^Error: 错误值$/
    121. );
    123. console.log("自定义测的错误验证函数=================")
    124. console.log(` `);
    126. // 自定义的错误验证函数：
    127. assert.throws(
    128.   () => {
    129.     // 如果指定 message，则当 fn 调用无法抛出或错误验证失败时， message 将附加到 AssertionError 提供的消息。
    130.     // return; // 此时没有抛出异常，错误验证失败
    131.     // 上一条语句如果未注释的话，则抛出异常，异常message为 "不是期望的错误"
    132.     throw new Error('错误值');
    133.   },
    134.   (err) => {
    135.     assert(err instanceof Error);
    136.     // assert(/value/.test(err)); // 这里会抛出异常，因为正则不匹配
    137.     return false;
    139.     // 除了 `true` 之外，不建议从验证函数返回任何内容。 
    140.     // 这样做会导致再次抛出捕获的错误。 
    141.     // 这通常不是理想的结果。 
    142.     // 抛出有关失败的特定验证的错误（如本例所示）。
    143.     return true;
    144.   },
    145.   '不是期望的错误'
    146. );
    1. /*
    2. assert.rejects(asyncFn[, error][, message])
    3.   除了等待的异步性质之外，完成行为与 assert.throws() 完全相同。
    5. assert.doesNotReject(asyncFn[, error][, message])
    6.   与rejects相反
    9. assert.fail([message: string | message]);
    10.   使用提供的错误消息或默认错误消息抛出 AssertionError。 如果 message 参数是 Error 的实例，则它将被抛出而不是 AssertionError。  
    11. */
    13. const assert = require('assert').strict;
    15. assert.rejects(
    16.   async () => {
    17.     throw new TypeError('错误值');
    18.   },
    19.   {
    20.     name: 'TypeError',
    21.     message: '错误值'
    22.   }
    23. );
    25. assert.rejects(
    26.   Promise.reject(new Error('错误值1')),
    27.   {
    28.     name: 'TypeError',
    29.     message: '错误值'
    30.   }
    31. ).then((res) => {
    32.   console.log('res', res);
    33. },(err) => {
    34.   console.log('err', err); // 此时抛出异常
    35. });
    37. try {
    38.   assert.fail("自定义错误消息A");
    39. } catch (err) {
    40.   console.log(err);
    41. }
    43. try {
    44.   assert.fail(new Error('自定义错误消息B'));
    45. } catch (err) {
    46.   console.log(err);
    47. }