SpringBoot（13）单元测试

1.单元测试

单元测试(unit test)是为了检验程序的正确性。一个单元可能是单个程序、类、对象、方法 等，它是应用程序的最小可测试部件。
单元测试的必要性如下：

• 预防Bug。
  
• 快速定位Bug。
  
• 提高代码质量，减少耦合。
  
• 减少调试时间。
  
• 减少重构的风险。
  

2.Spring Boot的测试库

Spring Boot提供了 spring-boot-starter-test启动器。通过它，能引入一些有用的测试库， 如下所示。

• Spring Test&Spring Boot Test： Spring Boot提供的应用程序功能集成化测试支持。
  
• Junit： Java应用程序单元测试标准类库。
  
• AssertJ：轻量级的断言类库。
  
• Hamcrest：对象匹配器类库。
  
• Mockito: Java Mock 测试框架。
  
• JsonPath： JSON 操作类库。
  
• JSONassert：用于JSON的断言库。
  

  2.1回归测试框架JUnit

JUnit是对程序代码进行单元测试的Java框架。它用来编写自动化测试工具，降低测试的难度、 减少烦琐性，并有效避免岀现程序错误。
JUnit测试是白盒测试(因为知道测试如何完成功能和完成什么样的功能)。要使用JUnit,则 只需要继承TestCase类。
JUnit提供以下注解。

• @BeforeClass：在所有测试单元前执行一次，一般用来初始化整体的代码。
  
• @AfterClass：在所有测试单元后执行一次，一般用来销毁和释放资源。
  
• @Before：在每个测试单元前执行，一般用来初始化方法。
  
• @After：任每个测试单元后执行，一股用来回滚测试数据。
  
• @Test：辐写测试用例。
  
• @Test(timeout=1000)：对测试单元进行限时。这里的"1000”表示若超过1s则超时， 测试失败。
  
• @Test(expected=Exception.class)：指定测试单元期望得到的异常类。如果执行完成后 没有抛出指定的异常，则测试失败。
  
• @Ignore：执行测试时将忽略掉此方法。如果用于修饰类，则忽略基个类。
  
• @RunWith： 再JUnit中有很多Runner,它们负责调用测试代码。毎个Runner都有特殊功能，应根据需要选择不同的Runner来运行测试代码。
  

  2.2assertThat

  Unit 4.4结合Hamcrest提供了一个新的断言语法 --------- assertThat。使用assertThat的一个断言语句结合Hamcrest提供的匹配符，就可以表达全部的测试思想。
  （1）assertThat的基本语法如下
  assertThat( [value], [matcher statement] )

• value：要测试的变量值。
  
• matcher statement：如果value值与matcher statement所表达的朗望值相符，则测试
  

  成功，否则失败。简单地说，就是“两个值逬行比较”
  （2）一般匹配符
  assertThat(testNumber,allof(greaterThan(5),lessThan(8)))：allOf 表示，所有条件必须都成立，测试才能通过
  assertThat(testNumber,anyOf(greaterThan(5),lessThan(8)))：anyOf 表示，所有 条件只要有一个成立，则测试通过G
  assertThat(testNumber,anything())：anything表示,无论什么条件，结果永远为“true”
  （3）字符串相关匹配符
  assertThat(testNumber,is("buretuzi"))：is 表示，如果前面待测的 testString 等于后面给出的String,则测试通过。
  assertThat(testNumber,not("buretuzi"))： not 表示，如果前面待测的 String 不等于后面给出的String,则测试通过。
  assertThat(testNumber,containsString("buretuzi"))：containsString 表示，如果测试的字符串teststring 子字符串 "buretuzi"  ,则测试通过
  assertThat(testNumber,endWith("zi"))：endsWith 表示，如果测试的字符串 teststring以子字符串 "zi" 结尾，则测试通过。
  assertThat(testNumber,startWith("bu"))：starts With 表示，如果测试的字符串 teststring以子字符串“bu”开始，则测试通过。
  assertThat(testNumber,equalTo("bu"))：equalTo 表示，如果测试的 testValue 等于Value,则测试通过。equalTo可以用来测试数值、字符串和对象。
  assertThat(testNumber,equalToIgnoreCase("bu"))：equalToIgnoringCase 表示， 如果测试的字符串teststring在忽略大小写的情况下等于“bu” ,则测试通过。
  assertThat(testNumber,equalToIgnoreWhiteSpace("bu"))：equalToIgnoring- WhiteSpace表示，如果测试的字符串teststring在忽略头尾的任意一个空格的情况下等于 “bu”，则测试通过。字符串中的空格不能被忽略。
  （4）数值相关匹配符
  assertThat(testDouble,closeTo(1.0,8.8))：closeTo 表示，如果测试的浮点型数 testDouble在1.0 ~8.8之间,则测试通过。
  assertThat(testNumber,greaterThan(2.0))：greaterThan 表示，如果测试的数值 testNumber大于2.0,则测试通过
  assertThat(testNumber,lessThan(35.0)))：lessThan 表示，如果测试的数值 testNumber小于35.0,则测试通过
  assertThat(testNumber,greaterThanOrEqualTo(3.0))：greaterThanOrEqualTo表示，如果测试的数值estNumber大于或等于3.0,则测试通过。
  assertThat(testNumber,lessThanOrEqualTo(3.0))：lessThanOrEqualTo 表示， 如果测试的数值testNumber小于或等于3.0,则测试通过。
  （5）collection相关匹配符
  assertThat(mObject,hasEntry("key","value"))：hasEntry 表示，如果测试的 Map 对象mObject含有一个键值为“key”对应元素值为“value”的Entry项，则测试通过
  assertThat(mObject,hasKey("key"))：hasKey 表示，如果测试的 Map 对象 mObject 含有键值“key”，则测试通过。
  assertThat(mObject,hasValue("key"))：hasVafue 表示，如果测试的 Map 对象 mObject含有元素值“value”，则测试通过。
  assertThat(mObject,hasItem("bu"))：hasltem 表示,如果测试的迭代对象 iterableObject含有元素“bu”项，则测试通过。
  2.3.了解 Mockito

  Mockito是GitHub上使用最广泛的Mocking框架。它提供简洁的API用来测试。Mockito简单易学、可读性强、验证语法简洁。
  与JUnit结合使用，Mockito框架可以创建和配置Mock对象。
  2.4了解 JSONPath

  JSONPath是xPath在JSON中的应用。它的数据结构通常不一定有根元素，它用一个抽象的名字来表示最外层对象，而且允许使用通配符“*”表示所有的子元素名和数组素引。
  JSONPath表达式可以使用符号解析JSON,如以下代码：
  $.person.card[0].num
    或使用符号，如以下代码：
  $['person']['card'][0]['num']
  2.5测试的回滚

  在单元测试中可能会产生垃圾数据,可以开启事务功能进行回滚——在方法或类头部添加注解 @Transactional即可。用法见以下代码：
 

1. package com.itheima.repository;
3. import com.itheima.domain.Book;
4. import com.itheima.service.BookService;
5. import org.junit.Test;
6. import org.junit.runner.RunWith;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.boot.test.context.SpringBootTest;
9. import org.springframework.test.context.junit4.SpringRunner;
10. import org.springframework.transaction.annotation.Transactional;
12. @RunWith(SpringRunner.class)
13. @SpringBootTest
14. @Transactional
15. public class CardRepositoryTest {
16.     @Autowired
17.     private BookService bookService;
18.     @Test
19.     public void testRollback() {
20.         Book book = new Book();
21.         book.setUsername("username");
22.         book.setPassword("password");
23.         bookService.insert(book);
24.     }
25. }

复制代码

  上述代码在类上添加了注解@Transactional,测试完成后就会回滚，不会产生垃圾数据。如果要关闭回滚，则只要加上注解@Rollback(false)即可
  2.6快速创建测试单元

  在Spring Boot中进行单元测试很简单，它已经自动添加好了 Test的Starter依赖，见下方依赖元素：

1. <dependency>
2.         <groupId>org.springframework.boot</groupId>
3.         <artifactId>spring-boot-starter-test</artifactId>
4.         <scope>test</scope>
5. </dependency>

复制代码

  创建一个测试类：

1. package com.itheima;
3. import org.junit.Test;
4. import org.junit.runner.RunWith;
5. import org.springframework.test.context.junit4.SpringRunner;
6. @RunWith(SpringRunner.class)
7. public class MyTest {
8.     @Test
9.     public void test() throws Exception {
10.     }
11. }

复制代码

代码解释如下。

• @SpringBootTest:是Spring Boot用于测试的注解，可指定入口类或测试环境等。
  
• @RunWith(SpringRunner.class):让测试运行于 Spring 的测试环境。
  
• @Test：表示为一个测试单元。在要测试的方法上加注解@Test,然后鼠标右击“Run” （或单击其左边的绿色三角箭头）即可进行测试。
  

除用这种方式创建测试单元外，还可以通过IDEA的快捷键快速完成创建。
在IDEA中，快速创建测试单元主要有以下3种方式：

• 通过快捷键Ctrl+Shift+T （在Windows系统中）来创建测试。
  
• 单击菜单栏中的"NavigatoLTest”命令。
  
• 在方法处单击鼠标右键，在弹出的菜单中选择“GoTo-Test"命令。
  

  2.7 Controller层的单元测试

  （1）创建一个用于测试的控制器

1. package com.itheima.controller;
3. import org.springframework.web.bind.annotation.RequestMapping;
4. import org.springframework.web.bind.annotation.RestController;
5. @RestController
6. public class JunitController {
7.     @RequestMapping("/hello")
8.     public String hello(String name){
9.         return "hello " + name;
10.     }
11. }

复制代码

  代码解释如下：

• @RestController：代表这个类是REST风格的控制器，返回JSON/XML类型的数据。
  
• @RequestMapping：用于配置URL和方法之间的映射。可用在类和方法上。用在方法上， 则其路径会继承用在类上的路径。
  

  （2）编写测试

1. package com.itheima;
3. import org.junit.Assert;
4. import org.junit.Before;
5. import org.junit.Test;
6. import org.junit.runner.RunWith;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.boot.test.context.SpringBootTest;
9. import org.springframework.http.MediaType;
10. import org.springframework.test.context.junit4.SpringRunner;
11. import org.springframework.test.web.servlet.MockMvc;
12. import org.springframework.test.web.servlet.MvcResult;
13. import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
14. import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
15. import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
16. import org.springframework.test.web.servlet.setup.MockMvcBuilders;
17. import org.springframework.web.context.WebApplicationContext;
19. @SpringBootTest
20. @RunWith(SpringRunner.class)
21. public class HelloControllerTest {
22.     //启用web上下文
23.     @Autowired
24.     private WebApplicationContext webApplicationContext;
25.     private MockMvc mockMvc;
26.     @Before
27.     public void setUp() throws Exception {
28.         //使用上下文构建MockMvc
29.         mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
30.     }
31.     @Test
32.     public void testHello() throws Exception {
33.         //得到MvcResult自定义验证，执行请求
34.         MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/hello")
35.                 //发送post请求
36.                 .contentType(MediaType.APPLICATION_JSON_UTF8)
37.                 //传入参数
38.                 .param("name","buretuzi")
39.                 //接收的类型
40.                 .accept(MediaType.APPLICATION_JSON_UTF8))
41.                 //判断接收到的状态是否是200，等同于Assert.assertEquals(200, status);
42.                 .andExpect(MockMvcResultMatchers.status().isOk())
43.                 //等同于Assert.assertEquals("hello buretuzi",content);
44.                 .andExpect(MockMvcResultMatchers.content().string("hello buretuzi"))
45.                 .andDo(MockMvcResultHandlers.print())
46.                 //返回MockMvc
47.                 .andReturn();
48.         int status = mvcResult.getResponse().getStatus();
49.         String content = mvcResult.getResponse().getContentAsString();
50.         Assert.assertEquals(200, status);
51.         Assert.assertEquals("hello buretuzi",content);
52.     }
53. }

复制代码

代码解释如下：

• @SpringBootTest：是Spring Boot用于测试的注解，可指定入口类或测试环境等。
  
• @RunWith(SpringRunner.class):让测试运行于 Spring 的测试环境。
  
• @Test：表示一个测试单元。
  
• WebApplicationContext：启用Web上下文，用于获取Bean中的内容。
  
• @Before：表示在测试单元执行前执行。这里使用上下文构建MockMvc
  
• get：指定请求方式是GET。一般用浏览器打开网页就是GET方式。
  

  运行测试，在控制器中会输出以下结果:

1. MockHttpServletRequest:
2.       HTTP Method = GET
3.       Request URI = /hello
4.        Parameters = {name=[buretuzi]}
5.           Headers = [Content-Type:"application/json;charset=UTF-8", Accept:"application/json;charset=UTF-8"]
6.              Body = null
7.     Session Attrs = {}
9. Handler:
10.              Type = com.itheima.controller.JunitController
11.            Method = com.itheima.controller.JunitController#hello(String)
13. Async:
14.     Async started = false
15.      Async result = null
17. Resolved Exception:
18.              Type = null
20. ModelAndView:
21.         View name = null
22.              View = null
23.             Model = null
25. FlashMap:
26.        Attributes = null
28. MockHttpServletResponse:
29.            Status = 200
30.     Error message = null
31.           Headers = [Content-Type:"application/json;charset=UTF-8", Content-Length:"14"]
32.      Content type = application/json;charset=UTF-8
33.              Body = hello buretuzi
34.     Forwarded URL = null
35.    Redirected URL = null
36.           Cookies = []

复制代码

  2.8 Service层的单元测试

  （1）创建实体类

1. package com.itheima.domain;
2. import lombok.AllArgsConstructor;
3. import lombok.Data;
4. import lombok.NoArgsConstructor;
5. @Data
6. @AllArgsConstructor
7. @NoArgsConstructor
8. public class User {
9.     private long id;
10.     private String name;
11.     private int age;
12. }

复制代码

  （2）创建服务类
  这里用@Service来标注服务类，并实例化了一个User对象，见以下代码。

1. package com.itheima.service;
3. import com.itheima.domain.User;
4. import org.springframework.stereotype.Service;
6. @Service
7. public class UserService {
8.     public User getUser(){
9.         User user = new User();
10.         user.setId(1);
11.         user.setAge(13);
12.         user.setName("八嘎");
13.         return user;
14.     }
15. }

复制代码

  （3）编写测试
  编写测试用于比较实例化的实体User和测试预期值是否一样，见以下代码：

1. package com.itheima;
3. import com.itheima.domain.User;
4. import com.itheima.service.UserService;
5. import org.junit.Assert;
6. import org.junit.Test;
7. import org.junit.runner.RunWith;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.boot.test.context.SpringBootTest;
10. import org.springframework.test.context.junit4.SpringRunner;
11. import static org.hamcrest.Matchers.is;
13. @RunWith(SpringRunner.class)
14. @SpringBootTest
15. public class UserServiceTest {
16.     @Autowired
17.     private UserService userService;
18.     @Test
19.     public void getUserinfo() {
20.         User user = userService.getUser();
21.         Assert.assertEquals(13,user.getAge());
22.         Assert.assertThat(user.getName(), is("嘎"));
23.     }
24. }

复制代码

   运行测试，结果显示出错，表示期望的值和实际值不一样，如下所示。
  java.lang.AssertionError:  
  Expected: is "嘎"  
    but: was "八嘎"
  
  2.9 Repository层的单元测试

1. package com.itheima;
3. import com.itheima.domain.Book;
4. import com.itheima.service.BookService;
5. import org.junit.Test;
6. import org.junit.runner.RunWith;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.boot.test.context.SpringBootTest;
9. import org.springframework.test.context.junit4.SpringRunner;
10. import org.springframework.transaction.annotation.Transactional;
12. import java.util.List;
14. @RunWith(SpringRunner.class)
15. @SpringBootTest
16. @Transactional
17. public class BookRepositoryTest {
18.     @Autowired
19.     private BookService bookService;
20.     @Test
21.     public void testQuery(){
22.         List<Book> books = (List<Book>) bookService.findAll();
23.         for (Book book : books) {
24.             System.out.println(book.getUsername());
25.         }
26.     }
27.     @Test
28.     public void testRollback(){
29.         Book book = new Book();
30.         book.setUsername("干净又卫生");
31.         bookService.insert(book);
32.     }
33. }

复制代码

代码解释如下。

• @Transactional：即回滚的意思。所有方法执行完之后，回滚成原来的样子。
  
• testRollBank方法：执行添加一条记录。如果开启了@Transactional,则会在添加之后进行回滚，删除刚添加的数据，如果注释掉@Transactional, 则完成添加后不回滚。在测试时可以尝试去掉和添加@Transactional状态下的不同效果。这里的@Transactional 放在类上，也可以加在方法上以作用于方法。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！