• 前端自动化测试 —— Jest 测试框架应用

    目录​​​​​​​

    什么是自动化测试

    为什么要用前端自动化测试

    前端自动化分类和思想

    单元测试

    集成测试

    TDD 测试驱动开发（Test Driven Development）

    BDD 行为驱动开发（Behavior Driven Development）

    如何自己写非框架测试用例

    是否能简化？

    如何能清晰地看到我测的是哪个呢？

    如何使用 Jest 测试框架进行自动化测试？

    主流的前端自动化测试框架

    Jasmine

    MOCHA

    Jest

    准备工作 —— Jest 的配置

    使用 babel 转换来使用 ES6 形式的导入和导出

    如何生成一个测试用例覆盖率报告？

    Jest 基础匹配器

    匹配器

    命令行操作

    异步测试

    钩子函数

    分组方法 discribe

    Mock

    Mock 高阶用法

    Mock-timers

    snapshot 快照

    对 dom 节点测试

    VSCode 插件

    常用配置解读

    小结

    代码地址

    参考文档

    什么是自动化测试

            在软件测试中，自动化测试指的是使用独立于待测软件的其他软件来自动执行测试、比较实际结果与预期并生成测试报告这一过程。在测试流程已经确定后，测试自动化可以自动执行的一些重复但必要的测试工作。也可以完成手动测试几乎不可能完成的测试。对于持续交付和持续集成的开发方式而言，测试自动化是至关重要的。   ——来自 WiKi 百科

    为什么要用前端自动化测试

            随着前端项目的发展，其规模和功能日益增加。为了提高项目的稳定性和可靠性，除了需要测试工程师外，前端自动化测试也成为了不可或缺的一环。采用前端自动化测试可以有效地提高代码质量，降低出错的概率，从而使项目更加健壮和更易维护。

    前端自动化分类和思想

    单元测试

            又称为模块测试 ，是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。在前端中，一个函数、一个类、一个模块文件，都可以进行单元测试，测试时每个模块都是互不干扰的。

    集成测试

            是在单元测试的基础上，测试再将所有的软件单元按照概要设计规格说明的要求组装成模块、子系统或系统的过程中各部分工作是否达到或实现相应技术指标及要求的活动。用户的开始操作到结束操作这一整个行为流程可以当作集成测试。

    TDD 测试驱动开发（Test Driven Development）

    开发流程：

    TDD 是趋向于白盒测试，需要开发者对当前编写的模块思路足够清晰。

    优势：

    1. 长期减少回归 bug。

    2. 代码质量更好，可维护性高。

    3. 测试覆盖率高（先写测试用例，再实现功能）。

    4. 错误测试代码不容易出现（测试在开发之前执行）。

    BDD 行为驱动开发（Behavior Driven Development）

    开发流程：

    BDD 趋向于黑盒测试，只关注用户的一整套行为流程下来是否会成功。

    优势：

    1. 对于用户行为的整个流程把控程度较高，对于开发人员来说这样安全感高。

    如何自己写非框架测试用例

            不使用测试框架，我们该如何测试自己的模块呢？如果我们想要测试下面的代码，应该需要两个值，一个是 期望值 ，另一个是函数执行的 结果值 ，我们需要对比两个值来进行判断当前函数是否通过了测试用例。

    1. // index.js
    2. function ZcyZooTeam(str) {
    3.   return 'Zcy' + str;
    4. }

            需要下面的 if / else 进行判断当前的期望值 value 和结果值 result 是否相等，如果相等说明我们的测试用例通过了。我们将这两段代码复制到浏览器中，下面的执行不会通过，并会抛出错误，只有我们将传入值改为 ZooTeam 才会成功执行。

    1. // no-jest.js
    2. const result = ZcyZooTeam('Zero');
    3. const value = 'ZooTeam';
    4. if(result !== value) {
    5.   throw Error(`ZcyZooTeam 结果应为${value}, 但实际结果为${result}`);
    6. }

    是否能简化？

            如果我们有多个函数需要测试，你应该不想写许多个 if / else 代码块吧？所以我们要将上面的代码块进行优化成一个函数。

    1. // no-jest.js
    2. function expect(result) {
    3.   return {
    4.     // 用于判断是否为期望值
    5.     toBe(value) {
    6.       if(result !== value) {
    7.         throw Error(`结果应为${value}, 但实际结果为${result}`);
    8.       }
    9.       console.log('测试通过！');
    10.     }
    11.   }
    12. }
    13.  
    14. // 执行测试
    15. expect(ZcyZooTeam('Zero')).toBe('ZcyZooTeam');

    经过上面的封装，我们就可以只写一行代码进行测试了！

    如何能清晰地看到我测的是哪个呢？

            虽然上面的封装只需要书写一行代码就可以测试了，但是我们不知道执行结果和测试用例之间的对应关系，我们需要输出的文字来告诉我们当前是哪个测试用例执行了。

    1. // no-jest.js
    2. // 再封装如下方法
    3. function test(msg, fn) {
    4.   try {
    5.     fn();
    6.     console.log(msg + '测试通过！');
    7.   } catch (error) {
    8.     console.log(msg + '测试未通过！' + error);
    9.   }
    10. }
    11.  
    12. test('测试ZcyZooTeam', () => {
    13.   expect(ZcyZooTeam('Zero')).toBe('ZcyZooTeam')
    14. })

    成功和失败都会进行提示，这样我们就可以知道当前是哪个测试用例成功/失败了。

        Jest 的书写方式也是同上，如果上面的一整套代码了解了的话，你已经可以写 Jest 的测试脚本了，下面将进入 Jest 的配置。

    如何使用 Jest 测试框架进行自动化测试？

    主流的前端自动化测试框架

    Jasmine

    Jasmine 优点：易于学习和使用，支持异步测试，可以在浏览器和 Node.js 环境中运行，可以生成易于阅读的测试报告，可以与其他库和框架集成。

    MOCHA

    MOCHA 优点：支持异步测试和 Promise ，可以在浏览器和 Node.js 环境中运行，可以与其他库和框架集成，可以生成易于阅读的测试报告，可以使用各种插件和扩展来增强其功能。

    Jest

    Jest 是针对模块进行测试，单元测试对单个模块进行测试，集成测试对多个模块进行测试。

    Jest 优点：速度快（单模块测试时，执行过的模块不会重复执行），API简单，易配置，隔离性好（执行环境相对隔离，每个文件单独隔离互不干扰），监控模式（更灵活的运行各种测试用例），适配编辑器多，Snapshot（快照），多项目运行（后台前台测试用例并行测试），生成可视化覆盖率简单，Mock 丰富。

    准备工作 —— Jest 的配置

    1. npm i jest --save-D
    2.  
    3. // 初始化 jest 的配置文件
    4. npx jest --init
    5.  
    6. // 你将在那个环境进行测试，回车即可选择
    7. // 第一个是 node 环境、第二个是浏览器环境
    8. ? Choose the test environment that will be used for testing › - Use arrow-keys. Return to submit.
    9.     node
    10. ❯   jsdom (browser-like)
    11.  
    12. // 是否需要 jest 生成测试覆盖率报告
    13. ? Do you want Jest to add coverage reports? › (y/N)
    14.  
    15. // 是否需要在测试结束后清除模拟调用
    16. ? Automatically clear mock calls and instances between every test? › (y/N)
    17.  
    18. // 创建 jest.config.js 文件
    19. 📝  Configuration file created at /Users/zcy1/Desktop/demo/auto-test-jest-demo/jest.config.js

            以上方法执行结束后，会生成一个 jest.config.js 文件，里面包含了 Jest 的配置项，每个配置项都会带有描述，在初始化的两个配置也会体现在配置文件中

    使用 babel 转换来使用 ES6 形式的导入和导出

    1. // .babelrc
    2. // 如果想用 es6 的形式导出，需要使用 babel 插件进行转换
    3. // @babel/core  @babel/preset-env
    4.  
    5. // 创建 .babelrc 文件
    6. // 为了在 node 环境下使用 es6 的导出，需要使用 babel 进行转换
    7. {
    8.   // 设置插件集合
    9.   "presets": [
    10.     // 使用当前插件，可以进行转换
    11.     // 数组的第二项为插件的配置项
    12.     [
    13.       "@babel/preset-env", {
    14.         // 根据 node 的版本号来结合插件对代码进行转换
    15.         "targets": {
    16.           "node": "current"
    17.         }
    18.       }
    19.     ]
    20.   ]
    21. }

            配置好后需要将 package.json 中的 test 命令的 value 改为 jest --watchAll，代表监听所有有修改的测试文件，然后控制台执行 npm run test 就可以执行测试用例了。

    Jest 启动时会进行如下流程：

    1. ·npm run test

    2. ·jest (babel-jest)  检测当前环境是否安装了 babel

    3. ·如果安装了则会去 babelrc 中取配置

    4. ·取到后执行代码转换

    5. ·最后再执行转化过的测试用例代码

    如何生成一个测试用例覆盖率报告？

    经过上面的 Jest 配置，我们就可以通过下面的 npx 命令来生成测试覆盖率报告了

    npx jest --coverage

            会生成一个名为 coverage 的文件夹，打开里面的 html 就可以看到你的覆盖率，其中 Statements 是语句覆盖率（每个语句是否执行），Branches 是分支覆盖率（每个 if块是否执行），Functions是函数覆盖率（每个函数是否执行），Lines 是行覆盖率（每行是否执行），通过修改 coverageDirectory 的值可以改变测试覆盖率生成文件夹的名字

    Jest 基础匹配器

            上面我们说过了，Jest 的用法和我们封装的那几个函数是一样的，都是执行 test 函数并向函数中传递参数，第一个参数是你当前测试用例的描述，第二个参数是需要执行的匹配规则。

    匹配器

    toBe

    toBe 匹配器，期待是否与匹配器中的值相等 相当于 object.is ===

    1. // jest.test.js
    2. test("测试", () => {
    3.   expect(1).toBe(1);  // 通过
    4.   const a = { name: 'Zero' };
    5.   // 因为 a 的引用地址，和 toBe 中对象的引用地址不一致，会导致测试不通过，需要使用其他的匹配器
    6.   expect(a).toBe({ name: 'Zero' });  // 失败
    7. });

    toEqual

    toEqual 匹配器，只会匹配对象中的内容是否相等。

    1. // jest.test.js
    2. test('测试对象相等', () => {
    3.   const a = { name: 'Zero' };
    4.   expect(a).toEqual({ name: 'Zero' });  // 断言
    5. })

    toBeNull

    toBeNull 匹配器，可以判断变量是否为 null ，只能匹配 null。

    1. // jest.test.js
    2. test('测试是否为null', () => {
    3.   const a = null;
    4.   expect(a).toBeNull();
    5. })

    toBeUndefined

    toBeUndefined 匹配器，可以判断变量是否为 undefined ，只能匹配 undefined。

    1. // jest.test.js
    2. test('测试是否为undefined', () => {
    3.   const a = undefined;
    4.   expect(a).toBeUndefined();
    5. })

    toBeDefined

    toBeDefined 匹配器，希望被测试的值是定义好的。

    1. // jest.test.js
    2. test('测试变量是否定义过', () => {
    3.   const a = '';
    4.   expect(a).toBeDefined();
    5. })

    toBeTruthy

    toBeTruthy 匹配器，可以判断变量是否为真值，会对非 bool 值进行转换。

    1. // jest.test.js
    2. test('测试变量真值', () => {
    3.   const a = '123';
    4.   expect(a).toBeTruthy();
    5. })

    toBeFalsy

    toBeFalsy 匹配器，可以判断变量是否为假值，会对非 bool 值进行转换。

    1. // jest.test.js
    2. test('测试变量假值', () => {
    3.   const a = '';
    4.   expect(a).toBeFalsy();
    5. })

    not修饰符

    not 匹配器，可以将匹配后的结果进行取反。

    1. // jest.test.js
    2. test('测试变量不是假值', () => {
    3.   const a = '1';
    4.   expect(a).not.toBeFalsy();
    5. })

    toBeGreaterThan

    toBeGreaterThan 匹配器，期望值是否大于匹配器的参数。

    1. // jest.test.js
    2. test('是否大于 a 的数字', () => {
    3.   const a = 123;
    4.   expect(a).toBeGreaterThan(1);
    5. })

    toBeLessThan

    toBeLessThan 匹配器，期望值是否小于匹配器的参数。

    1. // jest.test.js
    2. test('是否小于 a 的数字', () => {
    3.   const a = 0;
    4.   expect(a).toBeLessThan(1);
    5. })

    toBeGreaterThanOrEqual

    toBeGreaterThanOrEqual 匹配器，期望值是否大于或等于匹配器的参数。

    1. // jest.test.js
    2. test('是否大于等于 a 的数字', () => {
    3.   // toBeLessOrEqual 匹配器，与之相反
    4.   const a = 123;
    5.   expect(a).toBeGreaterThanOrEqual(1);
    6. })

    toBeCloseTo

    js 中，浮点数值在相加时不准确，使用 toBeCloseTo 匹配器解决，趋近于 0.3。

    1. // jest.test.js
    2. test('是否大于等于 a 的数字', () => {
    3.   const a1 = 0.1;
    4.   const a2 = 0.2;
    5.   expect(a1 + a2).toBeCloseTo(0.3);
    6. })

    toMatch

    toMatch 匹配器，匹配当前字符串中是否含有这个值，支持正则。

    1. // jest.test.js
    2. test('是否包含 day ', () => {
    3.   const a = 'happy every day';
    4.   expect(a).toMatch('day');
    5. })

    toContain

    toContain 匹配器，判断当前数组中是否包含这个元素，Set 也可以使用。

    1. // jest.test.js
    2. test('数组中是否包含 zoo 这个元素', () => {
    3.   const a = ['zoo', 'ZooTeam', 'Zero'];
    4.   expect(a).toContain('zoo');
    5. })

    toThrow

    toThrow 匹配器，可以捕捉抛出的异常，参数为抛出的 error ，可以用来判断是否为某个异常。

    1. // jest.test.js
    2. const error = () => {
    3.   throw new Error('error');
    4. }
    5. test('是否存在异常', () => {
    6.   expect(error).toThrow();
    7. })

            以上就是 Jest 中比较基础的匹配器，可以结合 初始化 + 配置 + 基础匹配器 进行书写测试用例。

    命令行操作

            在运行 npm run test 命令的时候，控制台执行测试用例成功或失败后都会像下面的图片一样出现几行提示，让你按对应的键进行操作。

    上面几个命令行的意思如下：

    1. f 只会跑测试未通过的用例，再次点击 f 会取消当前模式。

        我们使用一个失败的测试用例做一下示范

        按下 f 后，Jest 只会执行刚才失败的测试用例

    2. o 只监听已改变的文件，如果存在多个测试文件，可以开启，会与当前 git 仓库中的提交进行比较，需要使用 git 来监听哪个文件修改了，也可以将 --watchAll 改为 --watch 只会运行修改的文件。

    3. 根据测试用例文件的正则表达式，过滤需要执行的测试用例文件，No tests found, exiting with code 0 如果填写不对会进行提示，并不会跑任何测试用例。

    4. 根据测试用例描述的正则表达式，过滤需要执行的测试用例。

    5. 退出测试用例监听。

    异步测试

            在正常的业务开发中，项目中不只有同步代码，还会有请求接口的异步代码，异步代码的测试与同步代码有稍许不同，我们来看一下。

    编写一个接口请求

    1. // getData.js
    2. export const getData = (fn) => {
    3.   axios.get('/getData').then((res) => {
    4.     fn(res.data);
    5.   })
    6. }

    对异步请求进行测试

    1. // jest.test.js
    2. // 异步调用回调函数需要添加 done 参数，是一个函数
    3. test('getData 返回结果为 { success: true }', (done) => {
    4.   // 此处代码无效，因为测试用例不会等待请求结束后的回调，测试用例执行完就直接结束了
    5.   // getData1((data) => {
    6.   //   expect(data).toEqual({
    7.   //     success: true
    8.   //   })
    9.   // })
    10.   
    11.   getData1((data) => {
    12.     expect(data).toEqual({
    13.       success: true
    14.     })
    15.     // 需要在结束前调用 done 函数， Jest 会知道到 done 才会结束，才可以正确测试异步函数
    16.     done();
    17.   })
    18. })

            需要注意的是，如果传入了形参 done，但是没有使用，这个测试用例就会处于一直执行的状态，直到执行超时。

    还可以结合 promise 进行使用

    1. // getData.js
    2. export const getData2 = () => {
    3.   return axios.get('http://www.dell-lee.com/react/api/demo.json')
    4. }
    5.  
    6. // jest.test.js
    7. test('getData 返回结果为 { success: true }', () => {
    8.   // 使用 promise 时需要 return，在 then 中使用 done 也可以
    9.   return getData2().then(res => {
    10.     expect(res.data).toEqual({
    11.       success: true
    12.     })
    13.   })
    14. })
    15.  
    16. // 测试请求是否 404
    17. test('getData 返回结果为 404', () => {
    18.   // 由于不触发 catch 就不会走测试校验，所以会成功，我们需要做一下限制
    19.   // 这行代码限制下面的代码中必须要执行一次 expect 方法，
    20.   // 如果非 404 就不会走下面的 expect，则测试不会通过
    21.   expect.assertions(1);
    22.   // 使用 promise 时需要 return
    23.   // 如果只想测试 404 这样写是有问题的，需要配合 assertions 使用
    24.   return getData2().catch(err => {
    25.     expect(err.toString().indexOf('404') > -1).toBe(true)
    26.   })
    27. })
    28.  
    29. // 另一种写法
    30. test('getData 返回结果为 { success: true }', () => {
    31.   // 会返回很多数据，其中包含 data 对象
    32.   // getData2().then((res) => console.log(res))
    33.   // {
    34.   //   status: 200,
    35.   //   statusText: 'OK',
    36.   //   headers: {},
    37.   //   ......
    38.   //   data: { success: true }
    39.   // }
    40.   // resolves 方法会将接口返回的字段全部获取，再使用 toMatchObject 方法
    41.   // 进行匹配大对象中是否存在 data 对象
    42.   return expect(getData2()).resolves.toMatchObject({
    43.     data: {
    44.       success: true
    45.     }
    46.   })
    47. })
    48.  
    49. // 还可以使用 async/await
    50. test('getData 返回结果为 { success: true }', async () => {
    51.   await expect(getData2()).resolves.toMatchObject({
    52.     data: {
    53.       success: true
    54.     }
    55.   })
    56. })

    钩子函数

            钩子函数可以当作一个测试用例的生命周期来看待，有 beforeAll 、beforeEach 、afterEach 、afterAll 。

    以下是一些关于钩子函数的概念和场景：

            ·beforeAll：在所有测试用例执行前运行

            ·beforeEach：在每个测试用例执行前执行一次

            ·afterEach：在每个测试用例执行后执行一次

            ·afterAll：在所有测试用例结束后运行

            有时候，需要测试一个类中的多个方法，这些方法可能会反复操作同一个对象上的属性。如果使用同一个实例，就会相互干扰，导致测试用例无法通过。此时，需要使用不同的实例来进行测试。

    Counter 类

    1. // Counter.js
    2. class Counter {
    3.   constructor() {
    4.     this.number = 0;
    5.   }
    6.  
    7.   add() {
    8.     this.number += 1;
    9.   }
    10.  
    11.   minus() {
    12.     this.number -= 1;
    13.   }
    14. }
    15.  
    16. export default Counter;

            我们想要测试里面的 add 和 minus 方法是否正确，需要实例化一个对象进行测试。但是下面的测试用例使用的永远都是同一个实例，第二个测试用例永远都不会通过。因为执行了第一个测试用例，第二个测试用例的值只能是 0。

    1. // jest.test.js
    2. const count = new Counter();
    3. // 使用下方两种测试方法会互相影响，先加一后减一，结果永远是 0
    4. test('测试加法', () => {
    5.   count.add();
    6.   expect(count.number).toBe(1);
    7. })
    8.  
    9. test('测试减法', () => {
    10.   count.minus();
    11.   expect(count.number).toBe(-1);
    12. })

    需要使用钩子函数，在每次执行测试用例的时候，都让他重新实例化一个对象

    1. // jest.test.js
    2. let count = null;
    3. // 类似于生命周期
    4. // 会在测试用例执行前运行
    5. beforeAll(() => {
    6.   console.log('beforeAll')
    7. });
    8.  
    9. // 会在每个测试用例执行前执行一次，这样就会解决上面互相影响的问题
    10. beforeEach(() => {
    11.   console.log('beforeEach')
    12.   count = new Counter();
    13. });
    14.  
    15. // 会在每个测试用例执行后执行一次
    16. afterEach(() => {
    17.   console.log('afterEach')
    18. });
    19.  
    20. // 会在所有测试用例结束后运行
    21. afterAll(() => {
    22.   console.log('afterAll');
    23. });
    24.  
    25. test('测试加法', () => {
    26.   console.log('add')
    27.   count.add();
    28.   expect(count.number).toBe(1);
    29. })
    30.  
    31. test('测试减法', () => {
    32.   console.log('minus')
    33.   count.minus();
    34.   expect(count.number).toBe(-1);
    35. })

    分组方法 discribe

    1. // jest.test.js
    2. let count = null;
    3. // describe 方法，可以将测试用例进行分组，更加好维护同类型功能的测试用例
    4. describe('count 测试', () => {
    5.   beforeAll(() => {
    6.     console.log('beforeAll')
    7.   });
    8.   beforeEach(() => {
    9.     console.log('beforeEach')
    10.     count = new Counter();
    11.   });
    12.   afterEach(() => {
    13.     console.log('afterEach')
    14.   });
    15.   afterAll(() => {
    16.     console.log('afterAll');
    17.   });
    18.   
    19.   // 将 add 类型进行分组
    20.   describe('测试 add 类型用例', () => {
    21.     // 在 describe 方法中，钩子函数会按照层级嵌套进行执行，
    22.     // 先执行外部，再执行内部，不同的 describe 互不干扰
    23.     beforeEach(() => {
    24.       console.log('beforeEach add');
    25.     });
    26.     test('测试加法', () => {
    27.       console.log('add')
    28.       count.add();
    29.       expect(count.number).toBe(1);
    30.     })
    31.   })
    32.  
    33.   // 将 minus 类型进行分组
    34.   describe('测试 minus 类型用例', () => {
    35.     test('测试减法', () => {
    36.       console.log('minus')
    37.       count.minus();
    38.       expect(count.number).toBe(-1);
    39.     })
    40.   })
    41. })

    加上 describe 方法的执行效果如下图。

    Mock

            在日常开发中，当前端开发差不多后，后端接口可能还没有提供，这个时候我们就要用 Mock 数据。而 Jest 也有 Mock 方法，用于模拟一些 JavaScript 的函数等。

    我们先来一个比较简单的 mock.fn

    1. // mock.js
    2. export const runFn = (fn) => {
    3.   fn(123);
    4. }
    5.  
    6. // mock.test.js
    7. test('测试 runFn', () => {
    8.   // 通过 jest 的 fn 方法创建一个模拟函数，如果不传参数会默认生成一个函数
    9.   // 1. 通过 func.mock 获取想要的值
    10.   // 2. 可以自定义返回值
    11.   // 3. 改变内部函数的实现，模拟接口请求，不请求代码中的接口
    12.   const func = jest.fn( () => 456 );
    13.  
    14.   // 还可以使用 mockReturnValueOnce 方法进行控制输出，
    15.   // 两种方法都使用时会覆盖 fn 方法中的返回值，支持链式调用
    16.   // 将 Once 去掉与 fn 方法一样，多次会返回相同的值
    17.   func.mockReturnValueOnce('zoo')
    18.  
    19.   // 返回 this 方法 mockReturnThis
    20.   func.mockReturnThis();
    21.  
    22.   // 还可以使用 mockImplementation 方法书写函数内部，可以在函数内部写逻辑，
    23.   // 与 jest.fn 方法的参数一样，还可以填加 Once
    24.   func.mockImplementation(() => {
    25.     return '123';
    26.   })
    27.  
    28.   // 执行被测函数
    29.   runFn(func);
    30.   runFn(func);
    31.   
    32.   // console.log(func.mock)
    33.   // 因为被调用了两次，所以长度都是 2
    34.   // {
    35.   //   calls: [ [123], [123] ],  // 每次的调用情况，传递的参数是什么
    36.   //   instances: [ undefined, undefined ],  // 每次调用的 this 指向，被调用了几次
    37.   //   invocationCallOrder: [ 1, 2 ],  // 执行顺序，
    38.   //   可能会传入同一个或多个方法中，需要记录一下顺序
    39.   //   results: [  // mock 函数每次执行后的返回值
    40.   //     { type: 'return', value: 456 },
    41.   //     { type: 'return', value: 456 }
    42.   //   ]
    43.   // }
    44.  
    45.   // 通过 toBeCalled 判断函数是否被调用
    46.   expect(func).toBeCalled();
    47.  
    48.   // 判断当前函数调用了几次 被调用了两次
    49.   expect(func.mock.calls.length).toBe(2);
    50.  
    51.   // 判断参数是什么
    52.   expect(func.mock.calls[0]).toEqual([123]);
    53.  
    54.   // 判断每次调用的时候参数是什么
    55.   expect(func).toBeCalledWith(123);
    56.  
    57.   // 判断返回值
    58.   expect(func.mock.results[0].value).toBe('zoo');
    59. })

    Mock 高阶用法

            如果需要通过修改请求的方式进行测试，而不使用测试框架，我们可能需要修改请求的代码逻辑。但是，Jest 提供了一种高级的 Mock 方法。我们只需在项目根目录下创建一个名为 __mocks__ 的文件夹，然后在其中自定义文件内容并导出，就可以使用自己定义的 Mock 函数而不必修改请求代码逻辑。

    书写测试用例文件，引入 __mocks__ 文件夹中的函数

    1. // mocker.test.js
    2. // 使用 mock 方法引用 __mocks__ 下创建的 mock.js
    3. jest.mock("./mock");
    4. // 执行完上面的方法，会直接寻找 __mocks__ 下的getData，而不是正常的请求文件
    5. // 由于 mock 中没有 getCode 方法，最好只 mock 异步函数，同步函数直接测试即可
    6. // 可以不必须创建 __mocks__ 文件夹
    7. import {
    8.   getData,
    9. } from "./mock";
    10.  
    11. // 需要使用下面的 requireActual 方法来引用非 mock 文件夹下的 getCode
    12. const { getData } = jest.requireActual("./mock");
    13.  
    14. // 高阶mock
    15. // 此处直接使用 __mocks__ 目录下的 mock 文件中的函数
    16. test("测试 getData", () => {
    17.   return getData().then((data) => {
    18.     expect(eval(data)).toEqual("123");
    19.   });
    20. });

    Mock-timers

            在特定的业务中，需要使用到定时器，测试的时候也是需要修改代码来测试不同时间，最主要的一点是，我们需要等时间才能看到我们的执行结果，Jest 也有关于定时器的 Mock函数。

    1. // mock.js
    2. export const timer = (fn) => {
    3.   setTimeout(() => {
    4.     fn();
    5.     setTimeout(() => {
    6.       fn();
    7.     }, 3000)
    8.   }, 3000)
    9. }
    1. // mock-timers.test.js
    2. import { timer } from './mock';
    3.  
    4. // 使用 useFakeTimers 方法告知 Jest 在下面的测试用例，
    5. // 如果用到了定时器异步函数的时候，都是用假的 timers 进行模拟
    6. jest.useFakeTimers();
    7.  
    8. test('测试 timer', () => {
    9.   const fn = jest.fn();
    10.   timer(fn);
    11.  
    12.   // 使用 runAllTimers 方法，让定时器立即执行，和 useFakeTimers 配合使用
    13.   jest.runAllTimers();
    14.  
    15.   // 如果代码中有多个定时器嵌套，只想测试最外层的定时器，则需要使用 runOnlyPendingTimers 方法
    16.   // 这个方法会只执行当前在队列中的函数，可以多次调用
    17.   jest.runOnlyPendingTimers();
    18.   jest.runOnlyPendingTimers();
    19.  
    20.   // advanceTimersByTime 方法，可以快进时间
    21.   // 因为 timer 中，三秒后只执行了第一层，如果是六秒，则会执行两次 fn
    22.   jest.advanceTimersByTime(3000);
    23. })

    snapshot 快照

            到这里我们已经可以测试一些代码了，但是我们要如何捕捉执行结果和当前做对比呢？这时候就要使用快照功能了。

    1. // snapshot.js
    2. export const config1 = () => {
    3.   return {
    4.     method: 'GET',
    5.     url: '/api',
    6.     time: new Date()
    7.   }
    8. }
    9.  
    10. export const config2 = () => {
    11.   return {
    12.     method: 'GET',
    13.     url: '/api',
    14.     time: new Date().getTime()
    15.   }
    16. }
    1. // snapshot.test.js
    2. import { config1, config2 } from "./snapshot";
    3.  
    4. test('测试 config1 返回值', () => {
    5.   // 但如果每次函数修改的时候，当前测试用例也要不断地修改
    6.   // expect(config()).toEqual({
    7.   //   method: 'GET',
    8.   //   url: '/api'
    9.   // });
    10.  
    11.   // 需要使用快照匹配 toMatchSnapshot 方法
    12.   // 此方法会生成一个 __snapshots__ 目录，下面的文件中，
    13.   // 第一次执行中 config 生成的结果会存到快照文件中
    14.   // 快照会根据 test 方法中的描述生成一个映射关系
    15.   // 修改后的 config 的执行结果与快照中的结果不同时会报错，需要更新快照
    16.   // 如果 config 中有的值是每次运行都会变化的，那么每次快照都不会与当前执行相同，
    17.   // 除非执行后再更新快照
    18.   // 需要将在 toMatchSnapshot 方法中传递一个参数，设置一下 time 为任意格式的 Date 类型
    19.   expect(config1()).toMatchSnapshot({
    20.     time: expect.any(Date)
    21.   });
    22. })
    23.  
    24. test('测试 config2 返回值', () => {
    25.   expect(config2()).toMatchSnapshot({
    26.     time: expect.any(Number)
    27.   });
    28. })

    行内快照生成

    1. // snapshot.test.js
    2. // 需要安装 prettier
    3. test("测试 config2 返回值", () => {
    4.   // toMatchInlineSnapshot 方法，将执行快照放到行内中，
    5.   // 会放到 toMatchInlineSnapshot 方法中
    6.   expect(config2()).toMatchInlineSnapshot(
    7.     {
    8.       time: expect.any(Number)
    9.     },
    10.     `
    11.     Object {
    12.       "method": "GET",
    13.       "time": Any,
    14.       "url": "/api",
    15.     }
    16.     `
    17.   );
    18. });

    对 dom 节点测试

        Jest 内部自己模拟了一套 jsDom ，可以在 node 的环境下执行需要浏览器环境 dom的测试用例。

    1. // dom.js
    2. import $ from 'jquery';
    3. const addDiv = () => {
    4.   // jQuery
    5.   $('body').append('
      ');
    6. }
    7.  
    8. export default addDiv;
    9.  
    10. // dom.test.js
    11. import addDiv from './dom';
    12. import $ from 'jquery';
    13.  
    14. test('测试 addDiv', () => {
    15.   addDiv();
    16.   addDiv();
    17.   console.log($('body').find('div').length);
    18.  
    19.   // 测试dom
    20.   expect($('body').find('div').length).toBe(2);
    21.   expect(document.getElementsByTagName('div').length).toBe(2);
    22. })

    VSCode 插件

        Jest Snippets 用于快速生成 Jest 代码块的工具。

        Jest 能够检测当前文件夹中的测试用例并自动运行测试，还支持可视化操作，更新、执行以及单个执行等功能，非常方便！

    常用配置解读

    1. module.exports = {
    2.   // 检测从哪个目录开始，rootDir 代表根目录
    3.   roots: ["/src"],
    4.  
    5.   // 代码测试覆盖率通过分析那些文件生成的，!代表不要分析
    6.   collectCoverageFrom: [
    7.     // src 下所有 js jsx ts tsx 后缀的文件
    8.     "src/**/*.{js,jsx,ts,tsx}",
    9.  
    10.     // src 下所有 .d.ts 后缀的文件
    11.     "!src/**/*.d.ts"
    12.   ],
    13.  
    14.   // 运行测试之前，我们额外需要准备什么
    15.   setupFiles: ["react-app-polyfill/jsdom"],
    16.  
    17.   // 当测试环境建立好后，需要做其他事情时可以引入对应的文件
    18.   setupFilesAfterEnv: ["/src/setupTests.js"],
    19.  
    20.   // 哪些文件会被认为测试文件
    21.   testMatch: [
    22.     // src 下的所有 __tests__ 文件夹中的所有的 js jsx ts tsx 后缀的文件都会被认为是测试文件
    23.     "/src/**/__tests__/**/*.{js,jsx,ts,tsx}",
    24.  
    25.     // scr 下的所有一 .test/spec.js/jsx/ts/tsx 后缀的文件都会被认为是测试文件
    26.     "/src/**/*.{spec,test}.{js,jsx,ts,tsx}",
    27.   ],
    28.  
    29.   // 测试运行的环境，会模拟 dom
    30.   testEnvironment: "jsdom",
    31.  
    32.   // 测试文件中引用一下后缀结尾的文件会使用对应的处理方式
    33.   transform: {
    34.     // 如果引用的是 js jsx mjs cjs ts tsx 后缀的文件会使用 /config/jest/babelTransform.js 文件进行处理
    35.     "^.+\\.(js|jsx|mjs|cjs|ts|tsx)$": "/config/jest/babelTransform.js",
    36.  
    37.     // 如果引用的是 css 后缀的文件，会使用 /config/jest/cssTransform.js 文件处理
    38.     "^.+\\.css$": "/config/jest/cssTransform.js",
    39.  
    40.     // 不是以 js jsx mjs cjs ts tsx css json 这些为后缀的文件会使用 /config/jest/fileTransform.js 文件进行处理
    41.     "^(?!.*\\.(js|jsx|mjs|cjs|ts|tsx|css|json)$)":
    42.       "/config/jest/fileTransform.js",
    43.   },
    44.  
    45.   // 忽略 transform 配置转化的文件
    46.   transformIgnorePatterns: [
    47.     // node_modules 目录下的 js jsx mjs cjs ts tsx 后缀的文件都不需要转化
    48.     "[/\\\\]node_modules[/\\\\].+\\.(js|jsx|mjs|cjs|ts|tsx)$",
    49.  
    50.     // .module.css/sass/scss 后缀的文件都不需要转化
    51.     "^.+\\.module\\.(css|sass|scss)$",
    52.   ],
    53.  
    54.   // 自动化测试时，应用的模块应该从哪里寻找，默认是在 node_modules
    55.   modulePaths: [],
    56.  
    57.   // 模块名字使用哪种工具进行映射
    58.   moduleNameMapper: {
    59.     // 针对于 native 移动端
    60.     // "^react-native$": "react-native-web",
    61.  
    62.     // 将 .module.css/sass/scss 模块使用 identity-obj-proxy 工具进行转化
    63.     "^.+\\.module\\.(css|sass|scss)$": "identity-obj-proxy",
    64.   },
    65.  
    66.   // 引入模块时，进行自动查找模块类型，逐个匹配
    67.   moduleFileExtensions: [
    68.     "web.js",
    69.     "js",
    70.     "web.ts",
    71.     "ts",
    72.     "web.tsx",
    73.     "tsx",
    74.     "json",
    75.     "web.jsx",
    76.     "jsx",
    77.     "node",
    78.   ],
    79.  
    80.   // 监听插件
    81.   watchPlugins: [
    82.     "jest-watch-typeahead/filename",
    83.     "jest-watch-typeahead/testname",
    84.   ],
    85.  
    86.   // 重置 mock
    87.   resetMocks: true,
    88. };

    小结

            在实际业务应用中，我们建议对可复用的组件、工具函数、工具类等一些无副作用，可预知结果的代码来进行单元测试。在前期开发过程中的投入会大于没有单元测试的投入，因为要写一些测试用例，还要执行测试用例，优化代码等。但是在长久迭代中，这种方法会比没有进行单元测试的模块更加稳定。

    代码地址

    1. 前置 demo ：https://github.com/Jadony/Jest-demo

    2. Jest 简单配置：https://github.com/Jadony/jest-config

    3. Jest 匹配器：https://github.com/Jadony/jest-matchers

    4. 异步代码测试：https://github.com/Jadony/jest-async

    5. Jest 钩子函数：https://github.com/Jadony/jest-hook

    6. Jest 的 mock 函数：https://github.com/Jadony/jest-mock

    7. Jest 的快照：https://github.com/Jadony/jest-snapshot

    8. Jest 对 Dom 节点的测试：https://github.com/Jadony/jest-dom

    参考文档

    • 《前端要学的测试课 从Jest入门到TDD/BDD双实战》(https://coding.imooc.com/class/chapter/372.html#Anchor)

            如果想学习更多内容，请移步至 Jest(https://jestjs.io/zh-Hans/docs/getting-started) 官方文档。

  • 相关阅读:
    怎么判断自己是否适合转行软件测试
    《多线程案例》阻塞队列、定时器、线程池、饿汉与懒汉模式
    R语言—数据输入
    免费分享一套SpringBoot+Vue教务管理(课程管理)系统，帅呆了~~
    学习开发一个RISC-V上的操作系统（汪辰老师） — 一次RV32I加法指令的反汇编
    Spring 定时任务如何到达某一指定时间点后，触发任务机制
    ROS之rviz文件的加载和保存
    广州蓝景分享—前端开发JavaScript中的Array对象与其他数组
    聊聊分布式架构01——http通信基础
    node js AES加密
  • 原文地址：https://blog.csdn.net/lambert00001/article/details/130912370