PHPStorm中如何对nodejs项目进行单元测试详解

安装必要的包

nodejs的单元测试最常用的是使用mocha包。首先确保你本地安装nodejs，之后按照mocha包。

npm install mocha -g

然后还需要安装相关的断言工具，node.js中常用的断言库有：

• assert: tdd风格
• should: bdd风格
• expect: bdd风格
• chai: bdd/tdd风格

使用npm install安装这些断言库其中之一即可。

phpstorm配置nodejs单元测试环境

在phpstorm中选择菜单：run -> edit configurations，点击右上角添加mocha。

分别填写下面几项，关于mocha单元测试可以参考官网：https://mochajs.org/

• name: 随便一个运行配置的名称，如mochatest
• working directory: 当前项目目录
• mocha package: mocha安装包的目录，node_modules\mocha
• user interface: 测试类型，这里选择tdd（对应assert库）
• test directory: 这一项可以选择测试目录或文件
  • all in directory: 整个目录都进行测试
  • file patterns: 某种模式的文件，可以填正则表达式
  • test file: 某个特定的测试文件

填写完成并且没有报错后点击ok。

nodejs进行单元测试

这里我们选择assert库，tdd模式进行单元测试。在上面选定的test directory目录下新建一个测试文件test.js.

const assert = require('assert');

// 测试array类型的方法
suite('array', function() {
 // 测试 indexof方法
 suite('#indexof()', function() {
  // 测试用例
  test('should return -1 when not present', function() {
   assert.equal(-1, [1, 2, 3].indexof(4));
  });
 });
});

点击选择mocha运行，在phpstorm下面的输出框中有测试的结果，绿色表示通过，红色表示失败。

断言库的使用

mocha进行单元测试的时候，除了能够使用assert断言库，只要断言代码中抛出error，mocha就可以正常工作。

assert库：tdd风格

下面列举assert库中常用的断言函数，详情可参考官网：https://www.npmjs.com/package/assert

• assert.fail(actual, expected, message, operator)
• assert(value, message), assert.ok(value, [message])
• assert.equal(actual, expected, [message])
• assert.notequal(actual, expected, [message])
• assert.deepequal(actual, expected, [message])
• assert.notdeepequal(actual, expected, [message])
• assert.strictequal(actual, expected, [message])
• assert.notstrictequal(actual, expected, [message])
• assert.throws(block, [error], [message])
• assert.doesnotthrow(block, [message])
• assert.iferror(value)

其中的参数说明如下：

• value: 实际值
• actual: 实际值
• expected: 期望值
• block: 语句块
• message: 附加信息

bdd风格should.js断言库

安装方法：npm install should --save-dev，官网地址：https://github.com/shouldjs/should.js

const should = require('should');

const user = {
 name: 'tj'
 , pets: ['tobi', 'loki', 'jane', 'bandit']
};

user.should.have.property('name', 'tj');
user.should.have.property('pets').with.lengthof(4);

// if the object was created with object.create(null)
// then it doesn't inherit `object.prototype`, so it will not have `.should` getter
// so you can do:
should(user).have.property('name', 'tj');

// also you can test in that way for null's
should(null).not.be.ok();

someasynctask(foo, function(err, result){
 should.not.exist(err);
 should.exist(result);
 result.bar.should.equal(foo);
});

should库可以使用链式调用，功能非常强大。相关文档参考：http://shouldjs.github.io/

user.should.be.an.instanceof(object).and.have.property('name', 'tj');
user.pets.should.be.instanceof(array).and.have.lengthof(4);

常用的should断言方法：

无意义谓词，没作用增加可读性：.an, .of, .a, .and, .be, .have, .with, .is, .which

• should.equal(actual, expected, [message]): 判断是否相等
• should.notequal(actual, expected, [message]): 判断是否不相等
• should.strictequal(actual, expected, [message]): 判断是否严格相等
• should.notstrictequal(actual, expected, [message]): 判断是否严格不相等
• should.deepequal(actual, expected, [message]): 判断是否递归相等
• should.notdeepequal(actual, expected, [message]): 判断是否递归不想等
• should.throws(block, [error], [message]): 判断是否抛出异常
• should.doesnotthrow(block, [message]): 判断是否不抛出异常
• should.fail(actual, expected, message, operator): 判断是否不等
• should.iferror(err): 判断是否为错误
• should.exist(actual, [message]): 判断对象是否存在
• should.not.exist(actual, [message]): 判断对象是否不存在

另外should还提供了一系列类型判断断言方法：

// bool类型判断
(true).should.be.true();
false.should.not.be.true();

// 数组是否包含
[ 1, 2, 3].should.containdeep([2, 1]);
[ 1, 2, [ 1, 2, 3 ]].should.containdeep([ 1, [ 3, 1 ]]);

// 数字比较
(10).should.not.be.nan();
nan.should.be.nan();
(0).should.be.beloworequal(10);
(0).should.be.beloworequal(0);
(10).should.be.aboveorequal(0);
(10).should.be.aboveorequal(10);

// promise状态判断
// don't forget to handle async nature
(new promise(function(resolve, reject) { resolve(10); })).should.be.fulfilled();

// test example with mocha it is possible to return promise
it('is async', () => {
 return new promise(resolve => resolve(10))
  .should.be.fulfilled();
});

// 对象的属性判断
({ a: 10 }).should.have.property('a');
({ a: 10, b: 20 }).should.have.properties({ b: 20 });
[1, 2].should.have.length(2);
({}).should.be.empty();

// 类型检查
[1, 2, 3].should.is.array();
({}).should.is.object();

几种常见的测试风格代码举例

bdd

bdd提供的接口有：describe(), context(), it(), specify(), before(), after(), beforeeach(), and aftereach().

describe('array', function() {
 before(function() {
  // ...
 });

 describe('#indexof()', function() {
  context('when not present', function() {
   it('should not throw an error', function() {
    (function() {
     [1, 2, 3].indexof(4);
    }.should.not.throw());
   });
   it('should return -1', function() {
    [1, 2, 3].indexof(4).should.equal(-1);
   });
  });
  context('when present', function() {
   it('should return the index where the element first appears in the array', function() {
    [1, 2, 3].indexof(3).should.equal(2);
   });
  });
 });
});

tdd

提供的接口有： suite(), test(), suitesetup(), suiteteardown(), setup(), and teardown():

suite('array', function() {
 setup(function() {
  // ...
 });

 suite('#indexof()', function() {
  test('should return -1 when not present', function() {
   assert.equal(-1, [1, 2, 3].indexof(4));
  });
 });
});

qunit

和tdd类似，使用suite()和test()标记测试永烈，包含的接口有：before(), after(), beforeeach(), and aftereach()。

function ok(expr, msg) {
 if (!expr) throw new error(msg);
}

suite('array');

test('#length', function() {
 var arr = [1, 2, 3];
 ok(arr.length == 3);
});

test('#indexof()', function() {
 var arr = [1, 2, 3];
 ok(arr.indexof(1) == 0);
 ok(arr.indexof(2) == 1);
 ok(arr.indexof(3) == 2);
});

suite('string');

test('#length', function() {
 ok('foo'.length == 3);
});

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。