前言
如果你认为单元测试会降低开发效率，那么它做的事就是让你的开发效率少降低一点；如果你认为单元测试可以提高开发效率，那么恭喜你，它会是一份宝藏。
这是一篇涵盖了大部分场景下需要用到的单元测试方法介绍，不管你是新手还是老鸟，都建议读读看。
本文并不会去传导单元测试的重要性之类的思想，这不是本文的重点，本文只说明如何写单元测试案例 我们以SpringBoot构建一个简单的demo
引入依赖：
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-test
test
命名规范
测试类的命名一般要以Test为后缀，例如：XxxTest
测试方法的命名一般要以test为前缀，例如：testXxx
注意：如果你的类名不是XxxTest，那么你在执行类似
maven test命令时，是不会自动测试这个类的。
这个规范是在
maven-surefire-plugin插件中约定的，你也可以自定义的设置你自己的命名规范，但是不建议这样做。
简单测试简单测试只需在测试方法上加上
Test注解即可适用场景：测试一些工具类，验证心中所想(比如忘了正则怎么写了)
新建测试类： HelloTest, 测试方法：testHello
import org.junit.jupiter.api.Test;
public class HelloTest {@Test
public void testHello(){
System.out.println("Hello World!");
}
}接下来只需轻轻点击测试按钮
文章图片
1、运行整个测试类，测试类中所有的测试方法(加了Test注解的)
2、运行这个测试方法(点开运行方式的界面)
3、直接运行这个测试方法
4、以debug的方式运行这个测试方法
5、以测试覆盖率的方式运行这个测试方法
一般是点3、4这两个效果：
文章图片
关于断言
断言的意思就是：... 断言！
有时候我们测试了某个方法，在当时我们知道结果是正确的，但是很可能过了几天：咦，这代码是我写的？
所以加个断言就很有必要了，它能让我们知道：只要测试结果通过了断言，那么就是这个被测试的方法就是正确的。如果没有通过，那就需要好好检查一下代码了！
那么断言应该怎么写呢？
import org.hamcrest.CoreMatchers;
import org.hamcrest.MatcherAssert;
import org.junit.jupiter.api.Test;
public class HelloTest {@Test
public void testAssert(){
int a = 1, b =2 ;
// 断言
MatcherAssert.assertThat(a + b, CoreMatchers.is(3));
}
}第一个参数是实际测试的结果，第二个是match函数，里面放的是期望值业务测试
你也可以用junit的Assert方法，我比较喜欢上面的
所谓业务测试就是测试你的业务代码，这种情况下，我们就需要用Spring环境了。
新建接口: FooService
public interface FooService {String hello();
}实现类：FooServiceImpl
@Service
public class FooServiceImpl implements FooService {@Override
public String hello() {
System.out.println("foo hello");
return "foo hello";
}
}测试类：FooTest
@SpringBootTest
public class FooServiceTest {@Autowired
private FooService fooService;
@Test
public void testHello(){
String hello = fooService.hello();
MatcherAssert.assertThat(hello, CoreMatchers.is("foo hello"));
}
}注意：如果你的Test注解是junit4的：
org.junit.Test，那么还需要在类上再加一个注解：@RunWith(SpringRunner.class)数据测试
基本上每一个业务代码都离不开数据库，那么在做数据测试时，就离不开两个问题：
1、初始数据从哪里来(比如在做查询测试时)
2、测试产生的数据如何清除(比如在做新增测试时)
问题1：我们可以在测试方法上增加
@Sql注解用于初始化数据问题2：我们可以在测试方法上增加
@Transactional和@Rollback注解用于测试完毕自动回滚案例：
假设我们要测试查询逻辑，首先我们在
test/resourcs下新建sql目录，用于存放初始化数据sql接着在sql目录中新建
test_foo_select.sql文件insert into user (`name`) values ('张三');
新建测试方法：
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.transaction.annotation.Transactional;
@SpringBootTest
public class FooServiceTest {@Autowired
private FooService fooService;
@Transactional
@Rollback
@Sql(value = "https://www.it610.com/sql/test_foo_select.sql")
@Test
public void testSelect(){
// 假设该方法中调用了数据库
User user = fooService.selectUser("张三");
MatcherAssert.assertThat(user.getName(), CoreMatchers.is("张三"));
}}@Transactional和@Rollback注解是为了回滚初始化的测试数据假设要测试修改数据逻辑
@Rollback
@Transactional
@Test
public void testInsert(){
fooService.insertUser(new User("李四"));
}通常来说，不管测试任何业务都需加上Rollback和Transactional注解Before与After注解
如果在你的单元测试类中，所有方法都依赖于一份初始化数据文件，那么你还可以这样写
@Sql(value = "https://www.it610.com/sql/test_foo_select.sql")
@BeforeEach
public void init(){
// 这里可以写每个单元测试前需要做的事情
}如果你用的是juint4, 那么使用的便是Before注解同样，还有
AfterEach与After注解，使用方式相同，这里就不再赘述。接口测试 以上测试是在测试业务层逻辑，有时候我们还需要测试接口层逻辑，比如说参数校验
新增测试接口：
@RequestMapping("/foo")
@RestController
public class FooController {@GetMapping
public User getUser(String name){
return new User(name);
}
}新增测试类：
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
@AutoConfigureMockMvc
@SpringBootTest
public class FooControllerTest {@Autowired
private MockMvc mockMvc;
@Test
public void testGet() throws Exception {
// 构建请求
MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/foo?name=张三");
// 发起请求
ResultActions resultActions = mockMvc.perform(builder);
// 获取结果
MockHttpServletResponse response = resultActions.andReturn().getResponse();
response.setCharacterEncoding("UTF-8");
// 断言http响应状态码是否为2xx
resultActions.andExpect(MockMvcResultMatchers.status().is2xxSuccessful());
// 获取响应数据
String result = response.getContentAsString();
User user = JSON.parseObject(result, User.class);
MatcherAssert.assertThat(user.getName(), CoreMatchers.is("张三"));
}}测试接口虽然看起来很复杂，但是里面大多是样板代码，在实际开发中，可以将这些样板代码封装到工具中
比如测试post请求时，代码同样如此
@Test
public void testPost() throws Exception {
// 构建请求, 这里是唯一的变化，将get改为了post
MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.post("/foo");
// 发起请求
ResultActions resultActions = mockMvc.perform(builder);
// 获取结果
MockHttpServletResponse response = resultActions.andReturn().getResponse();
response.setCharacterEncoding("UTF-8");
// 断言http响应状态码是否为2xx
resultActions.andExpect(MockMvcResultMatchers.status().is2xxSuccessful());
// 获取响应数据
String result = response.getContentAsString();
MatcherAssert.assertThat(result, CoreMatchers.is("true"));
}MockMvcRequestBuilders里面有很多方法，这里给出常用的几个// post请求
MockMvcRequestBuilders.post("/foo")
// 请求参数
.queryParam("key", "value")
// header
.header("token", "123456")
.accept(MediaType.APPLICATION_JSON)
.contentType(MediaType.APPLICATION_JSON)
// 请求body
.content(JSON.toJSONString(new User("张三")))Mock测试 在如今分布式、微服务越来越火的情况下，一个系统总是不可避免的会与其他系统交互，但是在测试时，我们是不希望发生这种情况的，因为这样就需要依赖外部环境了。
单元测试的准则便是：能够独立运行。
此时，学会mock测试就是一件非常有必要的事情。
关于Mockito
在
spring-boot-test中，自带一个叫Mockito的工具，它能够帮助我们对不想调用的方法进行拦截，并且返回我们期望的结果比如有一个FooService调用BarService的场景
文章图片
当我们在测试时不想要真正调用barService，那么我们就可以使用Mockito进行拦截
文章图片
基本Mock
新增BarService
public interface BarService {String mock();
}@Service
public class BarServiceImpl implements BarService {@Override
public String mock() {
System.out.println("bar mock");
return "bar mock";
}
}在FooService中添加mock方法
@Override
public String mock() {
System.out.println("foo mock");
return barService.mock();
}【一文详尽单元测试】使用mocktio测试
import org.mockito.Mockito;
import org.springframework.boot.test.mock.mockito.MockBean;
@SpringBootTest
public class FooServiceTest {@Autowired
private FooService fooService;
// 使用MockBean注解注入barService
@MockBean
private BarService barService;
@Test
public void testMock(){
// 当调用barService.mock方法是返回it's mock
Mockito.doReturn("it's mock").when(barService).mock();
String mock = fooService.mock();
MatcherAssert.assertThat(mock, CoreMatchers.is("it's mock"));
}}使用参数控制mock
可能有时候会有这种奇怪的需求，当参数为1时使用mock，当参数为其他调用真实方法
@Test
public void testMockHasParam(){
// 当参数为1时生效
Mockito.doReturn("it's mock").when(barService).mock(Mockito.eq(1));
String mock = fooService.mock(1);
MatcherAssert.assertThat(mock, CoreMatchers.is("it's mock"));
}如果你觉得任何参数都应该使用mock，那你可以在参数上写：Mockito.any()Mockito中还有很多类似的方法，如果你觉得还不满足，mockito允许你自定义规则
@Test
public void testMockHasParam2() {
// 当参数为1时生效
Mockito.doReturn("it's mock")
.when(barService)
.mock(Mockito.intThat(arg -> {
// 这里写你的逻辑
return arg.equals(1);
}));
String mock = fooService.mock(1);
MatcherAssert.assertThat(mock, CoreMatchers.is("it's mock"));
}注意：虽然以上案例看起来像：当参数不为1时就调用真实方法，但实际上并不是的，因为barService实际上是Mockito生成的代理类，仅仅是个代理类，它并未持有真正的barService, 所以当不满足mock逻辑时，它永远都是返回null
那么该如何解决这个问题呢？
部分方法Mock
参数控制mock与部分方法mock的场景是共通的：在特定的情况下需要调用真实方法
改动方式特别简单：将原来的@MockBean注解替换为@SpyBean
SpyBean注解是真正的将Spring容器中的BarService进行代理，而不是简单的仅仅生成代理类，所以它具备了真正调用方法的能力比如我们在FooService中新增方法：partMock
public String partMock() {
barService.hello();
return barService.mock();
}现在我们期望在
barService.hello()调用实际方法，调用barService.mock()时被mockito拦截import org.springframework.boot.test.mock.mockito.SpyBean;
@SpringBootTest
public class FooServiceTest {@Autowired
private FooService fooService;
@SpyBean
private BarService barService;
@Test
public void testPartMock() {
Mockito.doReturn("it's mock").when(barService).mock();
final String mock = fooService.partMock();
MatcherAssert.assertThat(mock, CoreMatchers.is("it's mock"));
}
}你会发现使用方式没有任何的变化静态方法Mock 你可能想问，为什么Mock还要区分是不是静态方法？这是因为静态方法mock是
Mockito所不具备的能力，我们需要另外一个组件来完成：powermock但很可惜的是，
powermock只支持junit4，而且最近的release是在2020年11月2日不管怎样，我们还是应该学习它，让我们在未来能够遇到这种问题时有解决办法
引入依赖：
org.powermock
powermock-module-junit4
2.0.2
test
org.powermock
powermock-api-mockito2
2.0.2
test
新增方法：
@Override
public String powermock() {
return JSON.toJSONString(new User("张三"));
}现在，我们想要拦截
JSON.toJSONString方法，并且期望它返回xxximport org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
// 代理SpringRunner
@PowerMockRunnerDelegate(SpringRunner.class)
// 使用PowerMockRunner
@RunWith(PowerMockRunner.class)
// 延迟加载以下包中的所有类
@PowerMockIgnore(value = https://www.it610.com/article/{"javax.management.*", "javax.net.ssl.*", "javax.net.SocketFactory", "oracle.*"})
@SpringBootTest
// 想要mock的类
@PrepareForTest(JSON.class)
public class PowermockTest {@Autowired
private FooService fooService;
@Test
public void testPowermock(){
// 固定写法
PowerMockito.mockStatic(JSON.class);
// 以下写法与mockito相同
Mockito.when(JSON.toJSONString(Mockito.any())).thenReturn("xxx");
String s = fooService.powermock();
MatcherAssert.assertThat(s, CoreMatchers.is("xxx"));
}
}对于
PowerMockIgnore注解笔者也不是太懂其中的原理，如果你在测试时发现哪个包报错，并且是你看不懂的，那么你就把这个包加到这里面就好了。配置文件的划分 大部分情况下，单元测试时所使用的配置与实际在服务器上运行时所用的配置是相同的，那么我们就可以单独在
test/resources包下放入测试所用配置。注意：测试包下的配置文件与
main/resources下的配置文件是替换的关系比如测试包下有一个
application.yaml文件，里面的配置为:abc: xxxmain/resources下也有一个application.yaml文件，里面的配置为:def: xxx实际运行时并非像往常一样是合并所有配置，而是只存在
abc: xxx利用这样的方法，我们可以在单元测试时指定我们需要的环境，比如在微服务系统中单元测试时不需要连接注册中心，那么我们就可以在配置文件中将它关掉。
小结 编写单元测试是一件开头较难的事，对于未接触过单元测试的开发人员来说，可能编写一个接口需要1个小时，但是在编写单元测试的功夫上需要花费2个小时。本文的目的就在于能够让这样的同学快速的学习编写单元测试，让写单元测试也能快乐起来。
希望小伙伴们最终都能达到：单元测试可以提高开发效率
案例地址：https://gitee.com/lzj960515/j...
如果我的文章对你有所帮助，还请帮忙点赞、关注、转发一下，你的支持就是我更新的动力，非常感谢！
个人博客空间：https://zijiancode.cn
