【譯文】Nodejs官方文檔（Part 3 斷言測試）

時間  2019-11-10
標籤 譯文 nodejs 官方 文檔 斷言 測試 简体版
原文   原文鏈接

斷言

穩定級別：3 - 鎖定html

斷言模塊提供了一個簡單斷言集，用於測試不變量。本模塊本來是Node.js的內部使用，但也能夠經過require('assert')在應用中使用。可是要注意，斷言模塊並非一個測試框架，也不是一個通用的斷言庫。node

斷言模塊的API已經鎖定。意味着在將來，本模塊應用和暴露的方法都不會有任何修改或者增長。git

assert(value[, message])

v0.5.9版本加入github

是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版本加入api

用於測試 actual和expected的深等於。基本數據類型的值將會用等價運算符( == )做比較。框架

本方法只適用於可枚舉且返回自身的屬性。 deepEqual()不能用於測試對象原型、附加符號、不可枚舉的屬性。這一點可能會致使一些意想不到的結果。好比，下面的例子不會拋出AssertionError，由於Error對象的屬性是不可枚舉的。ide

// 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，就會給它賦值一個默認的錯誤信息。oop

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

全文目錄

請查看：全文目錄

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程