Jest单元测试

Jest单元测试

一、Jest简介

1、Jest介绍：

Jest是一个由Facebook开发的JavaScript测试框架，它旨在使编写单元测试变得简单、有趣，并且能够提供快速的反馈。Jest被设计为易于上手，具有强大的功能，包括内置的异步测试支持、快照测试、模拟HTTP请求等。

2、特点：

0. 简洁的语法：Jest的语法简单明了，接近自然语言，使得编写测试用例变得直观。
1. 内置的异步测试支持：Jest原生支持异步测试，使用async/await语法可以轻松编写异步测试，无需额外的库。

快照测试：Jest提供了快照测试功能，可以捕获大型数据结构的变化，并在数据结构变化时自动更新测试。

3. TypeScript 支持： Jest 内置了对 TypeScript 的支持，无需额外的配置即可运行 TypeScript 编写的测试。
4. 模拟浏览器环境：Jest 可以模拟浏览器环境，这对于前端应用来说是至关重要的。它允许你在 Node.js 环境中运行测试，同时提供了类似浏览器的 API，如 document, window 等。
5. 隔离： Jest以并行方式运行测试，并且每个测试都在自己的进程中运行，所以各个测试之间不会相互干扰。Jest会协调管理所有的测试并收集测试结果。
6. 兼容性： Jest 能够与 Babel、ESLint 等其他工具和库协同工作，确保流畅的集成。
7. 性能：Jest 的测试执行速度非常快，这对于大型项目的持续集成和开发体验至关重要。

3、其他主流测试框架：

Jasmine： Jasmine是一个专注于行为驱动的测试框架，它提供了丰富的匹配器和断言库。Jest和Jasmine都提供了丰富的断言和匹配器，但Jest通常被认为更现代，且对异步测试的支持更好。

Mocha: Mocha是一个功能丰富且灵活的测试框架，它允许你使用任何断言库，Mocha更注重于测试流程的控制，而Jest则提供了更丰富的断言库和内置的模拟功能。

主流测试工具比较:

框架	断言	仿真	快照	异步测试
Jasmine	默认支持	默认支持	默认支持	不友好
Mocha	默认不支持，可配置	默认不支持，可配置	默认不支持，可配置	友好
Jest	默认支持	默认支持	默认支持	友好

二、Jest的工作原理

1、测试环境

Jest 通过创建一个虚拟的 DOM 环境来模拟浏览器，使得开发者可以在内存中运行和测试前端代码。以下是 Jest 创建虚拟 DOM 环境的工作原理：

0. 集成 jsdom: Jest 集成了 jsdom 库，这是一个纯 JavaScript 实现的 DOM 模拟库。jsdom 提供了一个轻量级的 DOM 树，这个树结构包含了 HTML 文档的所有必需信息，如标签、属性、样式和事件处理等。
1. 创建虚拟 DOM: 当你运行 Jest 测试时，Jest 会自动创建一个虚拟的 DOM 环境。这个环境包括了一个模拟的 window 对象、document 对象以及其他必要的全局对象，如 navigator 和 location。这些模拟对象提供了与真实浏览器环境中相同的接口和方法。
2. 模拟浏览器行为: Jest 的虚拟 DOM 环境能够模拟各种浏览器行为，包括事件触发、页面加载、模块导入等。例如，你可以使用 fireEvent 方法来模拟用户点击按钮或键盘输入事件，并检查事件的响应。
3. 提供 API 用于交互: Jest 提供了一系列的 API，允许你与虚拟 DOM 环境进行交互。你可以使用这些 API 来编写测试，比如模拟用户的点击操作、填写表单、执行 AJAX 请求等。
4. 断言和匹配器: Jest 提供了丰富的断言和匹配器，用于验证代码的行为是否符合预期。你可以使用 expect 函数和匹配器来进行断言，比如验证元素的属性、样式或者函数的返回值。
5. 运行和调试测试: Jest 允许你运行和调试测试，就像在浏览器中一样。你可以查看测试的输出、断言失败的原因以及覆盖率报告，帮助你理解和修复代码中的问题。

2、断言库

Jest提供内置的断言库，使得测试编写更为简洁、易读。 ​ 测试的编写是以描述性的方式进行的，test函数接受一个测试名称和一个执行测试的回调函数。在回调函数中，我们使用expect和匹配器来编写测试逻辑。这种方式让测试代码本身就能够清晰地表达出测试的目的和预期结果，便于维护和理解。例如，假设我们想要测试一个函数返回的值是否为真，并且是一个字符串，我们可以这样写：

test('测试函数返回真值并且是字符串', () => {
  expect(someFunction()).toBeTruthy(); // 首先检查是否为真
  expect(someFunction()).toBeString(); // 然后检查是否为字符串
});

Jest常用的匹配器：

• expect(value).toBe(expected)： 用途：用于检查期望值和实际值是否相等。 例子：expect(42).toBe(42) ------ 预期结果为真。

• expect(value).not.toBe(expected)： 用途：用于检查期望值和实际值不相等。 例子：expect(43).not.toBe(42) ------ 预期结果为真。

• expect(value).toBeNull() 或 expect(value).toBeUndefined()： 用途：用于检查值是否为 null 或 undefined。 例子：expect(value).toBeNull() ------ 如果 value 是 null，预期结果为真。

• expect(value).toBeDefined()： 用途：用于检查值是否已被定义，即不是 undefined。 例子：expect(value).toBeDefined() ------ 如果 value 已被定义，预期结果为真。

• expect(value).toBeTruthy() 或 expect(value).toBeFalsy()： 用途：用于检查值在逻辑上的真假。 例子：expect(value).toBeTruthy() ------ 如果 value 在逻辑上是真的，预期结果为真。

• expect(value).toEqual(expected)： 用途：用于深度比较两个值的 equality，不仅仅是值相等，还要求对象结构的属性、类型也相等。 例子：expect({ a: 1, b: 2 }).toEqual({ b: 2, a: 1 }) ------ 如果两个对象的属性、类型都相同，预期结果为真。

• expect(value).not.toEqual(expected)： 用途：用于检查两个值不深度相等。 例子：expect({ a: 1 }).not.toEqual({ a: 1, b: 2 }) ------ 如果两个对象不完全相同，预期结果为真。

• expect(value).toBeInstanceOf(Class)： 用途：用于检查构造函数的 instanceof 操作符是否返回 true。 例子：expect(new Date()).toBeInstanceOf(Date) ------ 如果 value 是 Date 的一个实例，预期结果为真。

• expect(value).toMatch(regexp) 或 expect(value).toMatch(string)： 用途：用于检查字符串是否匹配正则表达式或模式。 例子：expect('hello').toMatch(/^he/) ------ 如果字符串以 'he' 开头，预期结果为真。

• expect(value).toContain(substring)： 用途：用于检查字符串或数组是否包含特定的子串或元素。 例子：expect('abc').toContain('b') ------ 如果字符串包含 'b'，预期结果为真。

• expect(value).toBeGreaterThan(number) 或 expect(value).toBeLessThan(number)： 用途：用于检查数字是否大于或小于某个值。 例子：expect(10).toBeGreaterThan(5) ------ 如果数字大于 5，预期结果为真。

• expect(fn).toHaveBeenCalled()： 用途：检查fn是否被调用过。 例子：

  const mockFn = jest.fn();
  mockFn();
  expect(mockFn).toHaveBeenCalled()

• expect(spy).toHaveBeenCalledWith(args)： 用途：检查 spy 是否被用特定的参数调用过。 例子：

  const mockSpy = jest.spyOn(console, "log");
  console.log("test");
  expect(mockSpy).toHaveBeenCalledWith("test");

• expect(spy).toHaveBeenCalledTimes(number)： 用途：检查 spy 是否被调用了特定的次数。 例子：

  const spy = jest.spyOn(object, 'method');
  object.method();
  object.method();
  expect(spy).toHaveBeenCalledTimes(2)

更多断言可查看官方API：jestjs.io/docs/expect

3、Mock对象

模拟函数（Mock Functions） 模拟函数是使用 jest.fn() 创建的。它们可以模拟任何函数的行为，不一定是来自特定模块的函数。当你想要模拟一个函数的返回值、抛出异常或者调用次数时，你会使用模拟函数。

示例：

import React from "react";
import { Button } from "antd";
import { render, screen } from "@testing-library/react";
​
describe("Button", () => {
  const mockClickHandler = jest.fn();
  it("should call the click handler when clicked", () => {
    // 渲染 Button 组件
    render(<Button onClick={mockClickHandler}>Click me</Button>);
    // 模拟点击事件
    const button = screen.getByText("Click me");
    button.click();
    // 验证点击处理函数是否被调用
    expect(mockClickHandler).toHaveBeenCalled();
  });
});

模拟模块（Mock Modules）

模拟模块是使用 jest.mock() 创建的。它们通常用于模拟第三方库或外部模块。当你想要模拟一个模块提供的函数、对象或类时，你会使用模拟模块。模拟模块可以让你轻松地模拟那些你无法直接控制的代码。

示例：

// externalService.js
function fetchData() {
  // 假设这个函数从外部服务获取数据
  return "data from external service";
}
module.exports = { fetchData };

// processData.js
const { fetchData } = require("./externalService");
function processData() {
  const data = fetchData();
  // 处理数据
  return data.toUpperCase();
}
module.exports = processData;
​

const processData = require("./processData");
​
// 使用 jest.mock() 模拟 externalService.js 模块中的 fetchData 函数
jest.mock("./externalService", () => ({
  fetchData: () => "mocked data",
}));
​
test("processData should uppercase the fetched data", () => {
  expect(processData()).toBe("MOCKED DATA");
});
​

区别 模拟函数 是一个单一的函数，它可以是任何函数，不一定是特定模块的一部分。 模拟模块 是一个模块的整个模拟，它通常用于模拟外部模块或第三方库。

在实际使用中，选择使用模拟函数还是模拟模块取决于你的测试需求。如果你只是需要模拟一个特定的函数，使用模拟函数就足够了。如果你需要模拟一个模块中的多个函数或对象，或者你需要模拟一个你无法直接修改的外部模块，那么使用模拟模块会更加方便。

三、Jest的配置

1、安装

1)、安装 Jest

npm install --save-dev jest

2)、安装 jest-environment-jsdom jest-environment-jsdom 插件可以让你在 Jest 中模拟浏览器环境，这对于那些需要操作 DOM 或者使用浏览器特定 API 的测试来说非常有用。使用这个插件，你可以编写类似于在浏览器中运行的测试，而不需要启动一个真实的浏览器。

npm install --save-dev jest-environment-jsdom

3)、安装 其他依赖：

• Babel：

npm install --save-dev babel-jest @babel/core @babel/preset-env

• React：

npm install --save-dev @babel/preset-react @testing-library/react

• Vue：

npm install --save-dev vue-jest @vue/test-utils

2、配置

Jest 的配置可以通过多种方式来完成，包括通过命令行参数、环境变量、或者通过一个配置文件。最常见的方式是使用一个名为 jest.config.js 或 jest.config.json 的文件来配置 Jest。

以下是一些常用的 Jest 配置项及其含义：

// jest.config.js
module.exports = {
  // 设置 Jest 的运行环境。常用的环境有 'node' 和 'jest-environment-jsdom'。
  testEnvironment: 'jest-environment-jsdom',
  
  // 设置测试文件的扩展名。定义了Jest 应该匹配哪些文件作为测试。它接受一个数组，数组中的每个元素都是一个匹配模式。默认情况下，Jest 会匹配文件名以 __tests__ 开头或结尾的文件，或者文件名包含 spec 或 test 的文件。
  testMatch: ['**/__tests__/*.(js|jsx|ts|tsx)', '**/?(*.)+(spec|test).(js|jsx|ts|tsx)'],
  
  // 设置 Jest 的缓存目录。缓存的目的是为了提高测试的运行效率，避免重复编译和解析模块。
  cacheDirectory: './node_modules/jest/cache',
  
  // 设置是否缓存每个测试文件的结果。这个配置项控制是否缓存每个测试文件的结果。如果你希望每次运行测试时都重新执行所有的测试，你可以将这个配置项设置为 false。默认是true
  cache: true,
  
  // 设置 Jest 的覆盖率报告阈值， 如果你的代码覆盖率低于这个阈值，Jest 会报告测试未通过。这个配置项可以帮助你确保你的测试覆盖了大部分的代码。
  coverageThreshold: {
    global: {
      branches: 80, // 分支覆盖率
      functions: 80, // 函数覆盖率
      lines: 80, // 行覆盖率
      statements: 80, //语句覆盖率
    },
  },
  
  // 设置 Jest 的模块文件扩展名。定义 Jest 应该处理的模块文件扩展名。默认情况下，Jest 只会处理 .js 文件，但是你可以添加其他扩展名，例如 .jsx、.ts、.tsx 等。
  moduleFileExtensions: ['js', 'jsx', 'json', 'vue'],
  
  // 设置 Jest 的插件，允许你使用 Jest 插件。插件可以提供额外的功能，例如代码覆盖率报告、快照测试等。
  plugins: [
    // 例如，使用 'plugin-name' 插件
    'plugin-name',
  ],
  
  // 设置 Jest 的根目录，定义了 Jest 应该搜索测试文件的根目录。但是也可以指定一个不同的目录。
  roots: ['<rootDir>/src'],
  
  // 设置 Jest 存储测试结果的目录。你可以指定一个目录，Jest 会将测试结果（包括覆盖率报告）保存在这个目录中。
  testResultsDirectory: './node_modules/jest/testresults',
  
  // 设置 Jest 的 transform 配置。定义了 Jest 应该如何转换文件。例如，你可以使用 babel-jest 来转换 JSX 为 JS，或者使用 vue-jest 来转换 Vue 文件。
  transform: {
    '^.+\.vue$': 'vue-jest',
    '^.+\.jsx?$': 'babel-jest',
  },
  
  // 设置 Jest 的 verbose 模式。当设置为 true 时，Jest 会输出更多的信息，包括每个测试的执行时间和状态。 默认是 false。 
  verbose: true,
};

提示：可以通过 npx jest --init 命令快捷生成jest.config.js文件

更多信息和完整配置项列表，请参考 Jest 的官方文档：jestjs.io/docs/en/con...

3、运行测试

1)、运行测试

npm test

当 Jest 运行测试后，会输出一系列的结果信息，其中包括测试套件（Suites）、测试（Tests）和快照（Snapshots）的状态，以及运行测试所花的时间。

2)、看详细测试结果

npm test -- --verbose

运行后，会输出每个测试用例的详细结果

3)、查看测试覆盖率

npm test -- --coverage

运行后，会输出测试用例的覆盖率

四、编写单元测试

1、测试文件结构

使用Jest进行单元测试时，测试文件通常遵循以下命名和组织方式：

• 文件命名： 测试文件通常以.test.js或.spec.js结尾。这是Jest默认识别测试文件的方式。
• 文件位置： 测试文件通常与它们所测试的代码文件位于同一目录中。例如，如果你的目标测试src/index.js，那么你的测试文件应该位于src/目录下，并且命名为index.test.js或index.spec.js。
• 测试代码： 一个测试文件可以包含多个测试用例，每个测试用例都是独立的，并使用test或it函数。这些函数接受一个测试名称和一个执行测试的回调函数。

下面是一个简单的测试文件的例子：

// sum.test.js
const sum = require('./sum'); // 假设你正在测试一个名为sum的模块
test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});
test('adds 5 + 5 to equal 10', () => {
  expect(sum(5, 5)).toBe(10);
});

此外，为了确保测试文件的清晰和可维护性，以下是一些额外的最佳实践：

• 为每个功能或模块编写单独的测试文件。
• 确保测试是可维护的、可读的，并且足够小，以便它们可以单独运行。
• 使用describe函数来对测试用例进行分类，特别是当你有多个测试用例需要共同的设置时。
• 尽量避免在测试之间共享状态，以减少测试之间的依赖和潜在的干扰。
• 使用模拟（mocking）和仿真（stubbing）来隔离测试并确保它们不依赖于外部系统。

2、测试案例编写

0. 设置测试环境： 确保已经安装了 Jest 并在项目中进行了配置。
1. 创建测试文件： 创建一个新的文件来编写测试用例。通常，测试文件位于与被测试代码相同的目录中，并且文件名以 .test.js 或 .spec.js 结尾。
2. 导入模块： 使用 import 语句或 require 函数从项目中导入想要测试的模块或组件。
3. 定义测试用例： 使用 describe 函数来分类测试用例，并在其中使用 test 或 it 函数来编写具体的测试用例。
4. 编写测试逻辑： 在测试用例中，使用 expect 函数来设置断言，并执行测试逻辑。
5. 使用快照测试（可选）： 如果想要测试一个返回复杂对象或数组的函数，可以使用 Jest 的快照测试功能来简化测试。

示例：

const { createComplexObject, add } = require("./complexObject");
​
// 测试用例分类
describe("ComplexObject", () => {
  // 编写测试用例
  test("adds 1 + 2 to equal 3", () => {
    // 设置断言
    expect(add(1, 2)).toBe(3);
  });
​
  test("returns an object with the correct properties", async () => {
    // 使用快照测试
    const snapshot = {
      number: expect.any(Number),
      string: "hello",
      boolean: true,
      array: expect.any(Array),
      nested: {
        nestedNumber: expect.any(Number),
        nestedString: "world",
      },
    };
    // 编写测试逻辑
    const result = await createComplexObject();
    expect(result).toMatchSnapshot(snapshot);
  });
});
​

3、异步测试

在 Jest 中编写异步测试通常涉及到使用 Promise 和 async/await 语法。下面是一个简单的例子，展示了如何测试一个异步函数。

异步函数：

// fetchData.js
module.exports = async function fetchData() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('Hello, world!');
    }, 1000);
  });
};

测试用例:

// fetchData.test.js
const fetchData = require('./fetchData');
​
describe('fetchData', () => {
  test('returns "Hello, world!" after 1 second', async () => {
    // 使用 async/await 语法来等待 Promise 解决
    const result = await fetchData();
    expect(result).toBe('Hello, world!');
  });
});

或者：

// fetchData.test.js
const fetchData = require('./fetchData');
​
describe('fetchData', () => {
  test('returns "Hello, world!" after 1 second', () => {
    // 使用 then() 方法来处理异步代码
    return fetchData().then((result) => {
      expect(result).toBe('Hello, world!');
    });
  });
});

五、Jest高级功能

1、快照测试

快照测试（Snapshot Testing）是一种测试方法，它允许捕获一个值（通常是复杂对象或数据结构）的快照，并在未来的测试中验证这个值是否发生了变化。这种测试方法非常适合于那些数据结构可能发生变化，但又需要确保这些变化不会破坏现有功能的场景。 ​ 在 Jest 中，快照测试是通过 toMatchSnapshot 匹配器来实现的。这个匹配器会序列化给定对象的所有可枚举属性，并创建一个快照。

例如前面的示例：

test("returns an object with the correct properties", async () => {
  // 使用快照测试
  const snapshot = {
    number: expect.any(Number),
    string: "hello",
    boolean: true,
    array: expect.any(Array),
    nested: {
      nestedNumber: expect.any(Number),
      nestedString: "world",
    },
  };
  // 编写测试逻辑
  const result = await createComplexObject();
  expect(result).toMatchSnapshot(snapshot);
});

2、覆盖率报告

Jest 提供了内置的代码覆盖率报告功能，它可以展示你的测试覆盖了代码库中的哪些部分。这些信息对于识别未测试的代码区域和改进测试策略非常有用。

1）查看代码覆盖率报告

(1). 运行测试并生成覆盖率报告

npm test -- --coverage

或者，如果在 jest.config.js 文件中collectCoverage 设置为 true:

module.exports = {
  collectCoverage: true,
};

(2). 查看覆盖率报告

如果在命令行中运行测试，Jest 会在测试完成后直接在控制台输出覆盖率报告。如果想要更详细的报告，则在根目录下coverage文件夹中查看。

2）利用覆盖率报告改进代码

(1). 识别未测试的代码: 覆盖率报告会显示哪些代码行被测试覆盖，哪些没有被覆盖。未覆盖的代码可能是由于缺少测试或者测试不正确。这些是改进测试的首选目标。 (2). 改进测试: 根据覆盖率报告，你可以编写新的测试用例来覆盖那些未测试的代码行。确保每个功能都有相应的测试用例，并且测试覆盖了所有可能的分支和异常情况。 (3). 简化代码: 有时候，覆盖率低可能是因为代码过于复杂或者难以理解。利用这个机会来重构代码，使其更加简洁和可测试。 (4). 避免过度测试: 覆盖率报告也可以帮助你识别那些被过度测试的代码。如果你发现某个函数或模块的覆盖率远高于其他部分，可能意味着你的测试过于冗余，需要优化。 (5). 设置覆盖率阈值: 你可以为你的项目设置一个合理的覆盖率阈值，比如 80%、90% 或 100%。这样，你可以确保代码的基本质量，并且在新代码合并到主分支之前，覆盖率不会下降。 (6). 持续集成: 将覆盖率检查集成到你的持续集成/持续部署（CI/CD）流程中，以确保所有提交和部署的代码都有足够的测试覆盖率。

六、实际案例

下面是一个React 组件的单元测试示例，这个示例结合 React Testing Library 来模拟 React 组件的行为。

React Testing Library 是一个由 React 官方提供的库，用于在 React 应用程序中进行测试。它是由 Facebook 开发的，旨在提供一个简单、直观且功能强大的测试框架，以便开发人员可以轻松地编写和运行 React 组件的测试。

// modalButtonComponent.jsx
import React, { useState } from "react";
import { Button, Modal } from "antd";
​
const ModalButtonComponent = () => {
  const [isModalVisible, setIsModalVisible] = useState(false);
​
  const showModal = () => {
    console.log("Button Clicked!");
    setIsModalVisible(true);
  };
​
  const handleOk = () => {
    setIsModalVisible(false);
  };
​
  return (
    <>
      <Button type="primary" onClick={showModal}>
        Open Modal
      </Button>
      <Modal title="Welcome" open={isModalVisible} onOk={handleOk}>
        <p>Some content...</p>
        <p>Some content...</p>
        <p>Some content...</p>
      </Modal>
    </>
  );
};
​
export default ModalButtonComponent;

// modalButtonComponent.test.js
import React from "react";
import { act } from "react-dom/test-utils";
import { render, screen, waitFor } from "@testing-library/react";
import ModalButtonComponent from "../../reactComponent/modalButtonComponent";
​
describe("ModalButtonComponent", () => {
  test("displays a button and a modal, and closes the modal when the OK button is clicked", async () => {
    const consoleLogSpy = jest.spyOn(console, "log");
​
    render(<ModalButtonComponent />);
​
    const button = screen.getByRole("button");
    expect(button).toBeInTheDocument();
​
    act(() => {
      button.click();
    });
​
    expect(consoleLogSpy).toHaveBeenCalledWith("Button Clicked!");
​
    // 等待模态框出现
    await waitFor(() => screen.getByRole("dialog"), { timeout: 5000 });
    const modal = screen.getByRole("dialog");
    expect(modal).toBeInTheDocument();
  });
});

七、Jest相关工具

1、React 组件的测试工具

React Testing Library / Enzyme

在 Jest 生态中，用于测试 React 组件的工具有很多，其中两个最受欢迎的是 React Testing Library 和 Enzyme。这两个库都提供了丰富的 API 来帮助开发者编写高效的 React 组件测试。

React Testing Library React Testing Library 是由 React 官方提供的一个用于测试 React 组件的库。它与 Jest 无缝集成，提供了简单、可预测的 API 来模拟组件的行为。 特点： 官方支持： 由 React 团队维护，与 React 的新特性和版本更新保持同步。 无需额外配置： 与Jest无缝集成，无需额外配置即可使用。 基于 React hooks： 利用 React 的 hooks 来模拟组件的渲染和行为。 快照测试： 支持快照测试，可以轻松捕捉组件的渲染结果并进行比对。

Enzyme Enzyme 是由 Airbnb 开发的一个用于 React 组件测试的库。它提供了类似 jQuery 的 API，使得测试 React 组件变得简单而直观。

特点： 成熟的生态系统： Enzyme 拥有广泛的社区支持和丰富的插件，如 enzyme-to-json 用于序列化组件树。 模拟和 stub： 提供强大的模拟（mock）和 stub 功能，可以模拟外部依赖和函数。 易于使用： 如果你熟悉 jQuery，那么你将会很快上手 Enzyme。

2、Vue组件测试工具

Vue Test Utils

用于测试 Vue 组件的工具主要有 Vue Test Utils 。Vue Test Utils 是 Vue 官方提供的一个用于测试 Vue 组件的库。

特点： 官方支持： 由 Vue 团队维护，与 Vue 的新特性和版本更新保持同步。 灵活性： 可以与 Jest、Mocha、Jasmine 等多种测试框架配合使用。 功能测试： 提供了模拟组件渲染、触发事件、模拟 props 和 slots 等功能。 快照测试： 支持快照测试，可以轻松捕捉组件的渲染结果并进行比对。

八、总结

Jest 是一个流行的 JavaScript 测试框架，它提供了一种简单、高效的方式来编写单元测试。以下是 Jest 单元测试的一些关键点：

• 断言：Jest 使用断言来验证代码的预期行为。开发者可以编写测试来检查代码的输出、状态变化等。
• 模拟（Mocking）：Jest 允许模拟外部依赖，这样可以在不依赖真实数据或服务的情况下测试组件。
• 快照测试：Jest 提供了快照测试功能，可以轻松捕捉大型数据结构的变化，并通过比对快照来验证代码的修改。
• 覆盖率报告：Jest 可以生成代码覆盖率报告，帮助开发者识别未测试的代码区域。 并行测试：Jest 支持并行测试，可以同时运行多个测试，从而加快测试的执行速度。
• 易用性：Jest 的语法简洁，易于上手，使得编写测试变得更加容易。

单元测试在保证代码质量中起着至关重要的作用。通过编写单元测试，开发者可以确保代码的每个部分按预期工作，并且在未来的开发中不会引入新的错误。单元测试也有助于文档化代码的行为，为其他开发者提供清晰的代码使用指南。