@Test public void testGetWithRemove() { String dir = "ftpSource/"; this.getGw.setOption(Option.DELETE); this.inboundGet.send(new GenericMessage<Object>(dir + "ftpSource2.txt")); Message<?> result = this.output.receive(1000); assertNotNull(result); File localFile = (File) result.getPayload(); assertThat(localFile.getPath().replaceAll(Matcher.quoteReplacement(File.separator), "/"), containsString(dir.toUpperCase())); assertThat(new File(getSourceRemoteDirectory(), "ftpSource2.txt").exists(), equalTo(false)); }
@Test(expected = ReplyRequiredException.class) public void splitterParserTestWithRequiresReply() { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( "splitterParserTests.xml", this.getClass()); context.start(); DirectChannel inputChannel = context.getBean("requiresReplyInput", DirectChannel.class); inputChannel.send(MessageBuilder.withPayload(Collections.emptyList()).build()); context.close(); }
@Test // INT-1107 public void messageReturningPojoAggregatorResultIsNotWrappedInAnotherMessage() { List<String> payload = Collections.singletonList("test"); this.pojoInput.send(MessageBuilder.withPayload(payload).build()); Message<?> result = this.pojoOutput.receive(); assertFalse(Message.class.isAssignableFrom(result.getPayload().getClass())); }
@Test public void defaultAggregatorResultIsNotWrappedInAnotherMessage() { List<String> payload = Collections.singletonList("test"); this.defaultInput.send(MessageBuilder.withPayload(payload).build()); Message<?> result = this.defaultOutput.receive(); assertFalse(Message.class.isAssignableFrom(result.getPayload().getClass())); }
private void testTransformerDefinitionSuccess(String configProperty) { ApplicationContext ac = this.bootStrap(configProperty); EventDrivenConsumer transformer = (EventDrivenConsumer) ac.getBean("testTransformer"); Assert.assertNotNull(transformer); MessageBuilder<String[]> inChannelMessageBuilder = MessageBuilder.withPayload(new String[]{"One", "Two"}); Message<String[]> inMessage = inChannelMessageBuilder.build(); DirectChannel inChannel = (DirectChannel) ac.getBean("inChannel"); inChannel.send(inMessage); PollableChannel outChannel = (PollableChannel) ac.getBean("outChannel"); String payload = (String) outChannel.receive().getPayload(); Assert.assertTrue(payload.equals("One,Two")); }
private void testSADefinitionSuccess(String configProperty) { ApplicationContext ac = this.bootStrap(configProperty); EventDrivenConsumer splitter = (EventDrivenConsumer) ac.getBean("testServiceActivator"); Assert.assertNotNull(splitter); MessageBuilder<String> inChannelMessageBuilder = MessageBuilder.withPayload("1"); Message<String> inMessage = inChannelMessageBuilder.build(); DirectChannel inChannel = (DirectChannel) ac.getBean("inChannel"); inChannel.send(inMessage); PollableChannel channel1 = (PollableChannel) ac.getBean("outChannel"); Assert.assertTrue(channel1.receive().getPayload().equals("1")); }
@Test public void testSendInSeparateThread() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); final DirectChannel channel = new DirectChannel(); ThreadNameExtractingTestTarget target = new ThreadNameExtractingTestTarget(latch); channel.subscribe(target); final GenericMessage<String> message = new GenericMessage<String>("test"); new Thread((Runnable) () -> channel.send(message), "test-thread").start(); latch.await(1000, TimeUnit.MILLISECONDS); assertEquals("test-thread", target.threadName); }
@Test public void testAggregationWithAnnotationStrategies() { input.send(MessageBuilder.withPayload("a").build()); input.send(MessageBuilder.withPayload("b").build()); @SuppressWarnings("unchecked") Message<String> result = (Message<String>) output.receive(); String payload = result.getPayload(); assertTrue("Wrong payload: " + payload, payload.matches(".*payload.*?=a.*")); assertTrue("Wrong payload: " + payload, payload.matches(".*payload.*?=b.*")); }
@Test public void delayHeaderIsDateInThePastAndDefaultDelayWouldTimeout() { delayHandler.setDefaultDelay(5000); this.setDelayExpression(); startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test") .setHeader("delay", new Date(new Date().getTime() - 60 * 1000)).build(); input.send(message); waitForLatch(10000); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertSame(Thread.currentThread(), resultHandler.lastThread); }
@Test public void testProxyDirect() { assertTrue(AopUtils.isCglibProxy(this.directChannel)); final AtomicReference<Message<?>> message = new AtomicReference<>(); this.directChannel.subscribe(m -> message.set(m)); this.directChannel.send(new GenericMessage<>("foo")); assertNotNull(message.get()); }
@Test public void delayHeaderIsDateInTheFutureAndDefaultDelayWouldTimeout() { delayHandler.setDefaultDelay(5000); this.setDelayExpression(); startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test") .setHeader("delay", new Date(new Date().getTime() + 150)).build(); input.send(message); waitForLatch(10000); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertNotSame(Thread.currentThread(), resultHandler.lastThread); }
@Test public void noDelayHeaderAndDefaultDelayIsZero() { startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test").build(); input.send(message); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertSame(Thread.currentThread(), resultHandler.lastThread); }
@Test(expected = TestTimedOutException.class) public void delayHeaderIsFutureDateAndTimesOut() { this.setDelayExpression(); startDelayerHandler(); Date future = new Date(new Date().getTime() + 60 * 1000); Message<?> message = MessageBuilder.withPayload("test") .setHeader("delay", future).build(); input.send(message); waitForLatch(100); }
@Test public void noDelayHeaderAndDefaultDelayIsPositive() { delayHandler.setDefaultDelay(10); startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test").build(); input.send(message); waitForLatch(10000); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertNotSame(Thread.currentThread(), resultHandler.lastThread); }
@Test public void delayHeaderIsValidStringAndDefaultDelayWouldTimeout() { delayHandler.setDefaultDelay(5000); this.setDelayExpression(); startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test") .setHeader("delay", "20").build(); input.send(message); waitForLatch(10000); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertNotSame(Thread.currentThread(), resultHandler.lastThread); }
private void testValidFilter(Object filter) { postProcessor.postProcessAfterInitialization(filter, "testFilter"); context.refresh(); inputChannel.send(new GenericMessage<>("good")); Message<?> passed = outputChannel.receive(0); assertNotNull(passed); inputChannel.send(new GenericMessage<>("bad")); assertNull(outputChannel.receive(0)); context.stop(); }
@Test public void delayHeaderIsNegativeAndDefaultDelayWouldTimeout() { delayHandler.setDefaultDelay(5000); this.setDelayExpression(); startDelayerHandler(); Message<?> message = MessageBuilder.withPayload("test") .setHeader("delay", -7000).build(); input.send(message); waitForLatch(10000); assertSame(message.getPayload(), resultHandler.lastMessage.getPayload()); assertSame(Thread.currentThread(), resultHandler.lastThread); }
@Test public void sendAndReceiveForAnnotatedEndpoint() { MessagingAnnotationPostProcessor postProcessor = new MessagingAnnotationPostProcessor(); postProcessor.setBeanFactory(this.context.getBeanFactory()); postProcessor.afterPropertiesSet(); TestEndpoint endpoint = new TestEndpoint(); postProcessor.postProcessAfterInitialization(endpoint, "testEndpoint"); this.context.refresh(); this.sourceChannel.send(new GenericMessage<>("foo")); Message<?> response = this.targetChannel.receive(); assertEquals("foo-from-annotated-endpoint", response.getPayload()); }
@Test public void sendAndReceiveForRegisteredEndpoint() { ServiceActivatingHandler serviceActivator = new ServiceActivatingHandler(new TestBean(), "handle"); serviceActivator.setOutputChannel(this.targetChannel); context.registerBean("testServiceActivator", serviceActivator); EventDrivenConsumer endpoint = new EventDrivenConsumer(this.sourceChannel, serviceActivator); context.registerEndpoint("testEndpoint", endpoint); context.refresh(); this.sourceChannel.send(new GenericMessage<>("foo")); Message<?> response = this.targetChannel.receive(); assertEquals("foo!", response.getPayload()); }
@Test(expected = MessagingException.class) public void exceptionThrownFromAnnotatedEndpoint() { QueueChannel errorChannel = new QueueChannel(); this.context.registerChannel(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME, errorChannel); MessagingAnnotationPostProcessor postProcessor = new MessagingAnnotationPostProcessor(); postProcessor.setBeanFactory(this.context.getBeanFactory()); postProcessor.afterPropertiesSet(); FailingTestEndpoint endpoint = new FailingTestEndpoint(); postProcessor.postProcessAfterInitialization(endpoint, "testEndpoint"); this.context.refresh(); this.sourceChannel.send(new GenericMessage<>("foo")); }