當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

学习 Spring Boot：（二十九）Spring Boot Junit 单元测试

發布時間：2023/12/9 javascript 38 豆豆

生活随笔收集整理的這篇文章主要介紹了学习 Spring Boot：（二十九）Spring Boot Junit 单元测试小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

From: https://blog.wuwii.com/springboot-test.html

前言

JUnit 是一個回歸測試框架，被開發者用于實施對應用程序的單元測試，加快程序編制速度，同時提高編碼的質量。

JUnit 測試框架具有以下重要特性：

測試工具
測試套件
測試運行器
測試分類

了解 Junit 基礎方法

加入依賴

在 pom.xml 中加入依賴：

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

創建測試類和測試方法

測試類的的命名規則一般是 xxxTest.java ；

測試類中測試的方法可以有前綴，這個看統一標準，所以有時候會發現別人的測試方法上有test前綴；

并且測試方法上加上注解 @Test。

使用 IDEA 中，選中當前類名，使用快捷鍵 ALT + ENTER（WIN），向下選則 Create Test 回車，即可進入生成測試類的選項中，再次回車，就快速的生成測試類。

OK 完你會發現，生成的測試類在 src/test 目錄下，測試類和源代碼的包名是一致的。生成后結果（注意下生成的方法名是不加 test）：

public class HelloServiceImplTest {

@Before

public void setUp() throws Exception {

}

@After

public void tearDown() throws Exception {

}

@Test

public void say() {

}

JUnit中的注解

@BeforeClass：針對所有測試，只執行一次，且必須為static void
@Before：初始化方法，執行當前測試類的每個測試方法前執行。
@Test：測試方法，在這里可以測試期望異常和超時時間
@After：釋放資源，執行當前測試類的每個測試方法后執行
@AfterClass：針對所有測試，只執行一次，且必須為static void
@Ignore：忽略的測試方法（只在測試類的時候生效，單獨執行該測試方法無效）
@RunWith:可以更改測試運行器，缺省值 org.junit.runner.Runner

一個單元測試類執行順序為：

@BeforeClass –> @Before –> @Test –> @After –> @AfterClass

每一個測試方法的調用順序為：

@Before –> @Test –> @After

超時測試

如果一個測試用例比起指定的毫秒數花費了更多的時間，那么 Junit 將自動將它標記為失敗。timeout 參數和 @Test注釋一起使用。現在讓我們看看活動中的 @test(timeout)。

@Test(timeout = 1000)

public void testTimeout() throws InterruptedException {

TimeUnit.SECONDS.sleep(2);

System.out.println("Complete");

}

上面測試會失敗，在一秒后會拋出異常 org.junit.runners.model.TestTimedOutException: test timed out after 1000 milliseconds

異常測試

你可以測試代碼是否它拋出了想要得到的異常。expected 參數和 @Test 注釋一起使用。現在讓我們看看活動中的 @Test(expected)。

@Test(expected = NullPointerException.class)

public void testNullException() {

throw new NullPointerException();

}

上面代碼會測試成功。

套件測試

public class TaskOneTest {

@Test

public void test() {

System.out.println("Task one do.");

}

public class TaskTwoTest {

@Test

public void test() {

System.out.println("Task two do.");

}

public class TaskThreeTest {

@Test

public void test() {

System.out.println("Task Three.");

}

@RunWith(Suite.class) // 1. 更改測試運行方式為 Suite

// 2. 將測試類傳入進來

@Suite.SuiteClasses({TaskOneTest.class, TaskTwoTest.class, TaskThreeTest.class})

public class SuitTest {

/**

* 測試套件的入口類只是組織測試類一起進行測試，無任何測試方法，

}

參數化測試

Junit 4 引入了一個新的功能參數化測試。參數化測試允許開發人員使用不同的值反復運行同一個測試。你將遵循 5 個步驟來創建參數化測試。

用 @RunWith(Parameterized.class)來注釋 test 類。
創建一個由 @Parameters 注釋的公共的靜態方法，它返回一個對象的集合(數組)來作為測試數據集合。
創建一個公共的構造函數，它接受和一行測試數據相等同的東西。
為每一列測試數據創建一個實例變量。
用實例變量作為測試數據的來源來創建你的測試用例。

//1.更改默認的測試運行器為RunWith(Parameterized.class)

@RunWith(Parameterized.class)

public class ParameterTest {

// 2.聲明變量存放預期值和測試數據

private String firstName;

private String lastName;

//3.聲明一個返回值為Collection的公共靜態方法，并使用@Parameters進行修飾

@Parameterized.Parameters //

public static List<Object[]> param() {

// 這里我給出兩個測試用例

return Arrays.asList(new Object[][]{{"Mike", "Black"}, {"Cilcln", "Smith"}});

}

//4.為測試類聲明一個帶有參數的公共構造函數，并在其中為之聲明變量賦值

public ParameterTest(String firstName, String lastName) {

this.firstName = firstName;

this.lastName = lastName;

}

// 5. 進行測試，發現它會將所有的測試用例測試一遍

@Test

public void test() {

String name = firstName + " " + lastName;

assertThat("Mike Black", is(name));

}

Hamcrest

JUnit 4.4 結合 Hamcrest 提供了一個全新的斷言語法——assertThat。

語法：

assertThat( [actual], [matcher expected] );

assertThat 使用了 Hamcrest 的 Matcher 匹配符，用戶可以使用匹配符規定的匹配準則精確的指定一些想設定滿足的條件，具有很強的易讀性，而且使用起來更加靈活。

具體使用的一些匹配規則可以查看源碼。

Spring Boot 中使用 JUnit

Spring 框架提供了一個專門的測試模塊（spring-test），用于應用程序的集成測試。在 Spring Boot 中，你可以通過spring-boot-starter-test啟動器快速開啟和使用它。

加入依賴

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

Spring Boot 測試

// 獲取啟動類，加載配置，確定裝載 Spring 程序的裝載方法，它回去尋找主配置啟動類（被 @SpringBootApplication 注解的）

@SpringBootTest

// 讓 JUnit 運行 Spring 的測試環境，獲得 Spring 環境的上下文的支持

@RunWith(SpringRunner.class)

public class EmployeeServiceImplTest {

// do

}

Spring MVC 測試

當你想對 Spring MVC 控制器編寫單元測試代碼時，可以使用@WebMvcTest注解。它提供了自配置的 MockMvc，可以不需要完整啟動 HTTP 服務器就可以快速測試 MVC 控制器。

需要測試的 Controller：

@RestController

@RequestMapping(value = "/emp", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)

public class EmployeeController {

private final EmployeeService employeeService;

@Autowired

public EmployeeController(EmployeeService employeeService) {

this.employeeService = employeeService;

}

@GetMapping

public ResponseEntity<List<EmployeeResult>> listAll() {

return ResponseEntity.ok(employeeService.findEmployee());

}

編寫 MockMvc 的測試類：

@RunWith(SpringRunner.class)

@WebMvcTest(EmployeeController.class)

public class EmployeeController2Test {

@Autowired

private MockMvc mvc;

@MockBean

private EmployeeService employeeService;

public void setUp() {

// 數據打樁，設置該方法返回的 body一直是空的

Mockito.when(employeeService.findEmployee()).thenReturn(new ArrayList<>());

}

@Test

public void listAll() throws Exception {

mvc.perform(MockMvcRequestBuilders.get("/emp"))

.andExpect(status().isOk()) // 期待返回狀態嗎碼200

// JsonPath expression https://github.com/jayway/JsonPath

//.andExpect(jsonPath("$[1].name").exists()) // 這里是期待返回值是數組，并且第二個值的 name 存在，所以這里測試是失敗的

.andDo(print()); // 打印返回的 http response 信息

}

使用@WebMvcTest注解時，只有一部分的 Bean 能夠被掃描得到，它們分別是：

@Controller
@ControllerAdvice
@JsonComponent
Filter
WebMvcConfigurer
HandlerMethodArgumentResolver
其他常規的@Component（包括@Service、@Repository等）Bean 則不會被加載到 Spring 測試環境上下文中。
所以我在上面使用了數據打樁，Mockito 在這篇文章最后一節。

我們也可以注入Spring 上下文的環境到 MockMvc 中，如下編寫 MockMvc 的測試類：

@RunWith(SpringRunner.class)

@SpringBootTest

public class EmployeeControllerTest {

/**

* Interface to provide configuration for a web application.

@Autowired

private WebApplicationContext ctx;

private MockMvc mockMvc;

/**

* 初始化 MVC 的環境

@Before

public void before() {

mockMvc = MockMvcBuilders.webAppContextSetup(ctx).build();

}

@Test

public void listAll() throws Exception {

mockMvc

.perform(get("/emp") // 測試的相對地址

.accept(MediaType.APPLICATION_JSON_UTF8) // accept response content type

)

.andExpect(status().isOk()) // 期待返回狀態嗎碼200

// JsonPath expression https://github.com/jayway/JsonPath

.andExpect(jsonPath("$[1].name").exists()) // 這里是期待返回值是數組，并且第二個值的 name 存在

.andDo(print()); // 打印返回的 http response 信息

}

值得注意的是需要首先使用 WebApplicationContext 構建 MockMvc。

Spring Boot Web 測試

當你想啟動一個完整的 HTTP 服務器對 Spring Boot 的 Web 應用編寫測試代碼時，可以使用@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)注解開啟一個隨機的可用端口。Spring Boot 針對 REST 調用的測試提供了一個 TestRestTemplate 模板，它可以解析鏈接服務器的相對地址。

@RunWith(SpringRunner.class)

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)

public class EmployeeController1Test {

@Autowired

private TestRestTemplate restTemplate;

@Test

public void listAll() {

ResponseEntity<List> result = restTemplate.getForEntity("/emp", List.class);

Assert.assertThat(result.getBody(), Matchers.notNullValue());

}

其實之前上面的測試返回結果不是很正確，只能接收個List，給測試代碼添加了不少麻煩，還好最終找到了解決辦法：

@Test

public void listAll() {

// 由于我返回的是 List 類型的，一直想不到辦法解決，網上給出了解決辦法，使用 exchange 函數代替

//public <T> ResponseEntity<T> exchange(String url, HttpMethod method,

// HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType,

// Object... urlVariables) throws RestClientException {

ParameterizedTypeReference<List<EmployeeResult>> type = new ParameterizedTypeReference<List<EmployeeResult>>() {};

ResponseEntity<List<EmployeeResult>> result = restTemplate.exchange("/emp", HttpMethod.GET, null, type);

Assert.assertThat(result.getBody().get(0).getName(), Matchers.notNullValue());

}

Spring Data JPA 測試

我們可以使用 @DataJpaTest注解表示只對 JPA 測試；@DataJpaTest注解它只掃描@EntityBean 和裝配 Spring Data JPA 存儲庫，其他常規的@Component（包括@Service、@Repository等）Bean 則不會被加載到 Spring 測試環境上下文。

@DataJpaTest 還提供兩種測試方式：

使用內存數據庫 h2database，Spring Data Jpa 測試默認采取的是這種方式；

使用真實環境的數據庫。

使用內存數據庫測試

默認情況下，@DataJpaTest使用的是內存數據庫進行測試，你無需配置和啟用真實的數據庫。只需要在 pom.xml 配置文件中聲明如下依賴即可：

<groupId>com.h2database</groupId>

</dependency>

gradle file:

testCompile('com.h2database:h2')
編寫測試方法：

@RunWith(SpringRunner.class)

@DataJpaTest

public class EmployeeDaoTest {

@Autowired

private EmployeeDao employeeDao;

@Test

public void testSave() {

Employee employee = new Employee();

EmployeeDetail detail = new EmployeeDetail();

detail.setName("kronchan");

detail.setAge(24);

employee.setDetail(detail);

assertThat(detail.getName(), Matchers.is(employeeDao.save(employee).getDetail().getName()));;

}

使用真實數據庫測試

如要需要使用真實環境中的數據庫進行測試，需要替換掉默認規則，使用@AutoConfigureTestDatabase(replace = Replace.NONE)注解：

@RunWith(SpringRunner.class)

@DataJpaTest

// 加入 AutoConfigureTestDatabase 注解

@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)

public class EmployeeDaoTest {

@Autowired

private EmployeeDao employeeDao;

@Test

public void testSave() {

Employee employee = new Employee();

EmployeeDetail detail = new EmployeeDetail();

detail.setName("kronchan");

detail.setAge(24);

employee.setDetail(detail);

assertThat(detail.getName(), Matchers.is(employeeDao.save(employee).getDetail().getName()));;

}

事務控制

執行上面的新增數據的測試，發現測試通過，但是數據庫卻并沒有新增數據。默認情況下，在每個 JPA 測試結束時，事務會發生回滾。這在一定程度上可以防止測試數據污染數據庫。

如果你不希望事務發生回滾，你可以使用@Rollback(false)注解，該注解可以標注在類級別做全局的控制，也可以標注在某個特定不需要執行事務回滾的方法級別上。

也可以顯式的使用注解 @Transactional 設置事務和事務的控制級別，放大事務的范圍。

Mockito

這部分參考使用Mockito和SpringTest進行單元測試

JUnit和SpringTest,基本上可以滿足絕大多數的單元測試了，但是，由于現在的系統越來越復雜，相互之間的依賴越來越多。特別是微服務化以后的系統，往往一個模塊的代碼需要依賴幾個其他模塊的東西。因此，在做單元測試的時候，往往很難構造出需要的依賴。一個單元測試，我們只關心一個小的功能，但是為了這個小的功能能跑起來，可能需要依賴一堆其他的東西，這就導致了單元測試無法進行。所以，我們就需要再測試過程中引入Mock測試。

所謂的Mock測試就是在測試過程中，對于一些不容易構造的、或者和這次單元測試無關但是上下文又有依賴的對象，用一個虛擬的對象（Mock對象）來模擬，以便單元測試能夠進行。

比如有一段代碼的依賴為：

當我們要進行單元測試的時候，就需要給A注入B和C,但是C又依賴了D，D又依賴了E。這就導致了，A的單元測試很難得進行。
但是，當我們使用了Mock來進行模擬對象后，我們就可以把這種依賴解耦，只關心A本身的測試，它所依賴的B和C，全部使用Mock出來的對象，并且給MockB和MockC指定一個明確的行為。就像這樣：

因此，當我們使用Mock后，對于那些難以構建的對象，就變成了個模擬對象，只需要提前的做Stubbing（樁）即可，所謂做樁數據，也就是告訴Mock對象，當與之交互時執行何種行為過程。比如當調用B對象的b()方法時，我們期望返回一個true，這就是一個設置樁數據的預期。

基礎

Mockito 簡明教程

Spring Boot 中使用

上面的 Spring MVC 測試中也使用到了 Mockito，

spring-boot-starter-test 自帶了 mockito-core。

基礎業務

@Entity

@Data

@NoArgsConstructor

public class User implements Serializable {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

@Column(unique = true, nullable = false, length = 50)

private String username;

private String password;

@CreationTimestamp

private Date createDate;

public User(Long id, String username) {

this.id = id;

this.username = username;

}

public interface IUserRepository extends JpaRepository<User, Long> {

boolean updateUser(User user);

}

@Service

@RequiredArgsConstructor(onConstructor = @__(@Autowired))

public class UserServiceImpl implements IUserService {

private final IUserRepository userRepository;

@Override

public User findOne(Long id) {

return userRepository.getOne(id);

}

@Override

public boolean updateUsername(Long id, String username) {

User user = findOne(id);

if (user == null) {

return false;

}

user.setUsername(username);

return userRepository.updateUser(user);

}

測試類

public class IUserServiceTest {

private IUserService userService;

//@Mock

private IUserRepository userRepository;

@Before

public void setUp() throws Exception {

// 對所有注解了@Mock的對象進行模擬

// MockitoAnnotations.initMocks(this);

// 不使用注解，可以對單個對象進行 mock

userRepository = Mockito.mock(IUserRepository.class);

// 構造被測試對象

userService = new UserServiceImpl(userRepository);

// 打樁，構建當 userRepository的 getOne 函數執行參數為 1的時候，設置返回的結果 User

Mockito.when(userRepository.getOne(1L)).thenReturn(new User(1L, "kronchan"));

// 打樁，構建當 userRepository的 getOne 函數執行參數為 2的時候，設置返回的結果 null

Mockito.when(userRepository.getOne(2L)).thenReturn(null);

// 打樁，構建當 userRepository的 getOne 函數執行參數為 3的時候，設置結果拋出異常

Mockito.when(userRepository.getOne(3L)).thenThrow(new IllegalArgumentException("The id is not support"));

// 打樁，當 userRepository.updateUser 執行任何User類型的參數，返回的結果都是true

Mockito.when(userRepository.updateUser(Mockito.any(User.class))).thenReturn(true);

}

@Test

public void testUpdateUsernameSuccess() {

long userId = 1L;

String newUsername = "new kronchan";

// 測試某個 service 的方法

boolean updated = userService.updateUsername(userId, newUsername);

// 檢查結果

Assert.assertThat(updated, Matchers.is(true));

// Verifies certain behavior <b>happened once</b>.

// mock對象一旦創建，就會自動記錄自己的交互行為。通過verify(mock).someMethod()方法，來驗證方法是否被調用。

// 驗證調用上面的service 方法后是否 userRepository.getOne(1L) 調用過，

Mockito.verify(userRepository).getOne(userId);

// 有條件可以測試下沒有被調用過的方法：

// Mockito.verify(userRepository).deleteById(userId);

// 則會測試失敗：

// Wanted but not invoked:

// userRepository.deleteById(1L);

// However, there were exactly 2 interactions with this mock:

// userRepository.getOne(1L);

// userRepository.updateUser(

// User(id=1, username=new kronchan, password=null, createDate=null)

// );

// updateUsername 函數中我們調用了已經打樁了的其他的函數，現在我們來驗證進入其他函數中的參數

//構造參數捕獲器，用于捕獲方法參數進行驗證

ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);

// 驗證updateUser方法是否被調用過，并且捕獲入參

Mockito.verify(userRepository).updateUser(userCaptor.capture());

// 獲取參數 updatedUser

User updatedUser = userCaptor.getValue();

// 驗證入參是否是預期的

Assert.assertThat(updatedUser.getUsername(), Matchers.is(newUsername));

//保證這個測試用例中所有被Mock的對象的相關方法都已經被Verify過了

Mockito.verifyNoMoreInteractions(userRepository);

// 如果有一個交互，但是我們沒有verify ，則會報錯，

// org.mockito.exceptions.verification.NoInteractionsWanted:

// No interactions wanted here:

// -> at com.wuwii.service.IUserServiceTest.testUpdateUsernameSuccess(IUserServiceTest.java:74)

// But found this interaction on mock 'iUserRepository':

// -> at com.wuwii.service.impl.UserServiceImpl.findOne(UserServiceImpl.java:21)

// ***

}

@Test

public void testUpdateUsernameFailed() {

long userId = 2L;

String newUsername = "new kronchan";

// 沒有經過 mock 的 updateUser 方法，它返回的是 false

boolean updated = userService.updateUsername(userId, newUsername);

Assert.assertThat(updated, Matchers.not(true));

//驗證userRepository的getOne(2L)這個方法是否被調用過，（這個是被測試過的，此步驟通過）

Mockito.verify(userRepository).getOne(2L);

// 驗證 userRepository 的 updateUser(null)這個方法是否被調用過，（這個沒有被測試過，此步驟不通過）

//Mockito.verify(userRepository).updateUser(null);

Mockito.verifyNoMoreInteractions(userRepository);

}

分析

創建MOCK的對象

我需要對 userService 進行測定，就需要模擬 userRepository 對象。

我在 setUp() 方法中，模擬對象并打樁。

模擬對象有兩種方式：

對注解了@Mock的對象進行模擬 MockitoAnnotations.initMocks(this);

對單個對象手動 mock ：userRepository = Mockito.mock(IUserRepository.class);

數據打樁，除了上面我代碼上用的幾個方法，還有非常多的方法，具體可以在使用的時候看到，主要分下面幾種：

最基本的用法就是調用 when以及thenReturn方法了。他們的作用就是指定當我們調用被代理的對象的某一個方法以及參數的時候，返回什么值。

提供參數匹配器，靈活匹配參數。any()、any(Class<T> type)、anyBoolean()、anyByte()、anyChar()、anyInt()、anyLong()等等，它支持復雜的過濾，可以使用正則 Mockito.matches(".*User$"))，開頭結尾驗證endsWith(String suffix)，startsWith(String prefix)、判空驗證isNotNull() isNull()
也還可以使用 argThat(ArgumentMatchermatcher)，如：ArgumentMatcher只有一個方法boolean matches(T argument);傳入入參，返回一個boolean表示是否匹配。

Mockito.argThat(argument -> argument.getUsername.length() > 6;

Mockito還提供了兩個表示行為的方法：thenAnswer(Answer<?> answer);、thenCallRealMethod();,分別表示自定義處理調用后的行為，以及調用真實的方法。這兩個方法在有些測試用例中還是很有用的。

對于同一個方法，Mockito可以是順序與次數關心的。也就是說可以實現同一個方法，第一次調用返回一個值，第二次調用返回一個值，甚至第三次調用拋出異常等等。只需要連續的調用thenXXXX即可。

如果為一個返回為Void的方法設置樁數據。上面的方法都是表示的是有返回值的方法，而由于一個方法沒有返回值，因此我們不能調用when方法(編譯器不允許)。因此，對于無返回值的方法，Mockito提供了一些列的doXXXXX方法，比如：doAnswer(Answer answer)、doNothing()、doReturn(Object toBeReturned)、doThrow(Class<? extends Throwable> toBeThrown)、doCallRealMethod()。他們的使用方法其實和上面的thenXXXX是一樣的，但是when方法傳入的是Mock的對象：

/*對void的方法設置模擬*/

Mockito.doAnswer(invocationOnMock -> {

System.out.println("進入了Mock");

return null;

}).when(fileRecordDao).insert(Mockito.any());

當 Mockito 監視一個真實的對象的時候，我們也可以模擬這個對象的方法返回我們設置的期望值，

List spy = spy(new LinkedList());

// IndexOutOfBoundsException (the list is yet empty)

when(spy.get(0)).thenReturn("foo");

// You have to use doReturn() for stubbing

doReturn("foo").when(spy).get(0);

when方法參數中spy.get(0)，調用的是真實list對象的get(0)，這會產生 IndexOutOfBoundsException異常，所以這時需要用到 doReturn 方法來設置返回值。

驗證測試方法的結果

使用斷言語句檢查結果。

驗證MOCK對象的調用

其實，在這里我們如果只是驗證方法結果的正確的話，就非常簡單，但是，在復雜的方法調用堆棧中，往往可能出現結果正確，但是過程不正確的情況。比如，updateUserName方法返回false是有兩種可能的，一種可能是用戶沒有找到，還有一種可能就是userRepository.updateUser(userPO)返回false。因此，如果我們只是使用Assert.assertFalse(updated);來驗證結果，可能就會忽略某些錯誤。

因此我在上面的測試中還需要驗證指定的方法 userRepository).getOne(userId);是否運行過，而且我還使用了參數捕獲器，抓取中間的方法參數，用來驗證。

提供了verify(T mock, VerificationMode mode)方法。VerificationMode 有很多作用，

// 驗證指定方法 get(3) 沒有被調用

verify(mock, never()).get(3);
verifyZeroInteractions和verifyNoMoreInteractions 驗證所有 mock 的方法是否都調用過了。

總結

以上是生活随笔為你收集整理的学习 Spring Boot：（二十九）Spring Boot Junit 单元测试的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： micropython源码分析之c模组注
下一篇： SpringBoot(六)：Spring