root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Update for Reactor API changes

This commit is contained in:
Brian Clozel 2020-08-05 13:31:39 +02:00
parent b0d273e047
commit b6d2a2980d
8 changed files with 58 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
spring-messaging/src/test/java/org/springframework/messaging/rsocket/RSocketBufferLeakTests.java
View File

@ -148,7 +148,8 @@ class RSocketBufferLeakTests {
} }
@Test // gh-24741 @Test // gh-24741
@Disabled // pending https://github.com/rsocket/rsocket-java/pull/777 @Disabled
// pending https://github.com/rsocket/rsocket-java/pull/777
void noSuchRouteOnChannelInteraction() { void noSuchRouteOnChannelInteraction() {
Flux<String> input = Flux.just("foo", "bar", "baz"); Flux<String> input = Flux.just("foo", "bar", "baz");
Flux<String> result = requester.route("no-such-route").data(input).retrieveFlux(String.class); Flux<String> result = requester.route("no-such-route").data(input).retrieveFlux(String.class);
@ -245,7 +246,7 @@ class RSocketBufferLeakTests {
void checkForLeaks() { void checkForLeaks() {
this.rsockets.stream().map(PayloadSavingDecorator::getPayloads) this.rsockets.stream().map(PayloadSavingDecorator::getPayloads)
.forEach(payloadInfoProcessor -> { .forEach(payloadInfoProcessor -> {
payloadInfoProcessor.complete(); payloadInfoProcessor.emitComplete();
payloadInfoProcessor.asFlux() payloadInfoProcessor.asFlux()
.doOnNext(this::checkForLeak) .doOnNext(this::checkForLeak)
.blockLast(); .blockLast();
@ -290,18 +291,18 @@ class RSocketBufferLeakTests {
private final RSocket delegate; private final RSocket delegate;
private Sinks.StandaloneFluxSink<PayloadLeakInfo> payloads = Sinks.replayAll(); private Sinks.Many<PayloadLeakInfo> payloads = Sinks.many().replay().all();
PayloadSavingDecorator(RSocket delegate) { PayloadSavingDecorator(RSocket delegate) {
this.delegate = delegate; this.delegate = delegate;
} }
Sinks.StandaloneFluxSink<PayloadLeakInfo> getPayloads() { Sinks.Many<PayloadLeakInfo> getPayloads() {
return this.payloads; return this.payloads;
} }
void reset() { void reset() {
this.payloads = Sinks.replayAll(); this.payloads = Sinks.many().replay().all();
} }
@Override @Override
@ -327,7 +328,7 @@ class RSocketBufferLeakTests {
} }
private io.rsocket.Payload addPayload(io.rsocket.Payload payload) { private io.rsocket.Payload addPayload(io.rsocket.Payload payload) {
this.payloads.next(new PayloadLeakInfo(payload)); this.payloads.emitNext(new PayloadLeakInfo(payload));
return payload; return payload;
} }

8
spring-messaging/src/test/java/org/springframework/messaging/rsocket/RSocketClientToServerIntegrationTests.java
View File

@ -224,14 +224,14 @@ public class RSocketClientToServerIntegrationTests {
@Controller @Controller
static class ServerController { static class ServerController {
final Sinks.StandaloneFluxSink<String> fireForgetPayloads = Sinks.replayAll(); final Sinks.Many<String> fireForgetPayloads = Sinks.many().replay().all();
final Sinks.StandaloneFluxSink<String> metadataPushPayloads = Sinks.replayAll(); final Sinks.Many<String> metadataPushPayloads = Sinks.many().replay().all();
@MessageMapping("receive") @MessageMapping("receive")
void receive(String payload) { void receive(String payload) {
this.fireForgetPayloads.next(payload); this.fireForgetPayloads.emitNext(payload);
} }
@MessageMapping("echo") @MessageMapping("echo")
@ -273,7 +273,7 @@ public class RSocketClientToServerIntegrationTests {
@ConnectMapping("foo-updates") @ConnectMapping("foo-updates")
public void handleMetadata(@Header("foo") String foo) { public void handleMetadata(@Header("foo") String foo) {
this.metadataPushPayloads.next(foo); this.metadataPushPayloads.emitNext(foo);
} }
@MessageExceptionHandler @MessageExceptionHandler

4
spring-messaging/src/test/java/org/springframework/messaging/rsocket/RSocketServerToClientIntegrationTests.java
View File

@ -217,11 +217,11 @@ public class RSocketServerToClientIntegrationTests {
private static class ClientHandler { private static class ClientHandler {
final Sinks.StandaloneFluxSink<String> fireForgetPayloads = Sinks.replayAll(); final Sinks.Many<String> fireForgetPayloads = Sinks.many().replay().all();
@MessageMapping("receive") @MessageMapping("receive")
void receive(String payload) { void receive(String payload) {
this.fireForgetPayloads.next(payload); this.fireForgetPayloads.emitNext(payload);
} }
@MessageMapping("echo") @MessageMapping("echo")

6
spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerTests.java
View File

@ -371,7 +371,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
this.messageHandler.handleMessage(message); this.messageHandler.handleMessage(message);
assertThat(controller.fluxSink).isNotNull(); assertThat(controller.fluxSink).isNotNull();
controller.fluxSink.next("foo"); controller.fluxSink.emitNext("foo");
verify(this.converter, never()).toMessage(any(), any(MessageHeaders.class)); verify(this.converter, never()).toMessage(any(), any(MessageHeaders.class));
} }
@ -587,7 +587,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
private MonoProcessor<String> monoProcessor; private MonoProcessor<String> monoProcessor;
private Sinks.StandaloneFluxSink<String> fluxSink; private Sinks.Many<String> fluxSink;
private boolean exceptionCaught = false; private boolean exceptionCaught = false;
@ -599,7 +599,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
@MessageMapping("flux") @MessageMapping("flux")
public Flux<String> handleFlux() { public Flux<String> handleFlux() {
this.fluxSink = Sinks.unicast(); this.fluxSink = Sinks.many().unicast().onBackpressureBuffer();
return this.fluxSink.asFlux(); return this.fluxSink.asFlux();
} }

6
spring-messaging/src/test/kotlin/org/springframework/messaging/rsocket/RSocketClientToServerCoroutinesIntegrationTests.kt
View File

@ -145,17 +145,17 @@ class RSocketClientToServerCoroutinesIntegrationTests {
@Controller @Controller
class ServerController { class ServerController {
val fireForgetPayloads = Sinks.replayAll<String>() val fireForgetPayloads = Sinks.many().replay().all<String>()
@MessageMapping("receive") @MessageMapping("receive")
fun receive(payload: String) { fun receive(payload: String) {
fireForgetPayloads.next(payload) fireForgetPayloads.emitNext(payload)
} }
@MessageMapping("receive-async") @MessageMapping("receive-async")
suspend fun receiveAsync(payload: String) { suspend fun receiveAsync(payload: String) {
delay(10) delay(10)
fireForgetPayloads.next(payload) fireForgetPayloads.emitNext(payload)
} }
@MessageMapping("echo-async") @MessageMapping("echo-async")

4
spring-web/src/test/java/org/springframework/http/codec/multipart/MultipartHttpMessageWriterTests.java
View File

@ -207,9 +207,9 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTests {
@Test // SPR-16402 @Test // SPR-16402
public void singleSubscriberWithResource() throws IOException { public void singleSubscriberWithResource() throws IOException {
Sinks.StandaloneFluxSink<Resource> sink = Sinks.unicast(); Sinks.Many<Resource> sink = Sinks.many().unicast().onBackpressureBuffer();
Resource logo = new ClassPathResource("/org/springframework/http/converter/logo.jpg"); Resource logo = new ClassPathResource("/org/springframework/http/converter/logo.jpg");
sink.next(logo); sink.emitNext(logo);
MultipartBodyBuilder bodyBuilder = new MultipartBodyBuilder(); MultipartBodyBuilder bodyBuilder = new MultipartBodyBuilder();
bodyBuilder.asyncPart("logo", sink.asFlux(), Resource.class); bodyBuilder.asyncPart("logo", sink.asFlux(), Resource.class);

46
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ReactiveTypeHandlerTests.java
View File

@ -138,11 +138,11 @@ public class ReactiveTypeHandlerTests {
Bar bar1 = new Bar("foo"); Bar bar1 = new Bar("foo");
Bar bar2 = new Bar("bar"); Bar bar2 = new Bar("bar");
Sinks.StandaloneFluxSink<Bar> sink = Sinks.unicast(); Sinks.Many<Bar> sink = Sinks.many().unicast().onBackpressureBuffer();
testDeferredResultSubscriber(sink.asFlux(), Flux.class, forClass(Bar.class), () -> { testDeferredResultSubscriber(sink.asFlux(), Flux.class, forClass(Bar.class), () -> {
sink.next(bar1); sink.emitNext(bar1);
sink.next(bar2); sink.emitNext(bar2);
sink.complete(); sink.emitComplete();
}, Arrays.asList(bar1, bar2)); }, Arrays.asList(bar1, bar2));
} }
@ -189,16 +189,16 @@ public class ReactiveTypeHandlerTests {
public void writeServerSentEvents() throws Exception { public void writeServerSentEvents() throws Exception {
this.servletRequest.addHeader("Accept", "text/event-stream"); this.servletRequest.addHeader("Accept", "text/event-stream");
Sinks.StandaloneFluxSink<String> sink = Sinks.unicast(); Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
SseEmitter sseEmitter = (SseEmitter) handleValue(sink.asFlux(), Flux.class, forClass(String.class)); SseEmitter sseEmitter = (SseEmitter) handleValue(sink.asFlux(), Flux.class, forClass(String.class));
EmitterHandler emitterHandler = new EmitterHandler(); EmitterHandler emitterHandler = new EmitterHandler();
sseEmitter.initialize(emitterHandler); sseEmitter.initialize(emitterHandler);
sink.next("foo"); sink.emitNext("foo");
sink.next("bar"); sink.emitNext("bar");
sink.next("baz"); sink.emitNext("baz");
sink.complete(); sink.emitComplete();
assertThat(emitterHandler.getValuesAsText()).isEqualTo("data:foo\n\ndata:bar\n\ndata:baz\n\n"); assertThat(emitterHandler.getValuesAsText()).isEqualTo("data:foo\n\ndata:bar\n\ndata:baz\n\n");
} }
@ -208,16 +208,16 @@ public class ReactiveTypeHandlerTests {
ResolvableType type = ResolvableType.forClassWithGenerics(ServerSentEvent.class, String.class); ResolvableType type = ResolvableType.forClassWithGenerics(ServerSentEvent.class, String.class);
Sinks.StandaloneFluxSink<ServerSentEvent<?>> sink = Sinks.unicast(); Sinks.Many<ServerSentEvent<?>> sink = Sinks.many().unicast().onBackpressureBuffer();
SseEmitter sseEmitter = (SseEmitter) handleValue(sink.asFlux(), Flux.class, type); SseEmitter sseEmitter = (SseEmitter) handleValue(sink.asFlux(), Flux.class, type);
EmitterHandler emitterHandler = new EmitterHandler(); EmitterHandler emitterHandler = new EmitterHandler();
sseEmitter.initialize(emitterHandler); sseEmitter.initialize(emitterHandler);
sink.next(ServerSentEvent.builder("foo").id("1").build()); sink.emitNext(ServerSentEvent.builder("foo").id("1").build());
sink.next(ServerSentEvent.builder("bar").id("2").build()); sink.emitNext(ServerSentEvent.builder("bar").id("2").build());
sink.next(ServerSentEvent.builder("baz").id("3").build()); sink.emitNext(ServerSentEvent.builder("baz").id("3").build());
sink.complete(); sink.emitComplete();
assertThat(emitterHandler.getValuesAsText()).isEqualTo("id:1\ndata:foo\n\nid:2\ndata:bar\n\nid:3\ndata:baz\n\n"); assertThat(emitterHandler.getValuesAsText()).isEqualTo("id:1\ndata:foo\n\nid:2\ndata:bar\n\nid:3\ndata:baz\n\n");
} }
@ -227,7 +227,7 @@ public class ReactiveTypeHandlerTests {
this.servletRequest.addHeader("Accept", "application/x-ndjson"); this.servletRequest.addHeader("Accept", "application/x-ndjson");
Sinks.StandaloneFluxSink<Bar> sink = Sinks.unicast(); Sinks.Many<Bar> sink = Sinks.many().unicast().onBackpressureBuffer();
ResponseBodyEmitter emitter = handleValue(sink.asFlux(), Flux.class, forClass(Bar.class)); ResponseBodyEmitter emitter = handleValue(sink.asFlux(), Flux.class, forClass(Bar.class));
EmitterHandler emitterHandler = new EmitterHandler(); EmitterHandler emitterHandler = new EmitterHandler();
@ -239,9 +239,9 @@ public class ReactiveTypeHandlerTests {
Bar bar1 = new Bar("foo"); Bar bar1 = new Bar("foo");
Bar bar2 = new Bar("bar"); Bar bar2 = new Bar("bar");
sink.next(bar1); sink.emitNext(bar1);
sink.next(bar2); sink.emitNext(bar2);
sink.complete(); sink.emitComplete();
assertThat(message.getHeaders().getContentType().toString()).isEqualTo("application/x-ndjson"); assertThat(message.getHeaders().getContentType().toString()).isEqualTo("application/x-ndjson");
assertThat(emitterHandler.getValues()).isEqualTo(Arrays.asList(bar1, "\n", bar2, "\n")); assertThat(emitterHandler.getValues()).isEqualTo(Arrays.asList(bar1, "\n", bar2, "\n"));
@ -250,16 +250,16 @@ public class ReactiveTypeHandlerTests {
@Test @Test
public void writeText() throws Exception { public void writeText() throws Exception {
Sinks.StandaloneFluxSink<String> sink = Sinks.unicast(); Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
ResponseBodyEmitter emitter = handleValue(sink.asFlux(), Flux.class, forClass(String.class)); ResponseBodyEmitter emitter = handleValue(sink.asFlux(), Flux.class, forClass(String.class));
EmitterHandler emitterHandler = new EmitterHandler(); EmitterHandler emitterHandler = new EmitterHandler();
emitter.initialize(emitterHandler); emitter.initialize(emitterHandler);
sink.next("The quick"); sink.emitNext("The quick");
sink.next(" brown fox jumps over "); sink.emitNext(" brown fox jumps over ");
sink.next("the lazy dog"); sink.emitNext("the lazy dog");
sink.complete(); sink.emitComplete();
assertThat(emitterHandler.getValuesAsText()).isEqualTo("The quick brown fox jumps over the lazy dog"); assertThat(emitterHandler.getValuesAsText()).isEqualTo("The quick brown fox jumps over the lazy dog");
} }

28
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ResponseBodyEmitterReturnValueHandlerTests.java
View File

@ -227,16 +227,16 @@ public class ResponseBodyEmitterReturnValueHandlerTests {
this.request.addHeader("Accept", "text/event-stream"); this.request.addHeader("Accept", "text/event-stream");
MethodParameter type = on(TestController.class).resolveReturnType(Flux.class, String.class); MethodParameter type = on(TestController.class).resolveReturnType(Flux.class, String.class);
Sinks.StandaloneFluxSink<String> sink = Sinks.unicast(); Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
this.handler.handleReturnValue(sink.asFlux(), type, this.mavContainer, this.webRequest); this.handler.handleReturnValue(sink.asFlux(), type, this.mavContainer, this.webRequest);
assertThat(this.request.isAsyncStarted()).isTrue(); assertThat(this.request.isAsyncStarted()).isTrue();
assertThat(this.response.getStatus()).isEqualTo(200); assertThat(this.response.getStatus()).isEqualTo(200);
sink.next("foo"); sink.emitNext("foo");
sink.next("bar"); sink.emitNext("bar");
sink.next("baz"); sink.emitNext("baz");
sink.complete(); sink.emitComplete();
assertThat(this.response.getContentType()).isEqualTo("text/event-stream"); assertThat(this.response.getContentType()).isEqualTo("text/event-stream");
assertThat(this.response.getContentAsString()).isEqualTo("data:foo\n\ndata:bar\n\ndata:baz\n\n"); assertThat(this.response.getContentAsString()).isEqualTo("data:foo\n\ndata:bar\n\ndata:baz\n\n");
@ -248,14 +248,14 @@ public class ResponseBodyEmitterReturnValueHandlerTests {
this.request.addHeader("Accept", "text/event-stream"); this.request.addHeader("Accept", "text/event-stream");
MethodParameter type = on(TestController.class).resolveReturnType(Flux.class, String.class); MethodParameter type = on(TestController.class).resolveReturnType(Flux.class, String.class);
Sinks.StandaloneFluxSink<String> sink = Sinks.unicast(); Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
this.handler.handleReturnValue(sink.asFlux(), type, this.mavContainer, this.webRequest); this.handler.handleReturnValue(sink.asFlux(), type, this.mavContainer, this.webRequest);
assertThat(this.request.isAsyncStarted()).isTrue(); assertThat(this.request.isAsyncStarted()).isTrue();
IllegalStateException ex = new IllegalStateException("wah wah"); IllegalStateException ex = new IllegalStateException("wah wah");
sink.error(ex); sink.emitError(ex);
sink.complete(); sink.emitComplete();
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.webRequest); WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.webRequest);
assertThat(asyncManager.getConcurrentResult()).isSameAs(ex); assertThat(asyncManager.getConcurrentResult()).isSameAs(ex);
@ -290,7 +290,7 @@ public class ResponseBodyEmitterReturnValueHandlerTests {
@Test @Test
public void responseEntityFlux() throws Exception { public void responseEntityFlux() throws Exception {
Sinks.StandaloneFluxSink<String> sink = Sinks.unicast(); Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
ResponseEntity<Flux<String>> entity = ResponseEntity.ok().body(sink.asFlux()); ResponseEntity<Flux<String>> entity = ResponseEntity.ok().body(sink.asFlux());
ResolvableType bodyType = forClassWithGenerics(Flux.class, String.class); ResolvableType bodyType = forClassWithGenerics(Flux.class, String.class);
MethodParameter type = on(TestController.class).resolveReturnType(ResponseEntity.class, bodyType); MethodParameter type = on(TestController.class).resolveReturnType(ResponseEntity.class, bodyType);
@ -299,10 +299,10 @@ public class ResponseBodyEmitterReturnValueHandlerTests {
assertThat(this.request.isAsyncStarted()).isTrue(); assertThat(this.request.isAsyncStarted()).isTrue();
assertThat(this.response.getStatus()).isEqualTo(200); assertThat(this.response.getStatus()).isEqualTo(200);
sink.next("foo"); sink.emitNext("foo");
sink.next("bar"); sink.emitNext("bar");
sink.next("baz"); sink.emitNext("baz");
sink.complete(); sink.emitComplete();
assertThat(this.response.getContentType()).isEqualTo("text/plain"); assertThat(this.response.getContentType()).isEqualTo("text/plain");
assertThat(this.response.getContentAsString()).isEqualTo("foobarbaz"); assertThat(this.response.getContentAsString()).isEqualTo("foobarbaz");
@ -311,7 +311,7 @@ public class ResponseBodyEmitterReturnValueHandlerTests {
@Test // SPR-17076 @Test // SPR-17076
public void responseEntityFluxWithCustomHeader() throws Exception { public void responseEntityFluxWithCustomHeader() throws Exception {
Sinks.StandaloneFluxSink<SimpleBean> sink = Sinks.unicast(); Sinks.Many<SimpleBean> sink = Sinks.many().unicast().onBackpressureBuffer();
ResponseEntity<Flux<SimpleBean>> entity = ResponseEntity.ok().header("x-foo", "bar").body(sink.asFlux()); ResponseEntity<Flux<SimpleBean>> entity = ResponseEntity.ok().header("x-foo", "bar").body(sink.asFlux());
ResolvableType bodyType = forClassWithGenerics(Flux.class, SimpleBean.class); ResolvableType bodyType = forClassWithGenerics(Flux.class, SimpleBean.class);
MethodParameter type = on(TestController.class).resolveReturnType(ResponseEntity.class, bodyType); MethodParameter type = on(TestController.class).resolveReturnType(ResponseEntity.class, bodyType);