@Override public List<HttpMessageReader<?>> messageReaders() { return strategies.messageReaders(); } @Override
@Override public List<HttpMessageWriter<?>> messageWriters() { return strategies.messageWriters(); } @Override
public DefaultWebClientBuilder() { this.exchangeStrategies = ExchangeStrategies.withDefaults(); }
@Test public void withDefaults() { ExchangeStrategies strategies = ExchangeStrategies.withDefaults(); assertFalse(strategies.messageReaders().isEmpty()); assertFalse(strategies.messageWriters().isEmpty()); }
@Test public void empty() { ExchangeStrategies strategies = ExchangeStrategies.empty().build(); assertTrue(strategies.messageReaders().isEmpty()); assertTrue(strategies.messageWriters().isEmpty()); }
private void customizeWebTestClientCodecs(WebTestClient.Builder clientBuilder, ApplicationContext context) { Collection<CodecCustomizer> codecCustomizers = context .getBeansOfType(CodecCustomizer.class).values(); if (!CollectionUtils.isEmpty(codecCustomizers)) { clientBuilder.exchangeStrategies(ExchangeStrategies.builder() .codecs((codecs) -> codecCustomizers.forEach( (codecCustomizer) -> codecCustomizer.customize(codecs))) .build()); } }
@Override public void customize(WebClient.Builder builder) { builder.exchangeStrategies(ExchangeStrategies.empty() .codecs(codecs -> this.codecCustomizers .forEach((customizer) -> customizer.customize(codecs))).build()); if (this.baseUrl != null) { builder.baseUrl(this.baseUrl); } } }
private void customizeWebTestClientCodecs(WebTestClient.Builder builder) { if (!CollectionUtils.isEmpty(this.codecCustomizers)) { builder.exchangeStrategies(ExchangeStrategies.builder() .codecs(applyCustomizers(this.codecCustomizers)).build()); } }
@Override public List<HttpMessageReader<?>> messageReaders() { return strategies.messageReaders(); } @Override
public BodyInserterContext() { this.exchangeStrategies = ExchangeStrategies.withDefaults(); }
@Override public List<HttpMessageWriter<?>> messageWriters() { return exchangeStrategies.messageWriters(); } @Override
.createUriBuilderFactory(endpointProvider); ExchangeStrategies strategies = ExchangeStrategies.builder() .codecs(configurer -> {
@Test public void bodyToMono() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Mono<String> resultMono = defaultClientResponse.bodyToMono(String.class); assertEquals("foo", resultMono.block()); }
/** * Create a response builder with the given status code and using default strategies for * reading the body. * @param statusCode the status code * @return the created builder */ static Builder create(HttpStatus statusCode) { return create(statusCode, ExchangeStrategies.withDefaults()); }
public DefaultExchangeFunction(ClientHttpConnector connector, ExchangeStrategies strategies) { Assert.notNull(connector, "ClientHttpConnector must not be null"); Assert.notNull(strategies, "ExchangeStrategies must not be null"); this.connector = connector; this.strategies = strategies; strategies.messageWriters().stream() .filter(LoggingCodecSupport.class::isInstance) .forEach(reader -> { if (((LoggingCodecSupport) reader).isEnableLoggingRequestDetails()) { this.enableLoggingRequestDetails = true; } }); }
@Test public void bodyToMonoTypeReference() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Mono<String> resultMono = defaultClientResponse.bodyToMono(new ParameterizedTypeReference<String>() { }); assertEquals("foo", resultMono.block()); }
/** * Create an {@code ExchangeFunction} with the given {@code ClientHttpConnector}. * This is the same as calling * {@link #create(ClientHttpConnector, ExchangeStrategies)} and passing * {@link ExchangeStrategies#withDefaults()}. * @param connector the connector to use for connecting to servers * @return the created {@code ExchangeFunction} */ public static ExchangeFunction create(ClientHttpConnector connector) { return create(connector, ExchangeStrategies.withDefaults()); }
@Test public void bodyParameterizedTypeReference() { String body = "foo"; Publisher<String> publisher = Mono.just(body); ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<String>() {}; ClientRequest result = ClientRequest.create(POST, URI.create("http://example.com")) .body(publisher, typeReference).build(); List<HttpMessageWriter<?>> messageWriters = new ArrayList<>(); messageWriters.add(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes())); ExchangeStrategies strategies = mock(ExchangeStrategies.class); when(strategies.messageWriters()).thenReturn(messageWriters); MockClientHttpRequest request = new MockClientHttpRequest(GET, "/"); result.writeTo(request, strategies).block(); assertNotNull(request.getBody()); StepVerifier.create(request.getBody()) .expectNextCount(1) .verifyComplete(); }
@Test public void bodyToFlux() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Flux<String> resultFlux = defaultClientResponse.bodyToFlux(String.class); Mono<List<String>> result = resultFlux.collectList(); assertEquals(Collections.singletonList("foo"), result.block()); }
@Test public void normal() { Flux<DataBuffer> body = Flux.just("baz") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse response = ClientResponse.create(HttpStatus.BAD_GATEWAY, ExchangeStrategies.withDefaults()) .header("foo", "bar") .cookie("baz", "qux") .body(body) .build(); assertEquals(HttpStatus.BAD_GATEWAY, response.statusCode()); HttpHeaders responseHeaders = response.headers().asHttpHeaders(); assertEquals("bar", responseHeaders.getFirst("foo")); assertNotNull("qux", response.cookies().getFirst("baz")); assertEquals("qux", response.cookies().getFirst("baz").getValue()); StepVerifier.create(response.bodyToFlux(String.class)) .expectNext("baz") .verifyComplete(); }