Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use Reactor 2.5 Flux and Mono Rx light API

Browse Source 
Flux and Mono are used both for implementation and exposed at API
level to express 1 versus N semantic and to provide default Rx
operators:
- Flux<T> for multiple values Publisher (issue #48)
- Mono<T> for single value Publisher (issue #50)
- Mono<Void> for Publisher with no value (issue #49)
This commit is contained in:
Sebastien Deleuze
2015-12-16 18:05:37 +01:00
parent 8ef2ce44f4
commit 8ef7e2ff77
77 changed files with 354 additions and 424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/EchoHandler.java
View File

@@ -16,11 +16,7 @@
package org.springframework.http.server.reactive;
import org.reactivestreams.Publisher;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import reactor.Mono;
/**
* @author Arjen Poutsma
@@ -28,7 +24,7 @@ import org.springframework.http.server.reactive.ServerHttpResponse;
public class EchoHandler implements HttpHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
return response.setBody(request.getBody());
}
}

22
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/ErrorHandlingHttpHandlerTests.java
View File

@@ -17,12 +17,11 @@ package org.springframework.http.server.reactive;
import java.net.URI;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Mono;
import reactor.rx.Streams;
import reactor.rx.stream.Signal;
@@ -56,8 +55,7 @@ public class ErrorHandlingHttpHandlerTests {
HttpHandler targetHandler = new TestHttpHandler(new IllegalStateException("boo"));
HttpHandler handler = new ErrorHandlingHttpHandler(targetHandler, exceptionHandler);
Publisher<Void> publisher = handler.handle(this.request, this.response);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
handler.handle(this.request, this.response).get();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatus());
}
@@ -73,8 +71,7 @@ public class ErrorHandlingHttpHandlerTests {
HttpHandler targetHandler = new TestHttpHandler(new IllegalStateException("boo"));
HttpHandler httpHandler = new ErrorHandlingHttpHandler(targetHandler, exceptionHandlers);
Publisher<Void> publisher = httpHandler.handle(this.request, this.response);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
httpHandler.handle(this.request, this.response).get();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatus());
}
@@ -98,15 +95,14 @@ public class ErrorHandlingHttpHandlerTests {
HttpHandler targetHandler = new TestHttpHandler(new IllegalStateException("boo"), true);
HttpHandler handler = new ErrorHandlingHttpHandler(targetHandler, exceptionHandler);
Publisher<Void> publisher = handler.handle(this.request, this.response);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
handler.handle(this.request, this.response).get();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatus());
}
private Throwable awaitErrorSignal(Publisher<?> publisher) throws Exception {
Signal<?> signal = Streams.wrap(publisher).materialize().toList().await(5, TimeUnit.SECONDS).get(0);
Signal<?> signal = Streams.from(publisher).materialize().toList().get().get(0);
assertEquals("Unexpected signal: " + signal, Signal.Type.ERROR, signal.getType());
return signal.getThrowable();
}
@@ -129,11 +125,11 @@ public class ErrorHandlingHttpHandlerTests {
}
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
if (this.raise) {
throw this.exception;
}
return Publishers.error(this.exception);
return Mono.error(this.exception);
}
}
@@ -142,8 +138,8 @@ public class ErrorHandlingHttpHandlerTests {
private static class UnresolvedExceptionHandler implements HttpExceptionHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response, Throwable ex) {
return Publishers.error(ex);
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response, Throwable ex) {
return Mono.error(ex);
}
}

38
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/FilterChainHttpHandlerTests.java
View File

@@ -16,15 +16,11 @@
package org.springframework.http.server.reactive;
import java.util.concurrent.TimeUnit;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.rx.Streams;
import reactor.Mono;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -57,8 +53,7 @@ public class FilterChainHttpHandlerTests {
TestFilter filter3 = new TestFilter();
FilterChainHttpHandler filterHandler = new FilterChainHttpHandler(handler, filter1, filter2, filter3);
Publisher<Void> voidPublisher = filterHandler.handle(this.request, this.response);
Streams.wrap(voidPublisher).toList().await(10, TimeUnit.SECONDS);
filterHandler.handle(this.request, this.response).get();
assertTrue(filter1.invoked());
assertTrue(filter2.invoked());
@@ -71,8 +66,7 @@ public class FilterChainHttpHandlerTests {
StubHandler handler = new StubHandler();
FilterChainHttpHandler filterHandler = new FilterChainHttpHandler(handler);
Publisher<Void> voidPublisher = filterHandler.handle(this.request, this.response);
Streams.wrap(voidPublisher).toList().await(10, TimeUnit.SECONDS);
filterHandler.handle(this.request, this.response).get();
assertTrue(handler.invoked());
}
@@ -85,8 +79,7 @@ public class FilterChainHttpHandlerTests {
TestFilter filter3 = new TestFilter();
FilterChainHttpHandler filterHandler = new FilterChainHttpHandler(handler, filter1, filter2, filter3);
Publisher<Void> voidPublisher = filterHandler.handle(this.request, this.response);
Streams.wrap(voidPublisher).toList().await(10, TimeUnit.SECONDS);
filterHandler.handle(this.request, this.response).get();
assertTrue(filter1.invoked());
assertTrue(filter2.invoked());
@@ -100,8 +93,7 @@ public class FilterChainHttpHandlerTests {
AsyncFilter filter = new AsyncFilter();
FilterChainHttpHandler filterHandler = new FilterChainHttpHandler(handler, filter);
Publisher<Void> voidPublisher = filterHandler.handle(this.request, this.response);
Streams.wrap(voidPublisher).toList().await(10, TimeUnit.SECONDS);
filterHandler.handle(this.request, this.response).get();
assertTrue(filter.invoked());
assertTrue(handler.invoked());
@@ -119,14 +111,14 @@ public class FilterChainHttpHandlerTests {
}
@Override
public Publisher<Void> filter(ServerHttpRequest req, ServerHttpResponse res,
public Mono<Void> filter(ServerHttpRequest req, ServerHttpResponse res,
HttpFilterChain chain) {
this.invoked = true;
return doFilter(req, res, chain);
}
public Publisher<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res,
public Mono<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res,
HttpFilterChain chain) {
return chain.filter(req, res);
@@ -136,25 +128,25 @@ public class FilterChainHttpHandlerTests {
private static class ShortcircuitingFilter extends TestFilter {
@Override
public Publisher<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res,
public Mono<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res,
HttpFilterChain chain) {
return Publishers.empty();
return Mono.empty();
}
}
private static class AsyncFilter extends TestFilter {
@Override
public Publisher<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res, HttpFilterChain chain) {
return Publishers.concatMap(doAsyncWork(), asyncResult -> {
public Mono<Void> doFilter(ServerHttpRequest req, ServerHttpResponse res, HttpFilterChain chain) {
return doAsyncWork().then(asyncResult -> {
logger.debug("Async result: " + asyncResult);
return chain.filter(req, res);
});
}
private Publisher<String> doAsyncWork() {
return Publishers.just("123");
private Mono<String> doAsyncWork() {
return Mono.just("123");
}
}
@@ -168,10 +160,10 @@ public class FilterChainHttpHandlerTests {
}
@Override
public Publisher<Void> handle(ServerHttpRequest req, ServerHttpResponse res) {
public Mono<Void> handle(ServerHttpRequest req, ServerHttpResponse res) {
logger.trace("StubHandler invoked.");
this.invoked = true;
return Publishers.empty();
return Mono.empty();
}
}

9
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/MockServerHttpRequest.java
View File

@@ -19,6 +19,7 @@ import java.net.URI;
import java.nio.ByteBuffer;
import org.reactivestreams.Publisher;
import reactor.Flux;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
@@ -34,7 +35,7 @@ public class MockServerHttpRequest implements ServerHttpRequest {
private HttpHeaders headers = new HttpHeaders();
private Publisher<ByteBuffer> body;
private Flux<ByteBuffer> body;
public MockServerHttpRequest(HttpMethod httpMethod, URI uri) {
@@ -43,7 +44,7 @@ public class MockServerHttpRequest implements ServerHttpRequest {
}
public MockServerHttpRequest(Publisher<ByteBuffer> body, HttpMethod httpMethod, URI uri) {
this.body = body;
this.body = Flux.from(body);
this.httpMethod = httpMethod;
this.uri = uri;
}
@@ -77,11 +78,11 @@ public class MockServerHttpRequest implements ServerHttpRequest {
}
@Override
public Publisher<ByteBuffer> getBody() {
public Flux<ByteBuffer> getBody() {
return this.body;
}
public void setBody(Publisher<ByteBuffer> body) {
this.body = body;
this.body = Flux.from(body);
}
}

7
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/MockServerHttpResponse.java
View File

@@ -18,7 +18,8 @@ package org.springframework.http.server.reactive;
import java.nio.ByteBuffer;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Flux;
import reactor.Mono;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
@@ -50,9 +51,9 @@ public class MockServerHttpResponse implements ServerHttpResponse {
}
@Override
public Publisher<Void> setBody(Publisher<ByteBuffer> body) {
public Mono<Void> setBody(Publisher<ByteBuffer> body) {
this.body = body;
return Publishers.concatMap(body, b -> Publishers.empty());
return Flux.from(body).after();
}
public Publisher<ByteBuffer> getBody() {

7
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/RandomHandler.java
View File

@@ -21,11 +21,10 @@ import java.util.Random;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import reactor.Mono;
import reactor.io.buffer.Buffer;
import reactor.rx.Streams;
import static org.junit.Assert.assertEquals;
@@ -41,7 +40,7 @@ public class RandomHandler implements HttpHandler {
private final Random rnd = new Random();
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
request.getBody().subscribe(new Subscriber<ByteBuffer>() {
private Subscription s;
@@ -73,7 +72,7 @@ public class RandomHandler implements HttpHandler {
});
response.getHeaders().setContentLength(RESPONSE_SIZE);
return response.setBody(Streams.just(ByteBuffer.wrap(randomBytes())));
return response.setBody(Mono.just(ByteBuffer.wrap(randomBytes())));
}
private byte[] randomBytes() {

26
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/WriteWithOperatorTests.java
View File

@@ -27,14 +27,12 @@ import org.junit.Test;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import reactor.Publishers;
import reactor.core.publisher.PublisherFactory;
import reactor.Flux;
import reactor.core.subscriber.SubscriberBarrier;
import reactor.rx.Streams;
import reactor.rx.stream.Signal;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
@@ -58,8 +56,8 @@ public class WriteWithOperatorTests {
@Test
public void errorBeforeFirstItem() throws Exception {
IllegalStateException error = new IllegalStateException("boo");
Publisher<Void> completion = Publishers.lift(Publishers.error(error), this.operator);
List<Signal<Void>> signals = Streams.wrap(completion).materialize().toList().await(5, TimeUnit.SECONDS);
Publisher<Void> completion = Flux.<String>error(error).lift(this.operator);
List<Signal<Void>> signals = Streams.from(completion).materialize().toList().get();
assertEquals(1, signals.size());
assertSame("Unexpected signal: " + signals.get(0), error, signals.get(0).getThrowable());
@@ -67,8 +65,8 @@ public class WriteWithOperatorTests {
@Test
public void completionBeforeFirstItem() throws Exception {
Publisher<Void> completion = Publishers.lift(Publishers.empty(), this.operator);
List<Signal<Void>> signals = Streams.wrap(completion).materialize().toList().await(5, TimeUnit.SECONDS);
Publisher<Void> completion = Flux.<String>empty().lift(this.operator);
List<Signal<Void>> signals = Streams.from(completion).materialize().toList().get();
assertEquals(1, signals.size());
assertTrue("Unexpected signal: " + signals.get(0), signals.get(0).isOnComplete());
@@ -79,8 +77,8 @@ public class WriteWithOperatorTests {
@Test
public void writeOneItem() throws Exception {
Publisher<Void> completion = Publishers.lift(Publishers.just("one"), this.operator);
List<Signal<Void>> signals = Streams.wrap(completion).materialize().toList().await(5, TimeUnit.SECONDS);
Publisher<Void> completion = Flux.just("one").lift(this.operator);
List<Signal<Void>> signals = Streams.from(completion).materialize().toList().get();
assertEquals(1, signals.size());
assertTrue("Unexpected signal: " + signals.get(0), signals.get(0).isOnComplete());
@@ -94,8 +92,8 @@ public class WriteWithOperatorTests {
@Test
public void writeMultipleItems() throws Exception {
List<String> items = Arrays.asList("one", "two", "three");
Publisher<Void> completion = Publishers.lift(Publishers.from(items), this.operator);
List<Signal<Void>> signals = Streams.wrap(completion).materialize().consumeAsList().await(5, TimeUnit.SECONDS);
Publisher<Void> completion = Flux.fromIterable(items).lift(this.operator);
List<Signal<Void>> signals = Streams.from(completion).materialize().toList().get();
assertEquals(1, signals.size());
assertTrue("Unexpected signal: " + signals.get(0), signals.get(0).isOnComplete());
@@ -110,15 +108,15 @@ public class WriteWithOperatorTests {
@Test
public void errorAfterMultipleItems() throws Exception {
IllegalStateException error = new IllegalStateException("boo");
Publisher<String> publisher = PublisherFactory.create(subscriber -> {
Flux<String> publisher = Flux.create(subscriber -> {
int i = subscriber.context().incrementAndGet();
subscriber.onNext(String.valueOf(i));
if (i == 3) {
subscriber.onError(error);
}
}, subscriber -> new AtomicInteger());
Publisher<Void> completion = Publishers.lift(publisher, this.operator);
List<Signal<Void>> signals = Streams.wrap(completion).materialize().toList().await(5, TimeUnit.SECONDS);
Publisher<Void> completion = publisher.lift(this.operator);
List<Signal<Void>> signals = Streams.from(completion).materialize().toList().get();
assertEquals(1, signals.size());
assertSame("Unexpected signal: " + signals.get(0), error, signals.get(0).getThrowable());

4
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/XmlHandler.java
View File

@@ -22,7 +22,7 @@ import javax.xml.bind.Unmarshaller;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.reactivestreams.Publisher;
import reactor.Mono;
import reactor.io.buffer.Buffer;
import reactor.rx.Streams;
@@ -40,7 +40,7 @@ public class XmlHandler implements HttpHandler {
private static final Log logger = LogFactory.getLog(XmlHandler.class);
@Override
public Publisher<Void> handle(ServerHttpRequest request,
public Mono<Void> handle(ServerHttpRequest request,
ServerHttpResponse response) {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(XmlHandlerIntegrationTests.Person.class);

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/decoder/ByteBufferDecoderTests.java
View File

@@ -49,8 +49,8 @@ public class ByteBufferDecoderTests {
ByteBuffer fooBuffer = Buffer.wrap("foo").byteBuffer();
ByteBuffer barBuffer = Buffer.wrap("bar").byteBuffer();
Stream<ByteBuffer> source = Streams.just(fooBuffer, barBuffer);
List<ByteBuffer> results = Streams.wrap(decoder.decode(source,
ResolvableType.forClassWithGenerics(Publisher.class, ByteBuffer.class), null)).toList().await();
List<ByteBuffer> results = Streams.from(decoder.decode(source,
ResolvableType.forClassWithGenerics(Publisher.class, ByteBuffer.class), null)).toList().get();
assertEquals(2, results.size());
assertEquals(fooBuffer, results.get(0));
assertEquals(barBuffer, results.get(1));

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/decoder/JacksonJsonDecoderTests.java
View File

@@ -48,8 +48,8 @@ public class JacksonJsonDecoderTests {
@Test
public void decode() throws InterruptedException {
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}").byteBuffer());
List<Object> results = Streams.wrap(decoder.decode(source, ResolvableType.forClass(Pojo.class), null))
.toList().await();
List<Object> results = Streams.from(decoder.decode(source, ResolvableType.forClass(Pojo.class), null))
.toList().get();
assertEquals(1, results.size());
assertEquals("foofoo", ((Pojo) results.get(0)).getFoo());
}

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/decoder/Jaxb2DecoderTests.java
View File

@@ -49,8 +49,8 @@ public class Jaxb2DecoderTests {
@Test
public void decode() throws InterruptedException {
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("<?xml version=\"1.0\" encoding=\"UTF-8\"?><pojo><bar>barbar</bar><foo>foofoo</foo></pojo>").byteBuffer());
List<Object> results = Streams.wrap(decoder.decode(source, ResolvableType.forClass(Pojo.class), null))
.toList().await();
List<Object> results = Streams.from(decoder.decode(source, ResolvableType.forClass(Pojo.class), null))
.toList().get();
assertEquals(1, results.size());
assertEquals("foofoo", ((Pojo) results.get(0)).getFoo());
}

16
spring-web-reactive/src/test/java/org/springframework/reactive/codec/decoder/JsonObjectDecoderTests.java
View File

@@ -37,11 +37,11 @@ public class JsonObjectDecoderTests {
public void decodeSingleChunkToJsonObject() throws InterruptedException {
JsonObjectDecoder decoder = new JsonObjectDecoder();
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}").byteBuffer());
List<String> results = Streams.wrap(decoder.decode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(decoder.decode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(1, results.size());
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", results.get(0));
}
@@ -50,11 +50,11 @@ public class JsonObjectDecoderTests {
public void decodeMultipleChunksToJsonObject() throws InterruptedException {
JsonObjectDecoder decoder = new JsonObjectDecoder();
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("{\"foo\": \"foofoo\"").byteBuffer(), Buffer.wrap(", \"bar\": \"barbar\"}").byteBuffer());
List<String> results = Streams.wrap(decoder.decode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(decoder.decode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(1, results.size());
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", results.get(0));
}
@@ -63,11 +63,11 @@ public class JsonObjectDecoderTests {
public void decodeSingleChunkToArray() throws InterruptedException {
JsonObjectDecoder decoder = new JsonObjectDecoder();
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("[{\"foo\": \"foofoo\", \"bar\": \"barbar\"},{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}]").byteBuffer());
List<String> results = Streams.wrap(decoder.decode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(decoder.decode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(2, results.size());
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", results.get(0));
assertEquals("{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}", results.get(1));
@@ -77,11 +77,11 @@ public class JsonObjectDecoderTests {
public void decodeMultipleChunksToArray() throws InterruptedException {
JsonObjectDecoder decoder = new JsonObjectDecoder();
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("[{\"foo\": \"foofoo\", \"bar\"").byteBuffer(), Buffer.wrap(": \"barbar\"},{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}]").byteBuffer());
List<String> results = Streams.wrap(decoder.decode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(decoder.decode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(2, results.size());
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", results.get(0));
assertEquals("{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}", results.get(1));

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/decoder/StringDecoderTests.java
View File

@@ -49,8 +49,8 @@ public class StringDecoderTests {
@Test
public void decode() throws InterruptedException {
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("foo").byteBuffer(), Buffer.wrap("bar").byteBuffer());
List<String> results = Streams.wrap(decoder.decode(source,
ResolvableType.forClassWithGenerics(Publisher.class, String.class), null)).toList().await();
List<String> results = Streams.from(decoder.decode(source,
ResolvableType.forClassWithGenerics(Publisher.class, String.class), null)).toList().get();
assertEquals(2, results.size());
assertEquals("foo", results.get(0));
assertEquals("bar", results.get(1));

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/encoder/ByteBufferEncoderTests.java
View File

@@ -49,8 +49,8 @@ public class ByteBufferEncoderTests {
ByteBuffer fooBuffer = Buffer.wrap("foo").byteBuffer();
ByteBuffer barBuffer = Buffer.wrap("bar").byteBuffer();
Stream<ByteBuffer> source = Streams.just(fooBuffer, barBuffer);
List<ByteBuffer> results = Streams.wrap(encoder.encode(source,
ResolvableType.forClassWithGenerics(Publisher.class, ByteBuffer.class), null)).toList().await();
List<ByteBuffer> results = Streams.from(encoder.encode(source,
ResolvableType.forClassWithGenerics(Publisher.class, ByteBuffer.class), null)).toList().get();
assertEquals(2, results.size());
assertEquals(fooBuffer, results.get(0));
assertEquals(barBuffer, results.get(1));

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/encoder/JacksonJsonEncoderTests.java
View File

@@ -46,11 +46,11 @@ public class JacksonJsonEncoderTests {
@Test
public void write() throws InterruptedException {
Stream<Pojo> source = Streams.just(new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar"));
List<String> results = Streams.wrap(encoder.encode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(encoder.encode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(2, results.size());
assertEquals("{\"foo\":\"foofoo\",\"bar\":\"barbar\"}", results.get(0));
assertEquals("{\"foo\":\"foofoofoo\",\"bar\":\"barbarbar\"}", results.get(1));

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/encoder/Jaxb2EncoderTests.java
View File

@@ -47,11 +47,11 @@ public class Jaxb2EncoderTests {
@Test
public void encode() throws InterruptedException {
Stream<Pojo> source = Streams.just(new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar"));
List<String> results = Streams.wrap(encoder.encode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(encoder.encode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(2, results.size());
assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><pojo><bar>barbar</bar><foo>foofoo</foo></pojo>", results.get(0));
assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><pojo><bar>barbarbar</bar><foo>foofoofoo</foo></pojo>", results.get(1));

12
spring-web-reactive/src/test/java/org/springframework/reactive/codec/encoder/JsonObjectEncoderTests.java
View File

@@ -37,11 +37,11 @@ public class JsonObjectEncoderTests {
public void encodeSingleElement() throws InterruptedException {
JsonObjectEncoder encoder = new JsonObjectEncoder();
Stream<ByteBuffer> source = Streams.just(Buffer.wrap("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}").byteBuffer());
List<String> results = Streams.wrap(encoder.encode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(encoder.encode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
String result = String.join("", results);
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", result);
}
@@ -52,11 +52,11 @@ public class JsonObjectEncoderTests {
Stream<ByteBuffer> source = Streams.just(
Buffer.wrap("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}").byteBuffer(),
Buffer.wrap("{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}").byteBuffer());
List<String> results = Streams.wrap(encoder.encode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(encoder.encode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
String result = String.join("", results);
assertEquals("[{\"foo\": \"foofoo\", \"bar\": \"barbar\"},{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}]", result);
}
@@ -69,11 +69,11 @@ public class JsonObjectEncoderTests {
Buffer.wrap("{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}").byteBuffer(),
Buffer.wrap("{\"foo\": \"foofoofoofoo\", \"bar\": \"barbarbarbar\"}").byteBuffer()
);
List<String> results = Streams.wrap(encoder.encode(source, null, null)).map(chunk -> {
List<String> results = Streams.from(encoder.encode(source, null, null)).map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
String result = String.join("", results);
assertEquals("[{\"foo\": \"foofoo\", \"bar\": \"barbar\"},{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"},{\"foo\": \"foofoofoofoo\", \"bar\": \"barbarbarbar\"}]", result);
}

4
spring-web-reactive/src/test/java/org/springframework/reactive/codec/encoder/StringEncoderTests.java
View File

@@ -45,12 +45,12 @@ public class StringEncoderTests {
@Test
public void write() throws InterruptedException {
List<String> results = Streams.wrap(encoder.encode(Streams.just("foo"), null, null))
List<String> results = Streams.from(encoder.encode(Streams.just("foo"), null, null))
.map(chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
}).toList().await();
}).toList().get();
assertEquals(1, results.size());
assertEquals("foo", results.get(0));
}

25
spring-web-reactive/src/test/java/org/springframework/web/reactive/DispatcherHandlerErrorTests.java
View File

@@ -19,12 +19,11 @@ import java.net.URI;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Mono;
import reactor.rx.Streams;
import reactor.rx.stream.Signal;
@@ -154,7 +153,7 @@ public class DispatcherHandlerErrorTests {
public void notAcceptable() throws Exception {
this.request.setUri(new URI("/request-body"));
this.request.getHeaders().setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
this.request.setBody(Publishers.just(ByteBuffer.wrap("body".getBytes("UTF-8"))));
this.request.setBody(Mono.just(ByteBuffer.wrap("body".getBytes("UTF-8"))));
Publisher<Void> publisher = this.dispatcherHandler.handle(this.request, this.response);
Throwable ex = awaitErrorSignal(publisher);
@@ -167,12 +166,14 @@ public class DispatcherHandlerErrorTests {
@Test
public void requestBodyError() throws Exception {
this.request.setUri(new URI("/request-body"));
this.request.setBody(Publishers.error(EXCEPTION));
this.request.setBody(Mono.error(EXCEPTION));
Publisher<Void> publisher = this.dispatcherHandler.handle(this.request, this.response);
Throwable ex = awaitErrorSignal(publisher);
ex.printStackTrace();
assertSame(EXCEPTION, ex);
}
@Test
@@ -183,7 +184,7 @@ public class DispatcherHandlerErrorTests {
HttpHandler httpHandler = new ErrorHandlingHttpHandler(this.dispatcherHandler, exceptionHandler);
Publisher<Void> publisher = httpHandler.handle(this.request, this.response);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
Streams.from(publisher).toList().get();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatus());
}
@@ -196,13 +197,13 @@ public class DispatcherHandlerErrorTests {
httpHandler = new ErrorHandlingHttpHandler(httpHandler, new ServerError500ExceptionHandler());
Publisher<Void> publisher = httpHandler.handle(this.request, this.response);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
Streams.from(publisher).toList().get();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatus());
}
private Throwable awaitErrorSignal(Publisher<?> publisher) throws Exception {
Signal<?> signal = Streams.wrap(publisher).materialize().toList().await(5, TimeUnit.SECONDS).get(0);
Signal<?> signal = Streams.from(publisher).materialize().toList().get().get(0);
assertEquals("Unexpected signal: " + signal, Signal.Type.ERROR, signal.getType());
return signal.getThrowable();
}
@@ -245,7 +246,7 @@ public class DispatcherHandlerErrorTests {
@RequestMapping("/error-signal")
@ResponseBody
public Publisher<String> errorSignal() {
return Publishers.error(EXCEPTION);
return Mono.error(EXCEPTION);
}
@RequestMapping("/raise-exception")
@@ -261,7 +262,7 @@ public class DispatcherHandlerErrorTests {
@RequestMapping("/request-body")
@ResponseBody
public Publisher<String> requestBody(@RequestBody Publisher<String> body) {
return Publishers.map(body, s -> "hello " + s);
return Mono.from(body).map(s -> "hello " + s);
}
}
@@ -271,16 +272,16 @@ public class DispatcherHandlerErrorTests {
private static class ServerError500ExceptionHandler implements HttpExceptionHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response, Throwable ex) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response, Throwable ex) {
response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
return Publishers.empty();
return Mono.empty();
}
}
private static class TestHttpFilter implements HttpFilter {
@Override
public Publisher<Void> filter(ServerHttpRequest req, ServerHttpResponse res, HttpFilterChain chain) {
public Mono<Void> filter(ServerHttpRequest req, ServerHttpResponse res, HttpFilterChain chain) {
return chain.filter(req, res);
}
}

4
spring-web-reactive/src/test/java/org/springframework/web/reactive/ResponseStatusExceptionHandlerTests.java
View File

@@ -60,7 +60,7 @@ public class ResponseStatusExceptionHandlerTests {
Throwable ex = new ResponseStatusException(HttpStatus.BAD_REQUEST);
Publisher<Void> publisher = this.handler.handle(this.request, this.response, ex);
Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
Streams.from(publisher).toList().get();
assertEquals(HttpStatus.BAD_REQUEST, this.response.getStatus());
}
@@ -69,7 +69,7 @@ public class ResponseStatusExceptionHandlerTests {
Throwable ex = new IllegalStateException();
Publisher<Void> publisher = this.handler.handle(this.request, this.response, ex);
List<Signal<Void>> signals = Streams.wrap(publisher).materialize().toList().await(5, TimeUnit.SECONDS);
List<Signal<Void>> signals = Streams.from(publisher).materialize().toList().get();
assertEquals(1, signals.size());
assertTrue(signals.get(0).hasError());
assertSame(ex, signals.get(0).getThrowable());

4
spring-web-reactive/src/test/java/org/springframework/web/reactive/handler/SimpleHandlerResultHandlerTests.java
View File

@@ -28,7 +28,7 @@ import rx.Observable;
import org.springframework.core.ResolvableType;
import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.core.convert.support.ReactiveStreamsToCompletableFutureConverter;
import org.springframework.core.convert.support.ReactiveStreamsToReactorConverter;
import org.springframework.core.convert.support.ReactiveStreamsToReactorStreamConverter;
import org.springframework.core.convert.support.ReactiveStreamsToRxJava1Converter;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.reactive.HandlerResult;
@@ -75,7 +75,7 @@ public class SimpleHandlerResultHandlerTests {
GenericConversionService conversionService = new GenericConversionService();
conversionService.addConverter(new ReactiveStreamsToCompletableFutureConverter());
conversionService.addConverter(new ReactiveStreamsToReactorConverter());
conversionService.addConverter(new ReactiveStreamsToReactorStreamConverter());
conversionService.addConverter(new ReactiveStreamsToRxJava1Converter());
SimpleHandlerResultHandler resultHandler = new SimpleHandlerResultHandler(conversionService);
TestController controller = new TestController();

11
spring-web-reactive/src/test/java/org/springframework/web/reactive/handler/SimpleUrlHandlerMappingIntegrationTests.java
View File

@@ -22,8 +22,7 @@ import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Mono;
import reactor.io.buffer.Buffer;
import reactor.rx.Streams;
@@ -136,7 +135,7 @@ public class SimpleUrlHandlerMappingIntegrationTests extends AbstractHttpHandler
private static class FooHandler implements HttpHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
return response.setBody(Streams.just(Buffer.wrap("foo").byteBuffer()));
}
}
@@ -144,7 +143,7 @@ public class SimpleUrlHandlerMappingIntegrationTests extends AbstractHttpHandler
private static class BarHandler implements HttpHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
return response.setBody(Streams.just(Buffer.wrap("bar").byteBuffer()));
}
}
@@ -152,9 +151,9 @@ public class SimpleUrlHandlerMappingIntegrationTests extends AbstractHttpHandler
private static class HeaderSettingHandler implements HttpHandler {
@Override
public Publisher<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
response.getHeaders().add("foo", "bar");
return Publishers.empty();
return Mono.empty();
}
}

24
spring-web-reactive/src/test/java/org/springframework/web/reactive/method/InvocableHandlerMethodTests.java
View File

@@ -21,12 +21,12 @@ import java.net.URI;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Flux;
import reactor.Mono;
import reactor.rx.Streams;
import reactor.rx.stream.Signal;
@@ -61,7 +61,7 @@ public class InvocableHandlerMethodTests {
InvocableHandlerMethod hm = createHandlerMethod("noArgs");
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
List<HandlerResult> values = Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
List<HandlerResult> values = Streams.from(publisher).toList().get();
assertEquals(1, values.size());
assertEquals("success", values.get(0).getResult());
@@ -74,7 +74,7 @@ public class InvocableHandlerMethodTests {
hm.setHandlerMethodArgumentResolvers(Collections.singletonList(new RequestParamArgumentResolver()));
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
List<HandlerResult> values = Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
List<HandlerResult> values = Streams.from(publisher).toList().get();
assertEquals(1, values.size());
assertEquals("success:null", values.get(0).getResult());
@@ -83,10 +83,10 @@ public class InvocableHandlerMethodTests {
@Test
public void resolveArgToOneValue() throws Exception {
InvocableHandlerMethod hm = createHandlerMethod("singleArg", String.class);
addResolver(hm, Publishers.just("value1"));
addResolver(hm, Mono.just("value1"));
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
List<HandlerResult> values = Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
List<HandlerResult> values = Streams.from(publisher).toList().get();
assertEquals(1, values.size());
assertEquals("success:value1", values.get(0).getResult());
@@ -95,10 +95,10 @@ public class InvocableHandlerMethodTests {
@Test
public void resolveArgToMultipleValues() throws Exception {
InvocableHandlerMethod hm = createHandlerMethod("singleArg", String.class);
addResolver(hm, Publishers.from(Arrays.asList("value1", "value2", "value3")));
addResolver(hm, Flux.fromIterable(Arrays.asList("value1", "value2", "value3")));
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
List<HandlerResult> values = Streams.wrap(publisher).toList().await(5, TimeUnit.SECONDS);
List<HandlerResult> values = Streams.from(publisher).toList().get();
assertEquals(1, values.size());
assertEquals("success:value1", values.get(0).getResult());
@@ -137,7 +137,7 @@ public class InvocableHandlerMethodTests {
@Test
public void resolveArgumentWithErrorSignal() throws Exception {
InvocableHandlerMethod hm = createHandlerMethod("singleArg", String.class);
addResolver(hm, Publishers.error(new IllegalStateException("boo")));
addResolver(hm, Mono.error(new IllegalStateException("boo")));
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
Throwable ex = awaitErrorSignal(publisher);
@@ -151,7 +151,7 @@ public class InvocableHandlerMethodTests {
@Test
public void illegalArgumentExceptionIsWrappedWithHelpfulDetails() throws Exception {
InvocableHandlerMethod hm = createHandlerMethod("singleArg", String.class);
addResolver(hm, Publishers.just(1));
addResolver(hm, Mono.just(1));
Publisher<HandlerResult> publisher = hm.invokeForRequest(this.request);
Throwable ex = awaitErrorSignal(publisher);
@@ -183,12 +183,12 @@ public class InvocableHandlerMethodTests {
private void addResolver(InvocableHandlerMethod handlerMethod, Publisher<Object> resolvedValue) {
HandlerMethodArgumentResolver resolver = mock(HandlerMethodArgumentResolver.class);
when(resolver.supportsParameter(any())).thenReturn(true);
when(resolver.resolveArgument(any(), any())).thenReturn(resolvedValue);
when(resolver.resolveArgument(any(), any())).thenReturn(Mono.from(resolvedValue));
handlerMethod.setHandlerMethodArgumentResolvers(Collections.singletonList(resolver));
}
private Throwable awaitErrorSignal(Publisher<?> publisher) throws Exception {
Signal<?> signal = Streams.wrap(publisher).materialize().toList().await(5, TimeUnit.SECONDS).get(0);
Signal<?> signal = Streams.from(publisher).materialize().toList().get().get(0);
assertEquals("Unexpected signal: " + signal, Signal.Type.ERROR, signal.getType());
return signal.getThrowable();
}

3
spring-web-reactive/src/test/java/org/springframework/web/reactive/method/annotation/RequestMappingHandlerMappingTests.java
View File

@@ -18,7 +18,6 @@ package org.springframework.web.reactive.method.annotation;
import java.net.URI;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
@@ -78,7 +77,7 @@ public class RequestMappingHandlerMappingTests {
private HandlerMethod toHandlerMethod(Publisher<?> handlerPublisher) throws InterruptedException {
assertNotNull(handlerPublisher);
List<?> handlerList = Streams.wrap(handlerPublisher).toList().await(5, TimeUnit.SECONDS);
List<?> handlerList = Streams.from(handlerPublisher).toList().get();
assertEquals(1, handlerList.size());
return (HandlerMethod) handlerList.get(0);
}

23
spring-web-reactive/src/test/java/org/springframework/web/reactive/method/annotation/RequestMappingIntegrationTests.java
View File

@@ -25,10 +25,9 @@ import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.Publishers;
import reactor.Mono;
import reactor.io.buffer.Buffer;
import reactor.rx.Promise;
import reactor.rx.Promises;
import reactor.rx.Stream;
import reactor.rx.Streams;
import rx.Observable;
@@ -46,7 +45,7 @@ import org.springframework.core.codec.support.StringEncoder;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.core.convert.support.ReactiveStreamsToCompletableFutureConverter;
import org.springframework.core.convert.support.ReactiveStreamsToReactorConverter;
import org.springframework.core.convert.support.ReactiveStreamsToReactorStreamConverter;
import org.springframework.core.convert.support.ReactiveStreamsToRxJava1Converter;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
@@ -321,7 +320,7 @@ public class RequestMappingIntegrationTests extends AbstractHttpHandlerIntegrati
// TODO: test failures with DefaultConversionService
GenericConversionService service = new GenericConversionService();
service.addConverter(new ReactiveStreamsToCompletableFutureConverter());
service.addConverter(new ReactiveStreamsToReactorConverter());
service.addConverter(new ReactiveStreamsToReactorStreamConverter());
service.addConverter(new ReactiveStreamsToRxJava1Converter());
return service;
}
@@ -398,7 +397,7 @@ public class RequestMappingIntegrationTests extends AbstractHttpHandlerIntegrati
@RequestMapping("/promise")
@ResponseBody
public Promise<Person> promiseResponseBody() {
return Promises.success(new Person("Robert"));
return Promise.success(new Person("Robert"));
}
@RequestMapping("/list")
@@ -428,7 +427,7 @@ public class RequestMappingIntegrationTests extends AbstractHttpHandlerIntegrati
@RequestMapping("/publisher-capitalize")
@ResponseBody
public Publisher<Person> publisherCapitalize(@RequestBody Publisher<Person> persons) {
return Streams.wrap(persons).map(person -> {
return Streams.from(persons).map(person -> {
person.setName(person.getName().toUpperCase());
return person;
});
@@ -482,20 +481,20 @@ public class RequestMappingIntegrationTests extends AbstractHttpHandlerIntegrati
@RequestMapping("/promise-capitalize")
@ResponseBody
public Promise<Person> promiseCapitalize(@RequestBody Promise<Person> personFuture) {
return personFuture.map(person -> {
return Streams.from(personFuture.map(person -> {
person.setName(person.getName().toUpperCase());
return person;
});
})).promise();
}
@RequestMapping("/publisher-create")
public Publisher<Void> publisherCreate(@RequestBody Publisher<Person> personStream) {
return Streams.wrap(personStream).toList().onSuccess(persons::addAll).after();
return Streams.from(personStream).toList().doOnSuccess(persons::addAll).after();
}
@RequestMapping("/stream-create")
public Promise<Void> streamCreate(@RequestBody Stream<Person> personStream) {
return personStream.toList().onSuccess(persons::addAll).after();
public Publisher<Void> streamCreate(@RequestBody Stream<Person> personStream) {
return Streams.from(personStream.toList().doOnSuccess(persons::addAll).after()).promise();
}
@RequestMapping("/observable-create")
@@ -512,7 +511,7 @@ public class RequestMappingIntegrationTests extends AbstractHttpHandlerIntegrati
@RequestMapping("/error-signal")
@ResponseBody
public Publisher<String> handleWithError() {
return Publishers.error(new IllegalStateException("Boo"));
return Mono.error(new IllegalStateException("Boo"));
}
@ExceptionHandler