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

RSocketRequester, RSocketStrategies, PayloadUtils

Browse Source 
See gh-21987
This commit is contained in:
Rossen Stoyanchev
2019-02-18 16:41:29 -05:00
parent 4e78b5df2f
commit 8bdd709683
14 changed files with 1263 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
spring-messaging/src/test/java/org/springframework/messaging/rsocket/DefaultRSocketRequesterTests.java Normal file
View File

@@ -0,0 +1,275 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.messaging.rsocket;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import io.reactivex.Completable;
import io.reactivex.Observable;
import io.reactivex.Single;
import io.rsocket.AbstractRSocket;
import io.rsocket.Payload;
import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import org.springframework.core.codec.CharSequenceEncoder;
import org.springframework.core.codec.StringDecoder;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.lang.Nullable;
import org.springframework.messaging.rsocket.RSocketRequester.RequestSpec;
import org.springframework.messaging.rsocket.RSocketRequester.ResponseSpec;
import org.springframework.util.MimeTypeUtils;
import static java.util.concurrent.TimeUnit.*;
import static org.junit.Assert.*;
/**
* Unit tests for {@link DefaultRSocketRequester}.
*
* @author Rossen Stoyanchev
*/
public class DefaultRSocketRequesterTests {
private static final Duration MILLIS_10 = Duration.ofMillis(10);
private TestRSocket rsocket;
private RSocketRequester requester;
private final DefaultDataBufferFactory bufferFactory = new DefaultDataBufferFactory();
@Before
public void setUp() {
RSocketStrategies strategies = RSocketStrategies.builder()
.decoder(StringDecoder.allMimeTypes())
.encoder(CharSequenceEncoder.allMimeTypes())
.build();
this.rsocket = new TestRSocket();
this.requester = RSocketRequester.create(rsocket, MimeTypeUtils.TEXT_PLAIN, strategies);
}
@Test
public void singlePayload() {
// data(Object)
testSinglePayload(spec -> spec.data("bodyA"), "bodyA");
testSinglePayload(spec -> spec.data(Mono.delay(MILLIS_10).map(l -> "bodyA")), "bodyA");
testSinglePayload(spec -> spec.data(Mono.delay(MILLIS_10).then()), "");
testSinglePayload(spec -> spec.data(Single.timer(10, MILLISECONDS).map(l -> "bodyA")), "bodyA");
testSinglePayload(spec -> spec.data(Completable.complete()), "");
// data(Publisher<T>, Class<T>)
testSinglePayload(spec -> spec.data(Mono.delay(MILLIS_10).map(l -> "bodyA"), String.class), "bodyA");
testSinglePayload(spec -> spec.data(Mono.delay(MILLIS_10).map(l -> "bodyA"), Object.class), "bodyA");
testSinglePayload(spec -> spec.data(Mono.delay(MILLIS_10).then(), Void.class), "");
}
private void testSinglePayload(Function<RequestSpec, ResponseSpec> mapper, String expectedValue) {
mapper.apply(this.requester.route("toA")).send().block(Duration.ofSeconds(5));
assertEquals("fireAndForget", this.rsocket.getSavedMethodName());
assertEquals("toA", this.rsocket.getSavedPayload().getMetadataUtf8());
assertEquals(expectedValue, this.rsocket.getSavedPayload().getDataUtf8());
}
@Test
public void multiPayload() {
String[] values = new String[] {"bodyA", "bodyB", "bodyC"};
Flux<String> stringFlux = Flux.fromArray(values).delayElements(MILLIS_10);
// data(Object)
testMultiPayload(spec -> spec.data(stringFlux), values);
testMultiPayload(spec -> spec.data(Flux.empty()), "");
testMultiPayload(spec -> spec.data(Observable.fromArray(values).delay(10, MILLISECONDS)), values);
testMultiPayload(spec -> spec.data(Observable.empty()), "");
// data(Publisher<T>, Class<T>)
testMultiPayload(spec -> spec.data(stringFlux, String.class), values);
testMultiPayload(spec -> spec.data(stringFlux.cast(Object.class), Object.class), values);
}
private void testMultiPayload(Function<RequestSpec, ResponseSpec> mapper, String... expectedValues) {
this.rsocket.reset();
mapper.apply(this.requester.route("toA")).retrieveFlux(String.class).blockLast(Duration.ofSeconds(5));
assertEquals("requestChannel", this.rsocket.getSavedMethodName());
List<Payload> payloads = this.rsocket.getSavedPayloadFlux().collectList().block(Duration.ofSeconds(5));
assertNotNull(payloads);
if (Arrays.equals(new String[] {""}, expectedValues)) {
assertEquals(1, payloads.size());
assertEquals("toA", payloads.get(0).getMetadataUtf8());
assertEquals("", payloads.get(0).getDataUtf8());
}
else {
assertArrayEquals(new String[] {"toA", "", ""},
payloads.stream().map(Payload::getMetadataUtf8).toArray(String[]::new));
assertArrayEquals(expectedValues,
payloads.stream().map(Payload::getDataUtf8).toArray(String[]::new));
}
}
@Test
public void send() {
String value = "bodyA";
this.requester.route("toA").data(value).send().block(Duration.ofSeconds(5));
assertEquals("fireAndForget", this.rsocket.getSavedMethodName());
assertEquals("toA", this.rsocket.getSavedPayload().getMetadataUtf8());
assertEquals("bodyA", this.rsocket.getSavedPayload().getDataUtf8());
}
@Test
public void retrieveMono() {
String value = "bodyA";
this.rsocket.setPayloadMonoToReturn(Mono.delay(MILLIS_10).thenReturn(toPayload(value)));
Mono<String> response = this.requester.route("").data("").retrieveMono(String.class);
StepVerifier.create(response).expectNext(value).expectComplete().verify(Duration.ofSeconds(5));
assertEquals("requestResponse", this.rsocket.getSavedMethodName());
}
@Test
public void retrieveMonoVoid() {
AtomicBoolean consumed = new AtomicBoolean(false);
Mono<Payload> mono = Mono.delay(MILLIS_10).thenReturn(toPayload("bodyA")).doOnSuccess(p -> consumed.set(true));
this.rsocket.setPayloadMonoToReturn(mono);
this.requester.route("").data("").retrieveMono(Void.class).block(Duration.ofSeconds(5));
assertTrue(consumed.get());
assertEquals("requestResponse", this.rsocket.getSavedMethodName());
}
@Test
public void retrieveFlux() {
String[] values = new String[] {"bodyA", "bodyB", "bodyC"};
this.rsocket.setPayloadFluxToReturn(Flux.fromArray(values).delayElements(MILLIS_10).map(this::toPayload));
Flux<String> response = this.requester.route("").data("").retrieveFlux(String.class);
StepVerifier.create(response).expectNext(values).expectComplete().verify(Duration.ofSeconds(5));
assertEquals("requestStream", this.rsocket.getSavedMethodName());
}
@Test
public void retrieveFluxVoid() {
AtomicBoolean consumed = new AtomicBoolean(false);
Flux<Payload> flux = Flux.just("bodyA", "bodyB")
.delayElements(MILLIS_10).map(this::toPayload).doOnComplete(() -> consumed.set(true));
this.rsocket.setPayloadFluxToReturn(flux);
this.requester.route("").data("").retrieveFlux(Void.class).blockLast(Duration.ofSeconds(5));
assertTrue(consumed.get());
assertEquals("requestStream", this.rsocket.getSavedMethodName());
}
@Test
public void rejectFluxToMono() {
try {
this.requester.route("").data(Flux.just("a", "b")).retrieveMono(String.class);
fail();
}
catch (IllegalArgumentException ex) {
assertEquals("No RSocket interaction model for Flux request to Mono response.", ex.getMessage());
}
}
private Payload toPayload(String value) {
return PayloadUtils.asPayload(bufferFactory.wrap(value.getBytes(StandardCharsets.UTF_8)));
}
private static class TestRSocket extends AbstractRSocket {
private Mono<Payload> payloadMonoToReturn = Mono.empty();
private Flux<Payload> payloadFluxToReturn = Flux.empty();
@Nullable private volatile String savedMethodName;
@Nullable private volatile Payload savedPayload;
@Nullable private volatile Flux<Payload> savedPayloadFlux;
void setPayloadMonoToReturn(Mono<Payload> payloadMonoToReturn) {
this.payloadMonoToReturn = payloadMonoToReturn;
}
void setPayloadFluxToReturn(Flux<Payload> payloadFluxToReturn) {
this.payloadFluxToReturn = payloadFluxToReturn;
}
@Nullable
String getSavedMethodName() {
return this.savedMethodName;
}
@Nullable
Payload getSavedPayload() {
return this.savedPayload;
}
@Nullable
Flux<Payload> getSavedPayloadFlux() {
return this.savedPayloadFlux;
}
public void reset() {
this.savedMethodName = null;
this.savedPayload = null;
this.savedPayloadFlux = null;
}
@Override
public Mono<Void> fireAndForget(Payload payload) {
this.savedMethodName = "fireAndForget";
this.savedPayload = payload;
return Mono.empty();
}
@Override
public Mono<Payload> requestResponse(Payload payload) {
this.savedMethodName = "requestResponse";
this.savedPayload = payload;
return this.payloadMonoToReturn;
}
@Override
public Flux<Payload> requestStream(Payload payload) {
this.savedMethodName = "requestStream";
this.savedPayload = payload;
return this.payloadFluxToReturn;
}
@Override
public Flux<Payload> requestChannel(Publisher<Payload> publisher) {
this.savedMethodName = "requestChannel";
this.savedPayloadFlux = Flux.from(publisher);
return this.payloadFluxToReturn;
}
}
}

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

@@ -16,15 +16,12 @@
package org.springframework.messaging.rsocket;
import java.time.Duration;
import java.util.Collections;
import io.rsocket.Payload;
import io.rsocket.RSocket;
import io.rsocket.RSocketFactory;
import io.rsocket.transport.netty.client.TcpClientTransport;
import io.rsocket.transport.netty.server.CloseableChannel;
import io.rsocket.transport.netty.server.TcpServerTransport;
import io.rsocket.util.DefaultPayload;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -43,6 +40,7 @@ import org.springframework.messaging.ReactiveSubscribableChannel;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.support.DefaultReactiveMessageChannel;
import org.springframework.stereotype.Controller;
import org.springframework.util.MimeTypeUtils;
import static org.junit.Assert.*;
@@ -55,11 +53,13 @@ public class RSocketClientToServerIntegrationTests {
private static AnnotationConfigApplicationContext context;
private static CloseableChannel serverChannel;
private static CloseableChannel server;
private static FireAndForgetCountingInterceptor interceptor = new FireAndForgetCountingInterceptor();
private static RSocket clientRsocket;
private static RSocket client;
private static RSocketRequester requester;
@BeforeClass
@@ -68,27 +68,30 @@ public class RSocketClientToServerIntegrationTests {
context = new AnnotationConfigApplicationContext(ServerConfig.class);
MessagingAcceptor acceptor = new MessagingAcceptor(
context.getBean("rsocketChannel", ReactiveMessageChannel.class));
ReactiveMessageChannel messageChannel = context.getBean(ReactiveMessageChannel.class);
RSocketStrategies rsocketStrategies = context.getBean(RSocketStrategies.class);
serverChannel = RSocketFactory.receive()
server = RSocketFactory.receive()
.addServerPlugin(interceptor)
.acceptor(acceptor)
.acceptor(new MessagingAcceptor(messageChannel))
.transport(TcpServerTransport.create("localhost", 7000))
.start()
.block();
clientRsocket = RSocketFactory.connect()
.dataMimeType("text/plain")
client = RSocketFactory.connect()
.dataMimeType(MimeTypeUtils.TEXT_PLAIN_VALUE)
.transport(TcpClientTransport.create("localhost", 7000))
.start()
.block();
requester = RSocketRequester.create(
client, MimeTypeUtils.TEXT_PLAIN, rsocketStrategies);
}
@AfterClass
public static void tearDownOnce() {
clientRsocket.dispose();
serverChannel.dispose();
client.dispose();
server.dispose();
}
@@ -96,7 +99,7 @@ public class RSocketClientToServerIntegrationTests {
public void fireAndForget() {
Flux.range(1, 3)
.concatMap(i -> clientRsocket.fireAndForget(payload("receive", "Hello " + i)))
.concatMap(i -> requester.route("receive").data("Hello " + i).send())
.blockLast();
StepVerifier.create(context.getBean(ServerController.class).fireForgetPayloads)
@@ -115,7 +118,7 @@ public class RSocketClientToServerIntegrationTests {
public void echo() {
Flux<String> result = Flux.range(1, 3).concatMap(i ->
clientRsocket.requestResponse(payload("echo", "Hello " + i)).map(Payload::getDataUtf8));
requester.route("echo").data("Hello " + i).retrieveMono(String.class));
StepVerifier.create(result)
.expectNext("Hello 1")
@@ -128,7 +131,7 @@ public class RSocketClientToServerIntegrationTests {
public void echoAsync() {
Flux<String> result = Flux.range(1, 3).concatMap(i ->
clientRsocket.requestResponse(payload("echo-async", "Hello " + i)).map(Payload::getDataUtf8));
requester.route("echo-async").data("Hello " + i).retrieveMono(String.class));
StepVerifier.create(result)
.expectNext("Hello 1 async")
@@ -140,8 +143,7 @@ public class RSocketClientToServerIntegrationTests {
@Test
public void echoStream() {
Flux<String> result = clientRsocket.requestStream(payload("echo-stream", "Hello"))
.map(io.rsocket.Payload::getDataUtf8);
Flux<String> result = requester.route("echo-stream").data("Hello").retrieveFlux(String.class);
StepVerifier.create(result)
.expectNext("Hello 0")
@@ -155,11 +157,9 @@ public class RSocketClientToServerIntegrationTests {
@Test
public void echoChannel() {
Flux<Payload> payloads = Flux.concat(
Flux.just(payload("echo-channel", "Hello 1")),
Flux.range(2, 9).map(i -> DefaultPayload.create("Hello " + i)));
Flux<String> result = clientRsocket.requestChannel(payloads).map(Payload::getDataUtf8);
Flux<String> result = requester.route("echo-channel")
.data(Flux.range(1, 10).map(i -> "Hello " + i), String.class)
.retrieveFlux(String.class);
StepVerifier.create(result)
.expectNext("Hello 1 async")
@@ -170,12 +170,6 @@ public class RSocketClientToServerIntegrationTests {
}
private static Payload payload(String destination, String data) {
return DefaultPayload.create(data, destination);
}
@Controller
static class ServerController {
@@ -226,10 +220,17 @@ public class RSocketClientToServerIntegrationTests {
@Bean
public RSocketMessageHandler rsocketMessageHandler() {
RSocketMessageHandler handler = new RSocketMessageHandler(rsocketChannel());
handler.setDecoders(Collections.singletonList(StringDecoder.allMimeTypes()));
handler.setEncoders(Collections.singletonList(CharSequenceEncoder.allMimeTypes()));
handler.setRSocketStrategies(rsocketStrategies());
return handler;
}
@Bean
public RSocketStrategies rsocketStrategies() {
return RSocketStrategies.builder()
.decoder(StringDecoder.allMimeTypes())
.encoder(CharSequenceEncoder.allMimeTypes())
.build();
}
}
}

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

@@ -19,11 +19,11 @@ import java.time.Duration;
import java.util.Collections;
import java.util.List;
import io.rsocket.Closeable;
import io.rsocket.Payload;
import io.rsocket.RSocket;
import io.rsocket.RSocketFactory;
import io.rsocket.transport.netty.client.TcpClientTransport;
import io.rsocket.transport.netty.server.CloseableChannel;
import io.rsocket.transport.netty.server.TcpServerTransport;
import io.rsocket.util.DefaultPayload;
import org.junit.AfterClass;
@@ -56,7 +56,7 @@ public class RSocketServerToClientIntegrationTests {
private static AnnotationConfigApplicationContext context;
private static CloseableChannel serverChannel;
private static Closeable server;
private static MessagingAcceptor clientAcceptor;
@@ -67,14 +67,14 @@ public class RSocketServerToClientIntegrationTests {
context = new AnnotationConfigApplicationContext(ServerConfig.class);
ReactiveMessageChannel messageChannel = context.getBean("serverChannel", ReactiveMessageChannel.class);
RSocketStrategies rsocketStrategies = context.getBean(RSocketStrategies.class);
clientAcceptor = new MessagingAcceptor(
context.getBean("clientChannel", ReactiveMessageChannel.class));
MessagingAcceptor serverAcceptor = new MessagingAcceptor(
context.getBean("serverChannel", ReactiveMessageChannel.class));
serverChannel = RSocketFactory.receive()
.acceptor(serverAcceptor)
server = RSocketFactory.receive()
.acceptor(new MessagingAcceptor(messageChannel, rsocketStrategies))
.transport(TcpServerTransport.create("localhost", 7000))
.start()
.block();
@@ -82,7 +82,7 @@ public class RSocketServerToClientIntegrationTests {
@AfterClass
public static void tearDownOnce() {
serverChannel.dispose();
server.dispose();
}
@@ -141,10 +141,10 @@ public class RSocketServerToClientIntegrationTests {
@MessageMapping("connect.echo")
void echo(RSocket rsocket) {
void echo(RSocketRequester requester) {
runTest(() -> {
Flux<String> result = Flux.range(1, 3).concatMap(i ->
rsocket.requestResponse(payload("echo", "Hello " + i)).map(Payload::getDataUtf8));
requester.route("echo").data("Hello " + i).retrieveMono(String.class));
StepVerifier.create(result)
.expectNext("Hello 1")
@@ -155,10 +155,10 @@ public class RSocketServerToClientIntegrationTests {
}
@MessageMapping("connect.echo-async")
void echoAsync(RSocket rsocket) {
void echoAsync(RSocketRequester requester) {
runTest(() -> {
Flux<String> result = Flux.range(1, 3).concatMap(i ->
rsocket.requestResponse(payload("echo-async", "Hello " + i)).map(Payload::getDataUtf8));
requester.route("echo-async").data("Hello " + i).retrieveMono(String.class));
StepVerifier.create(result)
.expectNext("Hello 1 async")
@@ -169,10 +169,9 @@ public class RSocketServerToClientIntegrationTests {
}
@MessageMapping("connect.echo-stream")
void echoStream(RSocket rsocket) {
void echoStream(RSocketRequester requester) {
runTest(() -> {
Flux<String> result = rsocket.requestStream(payload("echo-stream", "Hello"))
.map(io.rsocket.Payload::getDataUtf8);
Flux<String> result = requester.route("echo-stream").data("Hello").retrieveFlux(String.class);
StepVerifier.create(result)
.expectNext("Hello 0")
@@ -185,13 +184,11 @@ public class RSocketServerToClientIntegrationTests {
}
@MessageMapping("connect.echo-channel")
void echoChannel(RSocket rsocket) {
void echoChannel(RSocketRequester requester) {
runTest(() -> {
Flux<Payload> payloads = Flux.concat(
Flux.just(payload("echo-channel", "Hello 1")),
Flux.range(2, 9).map(i -> DefaultPayload.create("Hello " + i)));
Flux<String> result = rsocket.requestChannel(payloads).map(Payload::getDataUtf8);
Flux<String> result = requester.route("echo-channel")
.data(Flux.range(1, 10).map(i -> "Hello " + i), String.class)
.retrieveFlux(String.class);
StepVerifier.create(result)
.expectNext("Hello 1 async")
@@ -285,20 +282,23 @@ public class RSocketServerToClientIntegrationTests {
public RSocketMessageHandler clientMessageHandler() {
List<Object> handlers = Collections.singletonList(clientController());
RSocketMessageHandler handler = new RSocketMessageHandler(clientChannel(), handlers);
addDefaultCodecs(handler);
handler.setRSocketStrategies(rsocketStrategies());
return handler;
}
@Bean
public RSocketMessageHandler serverMessageHandler() {
RSocketMessageHandler handler = new RSocketMessageHandler(serverChannel());
addDefaultCodecs(handler);
handler.setRSocketStrategies(rsocketStrategies());
return handler;
}
private void addDefaultCodecs(RSocketMessageHandler handler) {
handler.setDecoders(Collections.singletonList(StringDecoder.allMimeTypes()));
handler.setEncoders(Collections.singletonList(CharSequenceEncoder.allMimeTypes()));
@Bean
public RSocketStrategies rsocketStrategies() {
return RSocketStrategies.builder()
.decoder(StringDecoder.allMimeTypes())
.encoder(CharSequenceEncoder.allMimeTypes())
.build();
}
}