스프링5 웹플럭스와 테스트 전략

호주에 거주하고 있지만 여러 나라를 다니며 일하기 좋아하는 개발자. 오래전 스
프링 프레임워크의 매력에 빠진 뒤로 스프링의 변화에 맞춰 기술을 공부하고 이
를 이용해 일을 하는 것을 좋아한다. 최신 스프링에 추가된 리액티브 함수형 프로
그래밍 기술을 블록체인 코어 개발을 비롯한 여러 분야에 적용해보고 있다. 토비
의 스프링이라는 책을 썼고, 유튜브에서 토비의 봄 TV라는 코딩 방송을 하기도 한
다.

public UserOrder orders(String email) {
try {
User user = findUserApi(email);
List<Order> orders = getOpenOrders(user);
return new UserOrder(email, orders);
}
catch(Exception e) {
return UserOrder.FAIL;
}
}

public UserOrder orders(String email) {
try {
User user = findUserApi(email);
List<Order> orders = getOpenOrders(user);
return new UserOrder(email, orders);
}
return UserOrder.FAIL;
}
}
두번의 동기 API 호출
RestTemplate

public DeferredResult<UserOrder> asyncOrders(String email) {
DeferredResult dr = new DeferredResult();
asyncFindUserApi(email).addCallback(
user -> asyncOrdersApi(user).addCallback(
orders -> {
dr.setResult(new UserOrder(email, orders));
},
e -> dr.setErrorResult(UserOrder.FAIL) ),
e -> dr.setErrorResult(UserOrder.FAIL));
return dr;
}

orders -> {
},
return dr;
}
두번의 비동기 API 호출
AsyncRestTemplate

orders -> {
},
return dr;
}
비동기 결과처리를 위한 콜백
매 단계마다 중첩

orders -> {
},
return dr;
}
매 단계마다 반복되는
예외 콜백

public CompletableFuture<UserOrder> asyncOrders2(String email) {
return asyncFindUser2(email)
.thenCompose(user -> asyncOrders2(user))
.thenApply(orders -> new UserOrder(email, orders))
.exceptionally(e -> UserOrder.FAIL);
}

} 비동기 결과처리 함수 이용
중첩되지 않음

}
Exceptional Programming
예외처리 단일화

try {
var user = await(asyncFindUser2(email));
var orders = await(asyncGetOrders2(user));
return completedFuture(new UserOrder(email, orders));
}
return completedFuture(UserOrder.FAIL);
}
} Java8+
빌드타임, 로딩타임, 런타임 코드생성

public Mono<UserOrder> asyncOrders4(String email) {
.flatMap(user -> asyncGetOrders4(user))
.map(orders -> new UserOrder(email, orders))
.onErrorReturn(UserOrder.FAIL);
} WebClient 이용
CompletableFuture와 유사해 보이지만…

public Mono<UserOrder> asyncOrders4(String email) {
.flatMap(user -> asyncGetOrders4(user))
.map(orders -> new UserOrder(email, orders))
.onErrorReturn(UserOrder.FAIL);
}
Mono<T> (0, 1)
Flux<T> (0 … n)

Mono<User> -> Mono<List<Order>> -> Mono<UserOrder>

•
o
o
o
o
o
•
o ßà
o
o
o
o
o

@Test
void mono() {
Mono<Integer> mono = Mono.just(1)
.subscribeOn(Schedulers.single());
mono.subscribe(item -> assertThat(item).isEqualTo(1));
}

@Test
void mono() {
}
테스트 성공!!

@Test
void mono() {
}
테스트 성공???

@Test
void mono3() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
mono.subscribe(item -> {
assertThat(item).isEqualTo(2);
latch.countDown();
});
latch.await();
}
테스트가 끝나지 않음!!

@Test
CountDownLatch latch = new CountDownLatch(1);
AtomicInteger item = new AtomicInteger();
mono.subscribe(
i -> item.set(i),
e -> latch.countDown(),
latch::countDown
);
latch.await();
assertThat(item.get()).isEqualTo(1);
}
테스트에서 동시성을 제어해야 하는
번거로움!

@Test
Integer item = mono.block();
}

@Test
Integer item = mono.block();
}
데이터 스트림이 종료될 때까지 대기

@Test
void stepVerifer() {
StepVerifier.create(mono)
.expectNext(2)
.verifyComplete();
}

@Test
.expectNext(2)
.verifyComplete();
}
Flux/Mono

@Test
.expectNext(2)
.verifyComplete();
}
동작을 검증

@Test
.expectNext(1)
.verifyComplete();
}
StepVerifier 생성

@Test
.expectNext(1)
.verifyComplete();
}
첫번째 데이터 아이템 값

@Test
.expectNext(1)
.verifyComplete();
}
스트림 완료

@Test
void stepVerifer2() {
var flux = Flux.just(1,2,3)
.concatWith(Mono.error(new RuntimeException()))
StepVerifier.create(flux)
.expectNext(1)
.expectNext(2)
.expectNext(3)
.expectError(RuntimeException.class)
.verify();
}

@Test
.expectNext(1)
.expectNext(2)
.expectNext(3)
.verify();
}
3 데이터 + 에러발생 스트림

@Test
.expectNext(1)
.expectNext(2)
.expectNext(3)
.verify();
}
첫번째 데이터 1

@Test
.expectNext(1)
.expectNext(2)
.expectNext(3)
.verify();
}
두번째 데이터 2

@Test
.expectNext(1)
.expectNext(2)
.expectNext(3)
.verify();
}
두번째 데이터 3

@Test
.expectNext(1)
.expectNext(2)
.expectNext(3)
.verify();
}
에러나고 종료

@GetMapping("/api")
public Mono<String> helloApi() {
return client.get()
.uri("/api/hello")
.retrieve()
.onStatus(HttpStatus::is4xxClientError,
res->Mono.error(new IllegalArgumentException()))
.onStatus(HttpStatus::is5xxServerError,
res->Mono.error(new RuntimeException()))
.bodyToMono(String.class)
.map(body -> body.toUpperCase())
.switchIfEmpty(Mono.just("Empty"));
}

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
원격 API 호출+로직

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
원격 API 요청 준비

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
원격 API 실행

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
응답 HTTP 상태 코드 처리

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
API 응답 body 변환

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
결과에 비즈니스 로직 적용

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
예외적인 결과 대응

@GetMapping("/api")
return client.get()
.uri("/api/hello")
.retrieve()
}
작성하기 매우 편리함
웹 플럭스 첫걸음은 WebClient로부터

@GetMapping(value="/api2", produces = "text/event-stream")
public Flux<String> helloStream() {
return client.get()
.uri("/stream")
.accept(MediaType.APPLICATION_STREAM_JSON)
.exchange()
.flatMapMany(res -> res.bodyToFlux(User.class))
.filter(user -> user.getId() > 1)
.map(user -> user.toString());
}
HTTP 스트리밍 API 요청도 간단

Flux 테스트로 작성 - StepVerifier

private WebClient.Builder builder;
private ExchangeFunction exchangeFunction;
@Captor private ArgumentCaptor<ClientRequest> captor;
@BeforeEach void setUp() {
MockitoAnnotations.initMocks(this);
this.exchangeFunction = mock(ExchangeFunction.class);
when(this.exchangeFunction.exchange(this.captor.capture())).thenReturn(Mono.empty());
this.builder = WebClient.builder().baseUrl("/").exchangeFunction(this.exchangeFunction);
}
@Test void getRequest() {
this.builder.build().get().uri("/hello").exchange();
ClientRequest request = this.captor.getValue();
Mockito.verify(this.exchangeFunction).exchange(request);
verifyNoMoreInteractions(this.exchangeFunction);
assertEquals("/hello", request.url().toString());
assertEquals(new HttpHeaders(), request.headers());
assertEquals(Collections.emptyMap(), request.cookies());
}
가능은 하지만 과연?

private MockWebServer server;
private WebClient webClient;
@Before
public void setup() {
var connector = new ReactorClientHttpConnector();
this.server = new MockWebServer();
this.webClient = WebClient
.builder()
.clientConnector(connector)
.baseUrl(this.server.url("/").toString())
.build();
}
com.squareup.okhttp3:mockwebserver
WebClientIntegrationTests 유용한 샘플

@Test
public void shouldReceiveResponseHeaders() {
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain")
.setBody("Hello Spring!"));
Mono<HttpHeaders> result = this.webClient.get()
.uri("/greeting?name=Spring").exchange()
.map(response -> response.headers().asHttpHeaders());
StepVerifier.create(result).consumeNextWith(
httpHeaders -> {
assertEquals(MediaType.TEXT_PLAIN, httpHeaders.getContentType());
assertEquals(13L, httpHeaders.getContentLength()); })
.expectComplete().verify(Duration.ofSeconds(3));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
}); }

@Test
httpHeaders -> {
}); }
MockWebServer의 응답 준비

@Test
httpHeaders -> {
}); }
WebClient 코드 실행

@Test
httpHeaders -> {
}); }
응답 결과 검증

@Test
httpHeaders -> {
}); }
MockWebServer 검증

@GetMapping("/api")
return client.get()
.uri("/hello")
.retrieve()
.switchIfEmpty(Mono.just("Empty"))
}
•

@GetMapping("/api")
return client.get()
.uri("/hello")
.retrieve()
}
•
WebClient 호출

@GetMapping("/api")
return client.get()
.uri("/hello")
.retrieve()
}
•
일반 Mono/Flux 코드

interface HelloService {
Mono<String> hello();
}
@Component
public class RemoteHelloService implements HelloService {
public Mono<String> hello() {
return client.get()
.uri("/hello")
.retrieve()
}
}

@Autowired HelloService helloService;
@GetMapping("/api")
return this.helloService.hello()
.doOnError(c -> c.printStackTrace());
}
단순한 리액티브 API를 이용하는 코드
Mock 서비스로 대체 가능

public interface HttpHandler {
Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response);
}
•
•

public interface WebHandler {
Mono<Void> handle(ServerWebExchange exchange);
}
•
•
•

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);
RouterFunction<ServerResponse> route =
route(GET("/person/{id}").and(accept(APPLICATION_JSON)), handler::getPerson)
.andRoute(GET("/person").and(accept(APPLICATION_JSON)), handler::listPeople)
.andRoute(POST("/person"), handler::createPerson);
public class PersonHandler {
public Mono<ServerResponse> listPeople(ServerRequest request) { … }
public Mono<ServerResponse> createPerson(ServerRequest request) { … }
public Mono<ServerResponse> getPerson(ServerRequest request) { … }
}
웹 요청을 처리하고 응답을 만드는 순수한 함수의 모음

}
웹 요청을 담당할 함수 핸들러를 찾음

}
ServerRequest->ServerResponse로 변환하는 리액티브 핸들러

HttpServer.create().host("localhost").handle(
new ReactorHttpHandlerAdapter(toHttpHandler(
route(path("/hello"),
req -> ok().body(fromObject("Hello Functional")))))
).bind().block();
스프링 컨테이너도 필요없음

•
o bindToApplicationContext 이용
@RunWith(SpringRunner.class)
@WebFluxTest
public class WebClientBootTest {
@Autowired WebTestClient webTestClient;
@Test
public void hello() {
webTestClient.get().uri("/hello/{name}", "Spring")
.exchange()
.expectStatus()
.isOk()
.expectBody(String.class)
.isEqualTo("Hello Spring");
}
}

•
@WebFluxTest
@Test
.exchange()
.expectStatus()
.isOk()
}
}
SpringBoot 앱을 MockServer에 배포
테스트에 사용할 WebTestClient 생성

•
@WebFluxTest
@Test
.exchange()
.expectStatus().isOk()
}
}
WebClient 처럼 API 호출하고

•
@WebFluxTest
@Test
.exchange()
}
}
API 호출 응답 결과 검증

•
var client = WebTestClient.bindToServer().baseUrl("http://localhost:8080").build();
client.get().uri("/hello/{name}", "Spring")
.exchange()
.expectStatus()
.isOk()
.isEqualTo("Hello");

• WebHttpHandlerBuilder가 이용할 수 있는 WebHandler API 구성
을 가진 ApplicationContext를 이용
var context = new AnnotationConfigApplicationContext(MyConfiguration.class);
WebTestClient client = WebTestClient.bindToApplicationContext(context).build();
.exchange()
.expectStatus()
.isOk()

WebTestClient client = WebTestClient.bindToController(
new MyController(), new HelloApi()
).build();
.exchange()
.expectStatus()
.isOk()

WebTestClient client = WebTestClient.bindToController(
new MyController(), new HelloApi()
).build();
.exchange()
.expectStatus()
.isOk()
특정 컨트롤러/핸들러만으로
테스트 대상 구성

•
Mono<ServerResponse> handler(ServerRequest request) {
return ServerResponse.ok().body(Mono.just("hello"),String.class);
}
@Test
void routerFunction() {
RouterFunction<ServerResponse> route = route(GET("/rf"), this::handler);
WebTestClient client = WebTestClient.bindToRouterFunction(route)
.build();
client.get().uri("/rf")
.exchange()
.isEqualTo("hello");
}

스프링5 웹플럭스와 테스트 전략

스프링5 웹플럭스와 테스트 전략

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a 스프링5 웹플럭스와 테스트 전략

Semelhante a 스프링5 웹플럭스와 테스트 전략 (20)

Mais de if kakao

Mais de if kakao (20)

Último

Último (20)

스프링5 웹플럭스와 테스트 전략