@Override public final void start() { synchronized (this.lifecycleMonitor) { this.clientInboundChannel.subscribe(this); this.running = true; } }
@Override public final void start() { Assert.isTrue(this.defaultProtocolHandler != null || !this.protocolHandlers.isEmpty(), "No handlers"); synchronized (this.lifecycleMonitor) { this.clientOutboundChannel.subscribe(this); this.running = true; } }
@Override public void start() { synchronized (this.lifecycleMonitor) { logger.info("Starting..."); this.clientInboundChannel.subscribe(this); this.brokerChannel.subscribe(this); if (this.clientInboundChannel instanceof InterceptableChannel) { ((InterceptableChannel) this.clientInboundChannel).addInterceptor(0, this.unsentDisconnectInterceptor); } startInternal(); this.running = true; logger.info("Started."); } }
@Before public void setUp() { requests.subscribe(this); }
@Test public void sendAndReceive() { SubscribableChannel channel = new ExecutorSubscribableChannel(this.executor); channel.subscribe(new MessageHandler() { @Override public void handleMessage(Message<?> message) throws MessagingException { MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel(); replyChannel.send(new GenericMessage<>("response")); } }); String actual = this.template.convertSendAndReceive(channel, "request", String.class); assertEquals("response", actual); }
expectedOutputChannel.subscribe(handler);
channel.subscribe(new AbstractReplyProducingMessageHandler() {
@Test public void testHappyPath() { // add a listener to this channel, otherwise there is not one defined // the reason we use a listener here is so we can assert truths on the // message and/or payload SubscribableChannel channel = (SubscribableChannel) incomingServerChannel; channel.subscribe(new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { byte[] payload = (byte[]) requestMessage.getPayload(); // we assert during the processing of the messaging that the // payload is just the content we wanted to send without the // framing bytes (STX/ETX) assertEquals("Hello World!", new String(payload)); return requestMessage; } }); String sourceMessage = wrapWithStxEtx("Hello World!"); String result = gw.send(sourceMessage); System.out.println(result); assertEquals("Hello World!", result); }
@Override public final void start() { synchronized (this.lifecycleMonitor) { this.clientInboundChannel.subscribe(this); this.running = true; } }
@Test public void testErrorChannel() { MessageHandler handler = mock(MessageHandler.class); this.errorChannel.subscribe(handler); this.routerAndErrorChannelInputChannel.send(new GenericMessage<String>("fail")); verify(handler, times(1)).handleMessage(Mockito.any(Message.class)); }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux. <Message<?>>create(emitter -> { MessageHandler messageHandler = emitter::next; this.channel.subscribe(messageHandler); emitter.onCancel(() -> this.channel.unsubscribe(messageHandler)); }, FluxSink.OverflowStrategy.IGNORE) .subscribe((Subscriber<? super Message<?>>) subscriber); }
@Test public void testDedicatedPollingThreadFlow() throws InterruptedException { AtomicReference<String> threadNameReference = new AtomicReference<>(); CountDownLatch resultLatch = new CountDownLatch(1); this.dedicatedResults.subscribe(m -> { threadNameReference.set(Thread.currentThread().getName()); resultLatch.countDown(); }); this.dedicatedQueueChannel.send(new GenericMessage<>("foo")); assertTrue(resultLatch.await(10, TimeUnit.SECONDS)); assertEquals("dedicatedTaskScheduler-1", threadNameReference.get()); }
@Test public void validateDefaultChannelPublishing() { MessageHandler handler = Mockito.mock(MessageHandler.class); defaultChannel.subscribe(handler); doAnswer(invocation -> { Message<?> message = invocation.getArgument(0); assertEquals("hello", message.getPayload()); return null; }).when(handler).handleMessage(any(Message.class)); testBean.echoDefaultChannel("hello"); verify(handler, times(1)).handleMessage(any(Message.class)); }
@Test @SuppressWarnings("unchecked") public void testIgnoredHeader() { MessageHandler messageHandler = mock(MessageHandler.class); ((SubscribableChannel) this.errorChannel).subscribe(messageHandler); this.ignoredHeaderGateway.service("foo", "theHeaderValue"); ArgumentCaptor<Message<?>> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); verify(messageHandler).handleMessage(messageArgumentCaptor.capture()); Message<?> message = messageArgumentCaptor.getValue(); assertFalse(message.getHeaders().containsKey(IGNORE_HEADER)); ((SubscribableChannel) this.errorChannel).unsubscribe(messageHandler); }
@Test public void testHandlerMBeanRegistration() throws Exception { Set<ObjectName> names = server.queryNames(new ObjectName("test.MethodInvoker:type=MessageHandler,*"), null); // System . err.println(names); // the router and the error handler... assertEquals(2, names.size()); underscores.subscribe(message -> assertEquals("foo", message.getPayload())); echos.send(MessageBuilder.withPayload("foo").setHeader("entity-type", "underscore").build()); }
@Test public void validateGatewayInTheChainViaChannel() { output.subscribe(message -> { Assert.assertEquals("echo:echo:echo:hello", message.getPayload()); Assert.assertEquals("foo", message.getHeaders().get("foo")); Assert.assertEquals("oleg", message.getHeaders().get("name")); }); channel.send(new GenericMessage<String>("hello")); }
@Test public void testGemfireInboundChannelAdapterDefault() { EventHandler eventHandler2 = new EventHandler(); channel2.subscribe(eventHandler2); region2.put("payload", "payload"); assertTrue(eventHandler2.event instanceof EntryEvent); EntryEvent<?, ?> event = (EntryEvent<?, ?>) eventHandler2.event; assertEquals("payload", event.getNewValue()); }