Mockito单元测试
mockito可以模拟一个真实的对象，如模拟需要连接数据库的对象或者是需要启动spring容器的对象，它并不真正的连接数据库，所以测试时间更快。该模拟出来的对象调用的方法默认情况都是null、0、false。使用方式1.在测试类上加上@RunWith(MockitoJUnitRunner.class)注解，如果是springboot应用用@ExtendWith(MockitoExtension.c
·
Mockito
mockito可以模拟一个真实的对象，如模拟需要连接数据库的对象或者是需要启动spring容器的对象，它并不真正的连接数据库，所以测试时间更快。该模拟出来的对象调用的方法默认情况都是null、0、false。
使用方式：
1.在测试类上加上@RunWith(MockitoJUnitRunner.class)注解，如果是springboot应用用@ExtendWith(MockitoExtension.class)注解。
2.模拟要测试的对象，有多种方式
- 使用mock方法，如ArrayList list = mock(ArrayList.class);
- 对象上加@Mock注解，并使用MockitoAnnotations.openMocks(this);注册，这个方法需要在运行测试函数之前被调用，一般放在@Before中
- @MockBean
验证verify
@DisplayName("MockitoDemo测试类")
@ExtendWith(MockitoExtension.class)
public class MockitoDemo {
ArrayList list;
@Test
public void mockList() {
list = mock(ArrayList.class); //mock该对象
list.get(0); //此时任何方法返回值都为null
verify(list).get(0); //验证该对象方法是否被执行过。此处执行过，成功
}
}verify()方法是验证该mock对象是否执行过某些方法，如果前面的代码中没有执行过，那会报错，并在控制台上输出 Wanted but not invoked错误。
和断言是一样的。
打桩Stub
让mock对象的方法返回某些特定的值，由自己diy，通过when和then设置。
@Test
public void mockList() {
list = mock(ArrayList.class);
//当get(0)时返回hello
when(list.get(0)).thenReturn("hello");
//get(1)时方法抛出异常
when(list.get(1)).thenThrow(new RuntimeException("get any"));
System.out.println(list.get(0)); //hello
System.out.println(list.get(1)); //java.lang.RuntimeException: get any
}-
默认情况下，没有打桩的函数和函数参数组合返回值没有意义，都是返回null类似的值
-
通过mock(Foo.class, new YourOwnAnswer()); 可以改变默认情况，没有打桩的程序自己决定返回值
-
打桩可以被复写(最后的才是最终结果)，但是最好不要
另一种方式：
doReturn(1).when(list).get(0);连续打桩
list = mock(ArrayList.class);
when(list.get(0)).thenReturn(1).thenReturn(2);
//等同于 when(list.get(0)).thenReturn(1,2);
System.out.println(list.get(0)); //1
System.out.println(list.get(0)); //2
System.out.println(list.get(0)); //后续的任然是2-
注意：如果多条打桩动作不在一条语句，那么就是覆盖
回调方式打桩
list = mock(ArrayList.class);
when(list.get(0)).thenAnswer(new Answer<String>() {
@Override
public String answer(InvocationOnMock invocation) throws Throwable {
Object[] arguments = invocation.getArguments();
Method method = invocation.getMethod();
//invocation.callRealMethod();
Object mock = invocation.getMock();
return "diy 调用方法";
}
});
list.get(0);//diy 调用方法- 通过thenAnswer方法，参数是自己实现的Answer类，这种方式和Proxy动态代理使用方式类似
另外还有：doNothing()、doCallRealMethod()
参数匹配器matchers
@ExtendWith(MockitoExtension.class)
public class MockitoDemo {
ArrayList list;
@Test
public void mockList() {
list = mock(ArrayList.class);
//可以使用内置的any()、anyInt()等匹配器，代表所有值、所有整数
when(list.get(anyInt())).thenReturn("get method");
//可以使用自定义的参数匹配器
when(list.contains(argThat(new MyMatcher()))).thenReturn(true);
System.out.println(list.get(999)); //get method
System.out.println(list.contains(998)); //true
System.out.println(list.contains(999)); //false
//验证是否调用过get函数。这里的anyInt()就是一个参数匹配器。
verify(list).get(anyInt());
}
}
//自定义参数匹配器类
class MyMatcher implements ArgumentMatcher<Integer> {
@Override
public boolean matches(Integer v) {
//表示所有的偶数
return v % 2 == 0;
}
}注意：如果你使用了参数匹配器, 那么所有参数都要用匹配器。
verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));
// 上述代码是正确的,因为eq()也是一个参数匹配器验证续
验证次数
verify()方法实则需要指定对应的方法被执行了多少次，默认是1次。
list = mock(ArrayList.class);
list.add(1);
list.add(2);list.add(2);
list.add(3);list.add(3);list.add(3);
verify(list,times(1)).add(1); //等于verify(list).add(1)
verify(list,times(2)).add(2); //表示add(2)需要执行正好2次
verify(list,times(3)).add(3);
verify(list,atLeast(2)).add(3); //最少执行2次
verify(list,atMost(2)).add(1); //最多执行2次
verify(list,never()).add(999); //违背执行过验证执行顺序
用于限制mock对象的执行顺序
list = mock(ArrayList.class);
list.get(0);
list.get(1);
//1.为该mock对象创建inorder验证器
InOrder inOrder = inOrder(list);
//2.以你想要的顺序执行验证,顺序一致就验证成功
inOrder.verify(list).get(0);
inOrder.verify(list).get(1);
//Verification in order failure ，验证失败
//inOrder.verify(list).get(1);
//inOrder.verify(list).get(0);上例是单个对象方法的执行顺序，也可以限制多个mock对象：
list1 = mock(ArrayList.class);
list2 = mock(ArrayList.class);
list1.get(0);
list2.get(1);
//1.为这两个mock对象创建inorder验证器
InOrder inOrder = inOrder(list1, list2);
//2.验证通过
inOrder.verify(list1).get(0);
inOrder.verify(list2).get(1);带超时的验证
验证的超时时间，验证时间太长了就立即失败
verify(mock, timeout(500).times(1)).method();spy监控
用于创建spy间谍，去监控真实对象，使用spy对象时会调用真实的方法，但是也可以给spy对象的方法打桩。其实就是真实对象和mock对象的中间形式。
LinkedList<String> linkedList = new LinkedList<>();
LinkedList<String> spy = spy(linkedList); //创建spy对象
doReturn(100).when(spy).size(); //给某些方法打桩
spy.add("one");
spy.add("two");
System.out.println(spy); //[one, two]
System.out.println(spy.size()); //100
verify(spy).add("one"); //验证通过- 注意真实对象还是不变的，变的只是spy对象。
- 和@Mock类似，还可以用@Spy注解。
ArgumentCaptor
前面的验证大部分是验证方法调用这一过程，如果要验证方法调用时使用的参数就需要用ArgumentCaptor。
ArrayList<String> list = mock(ArrayList.class);
//mock对象调用两次add方法，注意参数
list.add("zhangsan");
list.add("lisi");
//创建ArgumentCaptor对象，String泛型是需要捕捉的方法的参数类型
ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
//调用verify并且捕捉list.add调用的所有参数。需要注意防止验证失败
verify(list,atLeast(0)).add(argumentCaptor.capture());
//断言，argumentCaptor.getValue()返回最后一次方法调用的参数
Assertions.assertEquals("lisi", argumentCaptor.getValue());
//argumentCaptor.getAllValues()返回所有参数值
Assertions.assertArrayEquals(new Object[]{"zhangsan","lisi"},
argumentCaptor.getAllValues().toArray());使用上面的自定义参数匹配器Argument Matcher也可以实现参数的验证，使用ArgumentCaptor在以下的情况下更合适 :
- 自定义不能被重用的参数匹配器
- 你仅需要断言参数值
打桩时用自定义参数匹配器更好。
行为驱动开发
采用given->when->that的顺序编写单元测试
自动实例化
@InjectMocks注解和@Mock配合使用，用于有依赖关系的模拟对象
@Data
public class UserInfo {
private String name;
private String password;
public UserInfo(String name, String password) {
this.name = name;
this.password = password;
}
}@Service
public class UserInfoService {
@Autowired
private UserInfoDao userInfoDao;
public void printInfo() {
UserInfo userInfo = userInfoDao.select();
System.out.println(userInfo);
}
}
public interface UserInfoDao {
UserInfo select();
}如果我要测试这个service，并且不想和数据库有交互，那么可以创建一个UserInfoDao mock对象。被测试类标注为@InjectMocks时，会自动实例化，并且把@Mock或者@Spy标注过的依赖注入进去。
@ExtendWith(MockitoExtension.class)
public class UserInfoServiceTest {
@InjectMocks
private UserInfoService userInfoService;
@Mock
private UserInfoDao userInfoDao;
@Test
public void testPrint() {
UserInfo userInfo = new UserInfo("admin", "123");
when(userInfoDao.select()).thenReturn(userInfo);
userInfoService.printInfo();
}
}springboot测试
1.controller
mockito提供了MockMvc类，用于模拟web环境，发送请求到controller。
-
MockMvcBuilders.* 初始化web环境，有两种初始化方式
- MockMvcBuilders.standaloneSetup(hrjtCcsDealController).build() 针对单个controller进行构造环境
- MockMvcBuilders.webAppContextSetup(webAppContext).build() 针对整个web环境进行构造
- MockMvcRequestBuilders.* 构造请求：有get、post……
- MockMvcResultMatchers.*：搭配ResultActions接口的andExpect()方法来匹配期望的结果。MockMvcResultMatchers.status()方法返回常用的结果判断
- MockMvcResultHandlers.*：搭配ResultActions接口的andDo()方法对结果进行处理。MockMvcResultHandlers.print()方法返回常用的结果判断
注意：目前单个类容器还无法识别swagger对参数的校验注解。
@DisplayName("StudentController的测试")
@LunaFrameworkTest(classes = {BizTestConfig.class})
public class StudentControllerTest {
public MockMvc mockMvc;
@InjectMocks
public StudentController studentController;
@Mock
public StudentService studentService;
@Before
public void before() {
MockitoAnnotations.openMocks(this);
//构建MockMvc
mockMvc = MockMvcBuilders.standaloneSetup(studentController).build();
}
@Test
public void t1() throws Exception {
StudentPO studentPO = getStudent();
//任何情况都返回0
Mockito.when(studentService.create(any())).thenReturn(0);
//覆盖上一条语句，如果pojo校验正确，返回1
Mockito.when(studentService.create(argThat(new StudentVerfiy()))).thenReturn(1);
//发送create请求
mockMvc.perform(MockMvcRequestBuilders.post("/student/create")
//设置request请求的内容
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(asJson(studentPO))
.accept(MediaType.APPLICATION_JSON_UTF8)
)
//校验response是否为200，插入成功才是200
.andExpect(status().isOk())
//.andExpect(content().json("xxx"))
//打印
.andDo(print());
}
public StudentPO getStudent() {
StudentPO studentPO = new StudentPO();
studentPO.setUrid(UuidUtils.generateUuid());
studentPO.setAge(20);
studentPO.setName("马大哈");
studentPO.setClassid("2");
studentPO.setSex("男");
studentPO.setTenantid(20L);
studentPO.setHeight(169.2f);
return studentPO;
}
public String asJson(Object o) {
ObjectMapper objectMapper = new ObjectMapper();
String s;
try {
s = objectMapper.writeValueAsString(o);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
return s;
}
}
//自定义的校验器
class StudentVerfiy implements ArgumentMatcher<StudentPO> {
@Override
public boolean matches(StudentPO argument) {
//写校验逻辑
if (argument.getAge() > 150 || argument.getAge() < 0)
return false;
if (!argument.getSex().equals("男") && !argument.getSex().equals("女"))
return false;
return true;
}
}- .perform() : 执行一个MockMvcRequestBuilders的请求；MockMvcRequestBuilders有.get()、.post()、.put()、.delete()等请求。
- .andDo() : 添加一个MockMvcResultHandlers结果处理器，可以用于打印结果输出(MockMvcResultHandlers.print())。
- .andExpect : 添加MockMvcResultMatchers验证规则，验证执行结果是否正确。
2.service层
采用懒加载类的方式，只针对当前使用的service进行bean注入。当前service中涉及到的DaoManager和Client都要mock。
@DisplayName("StudentService的测试")
@LunaFrameworkTest(classes = {BizTestConfig.class, AbstractDaoTestConfig.class})
public class StudentServiceTest {
@InjectMocks //接口需要手动初始化
private StudentService studentService = new StudentServiceImpl();
@Mock
private StudentMapper studentMapper;
@Test
public void t1() {
Mockito.when(studentMapper.insert(any())).thenReturn(0);
Mockito.when(studentMapper.insert(argThat(new StudentVerfiy()))).thenReturn(1);
int res = studentService.create(getStudent());
Assertions.assertEquals(1, res);
}
@Before
public void start() {
MockitoAnnotations.openMocks(this);
}
}补充：@ParameterizedTest+@MethodSource获取数据
中文文档：
为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。
更多推荐
2
0- 0
已为社区贡献5条内容
所有评论(0)