스프링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 웹플럭스와 테스트 전략

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

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

Similar to 스프링5 웹플럭스와 테스트 전략 (20)

More from if kakao

More from if kakao (20)

Recently uploaded

Recently uploaded (20)

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