185 lines
6.1 KiB
Java
185 lines
6.1 KiB
Java
package it.tdlight.reactiveapi.test;
|
|
|
|
import com.google.common.collect.Collections2;
|
|
import com.google.common.net.HostAndPort;
|
|
import io.rsocket.Payload;
|
|
import io.rsocket.SocketAcceptor;
|
|
import io.rsocket.core.RSocketConnector;
|
|
import io.rsocket.core.RSocketServer;
|
|
import io.rsocket.frame.decoder.PayloadDecoder;
|
|
import io.rsocket.transport.local.LocalClientTransport;
|
|
import io.rsocket.transport.netty.server.TcpServerTransport;
|
|
import io.rsocket.util.DefaultPayload;
|
|
import it.tdlight.reactiveapi.ChannelCodec;
|
|
import it.tdlight.reactiveapi.EventConsumer;
|
|
import it.tdlight.reactiveapi.EventProducer;
|
|
import it.tdlight.reactiveapi.Timestamped;
|
|
import it.tdlight.reactiveapi.TransportFactory;
|
|
import it.tdlight.reactiveapi.rsocket.MyRSocketClient;
|
|
import it.tdlight.reactiveapi.rsocket.MyRSocketServer;
|
|
import java.time.Duration;
|
|
import java.util.List;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import org.junit.jupiter.api.Assertions;
|
|
import org.junit.jupiter.api.Test;
|
|
import reactor.core.publisher.Flux;
|
|
import reactor.core.publisher.Mono;
|
|
import reactor.core.scheduler.Schedulers;
|
|
|
|
public class TestRSocket {
|
|
|
|
private static final TransportFactory TEST_TRANSPORT_FACTORY = TransportFactory.tcp(HostAndPort.fromParts("127.0.0.1", 8085));
|
|
|
|
@Test
|
|
public void testClientOnClose() {
|
|
Assertions.assertThrows(IllegalStateException.class, () -> {
|
|
var client = new MyRSocketClient(TEST_TRANSPORT_FACTORY);
|
|
try {
|
|
client.onClose().block(Duration.ofSeconds(1));
|
|
} finally {
|
|
client.dispose();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Test
|
|
public void testServerConsumer() {
|
|
var server = new MyRSocketServer(TEST_TRANSPORT_FACTORY, 1);
|
|
try {
|
|
var rawClient = RSocketConnector.create()
|
|
.setupPayload(DefaultPayload.create("client", "setup-info"))
|
|
.payloadDecoder(PayloadDecoder.ZERO_COPY)
|
|
.connect(TEST_TRANSPORT_FACTORY.getClientTransport(0))
|
|
.block(Duration.ofSeconds(5));
|
|
Assertions.assertNotNull(rawClient);
|
|
var outputSequence = Flux.just("a", "b", "c").map(DefaultPayload::create);
|
|
var disposable = rawClient
|
|
.requestChannel(Flux.just(DefaultPayload.create("test", "channel")).concatWith(outputSequence))
|
|
.subscribeOn(Schedulers.parallel())
|
|
.subscribe(v -> {}, ex -> Assertions.fail(ex));
|
|
try {
|
|
EventConsumer<String> consumer = server.registerConsumer(ChannelCodec.UTF8_TEST, "test");
|
|
var events = consumer.consumeMessages().collectList().block(Duration.ofSeconds(5));
|
|
Assertions.assertNotNull(events);
|
|
var mappedEvents = List.copyOf(Collections2.transform(events, Timestamped::data));
|
|
Assertions.assertEquals(List.of("a", "b", "c"), mappedEvents);
|
|
} finally {
|
|
disposable.dispose();
|
|
}
|
|
} finally {
|
|
server.dispose();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testServerProducer() {
|
|
var server = new MyRSocketServer(TEST_TRANSPORT_FACTORY, 1);
|
|
try {
|
|
var rawClient = RSocketConnector.create()
|
|
.setupPayload(DefaultPayload.create("client", "setup-info"))
|
|
.payloadDecoder(PayloadDecoder.ZERO_COPY)
|
|
.connect(TEST_TRANSPORT_FACTORY.getClientTransport(0))
|
|
.block(Duration.ofSeconds(5));
|
|
Assertions.assertNotNull(rawClient);
|
|
EventProducer<String> producer = server.registerProducer(ChannelCodec.UTF8_TEST, "test");
|
|
var disposable = producer
|
|
.sendMessages(Flux.just("a", "b", "c"))
|
|
.subscribeOn(Schedulers.parallel())
|
|
.subscribe(v -> {}, ex -> Assertions.fail(ex));
|
|
try {
|
|
var events = rawClient
|
|
.requestStream(DefaultPayload.create("test", "channel"))
|
|
.map(Payload::getDataUtf8)
|
|
.collectList()
|
|
.block();
|
|
Assertions.assertNotNull(events);
|
|
Assertions.assertEquals(List.of("a", "b", "c"), events);
|
|
} finally {
|
|
disposable.dispose();
|
|
}
|
|
} finally {
|
|
server.dispose();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testClientConsumer() {
|
|
var client = new MyRSocketClient(TEST_TRANSPORT_FACTORY);
|
|
try {
|
|
var rawServer = RSocketServer.create(SocketAcceptor.forRequestStream(payload -> {
|
|
var metadata = payload.getMetadataUtf8();
|
|
Assertions.assertEquals("channel", metadata);
|
|
var data = payload.getDataUtf8();
|
|
Assertions.assertEquals("test", data);
|
|
return Flux.just("a", "b", "c").map(DefaultPayload::create);
|
|
}))
|
|
.payloadDecoder(PayloadDecoder.ZERO_COPY)
|
|
.bindNow(TEST_TRANSPORT_FACTORY.getServerTransport(0));
|
|
try {
|
|
var events = client
|
|
.<String>registerConsumer(ChannelCodec.UTF8_TEST, "test")
|
|
.consumeMessages()
|
|
.map(Timestamped::data)
|
|
.collectList()
|
|
.block(Duration.ofSeconds(5));
|
|
Assertions.assertNotNull(events);
|
|
Assertions.assertEquals(List.of("a", "b", "c"), events);
|
|
} finally {
|
|
rawServer.dispose();
|
|
}
|
|
} finally {
|
|
client.dispose();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testClientProducer() {
|
|
AtomicBoolean received = new AtomicBoolean();
|
|
var rawServer = RSocketServer
|
|
.create(SocketAcceptor.forRequestChannel(payloads -> Flux.from(payloads).switchOnFirst((first, flux) -> {
|
|
if (first.isOnNext()) {
|
|
var payload = first.get();
|
|
Assertions.assertNotNull(payload);
|
|
var metadata = payload.getMetadataUtf8();
|
|
Assertions.assertEquals("channel", metadata);
|
|
var data = payload.getDataUtf8();
|
|
Assertions.assertEquals("test", data);
|
|
return flux.skip(1).map(Payload::getDataUtf8).collectList().doOnSuccess(val -> {
|
|
received.set(true);
|
|
Assertions.assertEquals(List.of("a", "b", "c"), val);
|
|
}).then(Mono.just(DefaultPayload.create("ok", "response")));
|
|
} else {
|
|
return flux.take(1, true);
|
|
}
|
|
})))
|
|
.payloadDecoder(PayloadDecoder.ZERO_COPY)
|
|
.bindNow(TEST_TRANSPORT_FACTORY.getServerTransport(0));
|
|
try {
|
|
var client = new MyRSocketClient(TEST_TRANSPORT_FACTORY);
|
|
try {
|
|
client
|
|
.<String>registerProducer(ChannelCodec.UTF8_TEST, "test")
|
|
.sendMessages(Flux.just("a", "b", "c"))
|
|
.block(Duration.ofMinutes(1));
|
|
Assertions.assertTrue(received.get());
|
|
} finally {
|
|
client.dispose();
|
|
}
|
|
} finally {
|
|
rawServer.dispose();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testServerOnClose() {
|
|
Assertions.assertThrows(IllegalStateException.class, () -> {
|
|
var server = new MyRSocketServer(TEST_TRANSPORT_FACTORY, 1);
|
|
try {
|
|
server.onClose().block(Duration.ofSeconds(1));
|
|
} finally {
|
|
server.dispose();
|
|
}
|
|
});
|
|
}
|
|
}
|