带你入门带你飞Ⅰ 使用Mocha + Chai + Sinon单元测试Node.js

目录
1. 简介
2. 前提条件
3. Mocha入门
4. Mocha实战
     被测代码
  　　Example 1
  　　Example 2
  　　Example 3
5. Troubleshooting
6. 参考文档

简介

Mocha 是具有丰富特性的 JavaScript 测试框架，可以运行在 Node.js 和浏览器中，使得异步测试更简单更有趣。Mocha 可以持续运行测试，支持灵活又准确的报告，当映射到未捕获异常时转到正确的测试示例。

Chai 是一个针对 Node.js 和浏览器的行为驱动测试和测试驱动测试的断言库，可与任何 JavaScript 测试框架集成。

Sinon 是一个独立的 JavaScript 测试spy, stub, mock库，没有依赖任何单元测试框架工程。

前提条件

我用的node 和 npm 版本如下：

node -v = v0.12.2

npm -v = 2.7.4

当你成功安装nodejs 和 npm 后执行如下命令：

npm install -g mocha

npm install sinon

npm install chai

## mocha global 安装是为了能够在命令行下面使用命令。

Mocha入门

以下为最简单的一个mocha示例：

var 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(5));
            assert.equal(-1, [1,2,3].indexOf(0));
        })
    })
});

describe (moduleName, testDetails)
由上述代码可看出，describe是可以嵌套的，比如上述代码嵌套的两个describe就可以理解成测试人员希望测试Array模块下的#indexOf() 子模块。module_name 是可以随便取的，关键是要让人读明白就好。
it (info, function)
具体的测试语句会放在it的回调函数里，一般来说info字符串会写期望的正确输出的简要一句话文字说明。当该it block内的test failed的时候控制台就会把详细信息打印出来。一般是从最外层的describe的module_name开始输出（可以理解成沿着路径或者递归链或者回调链），最后输出info，表示该期望的info内容没有被满足。一个it对应一个实际的test case
assert.equal (exp1, exp2)
断言判断exp1结果是否等于exp2, 这里采取的等于判断是== 而并非 === 。即 assert.equal(1, ‘1’) 认为是True。这只是nodejs里的assert.js的一种断言形式，下文会提到同样比较常用的chai模块。

Mocha实战

项目是基于Express框架的，

项目后台逻辑的层级结构是这样的 Controller -> model -> lib

文件目录结构如下

├── config
│   └── config.json
├── controllers
│   └── dashboard
│       └── widgets
│           └── index.js
├── models
│   └── widgets.js
├── lib
│   └── jdbc.js
├── package.json
└── test
    ├── controllers
    │   └── dashboard
    │       └── widgets
    │           └── index_MockTest.js
    ├── models
    │   └── widgetsTest.js
    └── lib
        └── jdbc_mockTest.js

##转载注明出处：http://www.cnblogs.com/wade-xu/p/4665250.html

被测代码

Controller/dashboard/widgets/index.js

var _widgets = require('../../../models/widgets.js');
 
module.exports = function(router) {
 
  router.get('/', function(req, res) {
    _widgets.getWidgets(req.user.id)
            .then(function(widgets){
              return res.json(widgets);
            })
            .catch(function(err){
              return res.json ({
                code: '000-0001',
                message: 'failed to get widgets:'+err
              });
            });
  });
};

models/widgets.js -- functions to get widget of a user from system

var jdbc = require('../lib/jdbc.js');
var Q = require('q');
var Widgets = exports;

/**
 * Get user widgets
 * @param  {String} userId
 * @return {Promise}
 */
Widgets.getWidgets = function(userId) {
    var defer = Q.defer();
    jdbc.query('select * from t_widget A left join t_widget_config B on A.id = B.widgetId where userId =? order by x,y', [userId])
    .then(function(rows){
        defer.resolve(convertRows(rows));
    }).catch(function(err){
        defer.reject(err);
    });
 
    return defer.promise;
};

lib/jdbc.js -- function 连接数据库查询

var mysql = require('mysql');
var Promise = require('q');
var databaseConfig = require('../config/config.json').database;
 
var JDBC_MYSQL = exports;
 
var pool = mysql.createPool({
    connectionLimit: databaseConfig.connectionLimit,
    host: databaseConfig.host,
    user: databaseConfig.user,
    password: databaseConfig.password,
    port: databaseConfig.port,
    database: databaseConfig.database
});
 
/**
 * Run database query
 * @param  {String} query
 * @param  {Object} [params]
 * @return {Promise}
 */
JDBC_MYSQL.query = function(query, params) {
    var defer = Promise.defer();
    params = params || {};
    pool.getConnection(function(err, connection) {
        if (err) {
            if (connection) {
                connection.release();
            }
            return defer.reject(err);
        }
        connection.query(query, params, function(err, results){
            if (err) {
                if (connection) {
                    connection.release();
                }
                return defer.reject(err);
            }
            connection.release();
            defer.resolve(results);
        });
    });
    return defer.promise;
};

config/config.json --数据库配置

{
    "database": {
        "host" : "10.46.10.007",
        "port" : 3306,
        "user" : "wadexu",
        "password" : "wade001",
        "database" : "demo",
        "connectionLimit" : 100
    }
}

##转载注明出处：http://www.cnblogs.com/wade-xu/p/4665250.html

Example 1

我们来看如何测试models/widgets.js，因为是单元测试，所以不应该去连接真正的数据库，这时候sinon登场了， stub数据库的行为，就是jdbc.js这个依赖。

test/models/widgetsTest.js 如下

 var jdbc = require('../../lib/jdbc.js');
 var widgets = require('../../models/widgets.js');
 
 var chai = require('chai');
 var should = chai.should();
 var assert = chai.assert;
 
 var chaiAsPromised = require('chai-as-promised');
 chai.use(chaiAsPromised);
 
 var sinon = require('sinon');
 var Q = require('q');
 
 describe('Widgets', function() {
 
     describe('get widgets', function() {
 
         var stub;
 
         function jdbcPromise() {
             return Q.fcall(function() {
                 return [{
                     widgetId: 10
                 }];
             });
         };
 
         beforeEach(function() {
             stub = sinon.stub(jdbc, "query");
             stub.withArgs('select * from t_widget A left join t_widget_config B on A.id = B.widgetId where userId =? order by x,y', [1]).returns(jdbcPromise());
 
         });
 
         it('get widgets - 1', function() {
             return widgets.getWidgets(1).should.eventually.be.an('array');
         });
 
         afterEach(function() {
             stub.restore();
         });
     });
 });

被测代码返回的是promise, 所以我们用到了Chai as Promised，它继承了 Chai, 用一些流利的语言来断言 facts about promises.

我们stub住 jdbc.query方法 with 什么什么 Arguments，然后返回一个我们自己定义的promise, 这里用到的是Q promise

断言一定要加 eventually, 表示最终的结果是什么。如果你想断言array里面的具体内容，可以用chai-things， for assertions on array elements.

如果要测试catch error那部分代码，则需要模仿error throwing

     describe('get widgets - error', function() {
 
         var stub;
 
         function jdbcPromise() {
             return Q.fcall(function() {
                 throw new Error("widgets error");
             });
         };
 
         beforeEach(function() {
             stub= sinon.stub(jdbc, "query");
             stub.withArgs('select * from t_widget A left join t_widget_config B on A.id = B.widgetId where userId =? order by x,y', [1]).returns(jdbcPromise());
 
         });
 
         it('get widgets - error', function() {
             return widgets.getWidgets(1).should.be.rejectedWith('widgets error');
         });
 
         afterEach(function() {
             stub.restore();
         });
     });

运行测试结果如下：

Example 2

接下来我想测试controller层，那stub的对象就变成了widgets这个依赖了，

在这里我们用到了supertest来模拟发送http request, 类似功能的模块还有chai-http

如果我们不去stub,mock 的话也可以，这样利用supertest 来发送http request 测试controller->model->lib, 每层都测到了，这就是Integration testing了。

 var kraken = require('kraken-js');
 var express = require('express');
 var request = require('supertest');
 
 var chai = require('chai');
 var assert = chai.assert;
 var sinon = require('sinon');
 var Q = require('q');
 
 var widgets = require('../../../../models/widgets.js');
 
 describe('/dashboard/widgets', function() {
 
   var app, mock;
 
   before(function(done) {
     app = express();
     app.on('start', done);
 
     app.use(kraken({
       basedir: process.cwd(),
       onconfig: function(config, next) {
         //some config info, such as login user info in req
     } }));
 
     mock = app.listen(1337);
 
   });
 
   after(function(done) {
     mock.close(done);
   });
 
   describe('get widgets', function() {
 
     var stub;
 
     function jdbcPromise() {
       return Q.fcall(function() {
         return {
           widgetId: 10
         };
       });
     };
 
     beforeEach(function() {
       stub = sinon.stub(widgets, "getWidgets");
       stub.withArgs('wade-xu').returns(jdbcPromise());
 
     });
 
     it('get widgets', function(done) {
       request(mock)
         .get('/dashboard/widgets/')
         .expect(200)
         .expect('Content-Type', /json/)
         .end(function(err, res) {
           if (err) return done(err);
           assert.equal(res.body.widgetId, '10');
           done();
         });
     });
 
     afterEach(function() {
       stub.restore();
     });
   });
 });

注意，it里面用了Mocha提供的done()函数来测试异步代码，在最深处的回调函数中加done()表示结束测试, 否则测试会报错，因为测试不等异步函数执行完毕就结束了。

在Example1里面我们没有用done() 回调函数, 那是因为我们用了Chai as Promised 来代替。

运行测试结果如下：

##转载注明出处：http://www.cnblogs.com/wade-xu/p/4665250.html

Example 3

测试jdbc.js 同理，需要stub mysql 这个module的行为，代码如下：

 var mysql = require('mysql');
 
 var databaseConfig = require('../../config/config.json').database;
 
 var chai = require('chai');
 var assert = chai.assert;
 var expect = chai.expect;
 var should = chai.should();
 var sinon = require('sinon');
 var Q = require('q');
 var chaiAsPromised = require('chai-as-promised');
 
 chai.use(chaiAsPromised);
 
 var config = {
   connectionLimit: databaseConfig.connectionLimit,
   host: databaseConfig.host,
   user: databaseConfig.user,
   password: databaseConfig.password,
   port: databaseConfig.port,
   database: databaseConfig.database
 };
 
 describe('jdbc', function() {
 
   describe('mock query', function() {
 
     var stub;
     var spy;
     var myPool = {
       getConnection: function(cb) {
         var connection = {
           release: function() {},
           query: function(query, params, qcb) {
             var mockQueries = {
               q1: 'select * from t_widget where userId =?'
             }
 
             if (query === mockQueries.q1 && params === '81EFF5C2') {
               return qcb(null, 'success query');
             } else {
               return qcb(new Error('fail to query'));
             }
           }
         };
         spy = sinon.spy(connection, "release");
         cb(null, connection);
       }
     };
 
     beforeEach(function() {
       stub = sinon.stub(mysql, "createPool");
       stub.withArgs(config).returns(myPool);
 
     });
 
     it('query success', function() {
       delete require.cache[require.resolve('../../lib/jdbc.js')];
       var jdbc = require('../../lib/jdbc.js');
       jdbc.query('select * from t_widget where userId =?', '81EFF5C2').should.eventually.deep.equal('success query');
       assert(spy.calledOnce);
     });
 
     it('query error', function() {
       delete require.cache[require.resolve('../../lib/jdbc.js')];
       var jdbc = require('../../lib/jdbc.js');
       jdbc.query('select * from t_widget where userId =?', 'WrongID').should.be.rejectedWith('fail to query');
       assert(spy.calledOnce);
     });
 
     afterEach(function() {
       stub.restore();
       spy.restore();
     });
 
   });
 
   describe('mock query error ', function() {
 
     var stub;
     var spy;
 
     var myPool = {
       getConnection: function(cb) {
         var connection = {
           release: function() {},
         };
         spy = sinon.spy(connection, "release");
         cb(new Error('Pool get connection error'));
       }
     };
 
     beforeEach(function() {
       stub = sinon.stub(mysql, "createPool");
       stub.withArgs(config).returns(myPool);
     });
 
     it('query error without connection', function() {
       delete require.cache[require.resolve('../../lib/jdbc.js')];
       var jdbc = require('../../lib/jdbc.js');
       jdbc.query('select * from t_widget where userId =?', '81EFF5C2').should.be.rejectedWith('Pool get connection error');
 
       assert.isFalse(spy.called);
     });
 
     afterEach(function() {
       stub.restore();
       spy.restore();
     });
 
   });
 
 });

这里要注意的是我每个case里面都是 delete cache 不然只有第一个case会pass, 后面的都会报错, 后面的case返回的myPool都是第一个case的, 因为第一次create Pool之后返回的 myPool被存入cache里了。

测试运行结果如下

##转载注明出处：http://www.cnblogs.com/wade-xu/p/4665250.html

Troubleshooting

1. stub.withArgs(XXX).returns(XXX) 这里的参数要和stub的那个方法里面的参数保持一致。

2. stub某个对象的方法还有onFirstCall(), onSecondCall() 做不同的事情。

3. 文中提到过如何 remove module after “require” in node.js 不然创建的数据库连接池pool一直在cache里，后面的case无法更改它.

delete require.cache[require.resolve('../../lib/jdbc.js')];

4. 如何引入chai-as-promised

var chaiAsPromised = require('chai-as-promised');
chai.use(chaiAsPromised);

5. mocha无法命令行运行，设置好你的环境变量PATH路径

参考文档

Mocha: http://mochajs.org/

Chai: http://chaijs.com/

Sinon: http://sinonjs.org/

感谢阅读，如果您觉得本文的内容对您的学习有所帮助，您可以点击右下方的推荐按钮，您的鼓励是我创作的动力。

##转载注明出处：http://www.cnblogs.com/wade-xu/p/4665250.html