Spring Boot Test 系列4 - 深入探究使用WebTestClient作API测试

阳光穿透心脏的1/2处 2022-10-20 00:54 19阅读 0赞

### 文章目录 ###

*  Spring Boot Test 系列4 - 深入探究使用WebTestClient作API测试
 *   *  前言
     *  API设计
     *   *  资源
         *  URI
         *  API
     *  单元测试驱动开发
     *   *  创建单元测试类
         *  创建Controller类
         *  Case 1 - 查询全部用户
         *   *  编写测试
             *  运行测试-失败
             *  定义API
             *  运行测试-成功
         *  Case 2 - 创建新用户
         *   *  编写测试
             *  运行测试-失败
             *  定义POST方法
             *  运行测试-成功
         *  Case3 - 查询指定ID的用户
         *   *  编写测试
             *  运行测试-失败
             *  定义API
             *  运行测试-成功
         *  Case3 - 删除指定ID的用户
         *   *  编写测试
             *  运行测试-失败
             *  定义DELETE方法
             *  运行测试-成功
         *  单元测试小结
     *  集成测试驱动开发
     *   *  创建集成测试类
         *  Case 1 - 创建新用户
         *   *  编写测试
             *  运行测试-失败
             *  实现数据的存取逻辑
             *  运行测试-失败
             *  实现创建用户的逻辑
             *  实现根据ID查询用户的逻辑
             *  运行测试-成功
             *  编写测试-根据ID查找不到用户时返回NOT\_FOUND
             *  编写测试 - 创建新用户成功后，在response headers的Location中返回该用户的URI
             *  运行测试-失败
             *  实现将新用户的URI放到Location的逻辑：
             *  运行测试-成功
             *  编写测试 - 新建用户时，如果用户已存在，则返回BAD\_REQUEST的HTTP Status
             *  运行测试-失败
             *  实现在ID重复时返回BAD\_REQUEST的逻辑
             *  运行测试-成功
             *  重构测试方法
             *  运行测试-成功
         *  Case 2 - 删除用户
         *   *  编写测试
             *  运行测试-失败
             *  实现删除逻辑
             *  运行测试-成功
             *  在每个测试执行结束后清空数据
         *  Case 3 - 查找全部用户
         *   *  编写测试
             *  运行测试-失败
             *  实现逻辑
             *  运行测试-成功
             *  Case 4 - 校验入参
             *  编写测试
             *  运行测试-失败
             *  实现校验逻辑
             *  
             *  运行测试-成功
         *  集成测试小结
     *  在单元测试中mock UserService
     *  小结
     *  参考文档
     *   *  REST API
         *  HTTP
         *  Spring Boot
         *  Testing

# Spring Boot Test 系列4 - 深入探究使用WebTestClient作API测试 #

## 前言 ##

本文为Spring Boot Test系列的第四篇的深入探究使用WebTestClient作API测试。

前置文章：

*  [Spring Boot Test 系列3 - 使用WebTestClient测试Web层][Spring Boot Test _3 - _WebTestClient_Web]

## API设计 ##

### 资源 ###

资源：

*  User - 用户

数据示例：

{ 
        "id": 10,
        "name": "test",
        "tags": [
            "testing",
            "webtestclient"
        ]
    }

### URI ###

URI：

*  `/api/users` \- User资源集合路径
 *  `/api/users/{id}` \- User资源路径

说明：

*  **名词**：基于资源设计URI，资源为名词，在URI中使用名词的复数形式。
 *  **动词**：默认使用HTTP Method作为动词，如果URI中出现动词，需要有业务含义，不要用CRUD等动词。
 *  **前缀**：建议使用统一的URI前缀，比如`/api/`。

### API ###

<table> 
 <thead> 
  <tr> 
   <th>URI</th> 
   <th>HTTP Method</th> 
   <th>HTTP Status</th> 
   <th>Use Case</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>/api/users</code></td> 
   <td>GET</td> 
   <td>200</td> 
   <td>查询全部用户</td> 
  </tr> 
  <tr> 
   <td><code>/api/users/</code></td> 
   <td>POST</td> 
   <td>201, 400</td> 
   <td>创建新用户</td> 
  </tr> 
  <tr> 
   <td><code>/api/users/{id}</code></td> 
   <td>GET</td> 
   <td>200, 404</td> 
   <td>查询指定ID的用户</td> 
  </tr> 
  <tr> 
   <td><code>/api/users/{id}</code></td> 
   <td>DELETE</td> 
   <td>200</td> 
   <td>删除指定ID的用户</td> 
  </tr> 
 </tbody> 
</table>

说明：

*  只支持`application/json` 的Media Type。
 *  HTTP Status Code参见参考文档。

## 单元测试驱动开发 ##

### 创建单元测试类 ###

创建`UserControllerTest` 的单元测试类：

@WebFluxTest(UserController.class)
    public class UserControllerTest { 
    
        @Autowired
        private WebTestClient webTestClient;
    
    }

### 创建Controller类 ###

按`Alt` \+ `Enter` 创建`UserController` 类。

@RestController
    public class UserController { 
    }

### Case 1 - 查询全部用户 ###

#### 编写测试 ####

在`UserControllerTest` 类中添加测试方法：

@Test
    @DisplayName("should return all users")
    void shouldReturnAllUsers() { 
      this.webTestClient
        .get()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isOk();
    
    }

> Tips: 通过Intellij的live tempalte可以快捷地添加一个测试方法模板。

#### 运行测试-失败 ####

测试失败，因为还没有在`UserController`类中定义URI。

Status expected:<200 OK> but was:<404 NOT_FOUND>

#### 定义API ####

@RestController
    @RequestMapping("/api/users")
    public class UserController { 
    
        @GetMapping
        public List<User> getAllUsers() { 
            return null;
        }
    }

说明：

*  `@RequestMapping("/api/users")` 定义了URI的统一前缀。
 *  `@GetMapping` \- GET方法。

创建User类：

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User { 
        private Long id;
        private String name;
        private Set<String> tags;
    }

说明：

*  使用了Lombok的注解来简化代码。

#### 运行测试-成功 ####

测试成功。

> Tips: 使用Intellij的Split window功能来在左右两边分别显示测试类和实现类，方便测试和阅读。

### Case 2 - 创建新用户 ###

#### 编写测试 ####

@Test
    @DisplayName("should create new user")
    void shouldCreateNewUser() { 
      User newUser = new User(1L, "William", Set.of("java", "openshift"));
    
      this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(newUser), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.CREATED);
    
    }

说明：

*  创建新用户成功后，返回HTTP Status为`HttpStatus.CREATED`。

#### 运行测试-失败 ####

测试失败，因为还没有实现POST方法。

Status expected:<201> but was:<405>

#### 定义POST方法 ####

@PostMapping
    public ResponseEntity<Void> createNewUser(@RequestBody User user) { 
      return ResponseEntity.created(null).build();
    }

说明：

*  `@PostMapping` POST方法
 *  `@RequestBody User user` \- 接受一个User对象的JSON字符串。
 *  返回一个`ResponseEntity` 对象，包含的HTTP Status为`HttpStatus.CREATED`。

#### 运行测试-成功 ####

测试成功。

### Case3 - 查询指定ID的用户 ###

#### 编写测试 ####

@Test
    @DisplayName("should get user by id")
    void shouldGetUserById() { 
      Long userId = 1L;
      this.webTestClient
        .get()
        .uri("/api/users/{id}", userId)
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isOk();
    
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现该API。

Status expected:<200 OK> but was:<404 NOT_FOUND>

#### 定义API ####

@GetMapping("/{id}")
    public User getUserById(@PathVariable("id") Long id) { 
      return null;
    }

#### 运行测试-成功 ####

测试成功。

### Case3 - 删除指定ID的用户 ###

#### 编写测试 ####

@Test
    @DisplayName("should delete user by id")
    void shouldDeleteUserById() { 
      Long userId = 1L;
      this.webTestClient
        .delete()
        .uri("/api/users/{id}", userId)
        .exchange()
        .expectStatus()
        .isOk();
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现DELETE方法。

Status expected:<200 OK> but was:<405 METHOD_NOT_ALLOWED>

#### 定义DELETE方法 ####

@DeleteMapping("/{id}")
    public void deleteByUserId(@PathVariable("id") Long id) { 
    }

#### 运行测试-成功 ####

测试成功。

### 单元测试小结 ###

小结：

*  使用了`@WebFluxTest(UserController.class)` 来对`UserController`类作单元测试，不需要加载完整的Application Context和启动server，单元测试运行用时短。
 *  使用了`WebTestClient` 测试了API的Happy Path。
 *  本单元测试中未涉及业务逻辑，对业务逻辑的测试将在后面的集成测试章节介绍。

此时的`UserController`类还未包含业务逻辑：

@RestController
    @RequestMapping("/api/users")
    public class UserController { 
    
        @GetMapping
        public List<User> getAllUsers() { 
            return null;
        }
    
        @PostMapping
        public ResponseEntity<Void> createNewUser(@RequestBody User user) { 
            return ResponseEntity.created(null).build();
        }
    
        @GetMapping("/{id}")
        public User getUserById(@PathVariable("id") Long id) { 
            return null;
        }
    
        @DeleteMapping("/{id}")
        public void deleteByUserId(@PathVariable("id") Long id) { 
        }
    }

后面将在集成测试章节完善其业务逻辑。

## 集成测试驱动开发 ##

### 创建集成测试类 ###

创建`UserControllerIT` 的集成测试类：

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    @AutoConfigureWebTestClient
    public class UserControllerIT { 
    
        @Autowired
        private WebTestClient webTestClient;
        
    }

说明：

*  可以通过`XXXTest` 和`XXXIT` 区分单元测试和集成测试。
 *  通过`@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)` 启动server侦听随机端口。
 *  通过`@AutoConfigureWebTestClient` 自动配置WebTestClient。

### Case 1 - 创建新用户 ###

因为要先可以创建新用户，才能作其它测试。

#### 编写测试 ####

@Test
    @DisplayName("should create new user")
    void shouldCreateNewUser() { 
      User newUser = new User(1L, "William", Set.of("java", "openshift"));
    
      // create a new user
      this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(newUser), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.CREATED);
    
      // check new created user
      this.webTestClient
        .get()
        .uri("/api/users/{id}", newUser.getId())
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isOk()
        .expectBody(User.class)
        .isEqualTo(newUser);
    }

说明：

*  先创建一个新用户，再根据用户ID查找新创建的用户。

#### 运行测试-失败 ####

测试失败，因为还没有实现数据的存取逻辑。

Response body expected:<User(id=1, name=William, tags=[openshift, java])> but was:<null>

#### 实现数据的存取逻辑 ####

在`UserController` 类中调用`UserService`类实现数据的存取逻辑。

在`UserController` 类中以构造方法方式注入`UserService` bean。

private final UserService userService;
    
    public UserController(UserService userService) { 
      this.userService = userService;
    }

说明：

*  建议通过构造方法方式注入bean，原因后叙。

创建`UserService`类:

@Service
    public class UserService { 
    }

#### 运行测试-失败 ####

测试失败，同样的错误，但是没有bean注入的错，说明`UserService` bean注入成功。

#### 实现创建用户的逻辑 ####

在`UserController.createNewUser()` 方法中调用`UserService`来创建新用户。

@PostMapping
    public ResponseEntity<Void> createNewUser(@RequestBody User user) { 
      userService.addNewUser(user);
      return ResponseEntity.created(null).build();
    }

在`UserService` 类中创建`addNewUser` 方法：

private List<User> userList;
    
    @PostConstruct
    public void init() { 
      userList = new ArrayList<>();
    }
    
    public Optional<User> addNewUser(User user) { 
      this.userList.add(user);
      return Optional.of(user);
    }

说明：

*  将新用户保存到`userList` 中，并返回该User的Optional。

#### 实现根据ID查询用户的逻辑 ####

在`UserController.getUserById()` 方法中调用`UserService`来根据ID查询用户。

@GetMapping("/{id}")
    public User getUserById(@PathVariable("id") Long id) { 
      return userService
        .getUserById(id)
        .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND,
                                                       String.format("User with id [%s] not found", id)));
    }

说明：

*  在查找不到用户时，返回HTTP Status为`HttpStatus.NOT_FOUND`。

在`UserService` 类中创建`getUserById` 方法：

public Optional<User> getUserById(Long id) { 
      return this.userList
        .stream()
        .filter(user -> user.getId().equals(id))
        .findFirst();
    }

说明：

*  将userList转为Stream后来根据ID查找，并返回第一个找到的用户。

#### 运行测试-成功 ####

测试成功。

#### 编写测试-根据ID查找不到用户时返回NOT\_FOUND ####

@Test
    @DisplayName("should return not found for get unknown user")
    void shouldReturnNotFoundForGetUnknownUser() { 
      Long unknownId = 9999L;
      this.webTestClient
        .get()
        .uri("/api/users/{id}", unknownId)
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.NOT_FOUND);
    }

因为前面已实现根据ID查找不到用户时返回NOT\_FOUND的逻辑，这里添加的测试只是起到验证作用。

确保该测试通过。

#### 编写测试 - 创建新用户成功后，在response headers的Location中返回该用户的URI ####

修改`UserControllerIT` 的 `shouldCreateNewUser` 方法：

说明：

*  将创建新用户的response保存到`FluxExchangeResult<Void>` 对象中。
 *  将response headers的Location的值保存到`newUserURI`中。
 *  根据`newUserURI`去查询指定用户。

#### 运行测试-失败 ####

测试失败，因为还没有将新用户的URI放到Location中。

java.lang.NullPointerException

#### 实现将新用户的URI放到Location的逻辑： ####

@PostMapping
    public ResponseEntity<Void> createNewUser(@RequestBody User user, UriComponentsBuilder builder) { 
      userService.addNewUser(user);
      URI location = builder.path("/api/users/{id}").buildAndExpand(user.getId()).toUri();
      return ResponseEntity.created(location).build();
    }

#### 运行测试-成功 ####

测试成功。

#### 编写测试 - 新建用户时，如果用户已存在，则返回BAD\_REQUEST的HTTP Status ####

在测试类中，添加一个新的测试方法：

@Test
    @DisplayName("should return bad request for create existing user")
    void shouldReturnBadRequestForCreateExistingUser() { 
      Long existingId = 11L;
      User user1 = new User(existingId, "John", Set.of("python", "web"));
      User user2 = new User(existingId, "Tom", Set.of("mysql", "redis"));
    
      // create a new user
      this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(user1), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.CREATED);
    
      // create another user with existing id
      this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(user2), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.BAD_REQUEST);
    
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现在ID重复时返回BAD\_REQUEST的逻辑。

Status expected:<400> but was:<201>

#### 实现在ID重复时返回BAD\_REQUEST的逻辑 ####

修改`UserController`类的`createNewUser`方法：

@PostMapping
    public ResponseEntity<Void> createNewUser(@RequestBody User user, UriComponentsBuilder builder) { 
      User addedUser = userService
        .addNewUser(user)
        .orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST,
                                                       String.format("User with id [%s] already exist", user.getId())));
    
      URI location = builder.path("/api/users/{id}").buildAndExpand(addedUser.getId()).toUri();
      return ResponseEntity.created(location).build();
    }

说明：

*  在调用`UserService.addNewUser()` 方法返回空值时，返回`HttpStatus.BAD_REQUEST`。

修改`UserService.addNewUser()` 方法：

public Optional<User> addNewUser(User user) { 
      if (getUserById(user.getId()).isPresent()) { 
        return Optional.empty();
      }
      this.userList.add(user);
      return Optional.of(user);
    }

说明：

*  增加判断如果指定ID的用户已经存在，则返回空值。

#### 运行测试-成功 ####

测试成功。

#### 重构测试方法 ####

重构`shouldReturnBadRequestForCreateExistingUser` 测试方法，以精简重复代码。

@Test
    @DisplayName("should return bad request for create existing user")
    void shouldReturnBadRequestForCreateExistingUser() { 
      Long existingId = 11L;
      User user1 = new User(existingId, "John", Set.of("python", "web"));
      User user2 = new User(existingId, "Tom", Set.of("mysql", "redis"));
    
      // create a new user
      createNewUserWithStatus(user1, HttpStatus.CREATED);
    
      // create another user with existing id
      createNewUserWithStatus(user2, HttpStatus.BAD_REQUEST);
    
    }
    
    private void createNewUserWithStatus(User user, HttpStatus httpStatus) { 
      this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(user), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(httpStatus);
    }

说明：

*  抽取代码到新的`createNewUserWithStatus` 方法中。

#### 运行测试-成功 ####

确保重构后测试成功。

### Case 2 - 删除用户 ###

#### 编写测试 ####

扩展上面的`shouldCreateNewUser` 方法，先创建用户，再查找用户确认已添加，再删除用户，再查找用户确认已删除。

@Test
    @DisplayName("should create new user")
    void shouldCreateNewUser() { 
      User newUser = new User(1L, "William", Set.of("java", "openshift"));
    
      // create a new user
      FluxExchangeResult<Void> result = this.webTestClient
        .post()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .header(CONTENT_TYPE, APPLICATION_JSON_VALUE)
        .body(Mono.just(newUser), User.class)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.CREATED)
        .returnResult(Void.class);
    
      String newUserURI = result.getResponseHeaders().get(LOCATION).get(0);
    
      // check new created user
      this.webTestClient
        .get()
        .uri(newUserURI)
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isOk()
        .expectBody(User.class)
        .isEqualTo(newUser);
    
      // delete new created user
      this.webTestClient
        .delete()
        .uri(newUserURI)
        .exchange()
        .expectStatus()
        .isOk();
    
      // check if delete
      this.webTestClient
        .get()
        .uri(newUserURI)
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.NOT_FOUND);
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现删除逻辑。

Status expected:<404> but was:<200>

#### 实现删除逻辑 ####

在`UserController`类中调用`UserService`删除用户：

@DeleteMapping("/{id}")
    public void deleteByUserId(@PathVariable("id") Long id) { 
      userService.deleteById(id);
    }

在`UserService` 中实现删除逻辑：

public void deleteById(Long id) { 
      this.userList.removeIf(user -> user.getId().equals(id));
    }

#### 运行测试-成功 ####

测试成功。

#### 在每个测试执行结束后清空数据 ####

在每个测试执行结束后清空数据，避免测试方法互相干扰。

@AfterEach
    void cleanUp() { 
      List<User> userList =  this.webTestClient
        .get()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.OK)
        .expectBodyList(User.class)
        .returnResult()
        .getResponseBody();
      userList.forEach(user -> this.webTestClient
                       .delete()
                       .uri("/api/users/{id}", user.getId())
                       .exchange()
                       .expectStatus()
                       .isOk());
    }

### Case 3 - 查找全部用户 ###

#### 编写测试 ####

@Test
    @DisplayName("should get all users")
    void shouldGetAllUsers() { 
    
      this.webTestClient
        .get()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.OK)
        .expectBodyList(User.class)
        .hasSize(0);
    
      User user1 = new User(1L, "user1", Set.of("python", "web"));
      User user2 = new User(2L, "user2", Set.of("mysql", "redis"));
      User user3 = new User(3L, "user3", Set.of("java", "jenkins"));
    
      createNewUserWithStatus(user1, HttpStatus.CREATED);
      createNewUserWithStatus(user2, HttpStatus.CREATED);
      createNewUserWithStatus(user3, HttpStatus.CREATED);
    
      this.webTestClient
        .get()
        .uri("/api/users")
        .header(ACCEPT, APPLICATION_JSON_VALUE)
        .exchange()
        .expectStatus()
        .isEqualTo(HttpStatus.OK)
        .expectBodyList(User.class)
        .hasSize(3)
        .isEqualTo(List.of(user1, user2, user3));
    
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现逻辑。

Response body does not contain 3 elements expected:<3> but was:<0>

#### 实现逻辑 ####

`UserController` 类：

@GetMapping
    public List<User> getAllUsers() { 
      return userService.getAllUsers();
    }

`UserService` 类：

public List<User> getAllUsers() { 
      return this.userList;
    }

#### 运行测试-成功 ####

测试成功。

#### Case 4 - 校验入参 ####

#### 编写测试 ####

@Test
    @DisplayName("should return bad request for invalid parameters")
    void shouldReturnBadRequestForInvalidParameters() { 
      User emptyUser = new User(null, "", Set.of("python", "web"));
      createNewUserWithStatus(emptyUser, HttpStatus.BAD_REQUEST);
    }

#### 运行测试-失败 ####

测试失败，因为还没有实现校验逻辑。

Status expected:<400> but was:<201>

#### 实现校验逻辑 ####

引入`spring-boot-starter-validation` 依赖：

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

说明：

*  Spring Boot 2.4 需要单独引入 `spring-boot-starter-validation` 依赖。

给`UserController.createNewUser`方法的user参数加上`@Valid` 注解，表示对该参数作校验。

@PostMapping
    public ResponseEntity<Void> createNewUser(@RequestBody @Valid User user, UriComponentsBuilder builder) { 
      ...
    }

在`User`上对要校验的字段加上相应注解。

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User { 
        @NotNull(message = "Id is mandatory")
        private Long id;
        @NotBlank(message = "Name is mandatory")
        private String name;
        private Set<String> tags;
    }

说明：

*  `@NotNull` 声明该对象不能为null。
 *  `@NotBlank` 声明该字符串不能为空。

####  ####

#### 运行测试-成功 ####

测试成功。

### 集成测试小结 ###

小结：

*  同时测试了`UserController`和`UserService`。
 *  测试了Happy Path和Sad Path。
 *  测试了对返回单个对象或对象集合的断言。
 *  测试了用不同的HTTP Status Code表示资源的不同状态。
 *  在每次测试后清空数据，避免测试方法互相干扰。
 *  测试了校验逻辑。

## 在单元测试中mock UserService ##

在`UserController`中引入`UserService` 后会导致原来的`UserControllerTest`单元测试类报错。

需要在`UserControllerTest`单元测试类中mock UserService。

@WebFluxTest(UserController.class)
    class UserControllerTest { 
    
        @Autowired
        private WebTestClient webTestClient;
    
        @MockBean
        private UserService userService;
    
        @Test
        @DisplayName("should return all users")
        void shouldReturnAllUsers() { 
            when(userService.getAllUsers()).thenReturn(null);
          	// test
        }
    
        @Test
        @DisplayName("should create new user")
        void shouldCreateNewUser() { 
            User newUser = new User(1L, "William", Set.of("java", "openshift"));
    
            when(userService.addNewUser(newUser)).thenReturn(Optional.of(newUser));
    
            // test
    
        }
    
        @Test
        @DisplayName("should get user by id")
        void shouldGetUserById() { 
            Long userId = 1L;
            when(userService.getUserById(userId)).thenReturn(Optional.of(new User(userId, "mock", Set.of("tag1", "tag2"))));
            // test
    
        }
    
        @Test
        @DisplayName("should delete user by id")
        void shouldDeleteUserById() { 
            Long userId = 1L;
            doNothing().when(userService).deleteById(userId);
            // test
        }

## 小结 ##

如果只想测试Controller，就在Controller的单元测试中mock Service的bean。

如果想同时测试Controller和Service，就写集成测试。

WebTestClient同时支持API调用和对HTTP response的流式断言，不需要再引入第三方断言工具，使用起来也非常方面。

一个好的Controller：

*  使用正确的URI
 *  使用正确的HTTP Method
 *  使用不同的HTTP Status Code表示资源的不同状态
 *  对入参进行校验

本文示例代码参见：

*  [springboot-test-demo][]

## 参考文档 ##

### REST API ###

*  [IBM Cloud | What is REST API][IBM Cloud _ What is REST API]
 *  [IBM Cloud API handbook][]

### HTTP ###

*  [https://httpstatuses.com/][https_httpstatuses.com]
 *  [HTTP Status Code][]
 *  [HTTP Methods][]
 *  [HTTP headers - Accept][]
 *  [HTTP headers - Content-Type][]
 *  [HTTP headers - Location][]

### Spring Boot ###

*  [Spring WebTestClient for Efficient REST API Testing][]
 *  [Validation in Spring Boot][]
 *  [Error Handling for REST with Spring][]
 *  [Using Spring ResponseEntity to Manipulate the HTTP Response][]
 *  [Why You Should Use Constructor Injection in Spring][]
 *  [Spring DI Patterns: The Good, The Bad, and The Ugly][Spring DI Patterns_ The Good_ The Bad_ and The Ugly]

### Testing ###

*  [Mocking Void Methods with Mockito][]
 *  [使用Intellij IDEA和JUnit5练习FizzBuzz TDD Kata][Intellij IDEA_JUnit5_FizzBuzz TDD Kata]
 *  [Writing Tests with JUnit5][]

[Spring Boot Test _3 - _WebTestClient_Web]: https://cookcode.blog.csdn.net/article/details/118654505
[springboot-test-demo]: https://github.com/cookcodeblog/springboot-test-demo
[IBM Cloud _ What is REST API]: https://youtu.be/lsMQRaeKNDk
[IBM Cloud API handbook]: https://cloud.ibm.com/docs/api-handbook
[https_httpstatuses.com]: https://httpstatuses.com/
[HTTP Status Code]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
[HTTP Methods]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
[HTTP headers - Accept]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
[HTTP headers - Content-Type]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type
[HTTP headers - Location]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location
[Spring WebTestClient for Efficient REST API Testing]: https://rieckpil.de/spring-webtestclient-for-efficient-testing-of-your-rest-api/
[Validation in Spring Boot]: https://www.baeldung.com/spring-boot-bean-validation
[Error Handling for REST with Spring]: https://www.baeldung.com/exception-handling-for-rest-with-spring
[Using Spring ResponseEntity to Manipulate the HTTP Response]: https://www.baeldung.com/spring-response-entity
[Why You Should Use Constructor Injection in Spring]: https://reflectoring.io/constructor-injection/
[Spring DI Patterns_ The Good_ The Bad_ and The Ugly]: https://dzone.com/articles/spring-di-patterns-the-good-the-bad-and-the-ugly
[Mocking Void Methods with Mockito]: https://www.baeldung.com/mockito-void-methods
[Intellij IDEA_JUnit5_FizzBuzz TDD Kata]: https://cookcode.blog.csdn.net/article/details/118637076
[Writing Tests with JUnit5]: https://blog.jetbrains.com/idea/2020/09/writing-tests-with-junit-5/