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即可。用法见以下代码：

package com.itheima.repository;

import com.itheima.domain.Book;
import com.itheima.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class CardRepositoryTest {
    @Autowired
    private BookService bookService;
    @Test
    public void testRollback() {
        Book book = new Book();
        book.setUsername(\"username\");
        book.setPassword(\"password\");
        bookService.insert(book);
    }
}

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

  2.6快速创建测试单元

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

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
</dependency>

  创建一个测试类：

package com.itheima;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
public class MyTest {
    @Test
    public void test() throws Exception {
    }
}

代码解释如下。

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

除用这种方式创建测试单元外，还可以通过IDEA的快捷键快速完成创建。

在IDEA中，快速创建测试单元主要有以下3种方式：

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

  2.7 Controller层的单元测试

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

package com.itheima.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class JunitController {
    @RequestMapping(\"/hello\")
    public String hello(String name){
        return \"hello \" + name;
    }
}

  代码解释如下：

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

  （2）编写测试

package com.itheima;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@SpringBootTest
@RunWith(SpringRunner.class)
public class HelloControllerTest {
    //启用web上下文
    @Autowired
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;
    @Before
    public void setUp() throws Exception {
        //使用上下文构建MockMvc
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
    }
    @Test
    public void testHello() throws Exception {
        //得到MvcResult自定义验证，执行请求
        MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get(\"/hello\")
                //发送post请求
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                //传入参数
                .param(\"name\",\"buretuzi\")
                //接收的类型
                .accept(MediaType.APPLICATION_JSON_UTF8))
                //判断接收到的状态是否是200，等同于Assert.assertEquals(200, status);
                .andExpect(MockMvcResultMatchers.status().isOk())
                //等同于Assert.assertEquals(\"hello buretuzi\",content);
                .andExpect(MockMvcResultMatchers.content().string(\"hello buretuzi\"))
                .andDo(MockMvcResultHandlers.print())
                //返回MockMvc
                .andReturn();
        int status = mvcResult.getResponse().getStatus();
        String content = mvcResult.getResponse().getContentAsString();
        Assert.assertEquals(200, status);
        Assert.assertEquals(\"hello buretuzi\",content);
    }
}

代码解释如下：

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

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

MockHttpServletRequest:
      HTTP Method = GET
      Request URI = /hello
       Parameters = {name=[buretuzi]}
          Headers = [Content-Type:\"application/json;charset=UTF-8\", Accept:\"application/json;charset=UTF-8\"]
             Body = null
    Session Attrs = {}

Handler:
             Type = com.itheima.controller.JunitController
           Method = com.itheima.controller.JunitController#hello(String)

Async:
    Async started = false
     Async result = null

Resolved Exception:
             Type = null

ModelAndView:
        View name = null
             View = null
            Model = null

FlashMap:
       Attributes = null

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = [Content-Type:\"application/json;charset=UTF-8\", Content-Length:\"14\"]
     Content type = application/json;charset=UTF-8
             Body = hello buretuzi
    Forwarded URL = null
   Redirected URL = null
          Cookies = []

  2.8 Service层的单元测试

  （1）创建实体类

package com.itheima.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private long id;
    private String name;
    private int age;
}

  （2）创建服务类

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

package com.itheima.service;

import com.itheima.domain.User;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    public User getUser(){
        User user = new User();
        user.setId(1);
        user.setAge(13);
        user.setName(\"八嘎\");
        return user;
    }
}

  （3）编写测试

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

package com.itheima;

import com.itheima.domain.User;
import com.itheima.service.UserService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import static org.hamcrest.Matchers.is;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;
    @Test
    public void getUserinfo() {
        User user = userService.getUser();
        Assert.assertEquals(13,user.getAge());
        Assert.assertThat(user.getName(), is(\"嘎\"));
    }
}

   运行测试，结果显示出错，表示期望的值和实际值不一样，如下所示。

  java.lang.AssertionError:

  Expected: is \"嘎\"

    but: was \"八嘎\"

  <Click to see difference>

  2.9 Repository层的单元测试

package com.itheima;

import com.itheima.domain.Book;
import com.itheima.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class BookRepositoryTest {
    @Autowired
    private BookService bookService;
    @Test
    public void testQuery(){
        List<Book> books = (List<Book>) bookService.findAll();
        for (Book book : books) {
            System.out.println(book.getUsername());
        }
    }
    @Test
    public void testRollback(){
        Book book = new Book();
        book.setUsername(\"干净又卫生\");
        bookService.insert(book);
    }
}

代码解释如下。

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

来源：https://www.cnblogs.com/liwenruo/p/16489193.html
本站部分图文来源于网络，如有侵权请联系删除。