JS单元测试

发表于

单元测试

维基百科：单元测试是针对 程序的最小单元 来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。一个单元可能是单个程序、类、对象、方法等。
通俗百科：单元测试，是为了测试某一个类的某一个方法能否正常工作，而写的测试代码。

什么是单元测试

那么，什么是单元测试呢？简单来说就是对（一些不常变动的）单元进行测试，对前端来说你可以强行理解为😁：就是对一些通用函数和通用组件进行测试。再直白点说就是写一些测试代码来验证你的源代码是否符合预期，仅此而已。
正经点说，测试又可分为测试驱动开发（TDD）和行为驱动开发（BDD）两种，什么意思呢🤔？

  • TDD：通过测试来推动整个开发的进行（就是测着测着出了 bug 就返回修改代码，注重测试结果）
  • BDD：通过行为来推动整个开发的进行（就是按着按着出了 bug 就返回修改代码，注重测试逻辑）

单元测试属于轻量测试

  • 可重复
  • 快速
  • 一致性
  • 方便读写

设计原则

良好单元测试的关键在于编写可测试的代码。下面是一些有用的设计原则：

  • 使用良好的命名规范并注释代码（“为什么”而不是“怎么做”），要记住注释并不能代替糟糕的命名和设计
  • 不要重复自己，避免重复代码
  • 单一职责：每个对象 / 函数只应该关注一个任务
  • 在同一组件中保持单一抽象级别（例如，不要将业务逻辑与同一方法中的低层实现细节混合在一起）
  • 最小化组件间依赖：通过封装组件，减少组件之间的信息交换
  • 支持可配置性而不是硬编码，这避免了在测试时复制完全相同的环境
  • 适当地引用设计模式，尤其是依赖注入，因为它能将对象的创建职责与业务逻辑分离
  • 避免全局状态

单元测试的意义

减少bug、提高代码质量、快速定位bug、减少调试时间、放心重构。

单元测试的目的

当你的项目足够大的时候，在叠加模块和组件的过程中，是很有可能影响之前的模块。但是被影响的模块已经通过了测试，我们在迭代的时候，很少有测试人员会去重新测试这个系统。所以， 被影响的模块很可能就有了一个隐形的bug被部署到线上。因此我们采用自动化测试。最主要的作用是对于大型项目，在每次迭代的时候， 可以保证整个系统的正确运行， 确保系统的健壮。

测试工具

image

karma

karma 不是一个测试框架，也不是一个断言库，而是一个测试集成工具，它的主要作用就是集成其他各种测试工具（支持按需配置，你可以通过 karma 的配置文件来集成你喜欢的框架、断言库和浏览器等），然后自动打开浏览器运行你的测试脚本，测试结果通常会显示在命令行中。此外它还可以监听测试文件的变化，然后自执行。

总结：你可以粗浅的认为 karma 就是用来打开浏览器的。

mocha

mocha 是一个很常用的测试框架（类似的有 jasmine 和 jest 等），它既可以在 Node 中运行，也可以在浏览器中运行。它的主要作用是提供一些方便的语法来编写测试用例，以及对用例进行分组等。一个测试脚本可以由多个 descibe 组成，每个 describe 又可以由多个 it 组成。descibe 主要就是用来分组，it 就是具体的测试用例代码。

1
2
3
4
5
6
7
8
describe('分组一', () => {
    it('测试用例描述一', () => {})
    it('测试用例描述二', () => {})
})
describe('分组二', () => {
    it('测试用例描述一', () => {})
    it('测试用例描述二', () => {})
})

这个就是固定写法，记住就行，没有什么为什么👀。

总结：你可以粗浅的认为 mocha 就是用来编写测试用例的。

chai

因为 mocha 本身是不带断言的，所以需要和断言库结合使用。这里我们选择 chai 这个断言库。
总结：chai 是一个语义化的断言库

sinon

sinon 是一个测试辅助工具，它的本质工作是测试替身，也就是用来替换测试中的部分代码，使测试代码变得简洁。比如我们要测一个函数是否被调用过，就可以借助 sinon.fake() 来实现，这是一个特殊的函数，现在不懂没关系，用的时候你就知道了。

总结：sinon 是一个测试辅助工具

以上就是单元测试所需用到的大部分工具知识，如果大家想要加深了解的话，可以自行百度。

Mocha(‘摩卡’)

测试框架 Mocha 实例教程:里面使用的是chai断言库
Mocha 诞生于2011年，是现在最流行的JavaScript测试框架之一，在浏览器和Node环境都可以使用。

所谓”测试框架”，就是运行测试的工具。通过它，可以为JavaScript应用添加测试，从而保证代码的质量。

本文全面介绍如何使用Mocha，让你轻松上手。如果你以前对测试一无所知，本文也可以当作JavaScript单元测试入门。值得说明的是，除了Mocha以外，类似的测试框架还有Jasmine 、Karma 、Tape 等，也很值得学习。

一、安装

1
2
$ npm install --global mocha
$ npm install -g mocha

二、测试脚本的写法

Mocha的作用是运行测试脚本，首先必须学会写测试脚本。所谓”测试脚本”，就是用来测试源码的脚本。

下面是一个加法模块add.js的代码。

1
2
3
4
5
6
// add.js
function add(x, y) {
  return x + y;
}

module.exports = add;

要测试这个加法模块是否正确，就要写测试脚本。

通常，测试脚本与所要测试的源码脚本同名，但是后缀名为.test.js（表示测试）或者.spec.js（表示规格）。比如，add.js的测试脚本名字就是add.test.js 。

1
2
3
4
5
6
7
8
9
10

// add.test.js
var add = require('./add.js');
var expect = require('chai').expect;

describe('加法函数的测试', function() {
  it('1 加 1 应该等于 2', function() {
    expect(add(1, 1)).to.be.equal(2);
  });
});

上面这段代码，就是测试脚本，它可以独立执行。测试脚本里面应该包括一个或多个describe块，每个describe块应该包括一个或多个it块。

describe块称为”测试套件”（test suite），表示一组相关的测试。它是一个函数，第一个参数是测试套件的名称（”加法函数的测试”），第二个参数是一个实际执行的函数。

it块称为”测试用例”（test case），表示一个单独的测试，是测试的最小单位。它也是一个函数，第一个参数是测试用例的名称（”1 加 1 应该等于 2”），第二个参数是一个实际执行的函数。

三、断言库的用法

上面的测试脚本里面，有一句断言。

1
expect(add(1, 1)).to.be.equal(2);

所谓”断言”，就是判断源码的实际执行结果与预期结果是否一致，如果不一致就抛出一个错误。上面这句断言的意思是，调用add(1, 1)，结果应该等于2。

所有的测试用例（it块）都应该含有一句或多句的断言。它是编写测试用例的关键。断言功能由断言库来实现，Mocha本身不带断言库，所以必须先引入断言库。

1
var expect = require('chai').expect;

断言库有很多种，Mocha并不限制使用哪一种。上面代码引入的断言库是chai ，并且指定使用它的expect断言风格。

expect断言的优点是很接近自然语言，下面是一些例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

// 布尔值为true
expect('everthing').to.be.ok;
expect(false).to.not.be.ok;

// typeof
expect('test').to.be.a('string');
expect({ foo: 'bar' }).to.be.an('object');
expect(foo).to.be.an.instanceof(Foo);

// include
expect([1,2,3]).to.include(2);
expect('foobar').to.contain('foo');
expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');

// empty
expect([]).to.be.empty;
expect('').to.be.empty;
expect({}).to.be.empty;

// match
expect('foobar').to.match(/^foo/);

基本上，expect断言的写法都是一样的。头部是expect方法，尾部是断言方法，比如equal、a/an、ok、match等。两者之间使用to或to.be连接。

如果expect断言不成立，就会抛出一个错误。事实上，只要不抛出错误，测试用例就算通过。

1
it('1 加 1 应该等于 2',function(){});

上面的这个测试用例，内部没有任何代码，由于没有抛出了错误，所以还是会通过。

四、Mocha的基本用法

有了测试脚本以后，就可以用Mocha运行它。请进入demo01子目录，执行下面的命令。

1
2
3
4
$ mocha add.test.js

  加法函数的测试
    ✓ 1 加 1 应该等于 21 passing (8ms)

上面的运行结果表示，测试脚本通过了测试，一共只有1个测试用例，耗时是8毫秒。

mocha命令后面紧跟测试脚本的路径和文件名，可以指定多个测试脚本。

1
$ mocha file1 file2 file3

Mocha默认运行test子目录里面的测试脚本。所以，一般都会把测试脚本放在test目录里面，然后执行mocha就不需要参数了。 

1
2
3
4
5
6
7
$ mocha

  加法函数的测试
    ✓ 1 加 1 应该等于 2
    ✓ 任何数加0应该等于自身

  2 passing (9ms)

这时可以看到，test子目录里面的测试脚本执行了。但是，你打开test子目录，会发现下面还有一个test/dir子目录，里面还有一个测试脚本multiply.test.js ，并没有得到执行。原来，Mocha默认只执行test子目录下面第一层的测试用例，不会执行更下层的用例。

为了改变这种行为，就必须加上--recursive参数，这时test子目录下面所有的测试用例—-不管在哪一层—-都会执行。

1
2
3
4
5
6
7
8
$ mocha --recursive

  加法函数的测试
    ✓ 1 加 1 应该等于 2
    ✓ 任何数加0应该等于自身

  乘法函数的测试
    ✓ 1 乘 1 应该等于 13 passing (9ms)

五、通配符

命令行指定测试脚本时，可以使用通配符，同时指定多个文件。

1
2
$ mocha spec/{my,awesome}.js
$ mocha test/unit/*.js

上面的第一行命令，指定执行spec目录下面的my.js和awesome.js。第二行命令，指定执行test/unit目录下面的所有js文件。

除了使用Shell通配符，还可以使用Node通配符。

1
$ mocha 'test/**/*.@(js|jsx)'

上面代码指定运行test目录下面任何子目录中、文件后缀名为js或jsx的测试脚本。注意，Node的通配符要放在单引号之中，否则星号（*）会先被Shell解释。

上面这行Node通配符，如果改用Shell通配符，要写成下面这样。

1
$ mocha test/{,**/}*.{js,jsx}

六、命令行参数

除了前面介绍的--recursive，Mocha还可以加上其他命令行参数。请在demo02 子目录里面，运行下面的命令，查看效果。

6.1 –help, -h

--help或-h参数，用来查看Mocha的所有命令行参数。

1
$ mocha --help

6.2 –reporter, -R

--reporter参数用来指定测试报告的格式，默认是spec格式。

1
2
3
$ mocha
# 等同于
$ mocha --reporter spec

除了spec格式，官方网站还提供了其他许多报告格式 。

1
2
3
4
5
6
$ mocha --reporter tap
 
1..2
ok 1 加法函数的测试 1 加 1 应该等于 2
ok 2 加法函数的测试 任何数加0应该等于自身
# tests 2# pass 2# fail 0

上面是tap格式报告的显示结果。

--reporters参数可以显示所有内置的报告格式。

1
$ mocha --reporters

使用mochawesome模块，可以生成漂亮的HTML格式的报告。

1
2
$ npm install --save-dev mochawesome
$ ../node_modules/.bin/mocha --reporter mochawesome

上面代码中，mocha命令使用了项目内安装的版本，而不是全局安装的版本，因为mochawesome模块是安装在项目内的。

然后，测试结果报告就在`mochaawesome-reports 子目录生成。

6.3 –growl, -G

打开--growl 参数，就会将测试结果在桌面显示。

1
$ mocha --growl

6.4 –watch，-w

--watch参数用来监视指定的测试脚本。只要测试脚本有变化，就会自动运行Mocha。

1
$ mocha --watch

上面命令执行以后，并不会退出。你可以另外打开一个终端窗口，修改test目录下面的测试脚本add.test.js，比如删除一个测试用例，一旦保存，Mocha就会再次自动运行。

6.5 –bail, -b

--bail参数指定只要有一个测试用例没有通过，就停止执行后面的测试用例。这对持续集成很有用。

1
$ mocha --bail

6.6 –grep, -g

--grep参数用于搜索测试用例的名称（即it块的第一个参数），然后只执行匹配的测试用例。

1
$ mocha --grep "1 加 1"

上面代码只测试名称中包含”1 加 1”的测试用例。

6.7 –invert, -i

--invert参数表示只运行不符合条件的测试脚本，必须与--grep参数配合使用。

1
$ mocha --grep "1 加 1"--invert

七，配置文件mocha.opts

Mocha允许在test目录下面，放置配置文件mocha.opts，把命令行参数写在里面。 

1
$ mocha --recursive --reporter tap --growl

上面这个命令有三个参数--recursive、--reporter tap、--growl。

然后，把这三个参数写入test目录下的mocha.opts 文件。

1
2
3
--reporter tap
--recursive
--growl

然后，执行mocha就能取得与第一行命令一样的效果。

1
$ mocha

如果测试用例不是存放在test子目录，可以在mocha.opts写入以下内容。

1
2
server-tests
--recursive

上面代码指定运行server-tests目录及其子目录之中的测试脚本。

八、ES6测试

如果测试脚本是用ES6写的，那么运行测试之前，需要先用Babel转码。

1
2
3
4
5
6
7
8
9
10
11

import add from '../src/add.js';
import chai from 'chai';

let expect = chai.expect;

describe('加法函数的测试', function() {
  it('1 加 1 应该等于 2', function() {
    expect(add(1, 1)).to.be.equal(2);
  });
});

ES6转码，需要安装Babel。

1
$ npm install babel-core babel-preset-es2015 --save-dev

然后，在项目目录下面，新建一个.babelrc 配置文件。

1
{"presets":["es2015"]}

最后，使用--compilers参数指定测试脚本的转码器。

1
$ ../node_modules/mocha/bin/mocha --compilers js:babel-core/register

上面代码中，--compilers参数后面紧跟一个用冒号分隔的字符串，冒号左边是文件的后缀名，右边是用来处理这一类文件的模块名。上面代码表示，运行测试之前，先用babel-core/register模块，处理一下.js文件。由于这里的转码器安装在项目内，所以要使用项目内安装的Mocha；如果转码器安装在全局，就可以使用全局的Mocha。

下面是另外一个例子，使用Mocha测试CoffeeScript脚本。测试之前，先将.coffee文件转成.js文件。

1
$ mocha --compilers coffee:coffee-script/register

注意，Babel默认不会对Iterator、Generator、Promise、Map、Set等全局对象，以及一些全局对象的方法（比如Object.assign）转码。如果你想要对这些对象转码，就要安装babel-polyfill。

1
$ npm install babel-polyfill --save

然后，在你的脚本头部加上一行。

1
import'babel-polyfill'

九、异步测试

Mocha默认每个测试用例最多执行2000毫秒，如果到时没有得到结果，就报错。对于涉及异步操作的测试用例，这个时间往往是不够的，需要用-t或--timeout参数指定超时门槛。

1
2
3
4
5
6
7
8
9
10

it('测试应该5000毫秒后结束', function(done) {
  var x = true;
  var f = function() {
    x = false;
    expect(x).to.be.not.ok;
    done(); // 通知Mocha测试结束
  };
  setTimeout(f, 4000);
});

上面的测试用例，需要4000毫秒之后，才有运行结果。所以，需要用-t或--timeout参数，改变默认的超时设置。

1
$ mocha -t 5000 timeout.test.js

上面命令将测试的超时时限指定为5000毫秒。

另外，上面的测试用例里面，有一个done函数。it块执行的时候，传入一个done参数，当测试结束的时候，必须显式调用这个函数，告诉Mocha测试结束了。否则，Mocha就无法知道，测试是否结束，会一直等到超时报错。你可以把这行删除试试看。

Mocha默认会高亮显示超过75毫秒的测试用例，可以用-s或--slow调整这个参数。

1
$ mocha -t 5000 -s 1000 timeout.test.js

上面命令指定高亮显示耗时超过1000毫秒的测试用例。

1
2
3
4
5
6
7
8
it('异步请求应该返回一个对象', function(done){
  request
    .get('https://api.github.com')
    .end(function(err, res){
      expect(res).to.be.an('object');
      done();
    });
});

运行下面命令，可以看到这个测试会通过。

1
$ mocha -t 10000 async.test.js

另外，Mocha内置对Promise的支持，允许直接返回Promise，等到它的状态改变，再执行断言，而不用显式调用done方法。请看promise.test.js 。

1
2
3
4
5
6
7
8
9

it('异步请求应该返回一个对象', function() {
  return fetch('https://api.github.com')
    .then(function(res) {
      return res.json();
    }).then(function(json) {
      expect(json).to.be.an('object');
    });
});

十、测试用例的钩子

Mocha在describe块之中，提供测试用例的四个钩子：before()、after()、beforeEach()和afterEach()。它们会在指定时间执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

describe('hooks', function() {

  before(function() {
    // 在本区块的所有测试用例之前执行
  });

  after(function() {
    // 在本区块的所有测试用例之后执行
  });

  beforeEach(function() {
    // 在本区块的每个测试用例之前执行
  });

  afterEach(function() {
    // 在本区块的每个测试用例之后执行
  });

  // test cases
});

可以看到下面两个例子。首先是beforeEach的例子beforeEach.test.js 。

1
2
3
4
5
6
7
8
9
10
11
12
13

// beforeEach.test.js
describe('beforeEach示例', function() {
  var foo = false;

  beforeEach(function() {
    foo = true;
  });

  it('修改全局变量应该成功', function() {
    expect(foo).to.be.equal(true);
  });
});

上面代码中，beforeEach会在it之前执行，所以会修改全局变量。

另一个例子beforeEach-async.test.js 则是演示，如何在beforeEach之中使用异步操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// beforeEach-async.test.js
describe('异步 beforeEach 示例', function() {
  var foo = false;

  beforeEach(function(done) {
    setTimeout(function() {
      foo = true;
      done();
    }, 50);
  });

  it('全局变量异步修改应该成功', function() {
    expect(foo).to.be.equal(true);
  });
});

十一、测试用例管理

大型项目有很多测试用例。有时，我们希望只运行其中的几个，这时可以用only方法。describe块和it块都允许调用only方法，表示只运行某个测试套件或测试用例。

使用了only。

1
2
3
4
5
6
7
it.only('1 加 1 应该等于 2', function() {
  expect(add(1, 1)).to.be.equal(2);
});

it('任何数加0应该等于自身', function() {
  expect(add(1, 0)).to.be.equal(1);
});

上面代码中，只有带有only方法的测试用例会运行。

1
2
3
4
5
6
$ mocha test/add.test.js

  加法函数的测试
    ✓ 1 加 1 应该等于 2

  1 passing (10ms)

此外，还有skip方法，表示跳过指定的测试套件或测试用例。

1
2
3
4

it.skip('任何数加0应该等于自身', function() {
  expect(add(1, 0)).to.be.equal(1);
});

上面代码的这个测试用例不会执行。

vue单元测试

【大白话】单元测试

Vue Test Utils

vue单元测试学习笔记

使用 enzyme + jest 测试 React 组件