protected Splitter createSplitterInstance(Expression expression, Processor processor) { return new Splitter(expression, processor); }
/** * Static factory method to return a split index * * @param index * actual Index of an exchange in the corresponding collection of * sub exchanges * @param last * {@code true} if this index is the last in the corresponding * collection of sub exchanges * * @return A {@link SplitIndex} corresponding to the index information */ public static SplitIndex valueOf(int index, boolean last) { return new SplitIndex(index, last); }
@Test public void testSplitRuleResultsInNothing() throws Exception { Splitter splitterEmptyRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return null; }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterEmptyRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(0, received.size()); }
@Test public void testSplitRuleWithArrayResult() throws Exception { Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); Splitter splitterWithArrayResult = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast(getContent(exchange).split(",")); }}, dest); splitterWithArrayResult.aggregate(new TestAggregationStrategy()); splitterWithArrayResult.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("bla:blu", origExchange.getOut().getBody()); }
@Before public void setUp() { TestSplitRule splitRule = new TestSplitRule(); TestAggregationStrategy aggregationStrat = new TestAggregationStrategy(); dest = new TestProcessor(); splitter = new Splitter(splitRule, dest); splitter.aggregate(aggregationStrat); }
@Override protected void finalizeSubExchange(Exchange origExchange, Exchange subExchange, SplitIndex index) { super.finalizeSubExchange(origExchange, subExchange, index); if (splitOnlyHasSingleResult(index)) { return; } ManagedMessage origMessage = new PlatformMessage(origExchange); SplitHistory origHistory = origMessage.getSplitHistory(); SplitHistory subHistory = origHistory.split(index.getIndex(), index.isLast()); ManagedMessage subMessage = new PlatformMessage(subExchange); subMessage.setSplitHistory(subHistory); }
private Exchange processAllResults(Exchange origExchange, Iterable splitResult) throws Exception { Exchange aggregate = null; Iterator iterator = splitResult.iterator(); int counter = 0; while (iterator.hasNext()) { Object splitPart = iterator.next(); SplitIndex idx = SplitIndex.valueOf(counter, !iterator.hasNext()); Exchange subExchange = processResult(origExchange, idx, splitPart); aggregate = doAggregate(aggregate, subExchange); ++counter; } return aggregate; }
/** * Processes the given exchange * This method is the entry point for splitting the given exchange into * its parts via the split rule. Subclasses can change the created sub * exchanges by overriding {@link #finalizeSubExchange(Exchange, Exchange, SplitIndex)} * and the aggregate result by overriding {@link #finalizeAggregate(Exchange, Exchange)}. * * @param origExchange exchange that should be split by this processor */ @Override protected void processNext(Exchange origExchange) throws Exception { notNull(origExchange, "origExchange"); Iterable splitResult = evaluateSplitRule(origExchange); Exchange aggregate = processAllResults(origExchange, splitResult); finalizeAggregate(origExchange, aggregate); }
@Test public void testHashCode() { SplitIndex index1a = SplitIndex.valueOf(4, false); SplitIndex index1b = SplitIndex.valueOf(4, false); SplitIndex index2 = SplitIndex.valueOf(5, false); SplitIndex index3 = SplitIndex.valueOf(4, true); assertEquals(index1a.hashCode(), index1b.hashCode()); // Not necessary, but hash code shouldn't be too weak assertTrue(index1a.hashCode() != index2.hashCode()); assertTrue(index1a.hashCode() != index3.hashCode()); }
@Test public void testEquals() { SplitIndex index1a = SplitIndex.valueOf(4, false); SplitIndex index1b = SplitIndex.valueOf(4, false); SplitIndex index2 = SplitIndex.valueOf(5, false); SplitIndex index3 = SplitIndex.valueOf(4, true); assertTrue("Should be equal", index1a.equals(index1b)); assertFalse("Should not be equal", index1a.equals(index2)); assertFalse("Should not be equal", index1a.equals(index3)); assertFalse("Null is never equal", index1a.equals(null)); assertFalse("Unrelated class is never equal", index1a.equals(this)); assertTrue("Same instances should be equal", index1a.equals(index1a)); }
private Exchange processResult(final Exchange origExchange, final SplitIndex index, final Object splitPart) throws Exception { final Exchange subExchange = origExchange.copy(); Message message = subExchange.getIn(); message.setBody(splitPart); finalizeSubExchange(origExchange, subExchange, index); super.processNext(subExchange); return subExchange; }
@Override public <T> T evaluate(Exchange exchange, Class<T> type) { if (evaluateCalled) { throw new IllegalStateException("evaluate() can only be called once"); } evaluateCalled = true; String[] parts = getContent(exchange).split(","); return type.cast(new OneTimeUsageIterable<>(Arrays.asList(parts))); }
@Test public void testSplitRuleWithNonIterableResult() throws Exception { Splitter splitterSimpleRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast("smurf:" + exchange.getIn().getBody()); }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterSimpleRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(1, received.size()); assertEquals("smurf:bla,blu", getContent(received.get(0))); }
@Test(expected=IllegalArgumentException.class) public void testForNullSafeConstructor() { splitter = new Splitter(null, dest); }
@Test public void testResetToDefaults() throws Exception { splitter.aggregate(null); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitter.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("blu", origExchange.getOut().getBody()); }
@Test public void testProcess() throws Exception { Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitter.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("bla:blu", origExchange.getOut().getBody()); }
@Test public void testSplitRuleResultsInIterator() throws Exception { final List<String> results = Arrays.asList("bla", "blu"); Splitter splitterIteratorRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast(results.iterator()); }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterIteratorRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("blu", origExchange.getOut().getBody()); }