[英]Difference between @Mock and @InjectMocks
Mockito 框架中的@Mock
和@InjectMocks
有什么区别?
@Mock
创建一个模拟。 @InjectMocks
创建类的一个实例,并将使用@Mock
(或@Spy
)注解创建的@Spy
注入到这个实例中。
请注意,您必须使用@RunWith(MockitoJUnitRunner.class)
或Mockito.initMocks(this)
来初始化这些Mockito.initMocks(this)
并注入它们(JUnit 4)。
对于 JUnit 5,您必须使用@ExtendWith(MockitoExtension.class)
。
@RunWith(MockitoJUnitRunner.class) // JUnit 4
// @ExtendWith(MockitoExtension.class) for JUnit 5
public class SomeManagerTest {
@InjectMocks
private SomeManager someManager;
@Mock
private SomeDependency someDependency; // this will be injected into someManager
// tests...
}
这是关于@Mock
和@InjectMocks
如何工作的示例代码。
假设我们有Game
和Player
类。
class Game {
private Player player;
public Game(Player player) {
this.player = player;
}
public String attack() {
return "Player attack with: " + player.getWeapon();
}
}
class Player {
private String weapon;
public Player(String weapon) {
this.weapon = weapon;
}
String getWeapon() {
return weapon;
}
}
如您所见, Game
类需要Player
执行attack
。
@RunWith(MockitoJUnitRunner.class)
class GameTest {
@Mock
Player player;
@InjectMocks
Game game;
@Test
public void attackWithSwordTest() throws Exception {
Mockito.when(player.getWeapon()).thenReturn("Sword");
assertEquals("Player attack with: Sword", game.attack());
}
}
Mockito 将使用when
和thenReturn
方法模拟 Player 类及其行为。 最后,使用@InjectMocks
Mockito 会将那个Player
放入Game
。
请注意,您甚至不必创建new Game
对象。 Mockito 会为你注入它。
// you don't have to do this
Game game = new Game(player);
我们还将使用@Spy
注释获得相同的行为。 即使属性名称不同。
@RunWith(MockitoJUnitRunner.class)
public class GameTest {
@Mock Player player;
@Spy List<String> enemies = new ArrayList<>();
@InjectMocks Game game;
@Test public void attackWithSwordTest() throws Exception {
Mockito.when(player.getWeapon()).thenReturn("Sword");
enemies.add("Dragon");
enemies.add("Orc");
assertEquals(2, game.numberOfEnemies());
assertEquals("Player attack with: Sword", game.attack());
}
}
class Game {
private Player player;
private List<String> opponents;
public Game(Player player, List<String> opponents) {
this.player = player;
this.opponents = opponents;
}
public int numberOfEnemies() {
return opponents.size();
}
// ...
这是因为 Mockito 将检查 Game 类的Type Signature
,即Player
和List<String>
。
在您的测试类中,测试类应使用@InjectMocks
进行注释。 这告诉 Mockito 将模拟注入哪个类:
@InjectMocks
private SomeManager someManager;
从那时起,我们可以指定类中的哪些特定方法或对象,在本例中为SomeManager
,将替换为SomeManager
:
@Mock
private SomeDependency someDependency;
在这个例子中, SomeDependency
类中的SomeManager
将被SomeManager
。
@Mock
注释模拟相关对象。
@InjectMocks
注释允许将@Mock
创建的不同(和相关) @InjectMocks
注入底层对象。
两者是互补的。
例如
@Mock
StudentDao studentDao;
@InjectMocks
StudentService service;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
}
这里我们需要服务类的 DAO 类。 因此,我们模拟它并将其注入到服务类实例中。 同样,在 Spring 框架中,所有@Autowired bean 都可以被 jUnits 中的@Mock模拟,并通过 @InjectMocks 注入到您的 bean 中。
MockitoAnnotations.initMocks(this)
方法初始化这些MockitoAnnotations.initMocks(this)
并为每个测试方法注入它们,因此需要在setUp()
方法中调用它。
Mockito 所基于的“模拟框架”是一个框架,它使您能够创建 Mock 对象(在旧术语中,这些对象可以称为分流器,因为它们用作依赖功能的分流器)换句话说,模拟object 用于模仿您的代码所依赖的真实对象,您可以使用模拟框架创建一个代理对象。 通过在测试中使用模拟对象,您实际上是从正常的单元测试转向集成测试
Mockito 是在 MIT 许可下发布的 Java 开源测试框架,它是一个“模拟框架”,可让您使用干净简单的 API 编写漂亮的测试。 Java 领域中有许多不同的模拟框架,但是基本上有两种主要类型的模拟对象框架,一种是通过代理实现的,另一种是通过类重映射实现的。
像 Spring 这样的依赖注入框架允许你在不修改任何代码的情况下注入你的代理对象,模拟对象期望调用某个方法并返回预期的结果。
@InjectMocks
注释尝试实例化测试对象实例并将用@Mock
或@Spy
注释的字段注入到测试对象的私有字段中。
MockitoAnnotations.initMocks(this)
调用,重置测试对象并重新初始化模拟,所以请记住在@Before
/ @BeforeMethod
注释中使用它。
使用@Tom 提到的方法获得的一个优势是,您不必在 SomeManager 中创建任何构造函数,从而限制客户端对其进行实例化。
@RunWith(MockitoJUnitRunner.class)
public class SomeManagerTest {
@InjectMocks
private SomeManager someManager;
@Mock
private SomeDependency someDependency; // this will be injected into someManager
//You don't need to instantiate the SomeManager with default contructor at all
//SomeManager someManager = new SomeManager();
//Or SomeManager someManager = new SomeManager(someDependency);
//tests...
}
它是否是一种好的做法取决于您的应用程序设计。
@Mock
用于声明/模拟依赖 bean 的引用,而@InjectMocks
用于模拟正在为其创建测试的 bean。
例如:
public class A{
public class B b;
public void doSomething(){
}
}
A
类测试:
public class TestClassA{
@Mocks
public class B b;
@InjectMocks
public class A a;
@Test
public testDoSomething(){
}
}
尽管上面的答案已经涵盖,但我只是尝试添加我认为缺少的细节。 他们背后的原因(The Why)。
插图:
Sample.java
---------------
public class Sample{
DependencyOne dependencyOne;
DependencyTwo dependencyTwo;
public SampleResponse methodOfSample(){
dependencyOne.methodOne();
dependencyTwo.methodTwo();
...
return sampleResponse;
}
}
SampleTest.java
-----------------------
@RunWith(PowerMockRunner.class)
@PrepareForTest({ClassA.class})
public class SampleTest{
@InjectMocks
Sample sample;
@Mock
DependencyOne dependencyOne;
@Mock
DependencyTwo dependencyTwo;
@Before
public void init() {
MockitoAnnotations.initMocks(this);
}
public void sampleMethod1_Test(){
//Arrange the dependencies
DependencyResponse dependencyOneResponse = Mock(sampleResponse.class);
Mockito.doReturn(dependencyOneResponse).when(dependencyOne).methodOne();
DependencyResponse dependencyTwoResponse = Mock(sampleResponse.class);
Mockito.doReturn(dependencyOneResponse).when(dependencyTwo).methodTwo();
//call the method to be tested
SampleResponse sampleResponse = sample.methodOfSample()
//Assert
<assert the SampleResponse here>
}
}
@InjectMocks 注释可用于将模拟字段自动注入测试对象。
在下面的示例中,@InjectMocks 用于将模拟 dataMap 注入到 dataLibrary 中。
@Mock
Map<String, String> dataMap ;
@InjectMocks
DataLibrary dataLibrary = new DataLibrary();
@Test
public void whenUseInjectMocksAnnotation_() {
Mockito.when(dataMap .get("aData")).thenReturn("aMeaning");
assertEquals("aMeaning", dataLibrary .getMeaning("aData"));
}
许多人在这里对@Mock
与@InjectMocks
给出了很好的解释。 我喜欢它,但我认为我们的测试和应用程序应该以不需要使用@InjectMocks
。
进一步阅读示例的参考: https : //tedvinke.wordpress.com/2014/02/13/mockito-why-you-should-not-use-injectmocks-annotation-to-autowire-fields/
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.