测试 Webflux REST API 的正确方法答案

【问题标题】：Properly ways to testing Webflux REST API测试 Webflux REST API 的正确方法
【发布时间】：2020-06-22 00:03:51
【问题描述】：

我第一次使用 Webflux 和 Reactive Mongo 构建 REST 服务。

这是我的控制器和服务实现：

控制器：

@RestController
@RequestMapping("/endpoint/computer")
@RequiredArgsConstructor
public class ComputerEndpoint {

    private final ComputerServiceImpl computerService;

    @PostMapping
    @ResponseStatus(code = HttpStatus.CREATED)
    public Mono<Computer> createNewComputer(@Valid @RequestBody Computer computer) {
        return computerService.create(computer);
    }

    @GetMapping
    public Flux<Computer> findAllComputer() {
        return computerService.findAll();
    }

    @GetMapping("/{id}")
    public Mono<Computer> findOneComputer(@PathVariable("id") String id) {
        return computerService.findById(id);
    }

    @PutMapping("/{id}")
    public Mono<Computer> updateOneComputer(@PathVariable("id") String id, @Valid @RequestBody Computer parsedBody) {
        return computerService.update(id, parsedBody);
    }

    @DeleteMapping("/{id}")
    public Mono<Void> deleteOneComputer(@PathVariable("id") String id) {
        return computerService.deleteById(id);
    }

}

ServiceImpl：

@Service
@RequiredArgsConstructor
public class ComputerServiceImpl implements ComputerService {

    private final ComputerRepository repo;

    @Override
    public Flux<Computer> findAll() {
        return repo.findAll();
    }

    @Override
    public Mono<Computer> findById(String id) {
        return repo.findById(id)
                .switchIfEmpty(Mono.error(new Exception("COMPUTER_NOT_FOUND")));
    }

    @Override
    public Flux<Computer> saveAll(List<Computer> computers) {
        return repo.saveAll(computers);
    }

    @Override
    public Mono<Computer> create(Computer computer) {
        return repo.save(computer);
    }

    @Override
    public Mono<Computer> update(String id, Computer computer) {
        return repo.findById(id)
                .switchIfEmpty(Mono.error(new Exception("COMPUTER_NOT_FOUND")))
                .map(c -> {
                    computer.setId(id);
                    return computer;
                })
                .flatMap(repo::save);
    }

    @Override
    public Mono<Void> delete(Computer computer) {
        return repo.delete(computer);
    }

    @Override
    public Mono<Void> deleteById(String id) {
        return repo.deleteById(id);
    }

    @Override
    public Mono<Void> deleteAll() {
        return repo.deleteAll();
    }
}

Reactive Stream（Mono 和 Flux）的原理对我来说相当新。然后我尝试使用 JUnit 5 和 Mockito 为这些方法编写一些测试。

测试：

@ExtendWith(SpringExtension.class)
@WebFluxTest(controllers = ComputerEndpoint.class)
@Import(ComputerServiceImpl.class)
class ComputerEndpointTest {

    @MockBean
    ComputerServiceImpl service;

    @Autowired
    private WebTestClient client;

    @Test
    void createNewComputer() {

        Computer computer = new Computer();
        computer.setName("DESKTOP PC");
        computer.setComputerModel("OptiPlex 7020");
        computer.setComputerSpecs("Q87 Mainboard, i5-4590, 16Gb Ram, 1TB HDD, 256Gb SSD, 300W PSU");

        Mockito.when(service.create(computer)).thenReturn(Mono.just(computer));

        client.post()
                .uri("/endpoint/computer")
                .contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue(computer))
                .exchange()
                .expectStatus().isCreated();

        Mockito.verify(service, Mockito.times(1)).create(computer);

    }

    @Test
    void findAllComputer() {

        Computer computer1 = new Computer();
        computer1.setName("DELL WORKSTATION");
        computer1.setComputerModel("OptiPlex 7020 Ultra");
        computer1.setComputerSpecs("Q87 Mainboard, i5-4590, 16Gb Ram, 1TB HDD, 256Gb SSD, 300W PSU");

        Computer computer2 = new Computer();
        computer2.setName("DELL PC");
        computer2.setComputerModel("OptiPlex 7020 Power");
        computer2.setComputerSpecs("Q87 Mainboard, i3-4150, 8Gb Ram, 500Gb HDD, 120Gb SSD, 300W PSU");

        Mockito.when(service.findAll()).thenReturn(Flux.just(computer1, computer2));

        client.get()
                .uri("/endpoint/computer")
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(Computer.class);

        Mockito.verify(service, Mockito.times(1)).findAll();
    }

    @Test
    void findOneComputer() {

        Computer computer = new Computer();
        computer.setId("3b241101-e2bb-4255-8caf-4136c566a962");
        computer.setName("DESKTOP PC");
        computer.setComputerModel("OptiPlex 7020");
        computer.setComputerSpecs("Q87 Mainboard, i5-4590, 16Gb Ram, 1TB HDD, 256Gb SSD, 300W PSU");

        Mockito.when(service.findById(computer.getId())).thenReturn(Mono.just(computer));

        client.get()
                .uri("/endpoint/computer/{id}", computer.getId())
                .exchange()
                .expectStatus().isOk()
                .expectBody(Computer.class);

        Mockito.verify(service, Mockito.times(1)).findById(computer.getId());
    }

    @Test
    void updateOneComputer() {

        Computer computerOrigin = new Computer();
        computerOrigin.setId("3b241101-e2bb-4255-8caf-4136c566a962");
        computerOrigin.setName("DESKTOP PC");
        computerOrigin.setComputerModel("OptiPlex 7020");
        computerOrigin.setComputerSpecs("Q87 Mainboard, i5-4590, 16Gb Ram, 1TB HDD, 256Gb SSD, 300W PSU");

        Computer computerUpdated = new Computer();
        computerUpdated.setName("DELL PC");
        computerUpdated.setComputerModel("OptiPlex 7020 Power");
        computerUpdated.setComputerSpecs("Q87 Mainboard, i3-4150, 8Gb Ram, 500Gb HDD, 120Gb SSD, 300W PSU");

        Mockito.when(service.update(computerOrigin.getId(), computerUpdated))
                .thenReturn(Mono.just(computerOrigin));

        client.put()
                .uri("/endpoint/computer/{id}", computerOrigin.getId())
                .contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue(computerUpdated))
                .exchange()
                .expectStatus().isOk();

        Mockito.verify(service, Mockito.times(1)).update(computerOrigin.getId(), computerUpdated);

    }

    @Test
    void deleteOneComputer() {

        Computer computer = new Computer();
        computer.setId("3b241101-e2bb-4255-8caf-4136c566a962");
        computer.setName("DESKTOP PC");
        computer.setComputerModel("OptiPlex 7020");
        computer.setComputerSpecs("Q87 Mainboard, i5-4590, 16Gb Ram, 1TB HDD, 256Gb SSD, 300W PSU");

        Mockito.when(service.deleteById(computer.getId())).thenReturn(Mono.empty());
        System.out.println(service.findById(computer.getId()));

        client.delete()
                .uri("/endpoint/computer/{id}", computer.getId())
                .exchange()
                .expectStatus().isOk();


        Mockito.verify(service, Mockito.times(1)).deleteById(computer.getId());

    }
}

所有测试都通过了。但是我不确定模拟过程是否正确完成，并且在没有任何持久性模拟的情况下满足了期望。尤其是当我怀疑删除它的 ID 而不持久化它的模拟时，删除测试。

所以问题是，编写响应式服务测试的正确方法是什么？如何设置期望满足一切以真正通过测试？

我可能对 atm 感到困惑，但请帮忙。

【问题讨论】：

我只是看了一眼，第一个让我印象深刻的是使用Exception 通用异常不是好的做法，因为它往往非常通用且难以识别问题。返回ResponseStatusException 在这里会更合适docs.spring.io/spring/docs/current/spring-framework-reference/…
我认为你的东西很适合单元测试。但是您可以使用嵌入式 mongodb（端到端）进行另一个集成测试。
@TinyOS 谢谢。我刚刚找到了进行单元测试的一些要点，集成测试是个好主意。
@ThomasAndolf 谢谢。我会尝试寻找一些适当的方法来抛出异常。

标签： mongodb spring-boot junit reactive-programming spring-webflux

【解决方案1】：

这看起来不错。请记住，您实际上是在测试您的 url -> 控制器映射、控制器 -> 服务映射、url 安全性、http 动词、有效负载注释等。

您可能希望为实际的服务实现编写单独的集成测试。

【讨论】：