前端單元測試的基礎內容

對於沒有接觸過單元測試的前端人員來講，想要系統的瞭解它，可能會比較困難，由於東西比較零散，會毫無頭緒。因此，我理了一下單元測試要用到的工具和須要知道的概念，幫助系統的理解。

什麼是單元測試

單元測試（unit testing），顧名思義，是指對軟件中的最小的可測試單元進行檢查和驗證。一個function、一個模塊都是一個單元。通常來講，一個單元測試是用於判斷某個特定條件（或者場景）下某個特定函數的行爲，因此倡導你們學會函數式編程。

爲何要作單元測試

單元測試從短時間來看多是很浪費時間，增長程序員負擔的事，可是從長期來看，能夠提升代碼質量，減小維護成本，使代碼獲得了很好的迴歸，下降重構難度。
首先，咱們能夠保證代碼的正確性，爲上線作保障；
其次，能夠作到自動化，一次編碼，屢次運行。好比，咱們在項目中寫了一個function，這個function在10個地方都被用到了，那麼咱們就不用在去10個地方都測試一遍，咱們只要在單元測試的時候測試這個function就能夠了；
而後，可閱讀性強，一個項目由多人維護的時候，能夠幫助後來維護的人快速看懂前一我的寫的代碼要實現什麼功能；
還有，能夠驅動開發，編寫一個測試，它就定義了一個函數或一個函數的改進，開發人員就能夠清楚地瞭解該特性的規範和要求。
最後，保證重構，隨着互聯網愈來愈快速的迭代，項目的重構也是頗有必要的。對象、類、模塊、變量和方法名應該清楚地表示它們當前的用途，由於添加了額外的功能，會致使很難去分辨命名的意義。

什麼是TDD

上述有提到單元測試能夠驅動開發，這就是TDD的功能。TDD，即Test-driven Development，翻譯過來是測試驅動開發，就是在開發前，先編寫單元測試用例，用於指導軟件開發，使開發人員在編寫代碼以前關注需求。

斷言

編寫單元測試須要用到node.js的斷言，這裏就只列一下測試經常使用的，想要了解更多能夠查看node.js文檔。

首先要引入node.js自帶的斷言assert：

const assert = require('assert');

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

value <any>
message <string> | <Error>

測試值是否爲真，若是值不真實，則引起斷言錯誤，並將消息屬性設置爲等於消息參數的值。若是消息參數未定義，則會分配默認錯誤消息。若是消息參數是一個錯誤的實例，那麼它將被拋出，而不是斷言錯誤。若是沒有任何參數傳入，則消息將被設置爲字符串：沒有值參數傳遞給assert.ok( )。

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, 'it\'s false');
// AssertionError: it's false

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

actual <any>
expected <any>
message <string> | <Error>

測試實際參數和預期參數是否相等，這裏的相等是==，不是===，會作隱式轉換，若是傳入message，報錯內容爲message裏的內容

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'

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

assert.equal(1, 2, '1 should not equal 2');
// AssertionError [ERR_ASSERTION]: 1 should not equal 2

這裏要注意的是引用類型的相等，equal判斷的是指針地址是否相同，不會判斷裏面的值，從下面的例子能夠看到

assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

// 空對象的引用地址不一樣，必不會相等
assert.equal({}, {})
// AssertionError [ERR_ASSERTION]: {} == {}

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

actual <any>
expected <any>
message <string> | <Error>

測試實際參數和預期參數之間是否嚴格相等，與equal不一樣的是，strictEqual是===全等

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

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
// 1 !== 2

assert.strictEqual(1, '1');
// AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
// 1 !== '1'

assert.strictEqual(1, '1', '1 should not equal \'1\'');
// AssertionError [ERR_ASSERTION]: 1 should not equal '1'

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

actual <any>
expected <any>
message <string> | <Error>

測試實際參數和預期參數之間的深度相等性，用 == 進行比較。
與assert.equal( )比較，assert.deepequal( )能夠實現不測試對象的[[原型]]或可枚舉的本身的符號屬性，便可以判斷引用類型的值是否相等

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

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

assert.deepEqual(obj1, obj3);
// OK

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

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

actual <any>
expected <any>
message <string> | <Error>

assert.deepStrictEqual( )就很明顯是判斷引用類型的值是否全等

assert.deepStrictEqual(NaN, NaN);
// OK, because of the SameValue comparison

// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Input A expected to strictly deep-equal input B:
// + expected - actual
// - [Number: 1]
// + [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.

assert.deepStrictEqual(-0, -0);
// OK

// Different zeros using the SameValue Comparison:
assert.deepStrictEqual(0, -0);
// AssertionError: Input A expected to strictly deep-equal input B:
// + expected - actual
// - 0
// + -0

6. asser.throws(fn, error)

fn <Function>
error <RegExp> | <Function> | <Object> | <Error>
message <string>

捕獲函數fn引起的錯誤並拋出。
若是指定error，錯誤能夠是類、regexp、驗證函數、驗證對象（其中每一個屬性都將測試嚴格的深度相等），或者錯誤實例（其中每一個屬性都將測試嚴格的深度相等，包括不可枚舉的消息和名稱屬性）。
當使用對象時，還可使用正則表達式來驗證字符串屬性。
若是指定message，那麼若是fn調用未能拋出或錯誤驗證失敗，message將附加到錯誤消息中。

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

// 正則表達式
assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  /^Error: Wrong value$/
);

const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
  nested: true,
  baz: 'text'
};
err.reg = /abc/i;

assert.throws(
  () => {
    throw err;
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text'
    }
  }
);

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err;
  },
  {
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      baz: 'text'
    },
    reg: /abc/i
  }
);

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found');
    otherErr.code = 404;
    throw otherErr;
  },
  err
);

mocha測試框架

mocha是JavaScript的一種單元測試框架，能夠在node.js環境下運行，也能夠在瀏覽器環境運行。
使用mocha，咱們就只須要專一於編寫單元測試自己，而後讓mocha去自動運行全部的測試，並給出測試結果。mocha能夠測試簡單的JavaScript函數，也能夠測試異步代碼。

安裝

npm install mocha -g

GET STARTED

編寫代碼：

const assert = require('assert');

describe('Array', function() {
  describe('#indexOf()', function() {
    it('should return -1 when the value is not present', function() {
      assert.equal(-1, [1, 2, 3].indexOf(0))
    })
  })
})

在終端運行：

$ mocha

Array
    #indexOf()
      ✓ should return -1 when the value is not present
      
1 passing (9ms)

也能夠在package.json裏配置：

"scripts": {
    "test": "mocha"
}

而後在終端運行：

$ npm test

能夠支持before、after、beforEach、afterEach來編碼，經過給後面的匿名函數傳入done參數來實現異步代碼測試：

describe('should able to trigger an event', function () {
  var ele
  before(function () {
    ele = document.createElement('button')
    document.body.appendChild(ele)
  })

  it('should able trigger an event', function (done) {
    $(ele).on('click', function () {
      done()
    }).trigger('click')
  })

  after(function () {
    document.body.removeChild(ele)
    ele = null
  })
})

karma

karma是基礎node.js的測試工具，主要測試於主流瀏覽器中，它能夠監控文件的變化，而後自行執行，經過console.log顯示測試結果。

安裝

$ npm install karma-cli -g

$ npm install karma --save-dev

安裝依賴（這裏以mocha和chrome爲例，若是要用firefox啓動，就安裝karma-firefox-launcher，要在瀏覽器中運行，因此要安裝打開瀏覽器的插件）：

$ npm install karma-chrome-launcher karma-mocha mocha --save-dev

初始化測試：

$ karma init

1. Which testing framework do you want to use ? (mocha)
2. Do you want to use Require.js ? (no)
3. Do you want to capture any browsers automatically ? (Chrome)
4. What is the location of your source and test files ? (test/**.js)
5. Should any of the files included by the previous patterns be excluded ? ()
6. Do you want Karma to watch all the files and run the tests on change ? (yes)

init後獲得karma.conf.js文件：

module.exports = function(config) {
  config.set({
    // base path that will be used to resolve all patterns (eg. files, exclude)
    basePath: '',

    // frameworks to use
    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
    frameworks: ['mocha'],

    // list of files / patterns to load in the browser
    files: [
      'test/*.js'
    ],

    // list of files to exclude
    exclude: [
    ],

    // preprocess matching files before serving them to the browser
    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
    preprocessors: {
    },

    // test results reporter to use
    // possible values: 'dots', 'progress'
    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
    reporters: ['progress'],

    // web server port
    port: 9876,

    // enable / disable colors in the output (reporters and logs)
    colors: true,

    // level of logging
    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
    logLevel: config.LOG_INFO,

    // enable / disable watching file and executing tests whenever any file changes
    autoWatch: true,

    // start these browsers
    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
    browsers: ['Chrome'],

    // Continuous Integration mode
    // if true, Karma captures browsers, runs the tests and exits
    singleRun: false,

    // Concurrency level
    // how many browser should be started simultaneous
    concurrency: Infinity
  })
}

files表示要引用到的文件，若是有文件相互引用，不能用modules.exports暴露和require引入，會報錯，只要把文件寫入files就能夠了。port是啓動karma後，運行的端口，默認爲9876。singleRun表示是否只運行一次，若是值爲true，會默認執行一次後自動關閉瀏覽器，這樣的話就不能作到實時監控文件了。

啓動karma：

$ karma start

瀏覽器自動打開，還能夠進行debug：