跳转到主要内容
版本:26.倍

Funcoes de Simulacao

模拟函数也被称为“间谍”,因为它们允许您监视由其他代码间接调用的函数的行为,而不仅仅是测试输出。Você pode criar uma função de simulação (mock, em inglês) comjest.fn()。Se nenhuma implementação é dada, a função de simulação retornará不明确的Quando Invocada。

Métodos<一个类="hash-link" href="#métodos" title="#">#


参考<一个类="hash-link" href="#reference" title="#">#

mockfn.getmockname()#

返回通过调用设置的模拟名称字符串mockfn.mockname(价值)

mockfn.mock.calls.#

包含对此模拟功能所做的所有呼叫的调用参数的数组。数组中的每个项目都是在呼叫期间传递的参数数组。

例如:模拟功能f它被调用了两次,带有参数f('arg1','arg2'),然后是论点f(“长度”、“arg4”),会有一个mock.calls视图这样的数组:

(
( 'arg1' , 'arg2' ] ,
( 'arg3' , 'arg4' ] ,
] ;

mockfn.mock.results.#

包含已对此模拟功能所做的所有呼叫结果的数组。此数组中的每个条目都是包含a的对象类型财产,和一个价值财产。类型将是以下之一:

  • “返回”-表示调用通过正常返回完成。
  • “扔”- 表示通过抛出值完成的呼叫。
  • '不完整'- 表示呼叫尚未完成。如果您在模拟函数本身中测试结果,或者从模拟调用的函数中测试,则会发生这种情况。

价值属性包含抛出或返回的值。价值是未定义的type ==='不完整'

例如:模拟功能f这已被称为三次,返回“result1”编写此表达式,抛出错误,然后返回“result2”,会有一个mock.results.视图这样的数组:

(
{
类型 : “返回” ,
价值 : “result1”编写此表达式 ,
} ,
{
类型 : “扔” ,
价值 : {
/*错误实例*/
} ,
} ,
{
类型 : “返回” ,
价值 : “result2” ,
} ,
] ;

mockfn.mock.instances.#

例如:uma função de simulação我们的实例是这样的模拟:

重新定义Todas作为InformaçõesArmazenadasnos arrays de<一个href="#mockfnmockcalls">mockfn.mock.calls.e<一个href="#mockfnmockinstances">mockfn.mock.instances.

常量 Mockfn. = 开玩笑 fn ( ) ;
常量 一个 = 新的 Mockfn. ( ) ;
常量 b = 新的 Mockfn. ( ) ;
Mockfn. 嘲笑 实例 ( 0 ] === 一个 ; // 真的
Mockfn. 嘲笑 实例 ( 1 ] === b ; // 真的

mockFn.mockClear ()#

我们的网址是é útil quando você deseja limpar os dado de uso de uma simulação entre duas afirmações。

我们的网址是é útil quando você deseja limpar os dado de uso de uma simulação entre duas afirmações。

小心,笨拙爱尔兰共和军substituirmockFn.mock,nãoapenas.<一个href="#mockfnmockcalls">mockfn.mock.calls.e<一个href="#mockfnmockinstances">mockfn.mock.instances.。因此,您应该避免分配mockFn.mock访问其他变量,无论是临时的还是非临时的,以确保您不会访问过时的数据。

一个opçãodeciguração<一个href="//www.ieatrice.com/pt-BR/docs/configuration.html">clearMocksestá disponível para limpar as simulações automaticamente entre os testes。

mockfn.mockreset()#

做的一切<一个href="#mockfnmockclear">mockFn.mockClear ()是的,并且删除任何模拟的返回值或实现。

当您想要完全重置一个时,这很有用嘲笑回到初始状态。(注意,重置a间谍将导致一个没有返回值的函数)。

小心,笨拙爱尔兰共和军substituirmockFn.mock,nãoapenas.<一个href="#mockfnmockcalls">mockfn.mock.calls.e<一个href="#mockfnmockinstances">mockfn.mock.instances.。因此,您应该避免分配mockFn.mock访问其他变量,无论是临时的还是非临时的,以确保您不会访问过时的数据。

mockFn.mockRestore ()#

做的一切<一个href="#mockfnmockreset">mockfn.mockreset()执行,并恢复原始的(非模拟的)实现。

Isso é útil quando você quer simular funções em certos casos de teste restaurant a implementação original em outros。

注意,mockfn.mockrestore.仅在创建模拟时工作jest.spyon.。请给我restauração você我的手册jest.fn()

的<一个href="//www.ieatrice.com/pt-BR/docs/configuration.html">修复器配置选项可用于在测试之间自动还原模型。

mockFn.mockImplementation (fn)#

我的名字是função que deve ser usada como a implementação da simulação (mock, em inglês)。您的邮箱是simulação我的邮箱是irá您的邮箱是instâncias您的邮箱是vêm您的邮箱是própria您的邮箱是única diferença é您的邮箱是simulação é。

nota:jest.fn(实现)éuma forma abreviada parajest.fn () .mockImplementation(实现)

por presseo:

常量 Mockfn. = 开玩笑 fn ( ) 模仿 ( 标量 => 42 + 标量 ) ;
/ /或:笑话。fn(标量=>42+标量);
常量 一个 = Mockfn. ( 0 ) ;
常量 b = Mockfn. ( 1 ) ;
一个 === 42 ; // 真的
b === 43 ; // 真的
Mockfn. 嘲笑 调用 ( 0 ] ( 0 ] === 0 ; // 真的
Mockfn. 嘲笑 调用 ( 1 ] ( 0 ] === 1 ; // 真的

模仿TambémpodeSer Usado Para Simular(Mock,EmInglês)Construtores de Classe:

/ / SomeClass.js
模块 出口 = 一体的 {
( 一个 , b ) { }
} ;
/ / OtherModule.test.js
开玩笑 嘲笑 ( './someclass' ) ; //这将自动使用automocking
常量 一体的 = 需要 ( './someclass' ) ;
常量 MMOCK. = 开玩笑 fn ( ) ; 一体的 模仿 ( ( ) => {
返回 {
: MMOCK. ,
} ;
} ) ;
常量 一些 = 新的 一体的 ( ) ;
一些 ( “一个” , “b” ) ;
安慰 日志 ( '打电话给M:' , MMOCK. 嘲笑 调用 ) ;

mockFn.mockImplementationOnce (fn)#

Acyita UmaFumaçãoQueSerá美达Como UmaImpeedaçãodeImulaçãoPara UmaChamadaàfuçãosimulada(嘲笑,eminglês)。Podem ser encadeadas para queváriaschamadas defunçãoprestuzam结果os diferentes。

常量 mymockfn. = 开玩笑
fn ( )
mockImplementationOnce ( cb => cb ( 无效的 , 真的 ) )
mockImplementationOnce ( cb => cb ( 无效的 , ) ) ;
mymockfn. ( ( , 瓦尔 ) => 安慰 日志 ( 瓦尔 ) ) ; // 真的
mymockfn. ( ( , 瓦尔 ) => 安慰 日志 ( 瓦尔 ) ) ; // 错误的

Quando AFumçãoSimulada Fica SemImpeedaçõesimidaasComMockimplementationOnce,ElaIráexecutar o ConduntoPadrãodeifferaçãocomjest.fn(()=> defaultValue)OU..mockimplementation(()=> defaultValue)还有有孔虫:

常量 mymockfn. = 开玩笑
fn ( ( ) => '默认' )
mockImplementationOnce ( ( ) => '第一次打电话' )
mockImplementationOnce ( ( ) => '第二个电话' ) ;
//'第一次调用','第二个电话','默认','默认'
安慰 日志 ( mymockfn. ( ) , mymockfn. ( ) , mymockfn. ( ) , mymockfn. ( ) ) ;

mockfn.mockname(价值)#

接受一个字符串,用于在测试结果输出中代替“jest.fn()”,以指示所引用的是哪个模拟函数。

por presseo:

常量 Mockfn. = 开玩笑 fn ( ) mockName ( “mockedFunction” ) ;
// mockfn();
预计 ( Mockfn. ) TohaveBeencalled. ( ) ;

将导致这个错误:

期望mock函数"mockedFunction"被调用,但它没有被调用。

mockFn.mockReturnThis ()#

句法糖功能:

开玩笑 fn ( 功能 ( ) {
返回 ;
} ) ;

mockfn.mockreturnvalue(价值)#

我的号码是será我的号码是função simulação é chamada。

常量 嘲笑 = 开玩笑 fn ( ) ;
嘲笑 mockreturnvalue. ( 42 ) ;
嘲笑 ( ) ; / / 42
嘲笑 mockreturnvalue. ( 43 ) ;
嘲笑 ( ) ; / / 43

mockFn.mockReturnValueOnce(值)#

Aceita Um Valor QueSeráReyornadoPor Uma Chamada Para aFuchçãodesimulação。Podem ser encadeados para que sucessivas chamadas para afuomçãodesimulaçãoretornem valores diferentes。QuandonãoHáMaisvaloresmockReturnValueOncepara usar, chamadas irão retornar um value speciificado pelomockreturnvalue.

常量 mymockfn. = 开玩笑
fn ( )
mockreturnvalue. ( '默认' )
mockReturnValueOnce ( '第一次打电话' )
mockReturnValueOnce ( '第二个电话' ) ;
//'第一次调用','第二个电话','默认','默认'
安慰 日志 ( mymockfn. ( ) , mymockfn. ( ) , mymockfn. ( ) , mymockfn. ( ) ) ;

mockfn.mockresolvedvalue(价值)#

句法糖功能:

开玩笑 fn ( ) 模仿 ( ( ) => 承诺 解决 ( 价值 ) ) ;

用于在异步测试中模拟异步函数:

测试 ( '异步测试' , 异步 ( ) => {
常量 asyncMock = 开玩笑 fn ( ) mockResolvedValue ( 43 ) ;
等待 asyncMock ( ) ; / / 43
} ) ;

mockFn.mockResolvedValueOnce(值)#

句法糖功能:

开玩笑 fn ( ) mockImplementationOnce ( ( ) => 承诺 解决 ( 价值 ) ) ;

在多个异步调用上解析不同的值:

测试 ( '异步测试' , 异步 ( ) => {
常量 asyncMock = 开玩笑
fn ( )
mockResolvedValue ( '默认' )
mockresolvedvalueonce. ( '第一次打电话' )
mockresolvedvalueonce. ( '第二个电话' ) ;
等待 asyncMock ( ) ; / /第一个电话
等待 asyncMock ( ) ; / /第二个电话
等待 asyncMock ( ) ; / /默认
等待 asyncMock ( ) ; / /默认
} ) ;

mockfn.mockrejectedValue(价值)#

句法糖功能:

开玩笑 fn ( ) 模仿 ( ( ) => 承诺 拒绝 ( 价值 ) ) ;

用于创建总是拒绝的异步模拟函数:

测试 ( '异步测试' , 异步 ( ) => {
常量 asyncMock = 开玩笑 fn ( ) 模仿value. ( 新的 错误 ( '异步错误' ) ) ;
等待 asyncMock ( ) ; //抛出异步错误
} ) ;

mockFn.mockRejectedValueOnce(值)#

句法糖功能:

开玩笑 fn ( ) mockImplementationOnce ( ( ) => 承诺 拒绝 ( 价值 ) ) ;

示例用法:

测试 ( '异步测试' , 异步 ( ) => {
常量 asyncMock = 开玩笑
fn ( )
mockresolvedvalueonce. ( '第一次打电话' )
mockRejectedValueOnce ( 新的 错误 ( '异步错误' ) ) ;
等待 asyncMock ( ) ; / /第一个电话
等待 asyncMock ( ) ; //抛出异步错误
} ) ;

类型签字<一个类="hash-link" href="#typescript" title="#">#

jest本身是写的<一个href="https://www.typescriptlang.org" target="_blank" rel="noopener noreferrer">类型签字。

如果你正在使用<一个href="https://create-react-app.dev" target="_blank" rel="noopener noreferrer">创建应用程序反应然后是<一个href="https://create-react-app.dev/docs/adding-typescript/" target="_blank" rel="noopener noreferrer">打字稿模板有你开始在TypeScript中编写测试所需的一切。

否则,请看我们的<一个href="//www.ieatrice.com/pt-BR/docs/getting-started">开始使用TypeScript进行设置的指南。

您可以在我们的情况下查看使用CypeScript使用Jest的示例<一个href="https://github.com/facebook/jest/tree/master/examples/typescript" target="_blank" rel="noopener noreferrer">github存储库。

笑话。MockedFunction#

笑话。MockedFunction可在@类型/ jest版本中的模块24.9.0

以下示例将假设您对如何理解如何<一个href="//www.ieatrice.com/pt-BR/docs/mock-functions">Jest Mock函数与JavaScript一起使用。

UM数组quecontémtodas作为instânciasde objeto que tem sido Instanciasdos a partir destafunçãosimulada(模拟,eminglês)usando新的

使用<一个href="//www.ieatrice.com/pt-BR/docs/jest-object">自动的jest.mock:

//假设' add '被导入并在' calculate '中使用。
进口 添加 '。/添加' ;
进口 计算 './calc' ;
开玩笑 嘲笑 ( '。/添加' ) ;
//我们对' add '的模拟现在是完全输入的
常量 Mockadd. = 添加 作为 开玩笑 MockedFunction < typeof 添加 > ;
测试 ( “计算调用添加” , ( ) => {
计算 ( “添加” , 1 , 2 ) ;
预计 ( Mockadd. ) 禁食 ( 1 ) ;
预计 ( Mockadd. ) toBeCalledWith ( 1 , 2 ) ;
} ) ;

使用<一个href="//www.ieatrice.com/pt-BR/docs/jest-object">jest.fn:

//这里为它的类型导入' add '
进口 添加 '。/添加' ;
进口 计算 './calc' ;
测试 ( “计算调用添加” , ( ) => {
//创建一个新的mock,可以用来代替' add '。
常量 Mockadd. = 开玩笑 fn ( ) 作为 开玩笑 MockedFunction < typeof 添加 > ;
//注意:你可以使用' jest '。fn` type directly like this if you want:
// const mockadd = jest.fn ,参数>();
/ /的笑话。MockedFunction '是一个更友好的快捷方式。
//现在我们可以轻松地设置模拟实现。
//所有`.mock *`api现在可以为您提供适当的类型为`添加'。
/ / //www.ieatrice.comyabo2013/docs/en/mock-function-api
//`.mockimplementation`现在可以推断出'a`和`b`是`数字`
//并且返回值是一个' number '。
Mockadd. 模仿 ( ( 一个 , b ) => {
//是的,这个模拟仍然是两个数字相加,但是想象一下
//是我们正在嘲笑的复杂功能。
返回 一个 + b ;
} ) ;
//`mockadd`是正确的输入,因此被接受
//需要“添加”的东西。
计算 ( Mockadd. , 1 , 2 ) ;
预计 ( Mockadd. ) 禁食 ( 1 ) ;
预计 ( Mockadd. ) toBeCalledWith ( 1 , 2 ) ;
} ) ;

笑话。MockedClass#

笑话。MockedClass可在@类型/ jest版本中的模块24.9.0

以下示例将假设您对如何理解如何<一个href="//www.ieatrice.com/pt-BR/docs/es6-class-mocks">Jest Mock类与JavaScript一起工作。

您可以使用笑话。MockedClass表示已被Jest mock代替的类。

转换<一个href="//www.ieatrice.com/pt-BR/docs/es6-class-mocks">ES6类自动模拟示例看起来像这样:

进口 SoundPlayer “. . /留声机” ;
进口 SoundPlayerConsumer. '../sound-player-consumer' ;
开玩笑 嘲笑 ( “. . /留声机” ) ; // SoundPlayer现在是一个模拟构造函数
常量 SoundPlayerMock = SoundPlayer 作为 开玩笑 MockedClass < typeof SoundPlayer > ;
beforeEach ( ( ) => {
//清除所有实例并调用构造函数和所有方法:
SoundPlayerMock 笨拙 ( ) ;
} ) ;
( “我们可以检查消费者是否称为类构造函数' , ( ) => {
常量 SoundPlayerConsumer. = 新的 SoundPlayerConsumer. ( ) ;
预计 ( SoundPlayerMock ) tohavebeencalledtimes. ( 1 ) ;
} ) ;
( 我们可以检查消费者是否在类实例上调用了方法 , ( ) => {
//显示mockClear()工作:
预计 ( SoundPlayerMock ) TohaveBeencalled. ( ) ;
常量 SoundPlayerConsumer. = 新的 SoundPlayerConsumer. ( ) ;
//应该再次调用//构造函数:
预计 ( SoundPlayerMock ) tohavebeencalledtimes. ( 1 ) ;
常量 coolsoundfilename. = 'song.mp3' ;
SoundPlayerConsumer. playSomethingCool ( ) ;
/ /模拟。实例可以使用自动模拟:
常量 mockSoundPlayerInstance = SoundPlayerMock 嘲笑 实例 ( 0 ] ;
//但是,它不会允许访问“.mock`”中的“.mock`
//返回SoundPlayer。相反,您可以检查对a的调用
//像这样完全键入的方法:
预计 ( SoundPlayerMock 原型 playsoundfile. 嘲笑 调用 ( 0 ] ( 0 ] ) toEqual (
coolsoundfilename. ,
) ;
//相当于上述检查:
预计 ( SoundPlayerMock 原型 playsoundfile. ) Tohavebeencalledwith. (
coolsoundfilename. ,
) ;
预计 ( SoundPlayerMock 原型 playsoundfile. ) tohavebeencalledtimes. ( 1 ) ;
} ) ;