学习如何使用本教程中提供的工具，并在 Spring Boot 环境中编写单元测试和集成测试。

本文中，我们将了解如何编写单元测试并将其集成在 Spring Boot 环境中。你可在网上找到大量关于这个主题的教程，但很难在一个页面中找到你需要的所有信息。我经常注意到初级开发人员混淆了单元测试和集成测试的概念，特别是在谈到 Spring 生态系统时。我将尝试讲清楚不同注解在不同上下文中的用法。

维基百科是这么说 单元测试 的：

在计算机编程中，单元测试是一种软件测试方法，用以测试源代码的单个单元、一个或多个计算机程序模块的集合以及相关的控制数据、使用过程和操作过程，以确定它们是否适合使用。

集成测试：

“集成测试（有时也称集成和测试，缩写为 I&T）是软件测试的一个阶段，在这个阶段中，各个软件模块被组合在一起来进行测试。”

简而言之，当我们在做单元测试时，只是测试了一个代码单元，每次只测试一个方法，不包括与正测试组件相交互的其他所有组件。

另一方面，在集成测试中，我们测试各组件之间的集成。由于单元测试，我们可知这些组件行为与所需一致，但不清楚它们是如何在一起工作的。这就是集成测试的职责。

所有 Java 开发者都知道 JUnit 是执行单元测试的主要框架。它提供了许多注解来对期望进行断言。

Hamcrest 是一个用于软件测试的附加框架。Hamcrest 允许使用现有的 matcher 类来检查代码中的条件，还允许自定义 matcher 实现。要在 JUnit 中使用 Hamcrest matcher，必须使用 assertThat 语句，后跟一个或多个 matcher。

在这里，你可以看到使用这两种框架的简单测试：

  1. import static org.hamcrest.CoreMatchers.allOf;
  2. import static org.hamcrest.CoreMatchers.anyOf;
  3. import static org.hamcrest.CoreMatchers.both;
  4. import static org.hamcrest.CoreMatchers.containsString;
  5. import static org.hamcrest.CoreMatchers.equalTo;
  6. import static org.hamcrest.CoreMatchers.everyItem;
  7. import static org.hamcrest.CoreMatchers.hasItems;
  8. import static org.hamcrest.CoreMatchers.not;
  9. import static org.hamcrest.CoreMatchers.sameInstance;
  10. import static org.hamcrest.CoreMatchers.startsWith;
  11. import static org.junit.Assert.assertArrayEquals;
  12. import static org.junit.Assert.assertEquals;
  13. import static org.junit.Assert.assertFalse;
  14. import static org.junit.Assert.assertNotNull;
  15. import static org.junit.Assert.assertNotSame;
  16. import static org.junit.Assert.assertNull;
  17. import static org.junit.Assert.assertSame;
  18. import static org.junit.Assert.assertThat;
  19. import static org.junit.Assert.assertTrue;
  21. import java.util.Arrays;
  23. import org.hamcrest.core.CombinableMatcher;
  24. import org.junit.Test;
  26. public class AssertTests {
  27.   @Test
  28.   public void testAssertArrayEquals() {
  29.     byte[] expected = "trial".getBytes();
  30.     byte[] actual = "trial".getBytes();
  31.     assertArrayEquals("failure - byte arrays not same", expected, actual);
  32.   }
  34.   @Test
  35.   public void testAssertEquals() {
  36.     assertEquals("failure - strings are not equal", "text", "text");
  37.   }
  39.   @Test
  40.   public void testAssertFalse() {
  41.     assertFalse("failure - should be false", false);
  42.   }
  44.   @Test
  45.   public void testAssertNotNull() {
  46.     assertNotNull("should not be null", new Object());
  47.   }
  49.   @Test
  50.   public void testAssertNotSame() {
  51.     assertNotSame("should not be same Object", new Object(), new Object());
  52.   }
  54.   @Test
  55.   public void testAssertNull() {
  56.     assertNull("should be null", null);
  57.   }
  59.   @Test
  60.   public void testAssertSame() {
  61.     Integer aNumber = Integer.valueOf(768);
  62.     assertSame("should be same", aNumber, aNumber);
  63.   }
  65.   // JUnit Matchers assertThat
  66.   @Test
  67.   public void testAssertThatBothContainsString() {
  68.     assertThat("albumen", both(containsString("a")).and(containsString("b")));
  69.   }
  71.   @Test
  72.   public void testAssertThatHasItems() {
  73.     assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
  74.   }
  76.   @Test
  77.   public void testAssertThatEveryItemContainsString() {
  78.     assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
  79.   }
  81.   // Core Hamcrest Matchers with assertThat
  82.   @Test
  83.   public void testAssertThatHamcrestCoreMatchers() {
  84.     assertThat("good", allOf(equalTo("good"), startsWith("good")));
  85.     assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
  86.     assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
  87.     assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
  88.     assertThat(new Object(), not(sameInstance(new Object())));
  89.   }
  91.   @Test
  92.   public void testAssertTrue() {
  93.     assertTrue("failure - should be true", true);
  94.   }
  95. }

让我们来写一个简单的程序吧。其目的是为漫画提供一个基本的搜索引擎。

Kenshiro vs Roul

首先，需要添加一些依赖到我们的工程中。

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-test</artifactId>
  4.   <scope>test</scope>
  5. </dependency>
  6. <dependency>
  7.   <groupId>org.springframework.boot</groupId>
  8.   <artifactId>spring-boot-starter-web</artifactId>
  9. </dependency>
  10. <dependency>
  11.   <groupId>org.projectlombok</groupId>
  12.   <artifactId>lombok</artifactId>
  13.   <version>1.16.20</version>
  14.   <scope>provided</scope>
  15. </dependency>

我们的模型非常简单，只有两个类组成：Manga 和 MangaResult

Manga 类表示系统检索到的 Manga 实例。使用 Lombok 来减少样板代码。

  1. package com.mgiglione.model;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Builder;
  5. import lombok.Getter;
  6. import lombok.NoArgsConstructor;
  7. import lombok.Setter;
  9. @Getter @Setter @NoArgsConstructor @AllArgsConstructor @Builder
  10. public class Manga {
  11.     private String title;
  12.     private String description;
  13.     private Integer volumes;
  14.     private Double score;
  15. }

MangaResult 类是包含了一个 Manga List 的包装类。

  1. package com.mgiglione.model;
  3. import java.util.List;
  5. import lombok.Getter;
  6. import lombok.NoArgsConstructor;
  7. import lombok.Setter;
  9. @Getter @Setter @NoArgsConstructor
  10. public class MangaResult {
  11.     private List<Manga> result;
  12. }

为实现本 Service，我们将使用由 Jikan Moe 提供的免费 API 接口。

RestTemplate 是用来对 API 进行发起 REST 调用的 Spring 类。

  1. package com.mgiglione.service;
  3. import java.util.List;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Service;
  9. import org.springframework.web.client.RestTemplate;
  11. import com.mgiglione.model.Manga;
  12. import com.mgiglione.model.MangaResult;
  14. @Service
  15. public class MangaService {
  17.     Logger logger = LoggerFactory.getLogger(MangaService.class);
  18.     private static final String MANGA_SEARCH_URL="http://api.jikan.moe/search/manga/";
  19.     
  20.     @Autowired
  21.     RestTemplate restTemplate;
  22.     
  23.     public List<Manga> getMangasByTitle(String title) {
  24.         return restTemplate.getForEntity(MANGA_SEARCH_URL+title, MangaResult.class).getBody().getResult();
  25.     }
  27. }

下一步就是写一个暴露了两个端点的 REST Controller，一个是同步的，一个是异步的，其仅用于测试目的。该 Controller 使用了上面定义的 Service。

  1. package com.mgiglione.controller;
  3. import java.util.List;
  4. import java.util.concurrent.CompletableFuture;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.scheduling.annotation.Async;
  10. import org.springframework.web.bind.annotation.PathVariable;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RequestMethod;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  14. import org.springframework.web.bind.annotation.RestController;
  16. import com.mgiglione.model.Manga;
  17. import com.mgiglione.service.MangaService;
  19. @RestController
  20. @RequestMapping(value = "/manga")
  21. public class MangaController {
  23.     Logger logger = LoggerFactory.getLogger(MangaController.class);
  24.     
  25.     @Autowired
  26.     private MangaService mangaService;   
  27.     
  28.     @RequestMapping(value = "/async/{title}", method = RequestMethod.GET)
  29.     @Async
  30.     public CompletableFuture<List<Manga>> searchASync(@PathVariable(name = "title") String title) {
  31.         return CompletableFuture.completedFuture(mangaService.getMangasByTitle(title));
  32.     }
  33.     
  34.     @RequestMapping(value = "/sync/{title}", method = RequestMethod.GET)
  35.     public @ResponseBody <List<Manga>> searchSync(@PathVariable(name = "title") String title) {
  36.         return mangaService.getMangasByTitle(title);
  37.     }
  39. }
  1. mvn spring-boot:run

然后，Let’s try it：

  1. curl http://localhost:8080/manga/async/ken
  2. curl http://localhost:8080/manga/sync/ken

示例输出：

  1. {  
  2.    "title":"Rurouni Kenshin: Meiji Kenkaku Romantan",
  3.    "description":"Ten years have passed since the end of Bakumatsu, an era of war that saw the uprising of citizens against the Tokugawa shogunate. The revolutionaries wanted to create a time of peace, and a thriving c...",
  4.    "volumes":28,
  5.    "score":8.69
  6. },
  7. {  
  8.    "title":"Sun-Ken Rock",
  9.    "description":"The story revolves around Ken, a man from an upper-class family that was orphaned young due to his family's involvement with the Yakuza; he became a high school delinquent known for fighting. The only...",
  10.    "volumes":25,
  11.    "score":8.12
  12. },
  13. {  
  14.    "title":"Yumekui Kenbun",
  15.    "description":"For those who suffer nightmares, help awaits at the Ginseikan Tea House, where patrons can order much more than just Darjeeling. Hiruko is a special kind of a private investigator. He's a dream eater....",
  16.    "volumes":9,
  17.    "score":7.97
  18. }

Spring Boot 提供了一个强大的类以使测试变得简单：@SpringBootTest 注解

可以在基于 Spring Boot 运行的测试类上指定此注解。

除常规 Spring TestContext Framework 之外，其还提供以下功能：

  • 当 @ContextConfiguration (loader=…) 没有特别声明时，使用 SpringBootContextLoader 作为默认 ContextLoader。
  • 在未使用嵌套的 @Configuration 注解，且未显式指定相关类时，自动搜索 @SpringBootConfiguration。
  • 允许使用 Properties 来自定义 Environment 属性。
  • 对不同的 Web 环境模式提供支持，包括启动在已定义或随机端口上的完全运行的 Web 服务器的功能。
  • 注册 TestRestTemplate 和 / 或 WebTestClient Bean，以便在完全运行在 Web 服务器上的 Web 测试中使用。

此处，我们仅有两个组件需要测试：MangaService 和 MangaController

为了测试 MangaService，我们需要将其与外部组件隔离开来。本例中，只需要一个外部组件：RestTemplate，我们用它来调用远程 API。

我们需要做的是模拟 RestTemplate Bean，并让它始终以固定的给定响应进行响应。Spring Test 结合并扩展了 Mockito 库，通过 @MockBean 注解，我们可以配置模拟 Bean。

  1. package com.mgiglione.service.test.unit;
  3. import static org.mockito.ArgumentMatchers.any;
  4. import static org.mockito.Mockito.when;
  6. import java.io.IOException;
  7. import java.util.List;
  9. import org.junit.Test;
  10. import org.junit.runner.RunWith;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.boot.test.context.SpringBootTest;
  13. import org.springframework.boot.test.mock.mockito.MockBean;
  14. import org.springframework.http.HttpStatus;
  15. import org.springframework.http.ResponseEntity;
  16. import org.springframework.test.context.junit4.SpringRunner;
  17. import org.springframework.web.client.RestTemplate;
  18. import static org.assertj.core.api.Assertions.assertThat;
  20. import com.mgiglione.model.Manga;
  21. import com.mgiglione.model.MangaResult;
  22. import com.mgiglione.service.MangaService;
  23. import com.mgiglione.utils.JsonUtils;
  25. @RunWith(SpringRunner.class)
  26. @SpringBootTest
  27. public class MangaServiceUnitTest {
  28.     
  29.     @Autowired
  30.     private MangaService mangaService;
  31.     
  32.     // MockBean is the annotation provided by Spring that wraps mockito one
  33.     // Annotation that can be used to add mocks to a Spring ApplicationContext.
  34.     // If any existing single bean of the same type defined in the context will be replaced by the mock, if no existing bean is defined a new one will be added.
  35.     @MockBean
  36.     private RestTemplate template;
  37.     
  38.     @Test
  39.     public void testGetMangasByTitle() throws IOException {
  40.         // Parsing mock file
  41.         MangaResult mRs = JsonUtils.jsonFile2Object("ken.json", MangaResult.class);
  42.         // Mocking remote service
  43.         when(template.getForEntity(any(String.class), any(Class.class))).thenReturn(new ResponseEntity(mRs, HttpStatus.OK));
  44.         // I search for goku but system will use mocked response containing only ken, so I can check that mock is used.
  45.         List<Manga> mangasByTitle = mangaService.getMangasByTitle("goku");
  46.         assertThat(mangasByTitle).isNotNull()
  47.             .isNotEmpty()
  48.             .allMatch(p -> p.getTitle()
  49.                 .toLowerCase()
  50.                 .contains("ken"));
  51.     }
  52.     
  53. }

正如在 MangaService 的单元测试中所做的那样，我们需要隔离组件。在这种情况下，我们需要模拟 MangaService Bean。

然后，我们还有一个问题……Controller 部分是管理 HttpRequest 的系统的一部分，因此我们需要一个系统来模拟这种行为，而非启动完整的 HTTP 服务器。

MockMvc 是执行该操作的 Spring 类。其可以以不同的方式进行设置：

  1. 使用 Standalone Context
  2. 使用 WebApplication Context
  3. 让 Spring 通过在测试类上使用 @SpringBootTest、@AutoConfigureMockMvc 这些注解来加载所有的上下文，以实现自动装配
  4. 让 Spring 通过在测试类上使用 @WebMvcTest 注解来加载 Web 层上下文，以实现自动装配
  1. package com.mgiglione.service.test.unit;
  3. import static org.hamcrest.Matchers.is;
  4. import static org.mockito.ArgumentMatchers.any;
  5. import static org.mockito.Mockito.when;
  6. import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.asyncDispatch;
  7. import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
  8. import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
  9. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
  10. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.request;
  11. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
  12. import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;
  14. import java.util.ArrayList;
  15. import java.util.List;
  17. import org.junit.Before;
  18. import org.junit.Test;
  19. import org.junit.runner.RunWith;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.boot.test.context.SpringBootTest;
  22. import org.springframework.boot.test.mock.mockito.MockBean;
  23. import org.springframework.http.MediaType;
  24. import org.springframework.test.context.junit4.SpringRunner;
  25. import org.springframework.test.web.servlet.MockMvc;
  26. import org.springframework.test.web.servlet.MvcResult;
  27. import org.springframework.web.context.WebApplicationContext;
  29. import com.mgiglione.controller.MangaController;
  30. import com.mgiglione.model.Manga;
  31. import com.mgiglione.service.MangaService;
  33. @SpringBootTest
  34. @RunWith(SpringRunner.class)
  35. public class MangaControllerUnitTest {
  37.     MockMvc mockMvc;
  38.     
  39.     @Autowired
  40.     protected WebApplicationContext wac;
  41.     
  42.     @Autowired
  43.     MangaController mangaController;
  44.     
  45.     @MockBean
  46.     MangaService mangaService;
  47.     
  48.     /**
  49.      * List of samples mangas
  50.      */
  51.     private List<Manga> mangas;
  52.     
  53.     @Before
  54.     public void setup() throws Exception {
  55.         this.mockMvc = standaloneSetup(this.mangaController).build();// Standalone context
  56.         // mockMvc = MockMvcBuilders.webAppContextSetup(wac)
  57.         // .build();
  58.         Manga manga1 = Manga.builder()
  59.             .title("Hokuto no ken")
  60.             .description("The year is 199X. The Earth has been devastated by nuclear war...")
  61.             .build();
  62.         Manga manga2 = Manga.builder()
  63.             .title("Yumekui Kenbun")
  64.             .description("For those who suffer nightmares, help awaits at the Ginseikan Tea House, where patrons can order much more than just Darjeeling. Hiruko is a special kind of a private investigator. He's a dream eater....")
  65.             .build();
  66.         mangas = new ArrayList<>();
  67.         mangas.add(manga1);
  68.         mangas.add(manga2);
  69.     }
  70.     
  71.     @Test
  72.     public void testSearchSync() throws Exception {
  73.         // Mocking service
  74.         when(mangaService.getMangasByTitle(any(String.class))).thenReturn(mangas);
  75.         mockMvc.perform(get("/manga/sync/ken").contentType(MediaType.APPLICATION_JSON))
  76.             .andExpect(status().isOk())
  77.             .andExpect(jsonPath("$[0].title", is("Hokuto no ken")))
  78.             .andExpect(jsonPath("$[1].title", is("Yumekui Kenbun")));
  79.     }
  81.     @Test
  82.     public void testSearchASync() throws Exception {
  83.         // Mocking service
  84.         when(mangaService.getMangasByTitle(any(String.class))).thenReturn(mangas);
  85.         MvcResult result = mockMvc.perform(get("/manga/async/ken").contentType(MediaType.APPLICATION_JSON))
  86.             .andDo(print())
  87.             .andExpect(request().asyncStarted())
  88.             .andDo(print())
  89.             // .andExpect(status().is2xxSuccessful()).andReturn();
  90.             .andReturn();
  91.         // result.getRequest().getAsyncContext().setTimeout(10000);
  92.         mockMvc.perform(asyncDispatch(result))
  93.             .andDo(print())
  94.             .andExpect(status().isOk())
  95.             .andExpect(jsonPath("$[0].title", is("Hokuto no ken")));
  96.     }
  97. }

正如在代码中所看到的那样，选择第一种解决方案是因为其是最轻量的一个，并且我们可以对 Spring 上下文中加载的对象有更好的治理。

在异步测试中，必须首先通过调用服务，然后启动 asyncDispatch 方法来模拟异步行为。

对于集成测试，我们希望提供下游通信来检查我们的主要组件。

这个测试也是非常简单的。我们不需要模拟任何东西，因为我们的目的就是要调用远程 Manga API。

  1. package com.mgiglione.service.test.integration;
  3. import static org.assertj.core.api.Assertions.assertThat;
  5. import java.util.List;
  7. import org.junit.Test;
  8. import org.junit.runner.RunWith;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.boot.test.context.SpringBootTest;
  11. import org.springframework.test.context.junit4.SpringRunner;
  13. import com.mgiglione.model.Manga;
  14. import com.mgiglione.service.MangaService;
  16. @RunWith(SpringRunner.class)
  17. @SpringBootTest
  18. public class MangaServiceIntegrationTest {
  20.     @Autowired
  21.     private MangaService mangaService;
  22.     
  23.     @Test
  24.     public void testGetMangasByTitle() {
  25.            List<Manga> mangasByTitle = mangaService.getMangasByTitle("ken");
  26.            assertThat(mangasByTitle).isNotNull().isNotEmpty();
  27.     }
  28.     
  29. }

这个测试和单元测试很是相似，但在这个案例中，我们无需再模拟 MangaService。

  1. package com.mgiglione.service.test.integration;
  3. import static org.hamcrest.Matchers.hasItem;
  4. import static org.hamcrest.Matchers.is;
  5. import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.asyncDispatch;
  6. import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
  7. import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
  8. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
  9. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.request;
  10. import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
  11. import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;
  13. import org.junit.Before;
  14. import org.junit.Test;
  15. import org.junit.runner.RunWith;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.boot.test.context.SpringBootTest;
  18. import org.springframework.http.MediaType;
  19. import org.springframework.test.context.junit4.SpringRunner;
  20. import org.springframework.test.web.servlet.MockMvc;
  21. import org.springframework.test.web.servlet.MvcResult;
  22. import org.springframework.web.context.WebApplicationContext;
  24. import com.mgiglione.controller.MangaController;
  26. @SpringBootTest
  27. @RunWith(SpringRunner.class)
  28. public class MangaControllerIntegrationTest {
  30.     // @Autowired
  31.     MockMvc mockMvc;
  32.     
  33.     @Autowired
  34.     protected WebApplicationContext wac;
  35.     
  36.     @Autowired
  37.     MangaController mangaController;
  38.     
  39.     @Before
  40.     public void setup() throws Exception {
  41.         this.mockMvc = standaloneSetup(this.mangaController).build();// Standalone context
  42.         // mockMvc = MockMvcBuilders.webAppContextSetup(wac)
  43.         // .build();
  44.     }
  45.     
  46.     @Test
  47.     public void testSearchSync() throws Exception {
  48.         mockMvc.perform(get("/manga/sync/ken").contentType(MediaType.APPLICATION_JSON))
  49.             .andExpect(status().isOk())
  50.             .andExpect(jsonPath("$.*.title", hasItem(is("Hokuto no Ken"))));
  51.     }
  52.     
  53.     @Test
  54.     public void testSearchASync() throws Exception {
  55.         MvcResult result = mockMvc.perform(get("/manga/async/ken").contentType(MediaType.APPLICATION_JSON))
  56.             .andDo(print())
  57.             .andExpect(request().asyncStarted())
  58.             .andDo(print())
  59.             .andReturn();
  60.         mockMvc.perform(asyncDispatch(result))
  61.             .andDo(print())
  62.             .andExpect(status().isOk())
  63.             .andExpect(jsonPath("$.*.title", hasItem(is("Hokuto no Ken"))));
  64.     }
  66. }

我们已经了解了在 Spring Boot 环境下单元测试和集成测试的主要不同，了解了像 Hamcrest 这样简化测试编写的框架。当然，也可以在我的 GitHub 仓库 里找到所有代码。

原文：https://dzone.com/articles/unit-and-integration-tests-in-spring-boot-2

作者：Marco Giglione

9月福利，关注公众号
​
后台回复：004，领取8月翻译集锦!
​
往期福利回复：001，002, 003即可领取！

img

版权声明：本文为liululee原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/liululee/p/11595537.html