spring-boot-单元测试
pom依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.3.1</version>
</dependency>
快捷键
ctrl + shift + t
service层 测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class LearnServiceTest {
@Autowired
private LearnService learnService;
@Test
public void getLearn() {
LearnResource learnResource = learnService.selectByKey(1001L);
Assert.assertThat(learnResource.getAuthor(), is("嘟嘟MD独立博客"));
}
/**
* 这样测试完数据就会回滚了，不会造成垃圾数据
* <p>
*
* @Transactional :单元个测试的时候如果不想造成垃圾数据，可以开启事物功能，记在方法或者类头部添加
* <p>
* @Rollback(false): @Rollback 表示事务执行完回滚，支持传入一个参数value，默认true 即回滚，false不回滚。
*/
@Test
@Transactional
// @Rollback(false)
public void add() {
LearnResource bean = new LearnResource();
bean.setAuthor("测试回滚");
bean.setTitle("回滚用例");
bean.setUrl("http://tengj.top");
learnService.save(bean);
}
}
controller 测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class LearnControllerTest {
@Autowired
private WebApplicationContext wac;
private MockMvc mvc;
private MockHttpSession session;
@Before
public void setupMockMvc() {
//初始化MockMvc对象
mvc = MockMvcBuilders.webAppContextSetup(wac).build();
//构建session
session = new MockHttpSession();
User user = new User("root", "root");
//拦截器那边会判断用户是否登录，所以这里注入一个用户
session.setAttribute("user", user);
}
/**
* 新增教程测试用例
* <p>
* post 请求
*
* @throws Exception
*/
@Test
public void addLearn() throws Exception {
// 手动写 json
//String json = "{\"author\":\"HAHAHAA\",\"title\":\"Spring\",\"url\":\"http://tengj.top/\"}";
// 前端传递的 json 格式，对象 转 json
LearnResource learnResource = new LearnResource();
learnResource.setAuthor("HAHAHAAs");
learnResource.setTitle("Spring");
learnResource.setUrl("http://tengj.top/");
Gson gson = new Gson();
String json = gson.toJson(learnResource);
//mockMvc.perform执行一个请求
//MockMvcRequestBuilders构造一个请求
mvc.perform(MockMvcRequestBuilders.post("/learn/add")
//发送的数据格式
.accept(MediaType.APPLICATION_JSON_UTF8)
//传json参数 通过 @RequestBody注解 接受的参数
.content(json.getBytes())
// 注入一个session
.session(session)
)
//andExpect添加执行完成后的断言
.andExpect(MockMvcResultMatchers.status().isOk())
//andDo添加一个结果处理器，表示要对结果做点什么事情
.andDo(MockMvcResultHandlers.print());//输出整个响应结果信息
}
/**
* 获取教程测试用例
* <p>
* get 请求
*
* @throws Exception
*/
@Test
public void qryLearn() throws Exception {
mvc.perform(MockMvcRequestBuilders.get("/learn/resource/1001")
.contentType(MediaType.APPLICATION_JSON_UTF8)
.accept(MediaType.APPLICATION_JSON_UTF8)
.session(session)
)
.andExpect(MockMvcResultMatchers.status().isOk())
//jsonPath用来获取author字段比对是否为嘟嘟MD独立博客,不是就测试不通过
.andExpect(MockMvcResultMatchers.jsonPath("$.author").value("嘟嘟MD独立博客"))
.andExpect(MockMvcResultMatchers.jsonPath("$.title").value("Spring Boot干货系列"))
.andDo(MockMvcResultHandlers.print());
}
/**
* get 请求
* @RequestParam 注解接收参数 ,也可以用于无注解修饰的对象接受参数，如果字段名一样，则自动进行赋值
*
* @throws Exception
*
*/
@Test
public void qryLearn() throws Exception {
mvc.perform(MockMvcRequestBuilders.get("/learn/queryLean")
.contentType(MediaType.APPLICATION_JSON_UTF8)
.accept(MediaType.APPLICATION_JSON_UTF8)
.session(session)
.param("id", "1001")
)
.andExpect(MockMvcResultMatchers.status().isOk())
//jsonPath用来获取author字段比对是否为嘟嘟MD独立博客,不是就测试不通过
.andExpect(MockMvcResultMatchers.jsonPath("$.author").value("嘟嘟MD独立博客"))
.andExpect(MockMvcResultMatchers.jsonPath("$.title").value("Spring Boot干货系列"))
.andDo(MockMvcResultHandlers.print());
}
/**
* get 请求
* 对象接收参数，但无注解修饰，字段一样，则赋值
*
* @throws Exception
*/
@Test
public void qryLearn() throws Exception {
LearnResource learnResource = new LearnResource();
learnResource.setId(999L);
learnResource.setAuthor("zhang");
learnResource.setTitle("zhang");
//learnResource.setUrl("http://www.baidu.com");
Map<String, Object> stringObjectMap = objectToMap(learnResource);
String requestParams = stringJoinAt(stringObjectMap);
mvc.perform(MockMvcRequestBuilders.get("/learn/queryLean" + requestParams)
.contentType(MediaType.APPLICATION_JSON_UTF8)
.accept(MediaType.APPLICATION_JSON_UTF8)
.session(session)
)
.andExpect(MockMvcResultMatchers.status().isOk())
//jsonPath用来获取author字段比对是否为嘟嘟MD独立博客,不是就测试不通过
.andExpect(MockMvcResultMatchers.jsonPath("$.author").value("官方SpriongBoot例子"))
.andExpect(MockMvcResultMatchers.jsonPath("$.title").value("官方SpriongBoot例子"))
.andDo(MockMvcResultHandlers.print());
}
/**
* object 转 map ，字段值为 null 的，则添加
*
* @param obj
* @return
*/
public static Map<String, Object> objectToMap(Object obj) {
Map<String, Object> map = new HashMap<>();
Class<?> clazz = obj.getClass();
System.out.println(clazz);
for (Field field : clazz.getDeclaredFields()) {
field.setAccessible(true);
String fieldName = field.getName();
Object value = null;
try {
value = field.get(obj);
if (Objects.isNull(value)) {
continue;
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
map.put(fieldName, value);
}
return map;
}
/**
* map 转为 & 符号进行拼接的 字符串
*
* @param map
* @return
*/
public static String stringJoinAt(Map<String, Object> map) {
StringBuffer content = new StringBuffer();
// 按照key做首字母升序排列
List<String> keys = new ArrayList<String>(map.keySet());
Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
for (int i = 0; i < keys.size(); i++) {
String key = keys.get(i).toString();
String value = map.get(key).toString();
// 空串不参与签名
if (StringUtils.isBlank(value)) {
continue;
}
content.append((i == 0 ? "" : "&") + key + "=" + value);
}
String signSrc = content.toString();
if (signSrc.startsWith("&")) {
signSrc = signSrc.replaceFirst("&", "");
}
return "?" + signSrc;
}
/**
* 修改教程测试用例
*
* @throws Exception
*/
@Test
public void updateLearn() throws Exception {
String json = "{\"author\":\"测试修改\",\"id\":1031,\"title\":\"Spring Boot干货系列\",\"url\":\"http://tengj.top/\"}";
mvc.perform(MockMvcRequestBuilders.post("/learn/update")
.accept(MediaType.APPLICATION_JSON_UTF8)
.content(json.getBytes())//传json参数
.session(session)
)
.andExpect(MockMvcResultMatchers.status().isOk())
.andDo(MockMvcResultHandlers.print());
}
/**
* 删除教程测试用例
*
* @throws Exception
*/
@Test
public void deleteLearn() throws Exception {
String json = "[1031]";
mvc.perform(MockMvcRequestBuilders.post("/learn/delete")
.accept(MediaType.APPLICATION_JSON_UTF8)
.content(json.getBytes())//传json参数数组形式
.session(session)
)
.andExpect(MockMvcResultMatchers.status().isOk())
.andDo(MockMvcResultHandlers.print());
}
}
单元测试事物没有回滚
- 查看MySQL当前默认的存储引擎:
mysql> show variables like '%storage_engine%';
- user表用了什么引擎
mysql> show create table user;
- 将user表修为InnoDB存储引擎
mysql> ALTER TABLE user ENGINE=INNODB;
以下情况，事务也不回滚
使用RANDOM_PORT或DEFINED_PORT这种安排隐式提供了一个真正的servlet环境, 在这种情况下，在服务器上启动的任何事务都不会回滚。
@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@LocalServerPort
private int port;
断言 Assert.assertThat使用
例如：CoreMatchers.equalTo
assertThat( [value], [matcher statement] );
//value 是接下来想要测试的变量值；
//matcher statement 是使用 Hamcrest 匹配符来表达的对前面变量所期望的值的声明
//如果 value 值与 matcher statement 所表达的期望值相符，则测试成功，否则测试失败。
// 想判断某个字符串 s 是否含有子字符串 "developer" 或 "Works" 中间的一个
assertThat(s, anyOf(containsString("developer"), containsString("Works")));
// 匹配符 anyOf 表示任何一个条件满足则成立，类似于逻辑或 "||"， 匹配符 containsString 表示是否含有参数子
// 联合匹配符not和equalTo表示“不等于”
assertThat( something, not( equalTo( "developer" ) ) );
// 联合匹配符not和containsString表示“不包含子字符串”
assertThat( something, not( containsString( "Works" ) ) );
// 联合匹配符anyOf和containsString表示“包含任何一个子字符串”
assertThat(something, anyOf(containsString("developer"), containsString("Works")));
字符相关匹配符
/**
* equalTo匹配符断言被测的testedValue等于expectedValue，
* equalTo可以断言数值之间，字符串之间和对象之间是否相等，相当于Object的equals方法
*/
assertThat(testedValue, equalTo(expectedValue));
/**equalToIgnoringCase匹配符断言被测的字符串testedString
*在忽略大小写的情况下等于expectedString
*/
assertThat(testedString, equalToIgnoringCase(expectedString));
/**equalToIgnoringWhiteSpace匹配符断言被测的字符串testedString
*在忽略头尾的任意个空格的情况下等于expectedString，
*注意：字符串中的空格不能被忽略
*/
assertThat(testedString, equalToIgnoringWhiteSpace(expectedString);
/**containsString匹配符断言被测的字符串testedString包含子字符串subString**/
assertThat(testedString, containsString(subString) );
/**endsWith匹配符断言被测的字符串testedString以子字符串suffix结尾*/
assertThat(testedString, endsWith(suffix));
/**startsWith匹配符断言被测的字符串testedString以子字符串prefix开始*/
assertThat(testedString, startsWith(prefix));
一般匹配符
/**nullValue()匹配符断言被测object的值为null*/
assertThat(object,nullValue());
/**notNullValue()匹配符断言被测object的值不为null*/
assertThat(object,notNullValue());
/**is匹配符断言被测的object等于后面给出匹配表达式*/
assertThat(testedString, is(equalTo(expectedValue)));
/**is匹配符简写应用之一，is(equalTo(x))的简写，断言testedValue等于expectedValue*/
assertThat(testedValue, is(expectedValue));
/**is匹配符简写应用之二，is(instanceOf(SomeClass.class))的简写，
*断言testedObject为Cheddar的实例
*/
assertThat(testedObject, is(Cheddar.class));
/**not匹配符和is匹配符正好相反，断言被测的object不等于后面给出的object*/
assertThat(testedString, not(expectedString));
/**allOf匹配符断言符合所有条件，相当于“与”（&&）*/
assertThat(testedNumber, allOf( greaterThan(8), lessThan(16) ) );
/**anyOf匹配符断言符合条件之一，相当于“或”（||）*/
assertThat(testedNumber, anyOf( greaterThan(16), lessThan(8) ) );
数值相关匹配符
/**closeTo匹配符断言被测的浮点型数testedDouble在20.0¡À0.5范围之内*/
assertThat(testedDouble, closeTo( 20.0, 0.5 ));
/**greaterThan匹配符断言被测的数值testedNumber大于16.0*/
assertThat(testedNumber, greaterThan(16.0));
/** lessThan匹配符断言被测的数值testedNumber小于16.0*/
assertThat(testedNumber, lessThan (16.0));
/** greaterThanOrEqualTo匹配符断言被测的数值testedNumber大于等于16.0*/
assertThat(testedNumber, greaterThanOrEqualTo (16.0));
/** lessThanOrEqualTo匹配符断言被测的testedNumber小于等于16.0*/
assertThat(testedNumber, lessThanOrEqualTo (16.0));
集合相关匹配符
/**hasEntry匹配符断言被测的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项*/
assertThat(mapObject, hasEntry("key", "value" ) );
/**hasItem匹配符表明被测的迭代对象iterableObject含有元素element项则测试通过*/
assertThat(iterableObject, hasItem (element));
/** hasKey匹配符断言被测的Map对象mapObject含有键值“key”*/
assertThat(mapObject, hasKey ("key"));
/** hasValue匹配符断言被测的Map对象mapObject含有元素值value*/
assertThat(mapObject, hasValue(value));
Junit基本注解介绍
@BeforeClass 在所有测试方法前执行一次，一般在其中写上整体初始化的代码
@AfterClass 在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码
@Before 在每个测试方法前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据）
@After 在每个测试方法后执行，在方法执行完成后要做的事情
@Test(timeout = 1000) 测试方法执行超过1000毫秒后算超时，测试将失败
@Test(expected = Exception.class) 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败
@Ignore(“not ready yet”) 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类
@Test 编写一般测试用例
Test注解主要包含有expected属性，可指定所希望抛出的异常类型；也即如果抛出了指定的异常，则该测试被认为成功，否则为失败
@Test(expected = RuntimeException.class)
public void testException() {
ArrayList<Object> objects = new ArrayList<>();
Assert.assertThat(objects, notNullValue());
throw new RuntimeException("查询失败");
}
打包测试
测试套件，包含有一系列的需要测试的类;
我们用一个类，把所有的测试类整理进去，然后直接运行这个类，所有的测试类都会执行
@RunWith(Suite.class)
@Suite.SuiteClasses(LearnServiceTest.class)
public class SuitsTest {
}
MockMvc
@RunWith 在JUnit中有很多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。
assertThat一般与CoreMatchers一同使用
参考：
原文: http://tengj.top/2017/12/28/springboot12/
作者: 嘟嘟MD
作者：痴乙
来源：CSDN
原文：https://blog.csdn.net/fxbin123/article/details/80617754
博客所有内容仅供自已学习和学习过程的记录，如有侵权，请联系我删除！！！
