关于java:Java单元测试浅析JUnitMockito

作者：京东物流 秦彪

1. 什么是单元测试

（1）单元测试环节：

测试过程依照阶段划分分为：单元测试、集成测试、零碎测试、验收测试等。相干含意如下：

1)       单元测试：针对计算机程序模块进行输入正确性测验工作。

2)       集成测试：在单元测试根底上，整合各个模块组成子系统，进行集成测试。

3)       零碎测试：将整个交付所波及的合作内容都纳入其中思考，蕴含计算机硬件、软件、接口、操作等等一系列作为一个整体，测验是否满足软件或需要阐明。

4)       验收测试：在交付或者公布之前对所做的工作进行测试测验。

单元测试是阶段性测试的首要环节，也是白盒测试的一种，该内容的编写与实际能够前置在研发实现，研发在编写业务代码的时候就须要生成对应代码的单元测试。单元测试的发起人是程序设计者，受益人也是编写程序的人，所以对于程序员，十分有必要造成自我约束力，实现根本的单元测试用例编写。

（2）单元测试特色：

由上可知，单元测试其实是针对软件中最小的测试单元来进行验证的。这里的单元就是指相干的性能子集，比方一个办法、一个类等。值得注意的是作为最低级别的测试流动，单元测试验证的对象仅限于以后测试内容，与程序其它局部内容相隔离，总结起来单元测试有以下特色：

1)       次要性能是证实编写的代码内容与冀望输入统一。

2)       最小最低级的测试内容，由程序员本身发动，保障程序根本组件失常。

3)       单元测试尽量不要区分类与办法，主张以过程性的办法为测试单位，简略实用高效为指标。

4)       不要偏离主题，专一于测试一小块的代码，保障根底性能。

5)       剥离与内部接口、存储之间的依赖，使单元测试可控。

6)       任何工夫任何程序执行单元测试都须要是胜利的。

2. 为什么要单元测试

（1）单元测试意义：

程序代码都是由根本单元一直组合成简单的零碎，底层根本单元都无奈保障输入输出正确性，层级递增时，问题就会一直放大，直到整个零碎解体无奈应用。所以单元测试的意义就在于保障基本功能是失常可用且稳固的。而对于接口、数据源等起因造成的不稳固因素，是外在起因，不在单元测试思考范畴之内。

（2）应用 main 办法进行测试：

@PostMapping(value="/save")
public Map<String,Object> save(@RequestBody Student stu) {studentService.save(stu);
    Map<String,Object> params = new HashMap<>();
    params.put("code",200);
    params.put("message","保留胜利");
    return params;
}

如果要对下面的 Controller 进行测试，能够编写如下的代码示例，应用 main 办法进行测试的时候，先启动整个工程利用，而后编写 main 办法如下进行拜访，在单步调试代码。

public static void main(String[] args) {HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        String json = "{"name":" 张三 ","className":" 三年级一班 ","age":"20","sex":" 男 "}";
        HttpEntity<String> httpEntity = new HttpEntity<>(json, headers);
        String url = "http://localhost:9092/student/save";
        MainMethodTest test = new MainMethodTest();
        ResponseEntity<Map> responseEntity = test.getRestTemplate().postForEntity(url, httpEntity, Map.class);
        System.out.println(responseEntity.getBody());
    }

（3）应用 main 办法进行测试的毛病：

1)       通过编写大量的 main 办法针对每个内容做打印输出到控制台干燥繁琐，不具备优雅性。

2)       测试方法不能一起运行，后果须要程序员本人判断正确性。

3)       对立且重复性工作应该交给工具去实现。

3. 单元测试框架 -JUnit

3.1 JUnit 简介

JUnit 官网：https://junit.org/。JUnit 是一个用于编写可反复测试的简略框架。它是用于单元测试框架的 xUnit 体系结构的一个实例。

JUnit 的特点：

（1）针对于 Java 语言特定设计的单元测试框架，应用十分宽泛。

（2）特定畛域的规范测试框架。

（3）可能在多种 IDE 开发平台应用，蕴含 Idea、Eclipse 中进行集成。

（4）可能不便由 Maven 引入应用。

（5）能够不便的编写单元测试代码，查看测试后果等。

JUnit 的重要概念：

JUnit 的一些注意事项及标准：

（1）测试方法必须应用 @Test 润饰

（2）测试方法必须应用 public void 进行润饰，不能带参数

（3）测试代码的包应该和被测试代码包构造保持一致

（4）测试单元中的每个办法必须能够独立测试，办法间不能有任何依赖

（5）测试类个别应用 Test 作为类名的后缀

（6）测试方法使个别用 test 作为办法名的前缀

JUnit 失败后果阐明：

（1）Failure：测试后果和预期后果不统一导致，示意测试不通过

（2）error：由异样代码引起，它能够产生于测试代码自身的谬误，也能够是被测代码的 Bug

3.2 JUnit 内容

（1）断言的 API

（2）JUnit 罕用注解：

1）@Test: 定义一个测试方法 @Test(excepted=xx.class): xx.class 示意异样类，示意测试的办法抛出此异样时，认为是失常的测试通过的 @Test(timeout = 毫秒数) : 测试方法执行工夫是否合乎预期。

2）@BeforeClass：在所有的办法执行前被执行，static 办法全局只会执行一次，而且第一个运行。

3）@AfterClass：在所有的办法执行之后进行执行，static 办法全局只会执行一次，最初一个运行。

4）@Before：在每一个测试方法被运行前执行一次。

5）@After：在每一个测试方法运行后被执行一次。

6）@Ignore：所润饰的测试方法会被测试运行器疏忽。

7）@RunWith：能够更改测试执行器应用 junit 测试执行器。

3.3 JUnit 应用

3.3.1 Controller 层单元测试

（1）Springboot 中应用 maven 引入 Junit 非常简单, 应用如下依赖即可引入：

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

（2）下面应用 main 办法案例能够应用如下的 Junit 代码实现：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class StudentControllerTest {
    
    // 注入 Spring 容器
    @Autowired
    private WebApplicationContext applicationContext;
    // 模仿 Http 申请
    private MockMvc mockMvc;

    @Before
    public void setupMockMvc(){
        // 初始化 MockMvc 对象
        mockMvc = MockMvcBuilders.webAppContextSetup(applicationContext).build();}
    
    /**
     * 新增学生测试用例
     * @throws Exception
     */
    @Test
    public void addStudent() throws Exception{String json="{"name":" 张三 ","className":" 三年级一班 ","age":"20","sex":" 男 "}";
        mockMvc.perform(MockMvcRequestBuilders.post("/student/save")    // 结构一个 post 申请
                    // 发送端和接收端数据格式
                    .contentType(MediaType.APPLICATION_JSON_UTF8)
                    .accept(MediaType.APPLICATION_JSON_UTF8)
                    .content(json.getBytes())
            )
           // 断言校验返回的 code 编码
           .andExpect(MockMvcResultMatchers.status().isOk())
           // 增加处理器打印返回后果
           .andDo(MockMvcResultHandlers.print());
    }
}

只须要在类或者指定办法上右键执行即可，能够间接充当 postman 工作拜访指定 url，且不须要写申请代码，这些都由工具主动实现。

（3）案例中相干组件介绍

本案例中结构 mockMVC 对象时，也能够应用如下形式：

@Autowired
private StudentController studentController;
@Before
public void setupMockMvc(){
   // 初始化 MockMvc 对象
   mockMvc = MockMvcBuilders.standaloneSetup(studentController).build();}

其中 MockMVC 是 Spring 测试框架提供的用于 REST 申请的工具，是对 Http 申请的模仿，无需启动整个模块就能够对 Controller 层进行调用，速度快且不依赖网络环境。

应用 MockMVC 的根本步骤如下：

1) mockMvc.perform 执行申请

2) MockMvcRequestBuilders.post 或 get 结构申请

3) MockHttpServletRequestBuilder.param 或 content 增加申请参数

4) MockMvcRequestBuilders.contentType 增加申请类型

5) MockMvcRequestBuilders.accept 增加响应类型

6) ResultActions.andExpect 增加后果断言

7) ResultActions.andDo 增加返回后果后置解决

8) ResultActions.andReturn 执行实现后返回相应后果

3.3.2 Service 层单元测试

能够编写如下代码对 Service 层查询方法进行单测：

@RunWith(SpringRunner.class)
@SpringBootTest
public class StudentServiceTest {

    @Autowired
    private StudentService studentService;

    @Test
    public void getOne() throws Exception {Student stu = studentService.selectByKey(5);
         Assert.assertThat(stu.getName(),CoreMatchers.is("张三"));
    }
}

执行后果：

3.3.3 Dao 层单元测试

能够编写如下代码对 Dao 层保留办法进行单测：

@RunWith(SpringRunner.class)
@SpringBootTest
public class StudentDaoTest {

    @Autowired
    private StudentMapper studentMapper;

    @Test
    @Rollback(value = true)
    @Transactional
    public void insertOne() throws Exception {Student student = new Student();
         student.setName("李四");
         student.setMajor("计算机学院");
         student.setAge(25);
         student.setSex('男');
         int count = studentMapper.insert(student);
         Assert.assertEquals(1, count);
    }
}

其中 @Rollback(value = true) 能够执行单元测试之后回滚所新增的数据，放弃数据库不产生脏数据。

3.3.4 异样测试

（1）在 service 层定义一个异常情况：

public void computeScore() {int a = 10, b = 0;}

（2）在 service 的测试类中定义单元测试办法：

@Test(expected = ArithmeticException.class)
    public void computeScoreTest() {studentService.computeScore();
    }

（3）执行单元测试也会通过，起因是 @Test 注解中的定义了异样

3.3.5 测试套件测多个类

（1）新建一个空的单元测试类

（2）利用注解 @RunWith(Suite.class) 和 @SuiteClasses 表明要一起单元测试的类

@RunWith(Suite.class)
@Suite.SuiteClasses({StudentServiceTest.class, StudentDaoTest.class})
public class AllTest {}

运行后果：

3.3.6 idea 中查看单元测试覆盖率

（1）单测覆盖率

测试覆盖率是掂量测试过程工作自身的有效性，晋升测试效率和缩小程序 bug，晋升产品可靠性与稳定性的指标。

统计单元测试覆盖率的意义：

1）能够洞察整个代码中的根底组件性能的所有盲点，发现相干问题。

2）进步代码品质，通常覆盖率低示意代码品质也不会太高，因为单测不通过原本就映射出思考到各种状况不够充沛。

3）从覆盖率的达标上能够进步代码的设计能力。

（2）在 idea 中查看单元测试覆盖率很简略，只需依照图中示例的图标运行，或者在单元测试办法或类上右键 Run ‘xxx’ with Coverage 即可。执行后果是一个表格，列出了类、办法、行数、分支笼罩状况。

（3）在代码中会标识出笼罩状况，绿色的是已笼罩的，红色的是未笼罩的。

（4）如果想要导出单元测试的覆盖率后果，能够应用如下图所示的形式，勾选 Open generated HTML in browser

导出后果：

3.3.7 JUnit 插件主动生成单测代码

（1）装置插件，重启 idea 失效

（2）配置插件

（3）应用插件

在须要生成单测代码的类上右键 generate…，如下图所示。

生成后果：

4. 单元测试工具 -Mockito

4.1 Mockito 简介

在单元测试过程中主张不要依赖特定的接口与数据起源，此时就波及到对相干数据的模仿，比方 Http 和 JDBC 的返回后果等，能够应用虚构对象即 Mock 对象进行模仿，使得单元测试不在耦合。

Mock 过程的应用前提:

（1）理论对象时很难被结构进去的

（2）理论对象的特定行为很难被触发

（3）理论对象可能以后还不存在，比方依赖的接口还没有开发实现等等。

Mockito 官网：https://site.mockito.org。Mockito 和 JUnit 一样是专门针对 Java 语言的 mock 数据框架，它与同类的 EasyMock 和 jMock 性能十分类似，然而该工具更加简略易用。

Mockito 的特点：

（1）能够模仿类不仅仅是接口

（2）通过注解形式简略易懂

（3）反对程序验证

（4）具备参数匹配器

4.2 Mockito 应用

maven 引入 spring-boot-starter-test 会主动将 mockito 引入到工程中。

4.2.1 应用案例

（1）在之前的代码中在定义一个 BookService 接口, 含意是借书接口，暂且不做实现

public interface BookService {Book orderBook(String name);
}

（2）在之前的 StudentService 类中新增一个 orderBook 办法，含意是学生预约书籍办法，其中实现内容调用上述的 BookService 的 orderBook 办法。

public Book orderBook(String name) {return bookService.orderBook(name);
}

（3）编写单元测试办法，测试 StudentService 的 orderBook 办法

@Test
public void orderBookTest() {Book expectBook = new Book(1L, "钢铁是怎么炼成的", "书架 A01");
    Mockito.when(bookService.orderBook(any(String.class))).thenReturn(expectBook);
    Book book = studentService.orderBook("");
    System.out.println(book);
    Assert.assertTrue("预约书籍不符", expectBook.equals(book));
}

（4）执行后果：

（5）后果解析

上述内容并没有实现 BookService 接口的 orderBook(String name) 办法。然而应用 mockito 进行模仿数据之后，却通过了单元测试，起因就在于 Mockito 替换了原本要在 StudentService 的 orderBook 办法中获取的对象，此处就模仿了该对象很难获取或以后无奈获取到，用模仿数据进行代替。

4.2.2 相干语法

罕用 API:

上述案例中用到了 mockito 的 when、any、theWhen 等语法。接下来介绍下都有哪些罕用的 API：

1)       mock：模仿一个须要的对象

2)       when：个别配合 thenXXX 一起应用，示意当执行什么操作之后怎么。

3)       any:  返回一个特定对象的缺省值，上例中标识能够填写任何 String 类型的数据。

4)       theReturn: 在执行特定操作后返回指定后果。

5)       spy：发明一个监控对象。

6)       verify：验证特定的行为。

7)       doReturn：返回后果。

8)       doThrow：抛出特定异样。

9)       doAnswer：做一个自定义响应。

10)     times：操作执行次数。

11)     atLeastOnce：操作至多要执行一次。

12)     atLeast：操作至多执行指定的次数。

13)     atMost：操作至少执行指定的次数。

14)     atMostOnce：操作至少执行一次。

15)     doNothing：不做任何的解决。

16)     doReturn：返回一个后果。

17)     doThrow：抛出一个指定异样。

18)     doAnswer：指定一个特定操作。

19)     doCallRealMethod：用于监控对象返回一个实在后果。

4.2.3 应用要点

（1）打桩

Mockito 中有 Stub，所谓存根或者叫打桩的概念，下面案例中的 Mockito.when(bookService.orderBook(any(String.class))).thenReturn(expectBook); 就是打桩的含意，先定义好如果依照既定的形式调用了什么，后果就输入什么。而后在应用 Book book = studentService.orderBook(“”); 即依照指定存根输入指定后果。

    @Test
    public void verifyTest() {List mockedList = mock(List.class);

        mockedList.add("one");

        verify(mockedList).add("one");            // 验证通过，因为后面定义了这个桩
        verify(mockedList).add("two");            // 验证失败，因为后面没有定义了这个桩
    }

（2）参数匹配

上例 StudentService 的 orderBook 办法中的 any(String.class) 即为参数匹配器，能够匹配任何此处定义的 String 类型的数据。

（3）次数验证

    @Test
    public void timesTest() {List mockedList = mock(List.class);
        when(mockedList.get(anyInt())).thenReturn(1000);
        System.out.println(mockedList.get(1));
        System.out.println(mockedList.get(1));
        System.out.println(mockedList.get(1));
        System.out.println(mockedList.get(2));

        // 验证通过：get(1) 被调用 3 次
        verify(mockedList, times(3)).get(1);
        // 验证通过：get(1) 至多被调用 1 次
        verify(mockedList, atLeastOnce()).get(1);
        // 验证通过：get(1) 至多被调用 3 次
        verify(mockedList, atLeast(3)).get(1);
    }

（4）程序验证

    @Test
    public void orderBookTest1() {String json = "{"id":12,"location":" 书架 A12","name":" 三国演义 "}";
        String json1 = "{"id":21,"location":" 书架 A21","name":" 水浒传 "}";
        String json2 = "{"id":22,"location":" 书架 A22","name":" 红楼梦 "}";
        String json3 = "{"id":23,"location":" 书架 A23","name":" 西游记 "}";
        when(bookService.orderBook("")).thenReturn(JSON.parseObject(json, Book.class));
        Book book = bookService.orderBook("");
        Assert.assertTrue("预约书籍有误", "三国演义".equals(book.getName()));

        when(bookService.orderBook("")).thenReturn(JSON.parseObject(json1, Book.class)).
                thenReturn(JSON.parseObject(json2, Book.class)).
                thenReturn(JSON.parseObject(json3, Book.class));
        Book book1 = bookService.orderBook("");
        Book book2 = bookService.orderBook("");
        Book book3 = bookService.orderBook("");
        Book book4 = bookService.orderBook("");
        Book book5 = bookService.orderBook("");
        // 全副验证通过，按程序最初打桩打了 3 次，大于 3 次依照最初对象输入
        Assert.assertTrue("预约书籍有误", "水浒传".equals(book1.getName()));
        Assert.assertTrue("预约书籍有误", "红楼梦".equals(book2.getName()));
        Assert.assertTrue("预约书籍有误", "西游记".equals(book3.getName()));
        Assert.assertTrue("预约书籍有误", "西游记".equals(book4.getName()));
        Assert.assertTrue("预约书籍有误", "西游记".equals(book5.getName()));
}

（5）异样验证

    @Test(expected = RuntimeException.class)
    public void exceptionTest() {List mockedList = mock(List.class);
        doThrow(new RuntimeException()).when(mockedList).add(1);
        // 验证通过
        mockedList.add(1);
    }