@Test public void testResumePausedProducer() { BlockingQueue<Integer> sequence = new LinkedBlockingQueue<>(); AtomicReference<Context> handlerContext = new AtomicReference<>(); MessageConsumer<Integer> consumer = eb.consumer("some-address", msg -> { if (sequence.isEmpty()) { handlerContext.set(Vertx.currentContext()); } else { assertEquals(Vertx.currentContext(), handlerContext.get()); } sequence.add(msg.body()); }); consumer.pause(); MessageProducer<Integer> prod = eb.sender("some-address"); LinkedList<Integer> expected = new LinkedList<>(); int count = 0; while (!prod.writeQueueFull()) { int val = count++; expected.add(val); prod.send(val); } consumer.resume(); assertWaitUntil(() -> !prod.writeQueueFull()); int theCount = count; assertWaitUntil(() -> sequence.size() == theCount); while (expected.size() > 0) { assertEquals(expected.removeFirst(), sequence.poll()); } assertNotNull(handlerContext.get()); }
@Test public void testPump() { String str = TestUtils.randomUnicodeString(100); ReadStream<String> consumer = eb.<String>consumer(ADDRESS1).bodyStream(); consumer.handler(message -> { if (message.equals(str)) { testComplete(); } }); MessageProducer<String> producer = eb.sender(ADDRESS2); Pump.pump(consumer, producer); producer.write(str); }
@Test public void testFlowControlPauseConsumer() { MessageProducer<String> prod = eb.sender("some-address"); int numBatches = 10; int wqms = 100; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); AtomicBoolean paused = new AtomicBoolean(); consumer.handler(msg -> { assertFalse(paused.get()); int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } if (c % 100 == 0) { consumer.pause(); paused.set(true); vertx.setTimer(100, tid -> { paused.set(false); consumer.resume(); }); } }); sendBatch(prod, wqms, numBatches, 0); await(); }
@Test public void testSender() { String str = TestUtils.randomUnicodeString(100); WriteStream<String> sender = eb.sender(ADDRESS1); eb.consumer(ADDRESS1).handler(message -> { if (message.body().equals(str)) { testComplete(); } }); sender.write(str); await(); }
@Test public void testFlowControl() { MessageProducer<String> prod = eb.sender("some-address"); int numBatches = 1000; int wqms = 2000; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); consumer.handler(msg -> { int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } }); vertx.runOnContext(v -> { sendBatch(prod, wqms, numBatches, 0); }); await(); }
@Test public void testSenderWithOptions() { String str = TestUtils.randomUnicodeString(100); WriteStream<String> sender = eb.sender(ADDRESS1, new DeliveryOptions().addHeader("foo", "foo_value")); eb.consumer(ADDRESS1).handler(message -> { if (message.body().equals(str) && "foo_value".equals(message.headers().get("foo"))) { testComplete(); } }); sender.write(str); await(); }
@Test public void testFlowControlWithOptions() { MessageProducer<String> prod = eb.sender("some-address"); prod.deliveryOptions(new DeliveryOptions().addHeader("foo", "bar")); int numBatches = 1000; int wqms = 2000; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); consumer.handler(msg -> { int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } }); vertx.runOnContext(v -> { sendBatch(prod, wqms, numBatches, 0); }); await(); }
@Test public void testFlowControlNoConsumer() { MessageProducer<String> prod = eb.sender("some-address"); int wqms = 2000; prod.setWriteQueueMaxSize(wqms); boolean drainHandlerSet = false; for (int i = 0; i < wqms * 2; i++) { prod.send("message-" + i); if (prod.writeQueueFull() && !drainHandlerSet) { prod.drainHandler(v -> { fail("Should not be called"); }); drainHandlerSet = true; } } assertTrue(drainHandlerSet); vertx.setTimer(500, tid -> testComplete()); await(); }
@Test public void testDrainHandlerCalledWhenQueueAlreadyDrained() throws Exception { MessageConsumer<String> consumer = eb.consumer("some-address"); consumer.handler(msg -> {}); MessageProducer<String> prod = eb.sender("some-address"); prod.setWriteQueueMaxSize(1); prod.write("msg"); assertTrue(prod.writeQueueFull()); waitUntil(() -> !prod.writeQueueFull()); prod.drainHandler(v -> { testComplete(); }); await(); }
@Test public void testUpdateDeliveryOptionsOnProducer() { MessageProducer<String> producer = eb.sender(ADDRESS1); MessageConsumer<String> consumer = eb.<String>consumer(ADDRESS1); consumer.completionHandler(v -> { assertTrue(v.succeeded()); producer.write("no-header"); }); consumer.handler(msg -> { String body = msg.body(); assertNotNull(body); switch (body) { case "no-header": assertNull(msg.headers().get("header-name")); producer.deliveryOptions(new DeliveryOptions().addHeader("header-name", "header-value")); producer.write("with-header"); break; case "with-header": assertEquals("header-value", msg.headers().get("header-name")); testComplete(); break; default: fail(); } }); await(); }
@Test public void testArgumentValidation() throws Exception { assertNullPointerException(() -> eb.send(null, "")); assertNullPointerException(() -> eb.send(null, "", handler -> {})); assertNullPointerException(() -> eb.send(null, "", new DeliveryOptions())); assertNullPointerException(() -> eb.send("", "", (DeliveryOptions) null)); assertNullPointerException(() -> eb.send(null, "", new DeliveryOptions(), handler -> {})); assertNullPointerException(() -> eb.send("", "", null, handler -> {})); assertNullPointerException(() -> eb.publish(null, "")); assertNullPointerException(() -> eb.publish(null, "", new DeliveryOptions())); assertNullPointerException(() -> eb.publish("", "", null)); assertNullPointerException(() -> eb.consumer(null)); assertNullPointerException(() -> eb.consumer(null, msg -> {})); assertNullPointerException(() -> eb.consumer(ADDRESS1, null)); assertNullPointerException(() -> eb.localConsumer(null)); assertNullPointerException(() -> eb.localConsumer(null, msg -> {})); assertNullPointerException(() -> eb.localConsumer(ADDRESS1, null)); assertNullPointerException(() -> eb.sender(null)); assertNullPointerException(() -> eb.sender(null, new DeliveryOptions())); assertNullPointerException(() -> eb.publisher("", null)); assertNullPointerException(() -> eb.publisher(null, new DeliveryOptions())); assertNullPointerException(() -> eb.registerCodec(null)); assertNullPointerException(() -> eb.unregisterCodec(null)); assertNullPointerException(() -> eb.registerDefaultCodec(null, new MyPOJOEncoder1())); assertNullPointerException(() -> eb.registerDefaultCodec(Object.class, null)); assertNullPointerException(() -> eb.unregisterDefaultCodec(null)); }
@Test public void testFlowControlPauseConsumer() { MessageProducer<String> prod = eb.sender("some-address"); int numBatches = 10; int wqms = 100; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); AtomicBoolean paused = new AtomicBoolean(); consumer.handler(msg -> { assertFalse(paused.get()); int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } if (c % 100 == 0) { consumer.pause(); paused.set(true); vertx.setTimer(100, tid -> { paused.set(false); consumer.resume(); }); } }); sendBatch(prod, wqms, numBatches, 0); await(); }
@Test public void testFlowControl() { MessageProducer<String> prod = eb.sender("some-address"); int numBatches = 1000; int wqms = 2000; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); consumer.handler(msg -> { int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } }); vertx.runOnContext(v -> { sendBatch(prod, wqms, numBatches, 0); }); await(); }
@Test public void testSender() { String str = TestUtils.randomUnicodeString(100); WriteStream<String> sender = eb.sender(ADDRESS1); eb.consumer(ADDRESS1).handler(message -> { if (message.body().equals(str)) { testComplete(); } }); sender.write(str); await(); }
@Test public void testPump() { String str = TestUtils.randomUnicodeString(100); ReadStream<String> consumer = eb.<String>consumer(ADDRESS1).bodyStream(); consumer.handler(message -> { if (message.equals(str)) { testComplete(); } }); MessageProducer<String> producer = eb.sender(ADDRESS2); Pump.pump(consumer, producer); producer.write(str); }
@Test public void testSenderWithOptions() { String str = TestUtils.randomUnicodeString(100); WriteStream<String> sender = eb.sender(ADDRESS1, new DeliveryOptions().addHeader("foo", "foo_value")); eb.consumer(ADDRESS1).handler(message -> { if (message.body().equals(str) && "foo_value".equals(message.headers().get("foo"))) { testComplete(); } }); sender.write(str); await(); }
@Test public void testFlowControlWithOptions() { MessageProducer<String> prod = eb.sender("some-address"); prod.deliveryOptions(new DeliveryOptions().addHeader("foo", "bar")); int numBatches = 1000; int wqms = 2000; prod.setWriteQueueMaxSize(wqms); MessageConsumer<String> consumer = eb.consumer("some-address"); AtomicInteger cnt = new AtomicInteger(); consumer.handler(msg -> { int c = cnt.incrementAndGet(); if (c == numBatches * wqms) { testComplete(); } }); vertx.runOnContext(v -> { sendBatch(prod, wqms, numBatches, 0); }); await(); }
@Test public void testFlowControlNoConsumer() { MessageProducer<String> prod = eb.sender("some-address"); int wqms = 2000; prod.setWriteQueueMaxSize(wqms); boolean drainHandlerSet = false; for (int i = 0; i < wqms * 2; i++) { prod.send("message-" + i); if (prod.writeQueueFull() && !drainHandlerSet) { prod.drainHandler(v -> { fail("Should not be called"); }); drainHandlerSet = true; } } assertTrue(drainHandlerSet); vertx.setTimer(500, tid -> testComplete()); await(); }
@Test public void testDrainHandlerCalledWhenQueueAlreadyDrained() throws Exception { MessageConsumer<String> consumer = eb.consumer("some-address"); consumer.handler(msg -> {}); MessageProducer<String> prod = eb.sender("some-address"); prod.setWriteQueueMaxSize(1); prod.write("msg"); assertTrue(prod.writeQueueFull()); waitUntil(() -> !prod.writeQueueFull()); prod.drainHandler(v -> { testComplete(); }); await(); }
@Test public void testUpdateDeliveryOptionsOnProducer() { MessageProducer<String> producer = eb.sender(ADDRESS1); MessageConsumer<String> consumer = eb.<String>consumer(ADDRESS1); consumer.completionHandler(v -> { assertTrue(v.succeeded()); producer.write("no-header"); }); consumer.handler(msg -> { String body = msg.body(); assertNotNull(body); switch (body) { case "no-header": assertNull(msg.headers().get("header-name")); producer.deliveryOptions(new DeliveryOptions().addHeader("header-name", "header-value")); producer.write("with-header"); break; case "with-header": assertEquals("header-value", msg.headers().get("header-name")); testComplete(); break; default: fail(); } }); await(); }