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

Simulação de Classes ES6

Jest pode ser usado para simular (mock, em inglês)类ES6 que são importadas para arquivos que você deseja testar。

类ES6 são funções de constructor com uma sintaxe mais fácil de usar。因此,ES6类的任何模拟必须是一个函数或实际的ES6类(同样是另一个函数)。所以你可以用模拟功能

这是ES6课程的范例#

我们有一个例子是我们的同类,SoundPlayer在美国的等级中,SoundPlayerConsumer。我们将模拟SoundPlayer在我们的测试中SoundPlayerConsumer

/ / sound-player.js
出口 默认的 SoundPlayer {
构造函数 ( ) {
喷火 = “酒吧” ;
}
playSoundFile ( 文件名 ) {
控制台 日志 ( “播放声音文件” + 文件名 ) ;
}
}
/ / sound-player-consumer.js
进口 SoundPlayer “。/留声机” ;
出口 默认的 SoundPlayerConsumer {
构造函数 ( ) {
soundPlayer = SoundPlayer ( ) ;
}
playSomethingCool ( ) {
常量 coolSoundFileName = “song.mp3” ;
soundPlayer playSoundFile ( coolSoundFileName ) ;
}
}

As 4 maneiras de criar uma simulação de uma class ES6#

Simulacao自动化#

Chamandojest.mock(’。/留声机”)retorna uma“simulação automática”útil que você pode usar para spyar chamadas para constructor de classe todos os seus métodos。Substitui a class ES6 por um construct simulado e Substitui todos os seus métodos comfuncoes de simulacao是自始至终retornam未定义的。方法调用保存在theAutomaticMock.mock.instances .methodName.mock.calls(指数)

请使用você usar箭头函数作为类naoserão各方都会嘲笑。原因是箭头函数不存在于对象的原型中,它们只是持有对函数的引用的属性。

如果不需要替换类的实现,这是最容易设置的选项。为什么exemplo:

进口 SoundPlayer “。/留声机” ;
进口 SoundPlayerConsumer ”。/ sound-player-consumer ' ;
开玩笑 模拟 ( “。/留声机” ) ; // SoundPlayer现在是一个模拟构造函数
beforeEach ( ( ) = > {
// Limpa todas as instâncias e chamadas de construct e todos os métodos:
SoundPlayer mockClear ( ) ;
} ) ;
( " Nós我们可以验证这门课的构造" , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
预计 ( SoundPlayer ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;
( 'Nós podemos verificar se o consumidor chamou um método na instância da class ' , ( ) = > {
// Mostra que mockClear() está函数:
预计 ( SoundPlayer ) toHaveBeenCalled ( ) ;
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
//构造器deve ter sido chamado novamente:
预计 ( SoundPlayer ) toHaveBeenCalledTimes ( 1 ) ;
常量 coolSoundFileName = “song.mp3” ;
soundPlayerConsumer playSomethingCool ( ) ;
/ /模拟。实例está disponível com simulações automáticas:
常量 mockSoundPlayerInstance = SoundPlayer 模拟 实例 ( 0 ] ;
常量 mockPlaySoundFile = mockSoundPlayerInstance playSoundFile ;
预计 ( mockPlaySoundFile 模拟 调用 ( 0 ] ( 0 ] ) toEqual ( coolSoundFileName ) ;
//等价的a verificação acima:
预计 ( mockPlaySoundFile ) toHaveBeenCalledWith ( coolSoundFileName ) ;
预计 ( mockPlaySoundFile ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;

Simulacao手册#

创建一个人工模拟控件中保存模拟实现__mocks__文件夹中。这允许您指定实现,并且它可以跨测试文件使用。

/ / __mocks__ / sound-player.js
//导入这个命名的导出到你的测试文件:
出口 常量 mockPlaySoundFile = 开玩笑 fn ( ) ;
常量 模拟 = 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : mockPlaySoundFile } ;
} ) ;
出口 默认的 模拟 ;

导入一个simulação e o método simulado comppartilhado por todas as instâncias:

/ / sound-player-consumer.test.js
进口 SoundPlayer , { mockPlaySoundFile } “。/留声机” ;
进口 SoundPlayerConsumer ”。/ sound-player-consumer ' ;
开玩笑 模拟 ( “。/留声机” ) ; // SoundPlayer现在是一个模拟构造函数
beforeEach ( ( ) = > {
// Limpa todas as instâncias e chama o construct e todos os métodos:
SoundPlayer mockClear ( ) ;
mockPlaySoundFile mockClear ( ) ;
} ) ;
( " Nós我们可以验证se o conidor chamou o构造这个类" , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
预计 ( SoundPlayer ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;
( “Nós podemos verificar se o consumidor chamou um método da instância da class” , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
常量 coolSoundFileName = “song.mp3” ;
soundPlayerConsumer playSomethingCool ( ) ;
预计 ( mockPlaySoundFile ) toHaveBeenCalledWith ( coolSoundFileName ) ;
} ) ;

jest.mock ()com o parâmetro de“模块工厂”#

jest.mock(path, moduleFactory)需要一个模块的工厂论点。模块工厂是一个返回模拟的函数。

为了模拟构造函数,模块工厂必须返回一个构造函数。换句话说,模块工厂必须是一个返回一个函数的函数——一个高阶函数(HOF)。

进口 SoundPlayer “。/留声机” ;
常量 mockPlaySoundFile = 开玩笑 fn ( ) ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : mockPlaySoundFile } ;
} ) ;
} ) ;

工厂参数的一个限制是,since调用jest.mock ()被悬挂到文件顶部时,不可能先定义一个变量,然后再在工厂中使用它。以单词“mock”开头的变量会出现异常。由您来保证它们将按时初始化!例如,由于在变量声明中使用了'fake'而不是'mock',下面的语句将抛出一个超出作用域的错误:

//注意:这将失败
进口 SoundPlayer “。/留声机” ;
常量 fakePlaySoundFile = 开玩笑 fn ( ) ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : fakePlaySoundFile } ;
} ) ;
} ) ;

使用以下代码替换mockmockImplementation ()mockImplementationOnce ()#

通过调用,可以替换上述所有模拟以更改单个测试或所有测试的实现mockImplementation ()在现有的mock上。

调用笑话。模拟are hoisted to the top of the code. You can specify a mock later, e.g. inbeforeAll (),通过调用mockImplementation ()(或mockImplementationOnce ()),而不是使用factory参数。这还允许您在需要时更改测试之间的模拟:

进口 SoundPlayer “。/留声机” ;
进口 SoundPlayerConsumer ”。/ sound-player-consumer ' ;
开玩笑 模拟 ( “。/留声机” ) ;
描述 ( "当SoundPlayer抛出错误时" , ( ) = > {
beforeAll ( ( ) = > {
SoundPlayer mockImplementation ( ( ) = > {
返回 {
playSoundFile : ( ) = > {
错误 ( 测试错误的 ) ;
} ,
} ;
} ) ;
} ) ;
( '调用playSomethingCool时应该抛出错误' , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
预计 ( ( ) = > soundPlayerConsumer playSomethingCool ( ) ) toThrow ( ) ;
} ) ;
} ) ;

深入:理解模拟构造函数#

构建构造函数函数mock使用.mockImplementation jest.fn () ()使模拟看起来比实际复杂。本节展示如何创建自己的mock,以说明mock是如何工作的。

手动模拟是另一个ES6类#

类中的被模拟类使用相同的文件名来定义ES6类__mocks__文件夹,它将作为模拟。这个类将被用来代替真正的类。这允许您为类注入测试实现,但不提供监视调用的方法。

对于虚构的示例,模拟可能如下所示:

/ / __mocks__ / sound-player.js
出口 默认的 SoundPlayer {
构造函数 ( ) {
控制台 日志 ( " Mock SoundPlayer:构造函数被调用" ) ;
}
playSoundFile ( ) {
控制台 日志 ( " Mock SoundPlayer: playSoundFile was called " ) ;
}
}

使用模块工厂参数进行模拟#

传递给的模块工厂函数jest.mock(path, moduleFactory)可以是返回函数*的HOF。这将允许调用在模拟。同样,这允许您为测试注入不同的行为,但不提供监视调用的方法。

*模块工厂函数必须返回一个函数#

为了模拟构造函数,模块工厂必须返回一个构造函数。换句话说,模块工厂必须是一个返回一个函数的函数——一个高阶函数(HOF)。

开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 函数 ( ) {
返回 { playSoundFile : ( ) = > { } } ;
} ;
} ) ;

注意:箭头函数不起作用

注意,mock不能是一个箭头函数,因为调用在JavaScript中,箭头函数是不允许的。所以这行不通:

开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 ( ) = > {
//不能工作;箭头函数不能用new调用
返回 { playSoundFile : ( ) = > { } } ;
} ;
} ) ;

这将把_soundPlayer2.default不是构造函数,除非代码被编译为ES5,例如by@babel / preset-env。(ES5没有箭头函数也没有类,所以两者都将被编译为普通函数。)

跟踪使用情况(监视模拟)#

注入一个测试实现是有帮助的,但是您可能还想测试类构造函数和方法是否使用亚搏取款正确的参数调用。

监视建筑工人#

为了跟踪对构造函数的调用,用Jest模拟函数替换HOF返回的函数。创建它jest.fn (),然后用mockImplementation ()

进口 SoundPlayer “。/留声机” ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
//检查构造函数调用
返回 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : ( ) = > { } } ;
} ) ;
} ) ;

这将让我们检查我们的模拟类的使用,使用SoundPlayer.mock.calls:期望(SoundPlayer) .toHaveBeenCalled ();或near-equivalent:期望(SoundPlayer.mock.calls.length) .toEqual (1);

模拟非默认类导出#

如果这个类然后,您需要返回一个与类导出名称相同的键的对象。

进口 { SoundPlayer } “。/留声机” ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
//检查构造函数调用
返回 {
SoundPlayer : 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : ( ) = > { } } ;
} ) ,
} ;
} ) ;

监视我们班的方法#

我们的模拟类将需要提供任何成员函数(playSoundFile在我们的测试过程中会调用的),否则我们将会得到一个调用不存在的函数的错误。但是,我们可能还想监视对这些方法的调用,以确保它们是用预期的参数调用的。

在测试期间每次调用模拟构造函数都会创建一个新对象。为了监视所有这些对象中的方法调用,我们进行了填充playSoundFile使用另一个模拟函数,并在我们的测试文件中存储对该模拟函数的引用,以便在测试期间可用。

进口 SoundPlayer “。/留声机” ;
常量 mockPlaySoundFile = 开玩笑 fn ( ) ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : mockPlaySoundFile } ;
//现在我们可以跟踪playSoundFile的调用
} ) ;
} ) ;

与此类似的手动模拟是:

/ / __mocks__ / sound-player.js
//将这个命名的导出导入到您的测试文件
出口 常量 mockPlaySoundFile = 开玩笑 fn ( ) ;
常量 模拟 = 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : mockPlaySoundFile } ;
} ) ;
出口 默认的 模拟 ;

用法类似于模块工厂函数,只是可以省略from的第二个参数jest.mock (),并且您必须将所模拟的方法导入到您的测试文件中,因为它不再在那里定义了。使用原来的模块路径;不包括__mocks__

测试之间的清理#

要清除对模拟构造函数函数及其方法的调用记录,我们调用mockClear ()beforeEach ()功能:

beforeEach ( ( ) = > {
SoundPlayer mockClear ( ) ;
mockPlaySoundFile mockClear ( ) ;
} ) ;

完整的示例#

下面是一个完整的测试文件,它使用模块工厂参数来jest.mock:

/ / sound-player-consumer.test.js
进口 SoundPlayer “。/留声机” ;
进口 SoundPlayerConsumer ”。/ sound-player-consumer ' ;
常量 mockPlaySoundFile = 开玩笑 fn ( ) ;
开玩笑 模拟 ( “。/留声机” , ( ) = > {
返回 开玩笑 fn ( ) mockImplementation ( ( ) = > {
返回 { playSoundFile : mockPlaySoundFile } ;
} ) ;
} ) ;
beforeEach ( ( ) = > {
SoundPlayer mockClear ( ) ;
mockPlaySoundFile mockClear ( ) ;
} ) ;
( 消费者应该能够在SoundPlayer上调用new() , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
//确保构造函数创建对象:
预计 ( soundPlayerConsumer ) toBeTruthy ( ) ;
} ) ;
( 我们可以检查消费者是否调用了类构造函数 , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
预计 ( SoundPlayer ) toHaveBeenCalledTimes ( 1 ) ;
} ) ;
( 我们可以检查消费者是否在类实例上调用了方法 , ( ) = > {
常量 soundPlayerConsumer = SoundPlayerConsumer ( ) ;
常量 coolSoundFileName = “song.mp3” ;
soundPlayerConsumer playSomethingCool ( ) ;
预计 ( mockPlaySoundFile 模拟 调用 ( 0 ] ( 0 ] ) toEqual ( coolSoundFileName ) ;
} ) ;