【译文】Nodejs官方文档（Part 3 断言测试）

2024年2月19日 306次阅读 来源: uglybachelor

断言

稳固级别：3 – 锁定

断言模块供应了一个简朴断言集，用于测试不变量。本模块原本是Node.js的内部运用，但也能够经由过程require('assert')在运用中运用。然则要注意，断言模块并非一个测试框架，也不是一个通用的断言库。

断言模块的API已锁定。意味着在将来，本模块运用和暴露的要领都不会有任何修正或许增添。

assert(value[, message])

v0.5.9版本到场

是assert.ok()的alias。

const assert = require('assert');

assert(true);  // OK
assert(1);     // OK
assert(false);
  // throws "AssertionError: false == true"
assert(0);
  // throws "AssertionError: 0 == true"
assert(false, 'it\'s false');
  // throws "AssertionError: it's false"

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

v0.1.21版本到场

用于测试 actual和expected的深即是。基础数据范例的值将会用等价运算符( == )作比较。

本要领只适用于可罗列且返回本身的属性。 deepEqual()不能用于测试对象原型、附加标记、不可罗列的属性。这一点可能会致使一些意想不到的效果。比方，下面的例子不会抛出AssertionError，由于Error对象的属性是不可罗列的。

// WARNING: This does not throw an AssertionError!
assert.deepEqual(Error('a'), Error('b'));

”深”即是意味着：传入对象的子对象的可罗列且返回本身的属性也会被比较：

const assert = require('assert');

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, 一个对象和本身肯定是相称的

assert.deepEqual(obj1, obj2);
  // AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
  // b的值差别

assert.deepEqual(obj1, obj3);
  // OK, 两个对象是相称的

assert.deepEqual(obj1, obj4);
  // AssertionError: { a: { b: 1 } } deepEqual {}
  // 对象原型不能用于比较

假如传入的两个参数不相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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

v1.2.0版本到场

与assert.deepEqual()只要两个区分。第一，基础数据范例的值是用强等价运算符（===）来比较的。第二，对象之间的比较请求它们的原型（prototype）也一致。

假如传入的两个参数不相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

assert.doesNotThrow(block, error)

v0.1.21版本到场

断言block要领不会抛出毛病，关于抛出（throw）可列入assert.throw()相识更多细节。

当assert.doesNotThrow()被挪用的时刻，它会马上挪用block要领。

假如有毛病抛出，而且毛病范例与传参中的毛病范例一致，此要领将抛出一个AssertionError。假如毛病范例不一致，或许传参error未定义，那末毛病会被回传给挪用者。

比方下例中，将会抛出一个TypeError，由于毛病范例不一致。

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

但下例中就会抛出AssertionError并附带message“Got unwanted exception (TypeError)..”。

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

当有AssertionError抛出的时刻，假如传参中定义了message参数，那末它将会被附到AssertionError的message背面。

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

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

v0.1.21版本到场

用等价运算符（==）比较actual和expected的浅即是。

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

假如传入的两个参数不相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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

v0.1.21版本到场

抛出AssertionError。假如message也就是比较效果为假，那末毛病信息输出actual和expected的值，用传入的运算符离隔；假如效果为真，毛病信息输出传入的message。

const assert = require('assert');

assert.fail(1, 2, undefined, '>');
  // AssertionError: 1 > 2

assert.fail(1, 2, 'whoops', '>');
  // AssertionError: whoops

assert.ifError(value)

v0.1.97版本到场

假如value为真则输出value值。合适用于测试回调要领中的error参数。

const assert = require('assert');

assert.ifError(0); // OK
assert.ifError(1); // Throws 1
assert.ifError('error'); // Throws 'error'
assert.ifError(new Error()); // Throws Error

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

v0.1.21版本到场

测试深不等，与assert.deepEqual()对峙。

const assert = require('assert');

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

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

assert.notDeepEqual(obj1, obj2);
  // OK, obj1 and obj2 are not deeply equal

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

assert.notDeepEqual(obj1, obj4);
  // OK, obj1 and obj2 are not deeply equal

假如传入的两个参数深相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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

v1.2.0版本到场

测试深且强不等，与assert.deepStrictEqual()对峙。

const assert = require('assert');

assert.notDeepEqual({a:1}, {a:'1'});
  // AssertionError: { a: 1 } notDeepEqual { a: '1' }

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

假如传入的两个参数深且强相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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

v0.1.21版本到场

用不等价运算符（!=）测试浅不等。

const assert = require('assert');

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

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

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

假如传入的两个参数浅相称，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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

v0.1.21版本到场

用强不等运算符（!==）测试强不等。

const assert = require('assert');

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

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

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

假如传入的两个参数强等，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

assert.ok(value[, message])

v0.1.21版本到场

测试value是不是为真。实在与assert.equal(!!value, true, message)等价。

假如value不为真，抛出AssertionError，附带message信息与传入message一致。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

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.strictEqual(actual, expected[, message])

v0.1.21版本到场

用强等运算符（===）测试传参是不是强即是。

const assert = require('assert');

assert.strictEqual(1, 2);
  // AssertionError: 1 === 2

assert.strictEqual(1, 1);
  // OK

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

假如传入的两个参数不是强等，将会抛出一个AssertionError，它会自带一个message属性，可由message传参设置。假如message传参是undefined，就会给它赋值一个默许的毛病信息。

assert.throws(block, error)

v0.1.21版本到场

希冀block要领抛出毛病。

假如传入自定义error，能够是组织函数、正则表达式或考证函数。

假如传入message但没有毛病抛出，message将是AssertionError附带的。

用组织函数考证实例：

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

用正则表达式考证error：

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

自定义error考证：

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

请注意error参数能够为字符串。假如第二个传参是个字符串，那末error参数将会被疏忽，直接用这个字符串作为输出的message。但这可能会致使很轻易被疏忽的题目：

// THIS IS A MISTAKE! DO NOT DO THIS!
assert.throws(myFunction, 'missing foo', 'did not throw with expected message');

// Do this instead.
assert.throws(myFunction, /missing foo/, 'did not throw with expected message');

全文目次

请检察：全文目次

    原文作者：uglybachelor
    原文地址: https://segmentfault.com/a/1190000007852032
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞