您现在的位置是:首页 > 正文

Jest 学习03 - Mock 函数、声明周期钩子

2024-02-01 00:09:47阅读 3

Mock 函数

Mock Functions(模拟函数)也被称为“spies”(间谍),官方文档:Mock Functions

介绍

Mock Functions 的使用方法是抹除函数的实际实现,捕获对函数的调用(以及在这些调用中传递的参数),在使用 new 实例化时捕获构造函数的实例,并允许测试时配置返回值。

有两种方法可以 mock 函数:

  • 在测试代码中创建一个 mock 函数
  • 编写一个手动 mock 来覆盖模块依赖

Mock 函数的作用:

  1. 捕获函数的调用和返回结果,以及函数调用时的 this 指向
  2. 它可以让我们自由的设置返回结果
  3. 可以改变内部函数的实现

使用一个 mock function

假设正在测试一个函数 forEach 的实现,该函数为提供的数组中的每项调用回调:

function forEach(items, callback) {
  for (let index = 0; index < items.length; index++) {
    callback(items[index], index)
  }
}

我们发现,用常规的测试方法很难对该函数进行一些测试,如回调是否被调用,回调调用次数,每次回调传入的值,回调返回的结果等。

为了测试这个函数,可以使用一个 mock 函数,并检查 mock 的状态,以确保按预期调用回调。

test('Mock Functions', () => {
  const items = [1, 2, 3]

  // jest.fn() 创建一个空的 mock 函数
  // 如果传递一个函数,则可以创建自定义实现的 mock 
  // const mockFn = jest.fn().mockImplementation((value, index) => {
  //   return value * 10
  // })
  // 传入 implementation(实现)可以简写为:
  const mockFn = jest.fn((value, index) => {
    return value * 10
  })

  // 将 mock 函数作为回调参数传入
  forEach(items, mockFn)

  // 打印 .mock 属性
  console.log(mockFn.mock)
})

mock 函数的 .mock 属性存储了本身被调用的一些信息,打印结果:

{
  # 每次调用接收的参数
  calls: [ [ 1, 0 ], [ 2, 1 ], [ 3, 2 ] ],
  # 函数被实例化的结果
  instances: [ undefined, undefined, undefined ],
  invocationCallOrder: [ 1, 2, 3 ],
  # 每次调用返回的结果
  results: [
    { type: 'return', value: 10 },
    { type: 'return', value: 20 },
    { type: 'return', value: 30 }
  ],
  # 最后一次被调用接收的参数
  lastCall: [ 3, 2 ]
}

可以使用 .mock 属性中的信息进行断言判断:

// 断言 mock 函数被调用了3次
expect(mockFn.mock.calls.length).toBe(3)

// 断言第一次调用接收的第一个参数是1
expect(mockFn.mock.calls[0][0]).toBe(1)

模拟实例

instances 一般是 mock 函数作为构造函数时使用,返回实例化的对象:

test('mock function instances', () => {
  // 创建一个空函数,类似 function() {}
  const mockFn = jest.fn()

  // 实例化 a
  const a = new mockFn()

  // 创建 b 对象
  const b = {}

  // 创建一个相同实现的函数
  // this (实例)指向 b
  const bound = mockFn.bind(b)
  // 调用 bound() 执行实例化
  bound()

  console.log(mockFn.mock.instances[0] === a) // true
  console.log(mockFn.mock.instances[1] === b) // true
})

模拟返回值

mock 函数可以在测试期间将测试值注入代码:

const items = [1, 2, 3, 4]

const mockFn = jest.fn((value, index) => {
  return value * 10
})
// 指定调用所有 mock 函数的返回值
mockFn.mockReturnValue(100)

forEach(items, mockFn)

console.log(mockFn.mock.results)

// [
//   { type: 'return', value: 100 },
//   { type: 'return', value: 100 },
//   { type: 'return', value: 100 },
//   { type: 'return', value: 100 }
// ]

也可指定单次调用的返回值:

const items = [1, 2, 3, 4]

const mockFn = jest.fn((value, index) => {
  return value * 10
})
// 指定调用所有 mock 函数的返回值
mockFn.mockReturnValue(100)

// 指定依次调用一次 mock 函数的返回值
// 如果使用了 mockReturnValue,则将其作为默认的返回值
mockFn.mockReturnValueOnce('first').mockReturnValueOnce('second').mockReturnValue('default')

// 或在前面调用,结果一样
// mockFn.mockReturnValue('default').mockReturnValueOnce('first').mockReturnValueOnce('second')


forEach(items, mockFn)

console.log(mockFn.mock.results)

// [
//   { type: 'return', value: 'first' },
//   { type: 'return', value: 'second' },
//   { type: 'return', value: 'default' },
//   { type: 'return', value: 'default' }
// ]

使用模拟函数的返回值,有助于避免需要复杂的逻辑创建代表真实组件的行为,有利于在使用之前将值直接注入测试。

模拟模块

假设我们有一个使用 axios 请求 API 的方法:

// user.js
import axios from 'axios'

export const getAllUsers = () => {
  return axios.get('/users.json').then(res => res.data)
}

为了测试这个方法,只能等待这个异步请求完成,并且不能使用 Timers Mocks 加快等待时间。

// user.test.js
import { getAllUsers } from './user'

test('should fetch users', () => {
  return getAllUsers().then(data => expect(data).toEqual(users))
})

但是我们可以使用 jest.mock(...) 方法自动模拟 axios 模块。

一旦模拟了模块,它的方法成员就会被拦截代理访问。

这样,我们可以为 axios 模块的 .get 方法提供一个 mockResolvedValue,返回我们期望测试使用的数据。

实际上,我们所做的就是希望 axios.get('/user.json') 返回一个假的响应。

// user.test.js
import axios from 'axios'
import { getAllUsers } from './user'

// 模拟模块
// 注意:这里传入的是模块名,而不是导入后的自定义名称
jest.mock('axios')

test('should fetch users', () => {
  const users = [{ name: 'Bob' }]
  const res = { data: users }

  // 拦截 get 方法,模拟实现,响应自定义的测试数据
  axios.get.mockResolvedValue(res)
  // mockResolvedValue 是传入返回 resolved Promise 实现的简写:
  // axios.get.mockImplementation(() => Promise.resolve(res))

  return getAllUsers().then(data => expect(data).toEqual(users))
})

模拟实现

从上面的示例中,我们已经尝试了,可以模拟一个函数的具体实现,来减少耗时或逻辑,从而提高测试速度。

例如有一个 foo 模块:

// foo.js
export default function() {
  // some implementation
}

可以通过 jest.mock('./foo') 模拟这个模块:

// foo.test.js
// 模拟模块写在导入模块前后都可以
jest.mock('./foo')
import foo from './foo'

// 模拟具体实现
foo.mockImplementation(() => 42)

test('test foo implementation', () => {
  expect(foo()).toBe(42)
})

如果想要分别模拟函数多次调用的不同实现,可以使用 mockImplementationOnce

// foo.test.js
// 模拟模块写在导入模块前后都可以
jest.mock('./foo')
import foo from './foo'

// 模拟具体实现
// foo.mockImplementation(() => 42)
foo
  .mockImplementationOnce(() => true)
  .mockImplementationOnce(() => false)

test('test foo implementation', () => {
  // expect(foo()).toBe(42)
  expect(foo()).toBe(true)
  expect(foo()).toBe(false)
  // 当使用 mockImplementationOnce 定义的实现用完后,则使用默认实现:mockImplementation 定义的实现 或 原始实现
  expect(foo()).toBeUndefined()
})

模拟函数的名称

您可以选择提供模拟函数的名称,该名称将在测试函数的错误输出中显示,而不是 jest.fn

test('mock unnamed', () => {
  const mockFn = jest.fn()
  expect(mockFn).toHaveBeenCalled()
  // 输出 expect(jest.fn()).toHaveBeenCalled()
})

test('mock named', () => {
  const mockFn = jest.fn().mockName('mockedFunction')
  expect(mockFn).toHaveBeenCalled()
  // 输出 expect(mockedFunction).toHaveBeenCalled()
})

自定义匹配器

为了减少声明如何调用模拟函数的要求,Jest 添加了一些自定义匹配器函数:

// 模拟函数至少被调用了1次
expect(mockFunc).toHaveBeenCalled();

// 模拟函数使用指定的参数至少被调用了1次
expect(mockFunc).toHaveBeenCalledWith(arg1, arg2);

// 模拟函数最后一次调用使用了指定的参数
expect(mockFunc).toHaveBeenLastCalledWith(arg1, arg2);

// 模拟函数的快照测试
expect(mockFunc).toMatchSnapshot();

上面的匹配器都是用于检查 .mock 属性语法糖,你也可以手动完成:

// 模拟函数至少被调用了1次
expect(mockFunc.mock.calls.length).toBeGreaterThan(0);

// 模拟函数使用指定的参数至少被调用了1次
expect(mockFunc.mock.calls).toContainEqual([arg1, arg2]);

// 模拟函数最后一次调用使用了指定的参数
expect(mockFunc.mock.calls[mockFunc.mock.calls.length - 1]).toEqual([
  arg1,
  arg2,
]);

// 最后一次调用模拟函数的第一个参数是 `42`
// (请注意:对于这个特定的断言,没有对应的语法糖)
expect(mockFunc.mock.calls[mockFunc.mock.calls.length - 1][0]).toBe(42);

// 快照将检查模拟的调用次数是否相同,同样的顺序,同样的参数,同样的名称。
expect(mockFunc.mock.calls).toEqual([[arg1, arg2]]);
expect(mockFunc.getMockName()).toBe('a mock name');

钩子函数

官方文档:Setup and Teardown

分别设置每个测试

如果一些工作需要在许多测试中重复进行,可以在每次测试前或后使用 beforeEach/afterEach

例如在某个测试中修改对象的属性,影响到了其他测试:

const user = {
  foo: 'bar'
}

test('test 1', () => {
  user.foo = 'baz'
  expect(user.foo).toBe('baz')
})

test('test 2', () => {
  // user.foo 已被改变,这里将会影响
  expect(user.foo).toBe('bar')
})

可以在每个测试前初始化这个对象的值:

const data = {
  foo: 'bar'
}

let user = null

test('test 1', () => {
  user = Object.assign({}, data)
  user.foo = 'baz'
  expect(user.foo).toBe('baz')
})

test('test 2', () => {
  user = Object.assign({}, data)
  expect(user.foo).toBe('bar')
})

可以使用生命周期钩子优化这些重复操作:

const data = {
  foo: 'bar'
}

let user = null

// 运行每个测试用例之前执行
beforeEach(() => {
  user = Object.assign({}, data)
})

test('test 1', () => {
  user.foo = 'baz'
  expect(user.foo).toBe('baz')
})

test('test 2', () => {
  expect(user.foo).toBe('bar')
})

beforeEachafterEach 也可以写在测试用例后面,它们总会在测试执行前执行。

beforeEachafterEach 处理异步代码的方式与测试用例处理异步代码的方式一样——可以接收一个 done 参数,也可以返回一个 Promise。

一次性设置全部测试

在某些情况下,只需要在文件开头仅进行一次设置。当设置是异步的时候,这可能会特别麻烦,因此不能以内联的方式进行,可以使用 beforeAll/afterAll 钩子处理这种情况。

例如:

// 在运行全部测试前初始化数据库访问,以在每个测试中重用数据库
beforeAll(() => {
  return initializeCityDatabase();
});

// 在全部测试完成后,关闭数据库连接
afterAll(() => {
  return clearCityDatabase();
});

test('city database has Vienna', () => {
  expect(isCity('Vienna')).toBeTruthy();
});

test('city database has San Juan', () => {
  expect(isCity('San Juan')).toBeTruthy();
});

同样的,beforeAll/afterAll 代码的位置并不影响它们执行的时机。

钩子函数作用域

默认情况下,钩子函数应用于文件中的每个测试,还可以使用describe 块将测试分组。当钩子函数位于 describe 块内时,它们仅适用于该块内的测试。

请注意,顶层的钩子函数在 describe 块中的钩子函数之前(before*)或之后(after*)执行,可以执行下面的代码查看所有钩子的执行顺序:

beforeAll(() => console.log('1 - beforeAll'));
afterAll(() => console.log('1 - afterAll'));
beforeEach(() => console.log('1 - beforeEach'));
afterEach(() => console.log('1 - afterEach'));
test('', () => console.log('1 - test'));
describe('Scoped / Nested block', () => {
  beforeAll(() => console.log('2 - beforeAll'));
  afterAll(() => console.log('2 - afterAll'));
  beforeEach(() => console.log('2 - beforeEach'));
  afterEach(() => console.log('2 - afterEach'));
  test('', () => console.log('2 - test'));
});

// 1 - beforeAll
// 1 - beforeEach
// 1 - test
// 1 - afterEach
// 2 - beforeAll
// 1 - beforeEach
// 2 - beforeEach
// 2 - test
// 2 - afterEach
// 1 - afterEach
// 2 - afterAll
// 1 - afterAll

describe 和 test 块的执行顺序

Jest 在执行任何实际测试之前,先执行测试文件中的所有 describe 处理程序。

这也是在 before*after* 内部(而不是在 describe 块内部)进行设置和注销的另一个原因。

一旦 describe 块执行完成,默认情况下 Jest 会按照收集阶段获得的顺序串行运行所有测试,在等待每个测试完成和整理好之后再继续。

请查看下面的打印顺序:

describe('outer', () => {
  console.log('describe outer-a');

  describe('describe inner 1', () => {
    console.log('describe inner 1');
    test('test 1', () => {
      console.log('test for describe inner 1');
      expect(true).toEqual(true);
    });
  });

  console.log('describe outer-b');

  test('test 1', () => {
    console.log('test for describe outer');
    expect(true).toEqual(true);
  });

  describe('describe inner 2', () => {
    console.log('describe inner 2');
    test('test for describe inner 2', () => {
      console.log('test for describe inner 2');
      expect(false).toEqual(false);
    });
  });

  console.log('describe outer-c');
});

// describe outer-a
// describe inner 1
// describe outer-b
// describe inner 2
// describe outer-c
// test for describe inner 1
// test for describe outer
// test for describe inner 2

使用建议

如果一个测试失败了,首先要检查的事情之一应该时当它是唯一运行的测试时,该测试是否失败,可以临时使用 test.only 代替 test 告知 Jest 仅运行这一个测试。

如果有一个测试,当它作为一个更大的套件的一部分运行时经常失败,但当你单独运行它时却没有失败,那么很有可能来自领域给测试的某个东西正在干扰这个测试。通常可以通过清除来自 beforeEach 的共享状态来解决这个问题。如果不确定是否正在修改某些共享状态,也可以尝试使用 beforeEach 记录数据。

网站文章

  • 解析网页--BeautifulSoup-bs4-python爬虫知识点6

    BeautifulSoup 一、BeautifulSoup基本信息 定义 主要学bs4.BeautifulSoup,bs4内的一个非常好用的模块,美丽的汤,bs4:Beautiful Soup4 Be...

    2024-02-01 00:09:40
  • Maven传递依赖的原则

    maven引入的传递性依赖机制,一方面大大简化和方便了依赖声明,大部分情况下我们只需要关心项目的直接依赖是什么,而不永哥你考虑这些直接依赖会引入什么传递性依赖。但有时候,当歘地形依赖造成问题时,我们就需要清除知道该传递性依赖是从哪条依赖路径引入的。如下示例:1.依赖同一个jar包,深度不同:A->B->C->X(1.0)   依赖深度为3A->D->X(2.0)   依赖深度为2

    2024-02-01 00:09:34
  • 1951 查询具有最多共同关注者的所有两两结对组

    1951 查询具有最多共同关注者的所有两两结对组

    题目描述:写出一个查询语句,找到具有最多共同关注者的所有两两结对组。换句话说,如果有两个用户的共同关注者是最大的,我们应该返回所有具有此最大值的两两结对组The result table should...

    2024-02-01 00:09:06
  • axios拦截器之重复请求取消上次请求、路由切换取消接口

    在项目中经常会遇到需要主动取消接口的场景,axios提供CancelToken的功能可以主动停止当前请求,从而避免无效请求,优化网络性能场景:远程搜索接口频繁请求,第二个接口先成功导致显示第一个接口返...

    2024-02-01 00:08:58
  • CrawlSpider爬虫实战-猎云网爬虫(过程超详细)

    CrawlSpider爬虫实战-猎云网爬虫(过程超详细)

    CrawlSpider爬虫作用:可以定义规则,让Scrapy自动的去爬取我们想要的链接。而不必跟Spider类一样,手动的yield Request。创建:scrapy genspider -t cr...

    2024-02-01 00:08:51
  • swarm系列-swarm可视化之visualizer(4)

    swarm系列-swarm可视化之visualizer(4)

    visualizer是官方的简单容器状态可视化工具安装docker run -it -d -p 5000:8080 \ -v /var/run/docker.sock:/var/run/docker.sock \ dockersamples/visualizer访问ip:5000访问页面查看 ...

    2024-02-01 00:08:44
  • 数据集ISCX(12年到17年)已经打包,可下载

    数据集ISCX(12年到17年)已经打包,可下载

    感兴趣的可私聊下载。

    2024-02-01 00:08:15
  • 配置grails后,dos命令行出现如下错误

    配置grails后,dos命令行出现如下错误。我的java的环境变量设置也是正确的,平时运行java程序也没有出过问题,但是这里确提示我的JAVA_HOME是一个无效的目录,到网上看了一下,原来是JAVA_HOME所配置的名字不识别。C:\Users\JavaPlus>grails -versionERROR: JAVA_HOME is set to an invalid di

    2024-02-01 00:08:09
  • Redis

    什么是RedisRedis是一款内存高速缓存数据库,是Nosql数据库中使用较为广泛的非关系型内存数据库。Redis全称为:Remote Dictionary Server (远程数据服务),使用C语...

    2024-02-01 00:08:01
  • 对象的循环

    1.最基本: for(var i = 0,arr=[&#39;Z&#39;,&#39;S&#39;,&#39;T&#39;,&#39;Y&#39;];i&lt;arr.length;i++){ con...

    2024-02-01 00:07:33