Node.js Assertion Testing

Assert

Stability: 2 - Stable 稳定

Assert - Node.js 的断言库

在 Node.js 的开发过程中，Assert 绝对是必不可少的模块，本文将会结合官方文档系统地为您介绍一些实用的 API。

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

这两个 API 的功能是一样的，判断 value 是否为真，如果不为真，则会抛出 AssertionError 类型的错误

const assert = require('assert');

assert.ok(true);
// OK
assert.ok(1);
// OK
assert.ok(false);
// throws "AssertionError: false == true"
assert.ok(0);
// throws "AssertionError: 0 == true"
assert.ok(false, 'it\'s false');
// throws "AssertionError: it's false"
// assert.ok() 可以替换成 assert()

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

• assert.notEqual(actual, expected[, message]) 如果 actual != expected 为真，则不会抛出错误，否则抛出 AssertionError 类型的错误

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

• assert.notEqual(actual, expected[, message]) 如果 actual != expected 为真，则不会抛出错误，否则抛出 AssertionError 类型的错误

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

• assert.strictEqual(actual, expected[, message]) 如果 actual === expected 为真，则不会抛出错误，否则抛出 AssertionError 类型的错误

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

• assert.notStrictEqual(actual, expected[, message]) 如果 actual !== expected 为真，则不会抛出错误，否则抛出 AssertionError 类型的错误

注意：上面这4个 API 只能判断基本数据类型（数字，字符串等），不能判断复杂数据类型（对象，数组等），否则会得到非预期的结果

const assert = require('assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({a: {b: 1}}, {a: {b: 1}});
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } } 复杂数据类型无法判断出预期的结果

assert.ifError(value)

如果 value 是真，则抛出 value，这个方法经常用作判断回调函数的 error 参数

const fs = require('fs')
const assert = require('assert')
fs.readFile('/etc/passwd', (err, data) => {
  assert.ifError(err)
  // todo
});

assert.fail(actual, expected, message, operator)

抛出一个 AssertionError 错误，如果 message 是真，则错误信息是 message，否则错误信息是 actual， operator，expected 连接的字符串

const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// AssertionError: 1 > 2
assert.fail(1, 2, 'whoops', '>');
// AssertionError: whoops

assert.throws(block[, error][, message])

该 API 通过参数 block 抛出一个错误，用 error 参数进行验证抛出的错误是否符合预期，如果不符合，则会抛出错误，如果抛出错误失败，且指定了参数 message，则会抛出一个错误，错误信息是 message。error 参数可以是构造函数，正则表达式，和自定义的函数，不能是字符串，否则会出现非预期的结果

const assert = require('assert')

assert.throws(
  () => {
    throw new Error();
  },
  Error
);

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

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  function(err) {
    if ((err instanceof Error) && /value/.test(err)) {
      return true;
    }
  },
  'unexpected error'
);

// 没有抛出错误，则会显示 message
assert.throws(
  () => {},
  /test/,
  'throw error failed'
);

assert.doesNotThrow(block[, error][, message])

该 API 是验证参数 block 没有抛出错误的情况，如果抛出了错误，且抛出错误的类型与参数 error 一致，则抛出 AssertionError 错误；如果不一致，则直接把 block 的错误抛出

const assert = require('assert')

// 类型不一样，直接抛出TypeError
assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError
);

// 类型一样，抛出 AssertionError
assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError
);

// 抛出的 AssertionError 带有 message 信息
assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
  'Whoops'
);
// Throws: AssertionError: Got unwanted exception (TypeError). Whoops

// 不会抛出错误
assert.doesNotThrow(
  () => {},
  TypeError
);

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

assert.deepEqual(actual, expected[, message]) 使用 == 比较参数 actual 和 expected 的属性值，如果为真，则不会抛出错误，否则，抛出 AssertionError 错误。其功能与 assert.notDeepEqual(actual, expected[, message]) 相反

assert.deepStrictEqual(actual, expected[, message])、assert.notDeepStrictEqual(actual, expected[, message])

assert.deepStrictEqual(actual, expected[, message]) 使用 === 比较参数 actual 和 expected 的属性值，如果为真，则不会抛出错误，否则，抛出 AssertionError 错误。其功能与 assert.notDeepEqual(actual, expected[, message]) 相反
注意：上面4个 API 只会判定可枚举属性，对象的原型 prototypes, 符号attached symbols，和不可枚举属性无法判定

const assert = require('assert');

// Error的属性是不可枚举的，所以不会抛出错误
assert.deepEqual(Error('a'), Error('b'));

const obj1 = {
  a: {
    b: 1
  }
};
const obj2 = {
  a: {
    b: 2
  }
};
const obj3 = {
  a: {
    b: 1
  }
};
const obj4 = Object.create(obj1);

assert.deepEqual(obj1, obj1);
// OK, object is equal to itself

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

assert.deepEqual(obj1, obj3);
// OK, objects are equal

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

• Node.js Assertion Testing 官方文档。
• Node.js 文档版本为： v6.11.3

简书作者 小菜荔枝原创 转载请联系作者获得授权