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

一些必要的模拟

模拟函数也被称为“间谍”,因为它们让您监视由其他代码间接调用的函数的行为,而不仅仅是测试输出。希望你能找到funciónjest.fn ()。如果不是这样implementación, función mockeda devolverá未定义的cuando se invoque。

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


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

mockFn.getMockName ()#

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

mockFn.mock.calls#

一个数组,包含对这个模拟函数所做的所有调用的调用参数。数组中的每一项都是调用期间传递的参数数组。

例如:一个模拟函数f这已经被调用了两次了f(“__arg1”、“最长”),然后是论据f(“长度”、“arg4”),会有一个mock.calls数组看起来像这样:

(
( “__arg1” , “最长” ] ,
( “长度” , “arg4” ] ,
] ;

mockFn.mock.results#

一个数组,包含对这个模拟函数所做的所有调用的结果。数组中的每个条目都是包含类型财产,价值财产。类型将是以下之一:

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

价值属性包含被抛出或返回的值。价值是未定义的类型= = =“不完整”

在这个例子中,我们可以看到一个物体的形状,这个物体的形状为función

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

mockFn.mock.instances#

说到这里:función我想说的是:tendría la siuiente matriz demock.instances:

重新建立información almacenada在最后的矩阵<一个href="#mockfnmockcalls">mockFn.mock.callsy<一个href="#mockfnmockinstances">mockFn.mock.instances

常量 mockFn = 开玩笑 fn ( ) ;
常量 一个 = mockFn ( ) ;
常量 b = mockFn ( ) ;
mockFn 模拟 实例 ( 0 ] = = = 一个 ; / /正确的
mockFn 模拟 实例 ( 1 ] = = = b ; / /正确的

mockFn.mockClear ()#

一份menudo es útil的menudo quipiar datos de theso de mock centriones afirmaciones。

一份menudo es útil的menudo quipiar datos de theso de mock centriones afirmaciones。

小心欺诈esemockClearreemplazara一mockFn.mock,没有<一个href="#mockfnmockcalls">mockFn.mock.callsy<一个href="#mockfnmockinstances">mockFn.mock.instances。因此,您应该避免分配mockFn.mock对其他变量,无论是临时的还是非临时的,以确保您不会访问过时的数据。

的<一个href="/es-ES/docs/configuration.html">clearMocks配置选项可用于在测试之间自动清除模拟。

mockFn.mockReset ()#

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

当你想要完全重置模拟回到初始状态。(注意复位a间谍将导致一个没有返回值的函数)。

小心欺诈esemockClearreemplazara一mockFn.mock,没有<一个href="#mockfnmockcalls">mockFn.mock.callsy<一个href="#mockfnmockinstances">mockFn.mock.instances。因此,您应该避免分配mockFn.mock对其他变量,无论是临时的还是非临时的,以确保您不会访问过时的数据。

mockFn.mockRestore ()#

做的一切<一个href="#mockfnmockreset">mockFn.mockReset ()执行,并恢复原始的(非mock的)实现。

在此útil para casos donde desee类似的功能在该餐厅的implementación原始的para otras。

注意,mockFn.mockRestore仅当使用该mock创建时有效jest.spyOn。我想知道的是restauración这个国家的独立,一个笑话嘲笑了欺骗jest.fn ()

的<一个href="/es-ES/docs/configuration.html">restoreMocks配置选项可用于在测试之间自动恢复模拟。

mockFn.mockImplementation (fn)#

有一个función可以利用它,它可以是implementación,它的功能是嘲笑。El mockeo de sí mismo aún grabará它的目的是为了证明它是sí mismo,这个única的不同之处是aplicación también se ejecutará它的功能是模仿。

注意:jest.fn(实现)是对jest.fn () .mockImplementation(实现)

比如:

常量 mockFn = 开玩笑 fn ( ) mockImplementation ( 标量 = > 42 + 标量 ) ;
/ /或:笑话。fn(标量= >42+标量);
常量 一个 = mockFn ( 0 ) ;
常量 b = mockFn ( 1 ) ;
一个 = = = 42 ; / /正确的
b = = = 43 ; / /正确的
mockFn 模拟 调用 ( 0 ] ( 0 ] = = = 0 ; / /正确的
mockFn 模拟 调用 ( 1 ] ( 0 ] = = = 1 ; / /正确的

mockImplementationPuede utilzarse también para mockear constructers de class:

/ / SomeClass.js
模块 出口 = SomeClass {
( 一个 , b ) { }
} ;
/ / OtherModule.test.js
开玩笑 模拟 ( ”。/ SomeClass ' ) ; //这是自动锁
常量 SomeClass = 需要 ( ”。/ SomeClass ' ) ;
常量 mMock = 开玩笑 fn ( ) ;
SomeClass mockImplementation ( ( ) = > {
返回 {
: mMock ,
} ;
} ) ;
常量 一些 = SomeClass ( ) ;
一些 ( “一个” , “b” ) ;
控制台 日志 ( '对m的呼叫' , mMock 模拟 调用 ) ;

mockFn.mockImplementationOnce (fn)#

接受función因为它是utilizará como una implementación模仿驼羊驼的功能función mockeada。我们可能会在función的产品上做羊驼,结果是不一样的。

常量 myMockFn = 开玩笑
fn ( )
mockImplementationOnce ( cb = > cb ( , 真正的 ) )
mockImplementationOnce ( cb = > cb ( , ) ) ;
myMockFn ( ( 犯错 , 瓦尔 ) = > 控制台 日志 ( 瓦尔 ) ) ; / /正确的
myMockFn ( ( 犯错 , 瓦尔 ) = > 控制台 日志 ( 瓦尔 ) ) ; / /错误

Cuando se ejecuta función mockeada de implementaciones定义mockImplementationOnce, se ejecutará la aplicación por defecto conjest.fn(() = > defaultValue)o.mockImplementation(() = > defaultValue)如果se llamara:

常量 myMockFn = 开玩笑
fn ( ( ) = > “默认” )
mockImplementationOnce ( ( ) = > “第一个电话” )
mockImplementationOnce ( ( ) = > “第二个电话” ) ;
//第一次调用,第二次调用,'default'
控制台 日志 ( myMockFn ( ) , myMockFn ( ) , myMockFn ( ) , myMockFn ( ) ) ;

mockFn.mockName(值)#

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

比如:

常量 mockFn = 开玩笑 fn ( ) mockName ( “mockedFunction” ) ;
/ / mockFn ();
预计 ( mockFn ) toHaveBeenCalled ( ) ;

将导致以下错误:

期望(mockedFunction) .toHaveBeenCalled ()
预期的mock函数“mockedFunction”已经被调用,但没有调用。

mockFn.mockReturnThis ()#

语法糖功能:

开玩笑 fn ( 函数 ( ) {
返回 ;
} ) ;

mockFn.mockReturnValue(值)#

接受当调用模拟函数时将返回的值。

常量 模拟 = 开玩笑 fn ( ) ;
模拟 mockReturnValue ( 42 ) ;
模拟 ( ) ; / / 42
模拟 mockReturnValue ( 43 ) ;
模拟 ( ) ; / / 43

mockFn.mockReturnValueOnce(值)#

我们要勇敢地为您服务devolverá para una lamada a la función de proeba。可以被链接,以便对模拟函数的后续调用返回不同的值。当再也没有了mockReturnValueOnce值时,调用将返回指定的值mockReturnValue

常量 myMockFn = 开玩笑
fn ( )
mockReturnValue ( “默认” )
mockReturnValueOnce ( “第一个电话” )
mockReturnValueOnce ( “第二个电话” ) ;
//第一次调用,第二次调用,'default'
控制台 日志 ( myMockFn ( ) , myMockFn ( ) , myMockFn ( ) , myMockFn ( ) ) ;

mockFn.mockResolvedValue(值)#

语法糖功能:

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

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

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

mockFn.mockResolvedValueOnce(值)#

语法糖功能:

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

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

测试 ( “异步测试” , 异步 ( ) = > {
常量 asyncMock = 开玩笑
fn ( )
mockResolvedValue ( “默认” )
mockResolvedValueOnce ( “第一个电话” )
mockResolvedValueOnce ( “第二个电话” ) ;
等待 asyncMock ( ) ; / /第一个电话
等待 asyncMock ( ) ; / /第二个电话
等待 asyncMock ( ) ; / /默认
等待 asyncMock ( ) ; / /默认
} ) ;

mockFn.mockRejectedValue(值)#

语法糖功能:

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

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

测试 ( “异步测试” , 异步 ( ) = > {
常量 asyncMock = 开玩笑 fn ( ) mockRejectedValue ( 错误 ( “异步错误” ) ) ;
等待 asyncMock ( ) ; //抛出“异步错误”
} ) ;

mockFn.mockRejectedValueOnce(值)#

语法糖功能:

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

使用示例:

测试 ( “异步测试” , 异步 ( ) = > {
常量 asyncMock = 开玩笑
fn ( )
mockResolvedValueOnce ( “第一个电话” )
mockRejectedValueOnce ( 错误 ( “异步错误” ) ) ;
等待 asyncMock ( ) ; / /第一个电话
等待 asyncMock ( ) ; //抛出“异步错误”
} ) ;

打印稿<一个类="hash-link" href="#typescript" title="#">#

笑话本身就写在里面<一个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="/es-ES/docs/getting-started">开始使用TypeScript进行设置的指南。

你可以在我们的<一个href="https://github.com/facebook/jest/tree/master/examples/typescript" target="_blank" rel="noopener noreferrer">GitHub库。

笑话。MockedFunction#

笑话。MockedFunction可在@types /开玩笑模块的版本24.9.0

下面的例子假设您已经了解了如何操作<一个href="/es-ES/docs/mock-functions">Jest模拟函数适用于JavaScript。

您可以使用笑话。MockedFunction来表示一个已被Jest mock所取代的函数。

示例使用<一个href="/es-ES/docs/jest-object">自动jest.mock:

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

示例使用<一个href="/es-ES/docs/jest-object">jest.fn:

//这里,' add '被导入其类型
进口 添加 “添加/。” ;
进口 计算 “。/钙” ;
测试 ( “计算调用添加” , ( ) = > {
//创建一个可以代替' add '的新mock。
常量 mockAdd = 开玩笑 fn ( ) 作为 开玩笑 MockedFunction < typeof 添加 > ;
//注意:你可以用‘joke’。fn` type directly like this if you want:
// const mockAdd = jest。fn, Parameters>();
/ /的笑话。MockedFunction '是一个更友好的快捷方式。
//现在我们可以轻松地设置模拟实现。
//所有的'。模拟*` API can now give you proper types for `add`.
/ / //www.ieatrice.comyabo2013/docs/en/mock-function-api
/ /”。模拟Implementation` can now infer that `a` and `b` are `number`
//并且返回值是一个' number '。
mockAdd mockImplementation ( ( 一个 , b ) = > {
//是的,这个mock仍然是添加两个数字,但是想象一下
//是一个复杂的函数,我们模仿。
返回 一个 + b ;
} ) ;
// ' mockAdd '被正确输入,因此被
//任何需要添加的东西。
计算 ( mockAdd , 1 , 2 ) ;
预计 ( mockAdd ) toBeCalledTimes ( 1 ) ;
预计 ( mockAdd ) toBeCalledWith ( 1 , 2 ) ;
} ) ;

笑话。MockedClass#

笑话。MockedClass可在@types /开玩笑模块的版本24.9.0

下面的例子假设您已经了解了如何操作<一个href="/es-ES/docs/es6-class-mocks">Jest模拟类可以使用JavaScript。

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

转换<一个href="/es-ES/docs/es6-class-mocks">ES6类自动模拟示例看起来是这样的:

进口 SoundPlayer “. . /留声机” ;
进口 SoundPlayerConsumer “. . / sound-player-consumer” ;
开玩笑 模拟 ( “. . /留声机” ) ; // SoundPlayer现在是一个模拟构造函数
常量 SoundPlayerMock = SoundPlayer 作为 开玩笑 MockedClass < typeof SoundPlayer > ;
beforeEach ( ( ) = > {
//清除所有实例和调用构造函数和所有方法:SoundPlayerMock.mockClear();
} ) ;
( '我们可以检查消费者是否调用了类构造函数' , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
预计 ( SoundPlayerMock ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;
( '我们可以检查消费者是否调用了类实例上的方法' , ( ) = > {
//显示mockClear()正在工作:
预计 ( SoundPlayerMock ) toHaveBeenCalled ( ) ;
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
//应该再次调用构造函数:
预计 ( SoundPlayerMock ) toHaveBeenCalledTimes ( 1 ) ;
常量 coolSoundFileName = “song.mp3” ;
soundPlayerConsumer playSomethingCool ( ) ;
/ /模拟。实例是可用的自动模拟:
常量 mockSoundPlayerInstance = SoundPlayerMock 模拟 实例 ( 0 ] ;
//但是,它不允许访问'。在TypeScript中mock '
//返回' SoundPlayer '。相反,您可以检查对
//完全类型化方法:
预计 ( SoundPlayerMock 原型 playSoundFile 模拟 调用 ( 0 ] ( 0 ] ) toEqual (
coolSoundFileName ,
) ;
//相当于上面的检查:
预计 ( SoundPlayerMock 原型 playSoundFile ) toHaveBeenCalledWith (
coolSoundFileName ,
) ;
预计 ( SoundPlayerMock 原型 playSoundFile ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;