assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Future<Message> incoming = nc.request("subject", null); incoming.cancel(true); incoming = nc.request("subject", null); incoming.cancel(true); incoming = nc.request("subject", null); incoming.cancel(true); incoming = nc.request("subject", null); incoming.cancel(true); incoming = nc.request("subject", null); incoming.cancel(true); incoming = nc.request("subject", null); incoming.cancel(true);
@Test(expected = IllegalArgumentException.class) public void testThrowsWithoutSubject() throws IOException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { nc.request(null, null); assertFalse(true); } }
@Test(expected = IllegalArgumentException.class) public void testThrowsEmptySubject() throws IOException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { nc.request("", null); assertFalse(true); } }
@Test(expected = IllegalStateException.class) public void throwsIfClosed() throws IOException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { nc.close(); nc.request("subject", null); assertFalse(true); } }
@Test public void testHumanReadableString() throws Exception { // This test is purely for coverage, any test without a human is likely pedantic try (NatsTestServer ts = new NatsTestServer(); Connection nc = Nats.connect(new Options.Builder() .server(ts.getURI()) .turnOnAdvancedStats() .build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), new byte[16]); }); d.subscribe("subject"); nc.flush(Duration.ofMillis(500)); Future<Message> incoming = nc.request("subject", new byte[8]); nc.flush(Duration.ofMillis(500)); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); String str = nc.getStatistics().toString(); assertNotNull(msg); assertNotNull(str); assertTrue(str.length() > 0); assertTrue(str.contains("### Connection ###")); assertTrue(str.contains("Socket Writes")); } }
@Test public void testSimpleString() throws Exception { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), msg.getData()); }); d.subscribe("subject"); String body = "hello world"; byte[] bodyBytes = body.getBytes(StandardCharsets.UTF_8); Future<Message> incoming = nc.request("subject", bodyBytes); Message msg = incoming.get(50000, TimeUnit.MILLISECONDS); assertNotNull(msg); assertEquals(bodyBytes.length, msg.getData().length); assertEquals(body, new String(msg.getData(), StandardCharsets.UTF_8)); } }
@Test public void testUTF8String() throws Exception { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), msg.getData()); }); d.subscribe("subject"); String body = "??????"; byte[] bodyBytes = body.getBytes(StandardCharsets.UTF_8); Future<Message> incoming = nc.request("subject", bodyBytes); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertNotNull(msg); assertEquals(bodyBytes.length, msg.getData().length); assertEquals(body, new String(msg.getData(), StandardCharsets.UTF_8)); } }
@Test public void testDifferentSizes() throws Exception { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), msg.getData()); }); d.subscribe("subject"); String body = "hello world"; for (int i=0;i<10;i++) { byte[] bodyBytes = body.getBytes(StandardCharsets.UTF_8); Future<Message> incoming = nc.request("subject", bodyBytes); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertNotNull(msg); assertEquals(bodyBytes.length, msg.getData().length); assertEquals(body, new String(msg.getData(), StandardCharsets.UTF_8)); body = body+body; } } }
@Test public void testZeros() throws Exception { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(ts.getURI())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), msg.getData()); }); d.subscribe("subject"); byte[] data = new byte[17]; Future<Message> incoming = nc.request("subject", data); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertNotNull(msg); assertEquals(data.length, msg.getData().length); assertTrue(Arrays.equals(msg.getData(), data)); } }
@Test public void testSimpleRequest() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(new Options.Builder().server(ts.getURI()).maxReconnects(0).build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { assertTrue(msg.getReplyTo().startsWith(Options.DEFAULT_INBOX_PREFIX)); nc.publish(msg.getReplyTo(), null); }); d.subscribe("subject"); Future<Message> incoming = nc.request("subject", null); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertEquals(0, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); assertNotNull(msg); assertEquals(0, msg.getData().length); assertTrue(msg.getSubject().indexOf('.') < msg.getSubject().lastIndexOf('.')); } }
Future<Message> incoming = nc.request("subject", null); messages.add(incoming);
@Test(expected=IllegalStateException.class) public void testFirstTimeRequestReplyDuringDrain() throws Exception { try (NatsTestServer ts = new NatsTestServer(false); Connection subCon = Nats.connect(new Options.Builder().server(ts.getURI()).maxReconnects(0).build()); Connection pubCon = Nats.connect(new Options.Builder().server(ts.getURI()).maxReconnects(0).build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == subCon.getStatus()); assertTrue("Connected Status", Connection.Status.CONNECTED == pubCon.getStatus()); Subscription sub = subCon.subscribe("draintest"); subCon.flush(Duration.ofSeconds(1)); // Get the sub to the server Dispatcher d = pubCon.createDispatcher((msg) -> { pubCon.publish(msg.getReplyTo(), null); }); d.subscribe("reply"); pubCon.flush(Duration.ofSeconds(1)); // Get the sub to the server pubCon.publish("draintest", null); pubCon.publish("draintest", null); pubCon.flush(Duration.ofSeconds(1)); CompletableFuture<Boolean> tracker = subCon.drain(Duration.ofSeconds(500)); Message msg = sub.nextMessage(Duration.ofSeconds(1)); // read 1 assertNotNull(msg); CompletableFuture<Message> response = subCon.request("reply", null); subCon.flush(Duration.ofSeconds(1)); // Get the sub to the server assertNotNull(response.get(200, TimeUnit.SECONDS)); msg = sub.nextMessage(Duration.ofSeconds(1)); // read 1 assertNotNull(msg); assertTrue(tracker.get(500, TimeUnit.SECONDS)); // wait for the drain to complete assertTrue(Connection.Status.CLOSED == subCon.getStatus()); } }
@Test public void testSafeRequest() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(new Options.Builder().server(ts.getURI()).maxReconnects(0).build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), null); }); d.subscribe("subject"); Message msg = nc.request("subject", null, Duration.ofMillis(1000)); assertEquals(0, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); assertNotNull(msg); assertEquals(0, msg.getData().length); assertTrue(msg.getSubject().indexOf('.') < msg.getSubject().lastIndexOf('.')); } }
@Test public void testRequestWithCustomInbox() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(new Options.Builder().inboxPrefix("myinbox").server(ts.getURI()).maxReconnects(0).build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { assertTrue(msg.getReplyTo().startsWith("myinbox")); nc.publish(msg.getReplyTo(), null); }); d.subscribe("subject"); Future<Message> incoming = nc.request("subject", null); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertEquals(0, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); assertNotNull(msg); assertEquals(0, msg.getData().length); assertTrue(msg.getSubject().indexOf('.') < msg.getSubject().lastIndexOf('.')); } }
@Test public void testMultipleRequest() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false); Connection nc = Nats.connect(new Options.Builder().server(ts.getURI()).maxReconnects(0).build())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), new byte[7]); }); d.subscribe("subject"); for (int i=0; i<10; i++) { Future<Message> incoming = nc.request("subject", new byte[11]); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertEquals(0, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); assertNotNull(msg); assertEquals(7, msg.getData().length); assertTrue(msg.getSubject().indexOf('.') < msg.getSubject().lastIndexOf('.')); } } }
@Test public void testRequireCleanupOnCancel() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false)) { Options options = new Options.Builder().server(ts.getURI()).requestCleanupInterval(Duration.ofHours(1)).build(); Connection nc = Nats.connect(options); try { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Future<Message> incoming = nc.request("subject", null); incoming.cancel(true); assertEquals(1, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); } finally { nc.close(); assertTrue("Closed Status", Connection.Status.CLOSED == nc.getStatus()); } } }
@Test(expected = IllegalArgumentException.class) public void testThrowsIfTooBig() throws IOException, InterruptedException { String customInfo = "{\"server_id\":\"myid\",\"max_payload\":512}"; try (NatsServerProtocolMock ts = new NatsServerProtocolMock(null, customInfo); Connection nc = Nats.connect(ts.getURI())) { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); assertEquals("got custom info", "myid", ((NatsConnection) nc).getInfo().getServerId()); assertEquals("got custom info", 512, ((NatsConnection) nc).getInfo().getMaxPayload()); byte[] body = new byte[513]; nc.request("subject", body); assertFalse(true); } }
@Test public void testOldStyleRequest() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false)) { Options options = new Options.Builder().server(ts.getURI()).oldRequestStyle().build(); Connection nc = Nats.connect(options); try { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Dispatcher d = nc.createDispatcher((msg) -> { nc.publish(msg.getReplyTo(), null); }); d.subscribe("subject"); Future<Message> incoming = nc.request("subject", null); Message msg = incoming.get(500, TimeUnit.MILLISECONDS); assertEquals(0, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); assertNotNull(msg); assertEquals(0, msg.getData().length); assertTrue(msg.getSubject().indexOf('.') == msg.getSubject().lastIndexOf('.')); } finally { nc.close(); assertTrue("Closed Status", Connection.Status.CLOSED == nc.getStatus()); } } }
@Test public void testRequireCleanupOnTimeout() throws IOException, ExecutionException, InterruptedException { try (NatsTestServer ts = new NatsTestServer(false)) { Options options = new Options.Builder().server(ts.getURI()).requestCleanupInterval(Duration.ofHours(1)).build(); Connection nc = Nats.connect(options); try { assertTrue("Connected Status", Connection.Status.CONNECTED == nc.getStatus()); Future<Message> incoming = nc.request("subject", null); Message msg = null; try { msg = incoming.get(100, TimeUnit.MILLISECONDS); assertFalse(true); } catch(TimeoutException e) { assertTrue(true); } assertNull(msg); assertEquals(1, ((NatsStatistics)nc.getStatistics()).getOutstandingRequests()); } finally { nc.close(); assertTrue("Closed Status", Connection.Status.CLOSED == nc.getStatus()); } } }
d.subscribe("subject"); Future<Message> incoming = nc.request("subject", new byte[8]); Message msg = incoming.get(500, TimeUnit.MILLISECONDS);