How to use

allMimeTypes

method

in

org.springframework.core.codec.StringDecoder

/**
 * Create a {@code StringDecoder} that supports all MIME types.
 */
public static StringDecoder allMimeTypes() {
  return allMimeTypes(DEFAULT_DELIMITERS, true);
}

/**
 * Create a {@code StringDecoder} that supports all MIME types.
 * @param ignored ignored
 * @deprecated as of Spring 5.0.4, in favor of {@link #allMimeTypes()} or
 * {@link #allMimeTypes(List, boolean)}
 */
@Deprecated
public static StringDecoder allMimeTypes(boolean ignored) {
  return allMimeTypes();
}

/**
 * Return readers that need to be at the end, after all others.
 */
final List<HttpMessageReader<?>> getCatchAllReaders() {
  if (!this.registerDefaults) {
    return Collections.emptyList();
  }
  List<HttpMessageReader<?>> result = new ArrayList<>();
  result.add(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  return result;
}

public StringDecoderTests() {
  super(StringDecoder.allMimeTypes());
}

private HttpEntityArgumentResolver createResolver() {
  List<HttpMessageReader<?>> readers = new ArrayList<>();
  readers.add(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  return new HttpEntityArgumentResolver(readers, ReactiveAdapterRegistry.getSharedInstance());
}

@Before
public void setup() {
  List<HttpMessageReader<?>> readers = new ArrayList<>();
  readers.add(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  this.resolver = new RequestBodyArgumentResolver(readers, ReactiveAdapterRegistry.getSharedInstance());
}

@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());
}

@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());
}

@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 body() {
  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.body(toMono(String.class));
  assertEquals("foo", resultMono.block());
}

@Test
public void bodyToFluxTypeReference() {
  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(new ParameterizedTypeReference<String>() {
      });
  Mono<List<String>> result = resultFlux.collectList();
  assertEquals(Collections.singletonList("foo"), result.block());
}

@Test
public void toEntityList() {
  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);
  ResponseEntity<List<String>> result = defaultClientResponse.toEntityList(String.class).block();
  assertEquals(Collections.singletonList("foo"), result.getBody());
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(HttpStatus.OK.value(), result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Test
public void toEntityWithUnknownStatusCode() throws Exception {
  DefaultDataBufferFactory factory = new DefaultDataBufferFactory();
  DefaultDataBuffer dataBuffer
      = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8)));
  Flux<DataBuffer> body = Flux.just(dataBuffer);
  HttpHeaders httpHeaders = new HttpHeaders();
  httpHeaders.setContentType(MediaType.TEXT_PLAIN);
  when(mockResponse.getHeaders()).thenReturn(httpHeaders);
  when(mockResponse.getStatusCode()).thenThrow(new IllegalArgumentException("999"));
  when(mockResponse.getRawStatusCode()).thenReturn(999);
  when(mockResponse.getBody()).thenReturn(body);
  List<HttpMessageReader<?>> messageReaders = Collections
      .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
  ResponseEntity<String> result = defaultClientResponse.toEntity(String.class).block();
  assertEquals("foo", result.getBody());
  try {
    result.getStatusCode();
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException ex) {
    // do nothing
  }
  assertEquals(999, result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Test
public void toEntityListWithUnknownStatusCode() throws Exception {
  DefaultDataBufferFactory factory = new DefaultDataBufferFactory();
  DefaultDataBuffer dataBuffer =
      factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8)));
  Flux<DataBuffer> body = Flux.just(dataBuffer);
  HttpHeaders httpHeaders = new HttpHeaders();
  httpHeaders.setContentType(MediaType.TEXT_PLAIN);
  when(mockResponse.getHeaders()).thenReturn(httpHeaders);
  when(mockResponse.getStatusCode()).thenThrow(new IllegalArgumentException("999"));
  when(mockResponse.getRawStatusCode()).thenReturn(999);
  when(mockResponse.getBody()).thenReturn(body);
  List<HttpMessageReader<?>> messageReaders = Collections
      .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
  ResponseEntity<List<String>> result = defaultClientResponse.toEntityList(String.class).block();
  assertEquals(Collections.singletonList("foo"), result.getBody());
  try {
    result.getStatusCode();
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException ex) {
    // do nothing
  }
  assertEquals(999, result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Test
public void toEntity() {
  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);
  ResponseEntity<String> result = defaultClientResponse.toEntity(String.class).block();
  assertEquals("foo", result.getBody());
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(HttpStatus.OK.value(), result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Test
public void toEntityTypeReference() {
  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);
  ResponseEntity<String> result = defaultClientResponse.toEntity(
      new ParameterizedTypeReference<String>() {
      }).block();
  assertEquals("foo", result.getBody());
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(HttpStatus.OK.value(), result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Test
public void toEntityListTypeReference() {
  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);
  ResponseEntity<List<String>> result = defaultClientResponse.toEntityList(
      new ParameterizedTypeReference<String>() {
      }).block();
  assertEquals(Collections.singletonList("foo"), result.getBody());
  assertEquals(HttpStatus.OK, result.getStatusCode());
  assertEquals(HttpStatus.OK.value(), result.getStatusCodeValue());
  assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
}

@Before
public void createRequest() {
  MockServerHttpRequest request = MockServerHttpRequest.get("http://example.com/path").build();
  MockServerWebExchange webExchange = MockServerWebExchange.from(request);
  webExchange.getAttributes().put("exchange", "bar");
  this.request = new DefaultServerRequest(webExchange,
      Collections.singletonList(
          new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())));
}

@Before
public void createContext() {
  final List<HttpMessageReader<?>> messageReaders = new ArrayList<>();
  messageReaders.add(new DecoderHttpMessageReader<>(new ByteBufferDecoder()));
  messageReaders.add(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes()));
  messageReaders.add(new DecoderHttpMessageReader<>(new Jaxb2XmlDecoder()));
  messageReaders.add(new DecoderHttpMessageReader<>(new Jackson2JsonDecoder()));
  messageReaders.add(new FormHttpMessageReader());
  SynchronossPartHttpMessageReader partReader = new SynchronossPartHttpMessageReader();
  messageReaders.add(partReader);
  messageReaders.add(new MultipartHttpMessageReader(partReader));
  messageReaders.add(new FormHttpMessageReader());
  this.context = new BodyExtractor.Context() {
    @Override
    public List<HttpMessageReader<?>> messageReaders() {
      return messageReaders;
    }
    @Override
    public Optional<ServerHttpResponse> serverResponse() {
      return serverResponse;
    }
    @Override
    public Map<String, Object> hints() {
      return hints;
    }
  };
  this.hints = new HashMap<String, Object>();
}

@Test
public void decodeNewLineIncludeDelimiters() {
  this.decoder = StringDecoder.allMimeTypes(StringDecoder.DEFAULT_DELIMITERS, false);
  Flux<DataBuffer> input = Flux.just(
      stringBuffer("\r\nabc\n"),
      stringBuffer("def"),
      stringBuffer("ghi\r\n\n"),
      stringBuffer("jkl"),
      stringBuffer("mno\npqr\n"),
      stringBuffer("stu"),
      stringBuffer("vw"),
      stringBuffer("xyz")
  );
  testDecode(input, String.class, step -> step
      .expectNext("\r\n")
      .expectNext("abc\n")
      .expectNext("defghi\r\n")
      .expectNext("\n")
      .expectNext("jklmno\n")
      .expectNext("pqr\n")
      .expectNext("stuvwxyz")
      .expectComplete()
      .verify());
}