Spring/spring-integration
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed AbstractPoller and ChannelPoller. Refactored test cases to use PollingConsumerEndpoint.

Browse Source
This commit is contained in:
Mark Fisher
2008-10-20 15:27:03 +00:00
parent f8b2724f7a
commit 1dc2c175a2
6 changed files with 458 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
org.springframework.integration.stream/src/test/java/org/springframework/integration/stream/ByteStreamWritingMessageConsumerTests.java
View File

@@ -20,37 +20,62 @@ import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.endpoint.ChannelPoller;
import org.springframework.integration.endpoint.PollingConsumerEndpoint;
import org.springframework.integration.message.GenericMessage;
import org.springframework.integration.message.StringMessage;
import org.springframework.integration.scheduling.IntervalTrigger;
import org.springframework.integration.scheduling.SimpleTaskScheduler;
import org.springframework.integration.scheduling.Trigger;
/**
* @author Mark Fisher
*/
public class ByteStreamWritingMessageConsumerTests {
private ByteArrayOutputStream stream;
private ByteStreamWritingMessageConsumer consumer;
private QueueChannel channel;
private ChannelPoller poller;
private PollingConsumerEndpoint endpoint;
private TestTrigger trigger = new TestTrigger();
private SimpleTaskScheduler scheduler;
@Before
public void initialize() {
stream = new ByteArrayOutputStream();
consumer = new ByteStreamWritingMessageConsumer(stream);
this.channel = new QueueChannel(10);
this.poller = new ChannelPoller(channel, new IntervalTrigger(0));
this.endpoint = new PollingConsumerEndpoint(consumer, channel);
scheduler = new SimpleTaskScheduler(new SimpleAsyncTaskExecutor());
this.endpoint.setTaskScheduler(scheduler);
scheduler.start();
trigger.reset();
endpoint.setTrigger(trigger);
}
@After
public void stop() throws Exception {
scheduler.destroy();
}
@Test
public void testSingleByteArray() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
public void singleByteArray() {
consumer.onMessage(new GenericMessage<byte[]>(new byte[] {1,2,3}));
byte[] result = stream.toByteArray();
assertEquals(3, result.length);
@@ -60,9 +85,7 @@ public class ByteStreamWritingMessageConsumerTests {
}
@Test
public void testSingleString() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
public void singleString() {
consumer.onMessage(new StringMessage("foo"));
byte[] result = stream.toByteArray();
assertEquals(3, result.length);
@@ -70,15 +93,14 @@ public class ByteStreamWritingMessageConsumerTests {
}
@Test
public void testMaxMessagesPerTaskSameAsMessageCount() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(3);
poller.setConsumer(consumer);
public void maxMessagesPerTaskSameAsMessageCount() {
endpoint.setMaxMessagesPerPoll(3);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(9, result.length);
assertEquals(1, result[0]);
@@ -86,31 +108,29 @@ public class ByteStreamWritingMessageConsumerTests {
}
@Test
public void testMaxMessagesPerTaskLessThanMessageCount() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(2);
poller.setConsumer(consumer);
public void maxMessagesPerTaskLessThanMessageCount() {
endpoint.setMaxMessagesPerPoll(2);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(6, result.length);
assertEquals(1, result[0]);
}
@Test
public void testMaxMessagesPerTaskExceedsMessageCount() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(5);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
public void maxMessagesPerTaskExceedsMessageCount() {
endpoint.setMaxMessagesPerPoll(5);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result = stream.toByteArray();
assertEquals(9, result.length);
assertEquals(1, result[0]);
@@ -118,19 +138,21 @@ public class ByteStreamWritingMessageConsumerTests {
@Test
public void testMaxMessagesLessThanMessageCountWithMultipleDispatches() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(2);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(2);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
assertEquals(1, result1[0]);
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(9, result2.length);
assertEquals(1, result2[0]);
@@ -139,19 +161,21 @@ public class ByteStreamWritingMessageConsumerTests {
@Test
public void testMaxMessagesExceedsMessageCountWithMultipleDispatches() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(5);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(5);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(9, result1.length);
assertEquals(1, result1[0]);
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(9, result2.length);
assertEquals(1, result2[0]);
@@ -159,19 +183,21 @@ public class ByteStreamWritingMessageConsumerTests {
@Test
public void testStreamResetBetweenDispatches() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(2);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(2);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
stream.reset();
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(3, result2.length);
assertEquals(7, result2[0]);
@@ -179,20 +205,22 @@ public class ByteStreamWritingMessageConsumerTests {
@Test
public void testStreamWriteBetweenDispatches() throws IOException {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
ByteStreamWritingMessageConsumer consumer = new ByteStreamWritingMessageConsumer(stream);
poller.setMaxMessagesPerPoll(2);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(2);
endpoint.setReceiveTimeout(0);
channel.send(new GenericMessage<byte[]>(new byte[] {1,2,3}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {4,5,6}), 0);
channel.send(new GenericMessage<byte[]>(new byte[] {7,8,9}), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result1 = stream.toByteArray();
assertEquals(6, result1.length);
stream.write(new byte[] {123});
stream.flush();
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
byte[] result2 = stream.toByteArray();
assertEquals(10, result2.length);
assertEquals(1, result2[0]);
@@ -200,4 +228,38 @@ public class ByteStreamWritingMessageConsumerTests {
assertEquals(7, result2[7]);
}
private static class TestTrigger implements Trigger {
private final AtomicBoolean hasRun = new AtomicBoolean();
private volatile CountDownLatch latch = new CountDownLatch(1);
public Date getNextRunTime(Date lastScheduledRunTime, Date lastCompleteTime) {
if (!hasRun.getAndSet(true)) {
return new Date();
}
this.latch.countDown();
return null;
}
public void reset() {
this.latch = new CountDownLatch(1);
this.hasRun.set(false);
}
public void await() {
try {
this.latch.await(1000, TimeUnit.MILLISECONDS);
if (latch.getCount() != 0) {
throw new RuntimeException("test timeout");
}
}
catch (InterruptedException e) {
throw new RuntimeException("test latch.await() interrupted");
}
}
}
}

151
org.springframework.integration.stream/src/test/java/org/springframework/integration/stream/CharacterStreamWritingMessageConsumerTests.java
View File

@@ -19,138 +19,163 @@ package org.springframework.integration.stream;
import static org.junit.Assert.assertEquals;
import java.io.StringWriter;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.endpoint.ChannelPoller;
import org.springframework.integration.endpoint.PollingConsumerEndpoint;
import org.springframework.integration.message.GenericMessage;
import org.springframework.integration.message.StringMessage;
import org.springframework.integration.scheduling.IntervalTrigger;
import org.springframework.integration.scheduling.SimpleTaskScheduler;
import org.springframework.integration.scheduling.Trigger;
/**
* @author Mark Fisher
*/
public class CharacterStreamWritingMessageConsumerTests {
private StringWriter writer;
private CharacterStreamWritingMessageConsumer consumer;
private QueueChannel channel;
private ChannelPoller poller;
private PollingConsumerEndpoint endpoint;
private TestTrigger trigger = new TestTrigger();
private SimpleTaskScheduler scheduler;
@Before
public void initialize() {
writer = new StringWriter();
consumer = new CharacterStreamWritingMessageConsumer(writer);
this.channel = new QueueChannel(10);
this.poller = new ChannelPoller(channel, new IntervalTrigger(0));
trigger.reset();
this.endpoint = new PollingConsumerEndpoint(consumer, channel);
scheduler = new SimpleTaskScheduler(new SimpleAsyncTaskExecutor());
this.endpoint.setTaskScheduler(scheduler);
scheduler.start();
trigger.reset();
endpoint.setTrigger(trigger);
}
@After
public void stop() throws Exception {
scheduler.destroy();
}
@Test
public void singleString() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
consumer.onMessage(new StringMessage("foo"));
assertEquals("foo", writer.toString());
}
@Test
public void twoStringsAndNoNewLinesByDefault() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
poller.setConsumer(consumer);
poller.setMaxMessagesPerPoll(1);
endpoint.setMaxMessagesPerPoll(1);
channel.send(new StringMessage("foo"), 0);
channel.send(new StringMessage("bar"), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo", writer.toString());
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
}
@Test
public void twoStringsWithNewLines() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
consumer.setShouldAppendNewLine(true);
poller.setConsumer(consumer);
poller.setMaxMessagesPerPoll(1);
endpoint.setMaxMessagesPerPoll(1);
channel.send(new StringMessage("foo"), 0);
channel.send(new StringMessage("bar"), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine, writer.toString());
poller.run();
trigger.reset();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
}
@Test
public void maxMessagesPerTaskSameAsMessageCount() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
poller.setMaxMessagesPerPoll(2);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(2);
channel.send(new StringMessage("foo"), 0);
channel.send(new StringMessage("bar"), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
}
@Test
public void maxMessagesPerTaskExceedsMessageCountWithAppendedNewLines() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
poller.setMaxMessagesPerPoll(10);
poller.setReceiveTimeout(0);
poller.setConsumer(consumer);
endpoint.setMaxMessagesPerPoll(10);
endpoint.setReceiveTimeout(0);
consumer.setShouldAppendNewLine(true);
channel.send(new StringMessage("foo"), 0);
channel.send(new StringMessage("bar"), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
}
@Test
public void singleNonStringObject() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
poller.setConsumer(consumer);
poller.setMaxMessagesPerPoll(1);
endpoint.setMaxMessagesPerPoll(1);
TestObject testObject = new TestObject("foo");
channel.send(new GenericMessage<TestObject>(testObject));
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foo", writer.toString());
}
@Test
public void twoNonStringObjectWithOutNewLines() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
poller.setReceiveTimeout(0);
poller.setMaxMessagesPerPoll(2);
poller.setConsumer(consumer);
endpoint.setReceiveTimeout(0);
endpoint.setMaxMessagesPerPoll(2);
TestObject testObject1 = new TestObject("foo");
TestObject testObject2 = new TestObject("bar");
channel.send(new GenericMessage<TestObject>(testObject1), 0);
channel.send(new GenericMessage<TestObject>(testObject2), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
assertEquals("foobar", writer.toString());
}
@Test
public void twoNonStringObjectWithNewLines() {
StringWriter writer = new StringWriter();
CharacterStreamWritingMessageConsumer consumer = new CharacterStreamWritingMessageConsumer(writer);
consumer.setShouldAppendNewLine(true);
poller.setReceiveTimeout(0);
poller.setMaxMessagesPerPoll(2);
poller.setConsumer(consumer);
endpoint.setReceiveTimeout(0);
endpoint.setMaxMessagesPerPoll(2);
TestObject testObject1 = new TestObject("foo");
TestObject testObject2 = new TestObject("bar");
channel.send(new GenericMessage<TestObject>(testObject1), 0);
channel.send(new GenericMessage<TestObject>(testObject2), 0);
poller.run();
endpoint.start();
trigger.await();
endpoint.stop();
String newLine = System.getProperty("line.separator");
assertEquals("foo" + newLine + "bar" + newLine, writer.toString());
}
@@ -169,4 +194,38 @@ public class CharacterStreamWritingMessageConsumerTests {
}
}
private static class TestTrigger implements Trigger {
private final AtomicBoolean hasRun = new AtomicBoolean();
private volatile CountDownLatch latch = new CountDownLatch(1);
public Date getNextRunTime(Date lastScheduledRunTime, Date lastCompleteTime) {
if (!hasRun.getAndSet(true)) {
return new Date();
}
this.latch.countDown();
return null;
}
public void reset() {
this.latch = new CountDownLatch(1);
this.hasRun.set(false);
}
public void await() {
try {
this.latch.await(1000, TimeUnit.MILLISECONDS);
if (latch.getCount() != 0) {
throw new RuntimeException("test timeout");
}
}
catch (InterruptedException e) {
throw new RuntimeException("test latch.await() interrupted");
}
}
}
}