/*
* Copyright 2013-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.xd.dirt.integration.bus;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.PublishSubscribeChannel;
import org.springframework.integration.scheduling.PollerMetadata;
import org.springframework.integration.support.DefaultMessageBuilderFactory;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.integration.support.utils.IntegrationUtils;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.PeriodicTrigger;
/**
* @author Mark Fisher
* @author Gary Russell
*/
public class MessageBusAwareChannelResolverTests {
private final StaticApplicationContext context = new StaticApplicationContext();
private volatile MessageBusAwareChannelResolver resolver;
private volatile LocalMessageBus bus;
@Before
public void setupContext() throws Exception {
this.bus = new LocalMessageBus();
this.bus.setApplicationContext(context);
this.bus.afterPropertiesSet();
this.resolver = new MessageBusAwareChannelResolver(this.bus, null);
this.resolver.setBeanFactory(context);
context.getBeanFactory().registerSingleton("channelResolver",
this.resolver);
context.registerSingleton("other", DirectChannel.class);
context.registerSingleton("taskScheduler", ThreadPoolTaskScheduler.class);
context.registerSingleton(IntegrationUtils.INTEGRATION_MESSAGE_BUILDER_FACTORY_BEAN_NAME,
DefaultMessageBuilderFactory.class);
context.refresh();
PollerMetadata poller = new PollerMetadata();
poller.setTrigger(new PeriodicTrigger(1000));
bus.setPoller(poller);
}
@Test
public void resolveQueueChannel() {
MessageChannel registered = resolver.resolveDestination("queue:foo");
DirectChannel testChannel = new DirectChannel();
final CountDownLatch latch = new CountDownLatch(1);
final List<Message<?>> received = new ArrayList<Message<?>>();
testChannel.subscribe(new MessageHandler() {
@Override
public void handleMessage(Message<?> message) throws MessagingException {
received.add(message);
latch.countDown();
}
});
bus.bindConsumer("queue:foo", testChannel, null);
assertEquals(0, received.size());
registered.send(MessageBuilder.withPayload("hello").build());
try {
assertTrue("latch timed out", latch.await(1, TimeUnit.SECONDS));
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
fail("interrupted while awaiting latch");
}
assertEquals(1, received.size());
assertEquals("hello", received.get(0).getPayload());
context.close();
}
@Test
public void resolveTopicChannel() {
MessageChannel registered = resolver.resolveDestination("topic:bar");
PublishSubscribeChannel[] testChannels = {
new PublishSubscribeChannel(), new PublishSubscribeChannel(), new PublishSubscribeChannel()
};
final CountDownLatch latch = new CountDownLatch(testChannels.length);
final List<Message<?>> received = new ArrayList<Message<?>>();
for (PublishSubscribeChannel testChannel : testChannels) {
testChannel.subscribe(new MessageHandler() {
@Override
public void handleMessage(Message<?> message) throws MessagingException {
received.add(message);
latch.countDown();
}
});
bus.bindPubSubConsumer("topic:bar", testChannel, null);
}
assertEquals(0, received.size());
registered.send(MessageBuilder.withPayload("hello").build());
try {
assertTrue("latch timed out", latch.await(1, TimeUnit.SECONDS));
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
fail("interrupted while awaiting latch");
}
assertEquals(3, received.size());
assertEquals("hello", received.get(0).getPayload());
assertEquals("hello", received.get(1).getPayload());
assertEquals("hello", received.get(2).getPayload());
context.close();
}
@Test
public void resolveNonRegisteredChannel() {
MessageChannel other = resolver.resolveDestination("other");
assertSame(context.getBean("other"), other);
}
@Test
public void propertyPassthrough() {
Properties properties = new Properties();
MessageBus bus = mock(MessageBus.class);
doReturn(new DirectChannel()).when(bus).bindDynamicProducer("queue:foo", properties);
doReturn(new DirectChannel()).when(bus).bindDynamicPubSubProducer("topic:bar", properties);
MessageBusAwareChannelResolver resolver = new MessageBusAwareChannelResolver(bus, properties);
BeanFactory beanFactory = new DefaultListableBeanFactory();
resolver.setBeanFactory(beanFactory);
resolver.resolveDestination("queue:foo");
resolver.resolveDestination("topic:bar");
verify(bus).bindDynamicProducer("queue:foo", properties);
verify(bus).bindDynamicPubSubProducer("topic:bar", properties);
}
}