Junit Mockito实现单元测试方法介绍

相信做过开发的同学，都多多少少写过下面的代码，很长一段时间我一直以为这就是单元测试...

1. @SpringBootTest 
2. @RunWith(SpringRunner.class) 
3. public class UnitTest1 { 
4. @Autowired 
5. private UnitService unitService; 
6. @Test 
7. public void test() { 
8. System.out.println("----------------------"); 
9. System.out.println(unitService.sayHello()); 
10. System.out.println("----------------------"); 
11. } 
12. } 

但这是单元测试嘛？unitService 中可能还依赖了 Dao 的操作；如果是微服务，可能还要起注册中心。那么这个“单元”也太大了吧！如果把它称为集成测试，可能更恰当一点，那么有没有可能最小粒度进行单元测试嘛？

单元测试应该是一个带有隔离性的功能测试。在单元测试中，应尽量避免其他类或系统的副作用影响。

单元测试的目标是一小段代码，例如方法或类。方法或类的外部依赖关系应从单元测试中移除，而改为测试框架创建的 mock 对象来替换依赖对象。

单元测试一般由开发人员编写，通过验证或断言目标的一些行为或状态来达到测试的目的。

JUnit 框架

JUnit 是一个测试框架，它使用注解来标识测试方法。JUnit 是 Github 上托管的一个开源项目。

一个 JUnit 测试指的是一个包含在测试类中的方法，要定义某个方法为测试方法，请使用 @Test 注解标注该方法。该方法执行被测代码，可以使用 JUnit 或另一个 Assert 框架提供的 assert 方法来检查预期结果与实际结果是否一致，这些方法调用通常称为断言或断言语句。

public class UnitTest2 {
@Test
public void test() {
String sayHello = "Hello World";
Assert.assertEquals("Hello World", sayHello);
}
}

以下是一些常用的 JUnit 注解：

以下是一些常用的 Assert 断言：

三、Mockito 框架

从上面的介绍我们可以认识到，如何减少对外部的依赖才是实践单元测试的关键。而这正是Mockito的使命，Mockito 是一个流行的 mock 框架，可以与 JUnit 结合使用，Mockito 允许我们创建和配置 mock 对象，使用 Mockito 将大大简化了具有外部依赖项的类的测试开发。spring-boot-starter-test 中默认集成了 Mockito，不需要额外引入。

在测试中使用 Mockito，通常会：

mock 外部依赖关系并将 mock 对象插入待测代码执行被测代码验证代码是否正确执行

1 使用 Mockito 创建 mock 对象

Mockito 提供了几种创建 mock 对象的方法：

使用静态 mock() 方法使用 @Mock 注解

如果使用 @Mock 注解，则必须触发创建带有 @Mock 注解的对象。使用 MockitoRule 可以做到，它通过调用静态方法 MockitoAnnotations.initMocks(this) 来填充带 @Mock 注解的字段。或者可以使用 @RunWith(MockitoJUnitRunner.class)。

1. public class UnitTest3 { 
2. // 触发创建带有 @Mock 注解的对象 
3. @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); 
4. // 1. 使用 @Mock 注解创建 mock 对象 
5. @Mock private UnitDao unitDao; 
6. @Test 
7. public void test() { 
8. // 2. 使用静态 mock() 方法创建 mock 对象 
9. Iterator iterator = mock(Iterator.class); 
10. // when...thenReturn / doReturn...when 模拟依赖调用 
11. when(iterator.next()).thenReturn("hello"); 
12. doReturn(1).when(unitDao).delete(anyLong()); 
13. // 断言 
14. Assert.assertEquals("hello", iterator.next()); 
15. Assert.assertEquals(new Integer(1), unitDao.delete(1L)); 
16. } 
17. } 

2 使用 mock 对象实践单元测试

我们要单元测试的内容，常常包含着对数据库的访问等等，那么我们要如何 mock 掉这部分调用呢？我们可以使用 @InjectMocks 注解创建实例并使用 mock 对象进行依赖注入。

1. @Service 
2. public class UnitServiceImpl implements UnitService { 
3. @Autowired 
4. private UnitDao unitDao; 
5. @Override 
6. public String sayHello() { 
7. Integer delete = unitDao.delete(1L); 
8. System.out.println(delete); 
9. return "hello unit"; 
10. } 
11. } 
12. @RunWith(MockitoJUnitRunner.class) 
13. public class UnitTest2 { 
14. @Mock 
15. private UnitDao unitDao; 
16. @InjectMocks 
17. private UnitServiceImpl unitService; 
18. @Test 
19. public void unitTest() { 
20. // mock 调用 
21. when(unitDao.delete(anyLong())).thenReturn(1); 
22. Assert.assertEquals("hello unit", unitService.sayHello()); 
23. } 
24. } 

Mockito 还有很多有趣的实践，比如：@Spy或spy()方法、verify()验证等等，鉴于篇幅原因，读者可自行挖掘。

3 使用 PowerMock mock 静态方法。

Mockito 也有一些局限性。例如：不能 mock 静态方法和私有方法。这个时候我们就要用到 PowerMock，PowerMock 支持 JUnit 和 TestNG，扩展了 EasyMock 和 Mockito 框架，增加了mock static、final 方法的功能。

首先需要引入 PowerMock 的依赖：

1. <!-- PowerMock --> 
2. <dependency> 
3. <groupId>org.powermock</groupId> 
4. <artifactId>powermock-module-junit4</artifactId> 
5. <version>2.0.7</version> 
6. <scope>test</scope> 
7. </dependency> 
8. <dependency> 
9. <groupId>org.powermock</groupId> 
10. <artifactId>powermock-api-mockito2</artifactId> 
11. <version>2.0.7</version> 
12. </dependency> 

接下来就能愉快的 mock 静态方法了。

1. @RunWith(PowerMockRunner.class) 
2. @PrepareForTest({StringUtils.class}) 
3. public class UnitTest4 { 
4. @Test 
5. public void test() { 
6. mockStatic(StringUtils.class); 
7. when(StringUtils.getFilename(anyString())).thenReturn("localhost"); 
8. Assert.assertEquals("localhost", StringUtils.getFilename("")); 
9. } 
10. }