mocha 的基本介紹&&expect風格斷言庫的基本語法

艾倫先生發表於2017-12-14

mocha 介紹

mocha 是一個功能豐富的javascript測試框架，可以執行在nodejs和瀏覽器環境，能夠使非同步測試變得簡單有趣。mocha 串聯執行測試，允許靈活和精確地報告結果，同時對映未捕獲的異常用來糾正測試用例。 mocha 支援TDD/BDD 的 開發方式，結合 should.js/expect/chai/better-assert 斷言庫，能輕鬆構建各種風格的測試用例。

BDD,即行為驅動開發。不對程式碼的實現細節編寫測試，而針對行為編寫測試,下文的測試用例風格基本上都遵循BDD格式

mocha 安裝

全域性安裝

npm install mocha -g
複製程式碼

作為開發依賴安裝在專案中：

npm install mocha --save-dev
複製程式碼

安裝Mocha v3.0.0或者更新的版本，你需要v1.4.0或者更新版本的npm。此外，執行Mocha的Node版本不能低於v0.10

mocha 基本使用

安裝了專案依賴後,請在根目錄下建立一個/test的空資料夾。預設情況下，在命令列中執行mocha命令，mocha會自動執行/test一級目錄下的測試指令碼。

下面在test目錄下建立一個test_mocha.js

//模組依賴
var expect = require('chai').expect;

//斷言條件
describe('Array', function(){
  describe('#indexOf()', function(){
    it('should return -1 if value not exits', function(){
      expect([1,2,3].indexOf(5)).to.be.equal(-1)
    });
  });
});
複製程式碼

儲存檔案，執行命令

mocha 
複製程式碼

mocha 的基本介紹&&expect風格斷言庫的基本語法

可以很清晰的看到，在9ms內通過了一個測試用例。測試用例中可以看到描述的資訊

注意1：如果想遞迴的執行test目錄的所有子目錄，則需要帶上引數

mocha --recursive
複製程式碼

如果想指定目錄執行測試指令碼，請在mocha命令後面緊跟測試指令碼的路徑和檔名

mocha test/filename1.js
複製程式碼

注意2：也可以使用萬用字元來匹配測試指令碼時

mocha test/unit/{filename1,filename2}.js
mocha test/unit/*.js
複製程式碼

個性化

直接使用mocha執行測試用例檔案是可以的，但是並不能體現出mocha的豐富多彩的功能。下面通過一些比較常用的案例，為大家展示一下mocha的強大功能。

使用 mochawesome來製作漂亮的HTTP格式報告

mocha 的基本介紹&&expect風格斷言庫的基本語法

執行下面的程式碼會在當前目錄的mochawesome-reports子目錄內生成對應檔案

npm install --save-dev mochawesome
mocha --reporter mochawesome
複製程式碼

監聽檔案

一旦/test/目錄下測試指令碼被修改(並儲存)之後，會自動執行mocha

mocha --watch
複製程式碼

錯誤終止

引數指定只要有一個測試用例沒有通過，就停止執行後面的測試用例

mocha --bail
複製程式碼

檢索測試用例名字

檢索測試用例的名稱（即it塊的第一個引數），

mocha --grep "產品"          #只執行匹配的測試用例
mocha --grep "產品" --invert #只執行不匹配的測試用例
複製程式碼

使用配置檔案 mocha.opts

mocha允許在test目錄下面，放置配置檔案mocha.opts,把命令列引數寫在裡面,統一執行

mocha --recursive --reporter tap --growl
複製程式碼

上面三個引數，可以寫進 test目錄下的mocha.opts檔案

--reporter tap
--recursive
--growl
複製程式碼

然後執行 mocha 命令就能取得與上面一樣的執行結果

mocha
複製程式碼

如果測試用例不是存放在test子目錄，可以在mocha.opts寫入以下內容

server-tests
--recursive
複製程式碼

上面程式碼指定執行server-tests目錄及其子目錄之中的測試指令碼

幫助

mocha --help
mocha -h     
複製程式碼

斷言庫的使用

Mocha允許你使用你喜歡的斷言庫

  • should.js - BDD風格貫穿始終
  • expect.js - expect() 風格的斷言
  • chai - expect()、assert()和 should風格的斷言
  • better-assert - C風格的自文件化的assert()
  • unexpected - “可擴充套件的BDD斷言工具”

常用的should/expect庫都支援BDD風格，書寫的風格頁很類似。但是還是有區別的，前者在處理undefined.err值的呼叫時不友好，在IE下不完全相容，但是強在書寫起來很符合人話；後者則相反。都支援鏈式呼叫 具體參考官網http://chaijs.com/guide/styles/

簡單介紹一下expect斷言庫的使用

一般在測試用例檔案的頂部，宣告引用的斷言庫

var expect = require('chai').expect;
複製程式碼

上面這行程式碼引入的斷言庫是chai，並且制定使用它的expect斷言風格。

基本上，expect斷言的寫法都是一樣的。頭部是expect方法，尾部是斷言方法，比如equal、a/an、ok、match等。兩者之間使用to或to.be連線。

// equal 相等或不相等
expect(4 + 5).to.be.equal(9);
expect(4 + 5).to.be.not.equal(10);
expect('hello').to.equal('hello');  
expect(42).to.equal(42);  
expect(1).to.not.equal(true);  
expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });  
expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });

// above 斷言目標的值大於某個value,如果前面有length的鏈式標記，則可以用來判斷陣列長度或者字串長度
expect(10).to.be.above(5);
expect('foo').to.have.length.above(2);  
expect([ 1, 2, 3 ]).to.have.length.above(2); 
類似的還有least(value)表示大於等於；below(value)表示小於；most(value)表示小於等於

// 判斷目標是否為布林值true（隱式轉換）
expect('everthing').to.be.ok;
expect(1).to.be.ok;  
expect(false).to.not.be.ok;
expect(undefined).to.not.be.ok;  
expect(null).to.not.be.ok; 

// true/false 斷言目標是否為true或false
expect(true).to.be.true;  
expect(1).to.not.be.true;
expect(false).to.be.false;  
expect(0).to.not.be.false;

// null/undefined 斷言目標是否為null/undefined
expect(null).to.be.null;  
expect(undefined).not.to.be.null;
expect(undefined).to.be.undefined;  
expect(null).to.not.be.undefined;


// NaN  斷言目標值不是數值
expect('foo').to.be.NaN;
expect(4).not.to.be.NaN;

// 判斷型別大法(可以實現上面的一些例子):a/an
expect('test').to.be.a('string');
expect({ foo: 'bar' }).to.be.an('object');
expect(foo).to.be.an.instanceof(Foo);
expect(null).to.be.a('null');  
expect(undefined).to.be.an('undefined');
expect(new Error).to.be.an('error');
expect(new Promise).to.be.a('promise');

// 包含關係:用來斷言字串包含和陣列包含。如果用在鏈式呼叫中，可以用來測試物件是否包含某key 可以混著用。
expect([1,2,3]).to.include(2);
expect('foobar').to.contain('foo');
expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');

// 判斷空值
expect([]).to.be.empty;
expect('').to.be.empty;
expect({}).to.be.empty;

// match
expect('foobar').to.match(/^foo/);
    
// exist 斷言目標既不是null也不是undefined
var foo = 'hi' , bar = null, baz;
expect(foo).to.exist;  
expect(bar).to.not.exist;  
expect(baz).to.not.exist;

// within斷言目標值在某個區間範圍內，可以與length連用
expect(7).to.be.within(5,10);  
expect('foo').to.have.length.within(2,4);  
expect([ 1, 2, 3 ]).to.have.length.within(2,4);

// instanceOf 斷言目標是某個構造器產生的事例
var Tea = function (name) { this.name = name; } , Chai = new Tea('chai');
expect(Chai).to.be.an.instanceof(Tea);  
expect([ 1, 2, 3 ]).to.be.instanceof(Array); 

// property(name, [value])  斷言目標有以name為key的屬性,並且可以指定value斷言屬性值是嚴格相等的,此[value]引數為可選,如果使用deep鏈式呼叫,可以在name中指定物件或陣列的引用表示方法
// simple referencing
var obj = { foo: 'bar' };  
expect(obj).to.have.property('foo');  
expect(obj).to.have.property('foo', 'bar');// 類似於expect(obj).to.contains.keys('foo')

// deep referencing
var deepObj = {  
  green: { tea: 'matcha' },
  teas: [ 'chai', 'matcha', { tea: 'konacha' } ]
};
expect(deepObj).to.have.deep.property('green.tea', 'matcha');  
expect(deepObj).to.have.deep.property('teas[1]', 'matcha');  
expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha'); 

// ownproperty 斷言目標擁有自己的屬性，非原型鏈繼承
expect('test').to.have.ownProperty('length'); 

// throw 斷言目標丟擲特定的異常
var err = new ReferenceError('This is a bad function.');  
var fn = function () { throw err; }  
expect(fn).to.throw(ReferenceError);  
expect(fn).to.throw(Error);  
expect(fn).to.throw(/bad function/);  
expect(fn).to.not.throw('good function');  
expect(fn).to.throw(ReferenceError, /bad function/);  
expect(fn).to.throw(err);  
expect(fn).to.not.throw(new RangeError('Out of range.'));  

// satisfy(method) 斷言目標通過一個真值測試
expect(1).to.satisfy(function(num) { return num > 0; })
複製程式碼

BDD 風格的 hock方法

Mocha預設使用“BDD”風格的介面，提供測試用例的四個鉤子：before()、after()、beforeEach()和afterEach()，這些函式可以用來（在測試前）做預處理工作或在測試後清理工作。

describe('hooks', function() {

  before(function() {
    // 在本區塊的所有測試用例之前執行
  });

  //按1，2，3...順序執行
  it('1',func(){});
  it('2',func(){});        

  after(function() {
    // 在本區塊的所有測試用例之後執行
  });

  beforeEach(function() {
    // 在本區塊的每個測試用例之前執行
  });

  afterEach(function() {
    // 在本區塊的每個測試用例之後執行
  });

  // test cases
});
複製程式碼

測試用例和測試的鉤子可以混合排列。（相同的）鉤子函式會按照它們的書寫順序執行；（整體的執行順序是）所有的before()鉤子執行一次，然後是beforeEach()鉤子，測試用例，afterEach()鉤子（迴圈執行），最後是after()鉤子（執行一次）

  • 規則1：describe裡地it的非非同步部分按它們定義的順序執行，它們所觸發的回撥的註冊順序也遵從it的註冊順序

  • 規則2：不被describe包裹的部分執行順序的優先順序最高

      {block1}
  describe('1',function(){
      ...
  });
  {block2}
  describe('2',func(){..});
  //執行順序block1，block2，describe1，describe2
複製程式碼

  • 規則3：同一層次的describe執行順序遵從它們的定義順序

  • 規則4：外層describe的所有it執行優先順序高於巢狀的describe

      describe('parent',func(){
      it('1',func(){..});
      describe('child1',func(){...});
      it('2',func(){...});
      describe('child2',func(){..});
  });
  //執行順序為it1,it2,child1,child2
複製程式碼

非同步測試

mocha預設每個測試用例最多執行2000毫秒，如果到時沒有得到結果，就報錯。對於涉及非同步操作的測試用例，這個時間往往是不夠的，需要用-t或--timeout引數指定超時門檻,下面這段程式碼執行起來會超。

it('測試應該5000毫秒後結束', function(done) {
  var x = true;
  var f = function() {
    x = false;
    expect(x).to.be.not.ok;
    done(); // 通知Mocha測試結束
  };
  setTimeout(f, 4000);
});
複製程式碼

mocha 的基本介紹&&expect風格斷言庫的基本語法

在程式碼中設定超時時間後執行成功

describe('加法函式的測試', function() {
  it('測試應該5000毫秒後結束', function(done) {
    this.timeout(5000);//設定超時時間為5s
    var x = true;
    var f = function() {
      x = false;
      expect(x).to.be.not.ok;
      done(); // 通知Mocha測試結束
    };
    setTimeout(f, 4000);
  });
});
複製程式碼

注意到，在上面的測試用例裡面，有一個done函式。it塊執行的時候，傳入一個done引數，當測試結束的時候，必須顯式呼叫這個函式，告訴Mocha測試結束了。否則，Mocha就無法知道，測試是否結束，會一直等到超時報錯

Mocha預設會高亮顯示超過75毫秒的測試用例，可以用-s或--slow調整這個引數

mocha -t 5000 -s 1000 timeout.test.js
複製程式碼

上面命令指定高亮顯示耗時超過1000毫秒的測試用例。

附上一個基本的非同步請求程式碼

var request = require('superagent');
var expect = require('chai').expect;

describe('非同步測試', function() {
  this.timeout(5000);
  it('非同步請求應該返回一個物件', function(done){
    request
      .get('https://api.github.com')
      .end(function(err, res){
        expect(res).to.be.an('object');
        done();
      });
  });
});
複製程式碼

promise 支援

Mocha內建對Promise的支援，允許直接返回Promise，等到它的狀態改變，再執行斷言，而不用顯式呼叫done方

it('非同步請求應該返回一個物件', function() {
  this.timeout(5000);
  return fetch('https://api.github.com')
    .then(function(res) {
      return res.json();
    }).then(function(json) {
      expect(json).to.be.an('object');
    });
});
複製程式碼

動態生成測試

由於mocha 可以使用 function.prototype.call 和function 表示式定義測試套件和測試用例，所以可以動態生成測試用例。

var assert = require('assert');

function add() {
  return Array.prototype.slice.call(arguments).reduce(function(prev, curr) {
    return prev + curr;
  }, 0);
}

describe('add()', function() {
  var tests = [
    {args: [1, 2],       expected: 3},
    {args: [1, 2, 3],    expected: 6},
    {args: [1, 2, 3, 4], expected: 10}
  ];

  tests.forEach(function(test) {
    it('correctly adds ' + test.args.length + ' args', function() {
      var res = add.apply(null, test.args);
      assert.equal(res, test.expected);
    });
  });
});
複製程式碼

相關文章