private <E> ListBodySpec<E> getListBodySpec(Flux<E> flux) { List<E> body = flux.collectList().block(this.timeout); EntityExchangeResult<List<E>> entityResult = new EntityExchangeResult<>(this.exchangeResult, body); return new DefaultListBodySpec<>(entityResult); }
private static Mono<String> partFluxDescription(Flux<? extends Part> partsFlux) { return partsFlux.collectList().map(MultipartIntegrationTests::partListDescription); }
private Mono<List<View>> resolveViews(String viewName, Locale locale) { return Flux.fromIterable(getViewResolvers()) .concatMap(resolver -> resolver.resolveViewName(viewName, locale)) .collectList() .map(views -> { if (views.isEmpty()) { throw new IllegalStateException( "Could not resolve view with name '" + viewName + "'."); } views.addAll(getDefaultViews()); return views; }); }
private <T> Mono<ResponseEntity<List<T>>> toEntityListInternal(Flux<T> bodyFlux) { HttpHeaders headers = headers().asHttpHeaders(); int status = rawStatusCode(); return bodyFlux .collectList() .map(body -> createEntity(body, headers, status)); }
@Test public void rxObservableToPublisher() { List<Integer> sequence = Arrays.asList(1, 2, 3); Object source = rx.Observable.from(sequence); Object target = getAdapter(rx.Observable.class).toPublisher(source); assertTrue("Expected Flux Publisher: " + target.getClass().getName(), target instanceof Flux); assertEquals(sequence, ((Flux<Integer>) target).collectList().block(Duration.ofMillis(1000))); }
@Test public void reactivexObservableToPublisher() { List<Integer> sequence = Arrays.asList(1, 2, 3); Object source = io.reactivex.Observable.fromIterable(sequence); Object target = getAdapter(io.reactivex.Observable.class).toPublisher(source); assertTrue("Expected Flux Publisher: " + target.getClass().getName(), target instanceof Flux); assertEquals(sequence, ((Flux<Integer>) target).collectList().block(Duration.ofMillis(1000))); }
@Test public void reactivexFlowableToPublisher() { List<Integer> sequence = Arrays.asList(1, 2, 3); Object source = io.reactivex.Flowable.fromIterable(sequence); Object target = getAdapter(io.reactivex.Flowable.class).toPublisher(source); assertTrue("Expected Flux Publisher: " + target.getClass().getName(), target instanceof Flux); assertEquals(sequence, ((Flux<Integer>) target).collectList().block(Duration.ofMillis(1000))); }
@Test public void publisherToFlux() { List<Integer> sequence = Arrays.asList(1, 2, 3); Publisher<Integer> source = Flowable.fromIterable(sequence); Object target = getAdapter(Flux.class).fromPublisher(source); assertTrue(target instanceof Flux); assertEquals(sequence, ((Flux<Integer>) target).collectList().block(Duration.ofMillis(1000))); }
@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 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 fluxTestBean() throws Exception { String body = "[{\"bar\":\"b1\",\"foo\":\"f1\"},{\"bar\":\"b2\",\"foo\":\"f2\"}]"; ResolvableType type = forClassWithGenerics(Flux.class, TestBean.class); MethodParameter param = this.testMethod.arg(type); Flux<TestBean> flux = resolveValue(param, body); assertEquals(Arrays.asList(new TestBean("f1", "b1"), new TestBean("f2", "b2")), flux.collectList().block()); }
@Test public void echo() throws Exception { int count = 100; Flux<String> input = Flux.range(1, count).map(index -> "msg-" + index); ReplayProcessor<Object> output = ReplayProcessor.create(count); this.client.execute(getUrl("/echo"), session -> session .send(input.map(session::textMessage)) .thenMany(session.receive().take(count).map(WebSocketMessage::getPayloadAsText)) .subscribeWith(output) .then()) .block(TIMEOUT); assertEquals(input.collectList().block(TIMEOUT), output.collectList().block(TIMEOUT)); }
@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); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.setContentType(MediaType.TEXT_PLAIN); MockServerHttpRequest mockRequest = MockServerHttpRequest .method(HttpMethod.GET, "http://example.com?foo=bar") .headers(httpHeaders) .body(body); DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders); Flux<String> resultFlux = request.bodyToFlux(String.class); assertEquals(Collections.singletonList("foo"), resultFlux.collectList().block()); }
@Test public void bodyToFluxParameterizedTypeReference() { 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); MockServerHttpRequest mockRequest = MockServerHttpRequest .method(HttpMethod.GET, "http://example.com?foo=bar") .headers(httpHeaders) .body(body); DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders); ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<String>() {}; Flux<String> resultFlux = request.bodyToFlux(typeReference); assertEquals(Collections.singletonList("foo"), resultFlux.collectList().block()); }
@SuppressWarnings("unchecked") private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) { assertEquals(StringDecoder.class, decoder.getClass()); assertTrue(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)); assertEquals(!textOnly, decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)); Flux<String> decoded = (Flux<String>) decoder.decode( Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap()); assertEquals(Arrays.asList("line1", "line2"), decoded.collectList().block(Duration.ZERO)); }
@SuppressWarnings("unchecked") private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) { assertEquals(StringDecoder.class, decoder.getClass()); assertTrue(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)); assertEquals(!textOnly, decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)); Flux<String> flux = (Flux<String>) decoder.decode( Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap()); assertEquals(Arrays.asList("line1", "line2"), flux.collectList().block(Duration.ZERO)); }
@Parameters(name = "client[{0}] - server [{1}]") public static Object[][] arguments() throws IOException { WebSocketClient[] clients = new WebSocketClient[] { new TomcatWebSocketClient(), new JettyWebSocketClient(), new ReactorNettyWebSocketClient(), new UndertowWebSocketClient(Xnio.getInstance().createWorker(OptionMap.EMPTY)) }; Map<HttpServer, Class<?>> servers = new LinkedHashMap<>(); servers.put(new TomcatHttpServer(TMP_DIR.getAbsolutePath(), WsContextListener.class), TomcatConfig.class); servers.put(new JettyHttpServer(), JettyConfig.class); servers.put(new ReactorHttpServer(), ReactorNettyConfig.class); servers.put(new UndertowHttpServer(), UndertowConfig.class); Flux<WebSocketClient> f1 = Flux.fromArray(clients).concatMap(c -> Flux.just(c).repeat(servers.size())); Flux<HttpServer> f2 = Flux.fromIterable(servers.keySet()).repeat(clients.length); Flux<Class<?>> f3 = Flux.fromIterable(servers.values()).repeat(clients.length); return Flux.zip(f1, f2, f3).map(Tuple3::toArray).collectList().block() .toArray(new Object[clients.length * servers.size()][2]); }
public Mono<ServerResponse> parts(ServerRequest request) { return request.body(BodyExtractors.toParts()).collectList() .flatMap(parts -> { try { assertEquals(2, parts.size()); assertEquals("foo.txt", ((FilePart) parts.get(0)).filename()); assertEquals("bar", ((FormFieldPart) parts.get(1)).value()); } catch(Exception e) { return Mono.error(e); } return ServerResponse.ok().build(); }); } }
@Test public void fluxPart() { MethodParameter param = this.testMethod.annot(requestPart()).arg(Flux.class, Part.class); MultipartBodyBuilder bodyBuilder = new MultipartBodyBuilder(); bodyBuilder.part("name", new Person("Jones")); bodyBuilder.part("name", new Person("James")); Flux<Part> actual = resolveArgument(param, bodyBuilder); List<Part> parts = actual.collectList().block(); assertEquals("{\"name\":\"Jones\"}", partToUtf8String(parts.get(0))); assertEquals("{\"name\":\"James\"}", partToUtf8String(parts.get(1))); }
@Test public void fluxPerson() { MethodParameter param = this.testMethod.annot(requestPart()).arg(Flux.class, Person.class); MultipartBodyBuilder bodyBuilder = new MultipartBodyBuilder(); bodyBuilder.part("name", new Person("Jones")); bodyBuilder.part("name", new Person("James")); Flux<Person> actual = resolveArgument(param, bodyBuilder); List<Person> persons = actual.collectList().block(); assertEquals("Jones", persons.get(0).getName()); assertEquals("James", persons.get(1).getName()); }