[WebFlux] Test

BasicTest

@Slf4j
public class BasicTest {
    @Test
    public void test1() {
        Flux<Integer> flux = Flux.range(1, 3);

        StepVerifier.create(flux.log())
            .expectNext(1)
            .expectNext(2)
            .expectNext(3)
            .verifyComplete();
    }

    @Test
    public void test2() {
        Flux<Integer> flux = Flux.range(1, 3);

        StepVerifier.create(flux.log())
            .expectNext(1, 2, 3)
            .verifyComplete();
    }

    @Test
    public void test3() {
        Flux<String> flux = Flux.just("A", "B", "C")
            .delayElements(Duration.ofSeconds(1))
            .doFinally(signalType -> {
                log.warn("signalType : {}", signalType);
            });

        StepVerifier.create(flux.log())
            .expectNext("A", "B")
            .thenCancel()
            .verify();
    }

    @Test
    public void test4() {
        VirtualTimeScheduler.getOrSet();

        Flux<Long> flux = Flux.interval(Duration.ofSeconds(1)).take(3);

        StepVerifier.withVirtualTime(() -> flux.log())
            .thenAwait(Duration.ofSeconds(10))
            .expectNext(0L, 1L, 2L)
            .verifyComplete();
    }
}

ErrorTest

public class ErrorTest {
    @Test
    public void test1() {
        Flux<Integer> flux = Flux
            .range(1, 3)
            .concatWith(Flux.error(new RuntimeException()));

        StepVerifier.create(flux)
            .expectNext(1, 2, 3)
            .expectError(RuntimeException.class)
            .verify();
    }

    @Test
    public void test2() {
        Flux<Integer> flux = Flux
            .range(1, 3)
            .concatWith(Flux.error(new RuntimeException("Some Error")));

        StepVerifier.create(flux)
            .expectNext(1, 2, 3)
            .expectErrorMessage("Some Error")
            .verify();
    }

    @Test
    public void test3() {
        Flux<String> flux = Flux.just("A", "B", "C")
            .concatWith(Flux.error(new RuntimeException("Some Error")))
            .onErrorReturn("some default value");

        StepVerifier.create(flux)
            .expectNext("A", "B", "C")
            .expectNext("some default value")
            .verifyComplete();
    }

    @Test
    public void test4() {
        Flux<String> flux = Flux.just("A", "B", "C")
            .concatWith(Flux.error(new RuntimeException("Some Error")))
            .onErrorResume(throwable -> Flux.just("D"));

        StepVerifier.create(flux.log())
            .expectNext("A", "B", "C")
            .expectNext("D")
            .verifyComplete();
    }
}

MockTest

@SpringBootTest
public class MockTest {
    @InjectMocks
    private StudentController studentController;

    @Mock
    private StudentService studentServiceMock;

    @Test
    public void test1() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        StepVerifier.create(studentController.getStudents().log())
            .expectSubscription()
            .expectNext(student)
            .verifyComplete();
    }
}

ControllerTest

@SpringBootTest
@AutoConfigureWebTestClient
public class ControllerTest {
    @Autowired
    private WebTestClient webTestClient;

    @MockBean
    private StudentService studentServiceMock;

    @Test
    public void test1() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().is2xxSuccessful()
            .expectBody()
            .jsonPath("$.[0].id").isEqualTo(student.getId())
            .jsonPath("$.[0].name").isEqualTo(student.getName())
            .jsonPath("$.[0].age").isEqualTo(student.getAge());
    }

    @Test
    public void test2() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().is2xxSuccessful()
            .expectBodyList(Student.class)
            .hasSize(1)
            .contains(student);
    }

    @Test
    public void test3() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudent(ArgumentMatchers.anyString())).thenReturn(Mono.just(student));

        webTestClient.get()
            .uri("/api/students/{id}", student.getId())
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().is2xxSuccessful()
            .expectBody(Student.class)
            .isEqualTo(student);
    }

    @Test
    public void test4() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        Flux<Student> students = webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isOk()
            .returnResult(Student.class)
            .getResponseBody();

        StepVerifier.create(students.log())
            .expectSubscription()
            .expectNext(student)
            .verifyComplete();
    }

    @Test
    public void test5() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isOk()
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .expectBodyList(Student.class)
            .hasSize(1);
    }

    @Test
    public void test6() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        EntityExchangeResult<List<Student>> result = webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isOk()
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .expectBodyList(Student.class)
            .returnResult();

        assertEquals(List.of(student), result.getResponseBody());
    }

    @Test
    public void test7() {
        Student student = new Student("TEST_ID", "TEST_NAME", 20);

        BDDMockito.when(studentServiceMock.getStudents()).thenReturn(Flux.just(student));

        webTestClient.get()
            .uri("/api/students")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isOk()
            .expectHeader().contentType(MediaType.APPLICATION_JSON)
            .expectBodyList(Student.class)
            .consumeWith((response) -> {
                assertEquals(List.of(student), response.getResponseBody());
            });
    }

    @Test
    public void test8() {
        BDDMockito.when(studentServiceMock.deleteStudent(ArgumentMatchers.anyString())).thenReturn(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)));

        webTestClient.delete()
            .uri("/api/students/{id}", "INVALID_ID")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isNotFound();
    }
}