Project setup

I'm using Gradle, but Maven is well supported

...

dependencies {
    //It needs to be one of the first dependencies to work
    compile 'ch.qos.logback:logback-classic:1.1.6'

    compile 'org.codehaus.groovy:groovy-all:2.3.11'

    // Camel dependencies
    def camelVersion = '2.16.2'
    compile "org.apache.camel:camel-core:$camelVersion"
    compile "org.apache.camel:camel-groovy:$camelVersion"

    testCompile 'junit:junit:4.11'
    testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
    testCompile 'cglib:cglib-nodep:2.2'
}

group 'com.jackfrosch.camel'
version '1.0-SNAPSHOT'

apply plugin: 'groovy'
apply plugin: 'java'
apply plugin: 'idea'

sourceCompatibility = 1.8 // Camel 2.14 onwards requires JDK 1.7 or better

repositories {
    jcenter()
    mavenCentral()
}


...

build.gradle

...

sourceSets {
    integrationTest {
        groovy {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/groovy')
        }
        resources.srcDir file('src/integration-test/resources')
    }
}

configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime

    all*.exclude group: "org.slf4j", module: "slf4j-simple"
    all*.exclude group: "log4j", module: "log4j"
}

idea {
    module {
        //add integration test source dirs to IDEA
        testSourceDirs += file('src/integration-test/groovy')
        scopes.TEST.plus += [ configurations.integrationTestCompile ]
        downloadJavadoc = false
        downloadSources = false
    }
}

...

build.gradle

...

dependencies {
    //It needs to be one of the first dependencies to work
    compile 'ch.qos.logback:logback-classic:1.1.6'

    compile 'org.codehaus.groovy:groovy-all:2.3.11'

    // Camel dependencies
    def camelVersion = '2.16.2'
    compile "org.apache.camel:camel-core:$camelVersion"
    compile "org.apache.camel:camel-groovy:$camelVersion"

    testCompile 'junit:junit:4.11'
    testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
    testCompile 'cglib:cglib-nodep:2.2'
}

build.gradle

Demo

Hello World

Creating & testing routes

Demo

Inventory Reporting Workflow

Input & Output

SKU,Qty,Price,Taxable
 101,30,20.00,Y
 102,40,10.00,N
 103,100,0.50,Y

Inventory Report - 04 / 03 / 2016

Summary
----------------------------------------------

Total SKUs in inventory: 3
Total Taxable Value in inventory: 650.00
Total Non-taxable Value in inventory: 400.00
----------------------------------------------

Inventory Details
----------------------------------------------
Item #        SKU   Qty   Price   Value   Tax?
------ ---------- ----- ------- -------   ----
     1        101    30   20.00  600.00      Y
     2        102    40   10.00  400.00      N
     3        103   100    0.50   50.00      Y
----------------------------------------------

--End Report--

Store123_Inventory_2016-04-01_01-35-45.csv

Store123_Inventory_2016-04-01_01-35-45_Report.txt

Our main app

package com.jackfrosch.camel.inventory;

import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class InventoryReportingApp {
    final static Logger logger = LoggerFactory.getLogger(InventoryReportingApp.class);

    public static void main(String[] args) throws Exception {

        CamelContext ctx = new DefaultCamelContext();

        // Use a timer component to generate message events
        ctx.addRoutes(new InventoryReporterRouteBuilder());

        ctx.start();
        Thread.sleep(20000);
        ctx.stop();
    }
}

The RouteBuilder

// package and import statements omitted

/**
 * These routes are a bit contrived, but illustrate some fundamental Camel
 * routing and processing ideas
 */
class InventoryReporterRouteBuilder extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        from("file:/tmp/camel-demo/inventory/in?delay=1s&move=../archive") // consumer
            .convertBodyTo(String.class)
            .process(new InventoryProcessor())
            .to("direct:valueInventory");

        from("direct:valueInventory")
            .process(new InventoryValuator())
            .to("direct:reportInventory");

        from("direct:reportInventory")
            .process(new InventoryReportGenerator())
            .to("file:///tmp/camel-demo/inventory/out");                  //  producer

    }
}

InventoryProcessor

// package and import statements omitted

public class InventoryProcessor implements Processor {
    @Override
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        String input = (String) in.getBody(); // in.getBody(String.class) & no cast

        List<StockItem> items = parseInput(input);
        in.setBody(items);
        in.setHeader("INVENTORY_COUNT", items.size());
    }

    private List<StockItem> parseInput(String input) {
        List<StockItem> items = new ArrayList<>();

        String[] lines = input.split("\n");
        for(int i = 1; i < lines.length; i++) {
            items.add(createStockItem(lines[i].split(",")));
        }

        return items;
    }

    private StockItem createStockItem(String[] fields) {
        return new StockItem(fields[0], Integer.valueOf(fields[1]), 
                             new BigDecimal(fields[2]), "Y".equals(fields[3]));
    }
}

StockItem

// package and import statements omitted

public class StockItem {
    private final String itemSku;
    private final int quantityOnHand;
    private final BigDecimal markedPrice;
    private final boolean taxable;
    private BigDecimal itemValuation;

    public StockItem(String itemSku, int quantityOnHand, BigDecimal markedPrice, boolean taxable) {
        this.itemSku = itemSku;
        this.quantityOnHand = quantityOnHand;
        this.markedPrice = markedPrice;
        this.taxable = taxable;
        this.itemValuation = new BigDecimal(quantityOnHand).multiply(markedPrice);
    }
    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        StockItem stockItem = (StockItem) o;
        return itemSku.equals(stockItem.itemSku);
    }
    public String getItemSku() { return itemSku; }
    public int getQuantityOnHand() { return quantityOnHand; }
    public BigDecimal getMarkedPrice() { return markedPrice; }
    @Override public int hashCode() { return itemSku.hashCode(); }
    public boolean isTaxable() { return taxable; }
    public boolean isNotTaxable() { return !taxable; }
    public BigDecimal getItemValuation() { return itemValuation; }
}

InventoryValuator

// package and import statements omitted

public class InventoryValuator implements Processor {
    @Override
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();

        @SuppressWarnings("unchecked")
        List<StockItem> items = (List<StockItem>) in.getBody();

        in.setHeader("INVENTORY_TAXABLE_VALUATION", 
                        calculateInventoryValuation(items, StockItem::isTaxable));

        in.setHeader("INVENTORY_NONTAXABLE_VALUATION", 
                        calculateInventoryValuation(items, StockItem::isNotTaxable));
    }

    // Note: The Predicate here is a Java 8 Predicate functional interface, not a Camel Predicate!
    private BigDecimal calculateInventoryValuation(List<StockItem> items, 
                                                   Predicate<StockItem> selector) {

        return items.stream()  // we could use a parallelStream() here
                    .filter(selector)
                    .map(StockItem::getItemValuation)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

InventoryReportGenerator

// package and import statements omitted

public class InventoryReportGenerator implements Processor {
    @Override
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        in.setHeader(Exchange.FILE_NAME, 
                        createReportFileName(in.getHeader(Exchange.FILE_NAME, String.class)));
        in.setBody(buildReport(in));
    }

    private String createReportFileName(String inputFileName) {
        return inputFileName.substring(0, inputFileName.indexOf('.')) + "_Report.txt";
    }

    ...

InventoryReportGenerator

    ...

    private String buildReport(Message in) {
        StringBuilder sb = new StringBuilder();
        sb.append("Inventory Report - ")
            .append(LocalDate.now().format(DateTimeFormatter.ofPattern("MM / dd / yyyy")))
            .append("\n\n")
            .append("Summary")
            .append("\n----------------------------------------------\n\n")
            .append("Total SKUs in inventory: ").append(in.getHeader("INVENTORY_COUNT"))
            .append("\n")
            .append("Total Taxable Value in inventory: ")
            .append(in.getHeader("INVENTORY_TAXABLE_VALUATION"))
            .append("\n")
            .append("Total Non-taxable Value in inventory: ")
            .append(in.getHeader("INVENTORY_NONTAXABLE_VALUATION"))
            .append("\n----------------------------------------------\n\n")
            .append("Inventory Details")
            .append("\n----------------------------------------------\n")
            .append(String.format("%6s %10s %5s %7s %7s %6s", 
                                    "Item #", "SKU", "Qty", "Price", "Value", "Tax?"))
            .append("\n")
            .append(String.format("%6s %10s %5s %7s %7s %6s", 
                                    "------", "----------", "-----", "-------", "-------", "----"))
            .append("\n");


            // ... more

InventoryReportGenerator

    ...

        // @formatter:off
        @SuppressWarnings("unchecked")
        List<StockItem> items = (List<StockItem>) in.getBody();
        int index = 1;
        for (StockItem item : items) {
            sb.append(String.format("%6d %10s %5d %7.2f %7.2f %6s", 
                                    index, item.getItemSku(), item.getQuantityOnHand(),
                                    item.getMarkedPrice(), item.getItemValuation(), 
                                    item.isTaxable() ? "Y" : "N"))
              .append("\n");

            index++;
        }
        sb.append("----------------------------------------------\n\n--End Report--");

        return sb.toString();
    }
}

Demo

Adding tests

• I'm going to start transitioning the app over to Groovy.
• ... Because Spock is a Groovy-based testing framework
• ... Because our code gets simpler, often much simpler
• ... Because we'll be able to leverage Camel's excellent Groovy DSL support
• ... Because the semicolon on my keyboard is broken from all the Java code so far

Preparing for testing

dependencies {
    //It needs to be one of the first dependencies to work
    compile 'ch.qos.logback:logback-classic:1.1.6'

    compile 'org.codehaus.groovy:groovy-all:2.3.11'

    // Camel dependencies
    def camelVersion = '2.16.2'
    compile "org.apache.camel:camel-core:$camelVersion"
    compile "org.apache.camel:camel-groovy:$camelVersion"
    testCompile "org.apache.camel:camel-test:$camelVersion"

    testCompile 'junit:junit:4.11'
    testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
    testCompile 'cglib:cglib-nodep:2.2'
}

Preparing for testing

public class InventoryReporterRouteBuilder extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        getContext().setTracing(true);          // Camel Tracer logs routing at INFO level

        from("file:/tmp/camel-demo/inventory/in?delay=1s&move=../archive")  // consumer
            .routeId("inventoryReporterEntry")
            .convertBodyTo(String.class)
            .process(new InventoryProcessor())
            .to("direct:valueInventory");

        from("direct:valueInventory")
            .routeId("valueInventory")          // routeId gives us a handle to the route
            .process(new InventoryValuator())
            .to("direct:reportInventory");

        from("direct:reportInventory")
            .routeId("reportInventory")
            .process(new InventoryReportGenerator())
            .to("file:///tmp/camel-demo/inventory/out");                    //  producer

    }
}

Route testing in general

// I'll use Groovy syntax here, but Java's is similar - just more verbose!
class MyTest extends CamelTestSupport {

    // Register our routes with the test CamelContext
    @Override
    protected RouteBuilder createRouteBuilder() {
        new InventoryReporterRouteBuilder()
    }

    @Test
    void "verify Route A will send correct Message to Route B"() {
        // Mock out routing to route B so we can evaluate what route A sends
        context.getRouteDefinition('routeA').adviceWith(context, 
                                                new AdviceWithRouteBuilder() {
            void configure() throws Exception {
                interceptSendToEndpoint('direct:routeB')
                        .skipSendToOriginalEndpoint()
                        .to('mock:routeB')
            }
        })

        // create a Notifier so tell us when the routing happened
        NotifyBuilder notifier = new NotifyBuilder(context).fromRoute('routeA')
                                                           .wereSentTo('mock:routeB')
                                                           .whenCompleted(1)
                                                           .create()

Route testing in general

    @Test
    void "verify Route A will send correct Message to Route B"() {
        //... we previously mocked next route endpoint and configure a notifier

        // now set up expectations for the mock
        MockEndpoint mockEp = getMockEndpoint('mock:routeB');
        mockEp.expectedHeaderReceived('headerName', headerValue);
        mockEp.expectedBodiesReceived(oneOrMoreBodies);
        mockEp.resultMinimumWaitTime = 500;

        // now send the inbound message to the route we're testing
        // template is a ProducerTemplate for sending messages, usually in tests
        template.sendBodyAndHeaders('direct:routeA', theBody,
                                    [headerName : headerValue])


        // Now do the assertions. Suppose we expect route A to send
        // In Java use JUnit assertMethods. With Groovy we can use power assert
        assert notifier.matchesMockWaitTime() // Groovy power assert
        assertMockEndpointsSatisfied()
    }

Testing our RouteBuilder

class InventoryRouteBuilderTest extends CamelTestSupport {
    private static final String TEST_INPUT_FILE_NAME = 'Store123_Inventory_2016-04-01_01-35-45.csv'
    private static final String TEST_OUTPUT_FILE_NAME = 'Store123_Inventory_2016-04-01_01-35-45_Report.txt'

    List<StockItem> items

    @Before
    public void setUp() {
        super.setUp()
        items = createStockItems()
    }

    @Test
    void "test inventoryReporterEntry route"() {
        mockToRoute('inventoryReporterEntry', 'direct:valueInventory', 'mock:valueInventory');
        NotifyBuilder notifier = createNotifier('inventoryReporterEntry', 'mock:valueInventory')

        MockEndpoint mockEp = getMockEndpoint('mock:valueInventory')
        mockEp.expectedHeaderReceived(Exchange.FILE_NAME, TEST_INPUT_FILE_NAME)
        mockEp.expectedHeaderReceived('INVENTORY_COUNT', items.size())
        mockEp.expectedBodiesReceived([items])  // This looks strange, but I'll explain
        mockEp.resultMinimumWaitTime = 500

        // This will actually write the file out to the inbound directory
        template.sendBodyAndHeader('file:/tmp/camel-demo/inventory/in?delay=1s&move=../archive', createInput(),
                                    Exchange.FILE_NAME, TEST_INPUT_FILE_NAME)

        assert notifier.matchesMockWaitTime()
        assertMockEndpointsSatisfied()

        List skus = mockEp.exchanges[0].in.body.collect { StockItem item -> item.itemSku }
        assert skus == ['101', '102', '103']
    }

    // more...

Testing

    // ... more

    @Test
    void "test valueInventory route"() {
        mockToRoute('valueInventory', 'direct:reportInventory', 'mock:reportInventory');
        NotifyBuilder notifier = createNotifier('valueInventory', 'mock:reportInventory')

        MockEndpoint mockEp = getMockEndpoint('mock:reportInventory')
        mockEp.expectedHeaderReceived(Exchange.FILE_NAME, TEST_INPUT_FILE_NAME)
        mockEp.expectedHeaderReceived('INVENTORY_COUNT', this.items.size())
        mockEp.expectedHeaderReceived('INVENTORY_TAXABLE_VALUATION', new BigDecimal("650.00"))
        mockEp.expectedHeaderReceived('INVENTORY_NONTAXABLE_VALUATION', new BigDecimal("400.00"))
        mockEp.expectedBodiesReceived([this.items])
        mockEp.resultMinimumWaitTime = 500

        // This will actually write the file out to the inbound directory
        template.sendBodyAndHeaders('direct:valueInventory', this.items,
                                    [(Exchange.FILE_NAME) : TEST_INPUT_FILE_NAME, 
                                     INVENTORY_COUNT : this.items.size()])

        assert notifier.matchesMockWaitTime()
        assertMockEndpointsSatisfied()

        List skus = mockEp.exchanges[0].in.body.collect { StockItem item -> item.itemSku }
        assert skus == ['101', '102', '103']
    }

    // more ...

Testing

    // ... more

    @Test
    void "test reportInventory route"() {
        mockToRoute('reportInventory', 'file:/tmp/camel-demo/inventory/out', 
                    'mock:reportDir')

        NotifyBuilder notifier = createNotifier('reportInventory', 'mock:reportDir')

        MockEndpoint mockEp = getMockEndpoint('mock:reportDir')
        mockEp.expectedHeaderReceived(Exchange.FILE_NAME, TEST_OUTPUT_FILE_NAME)
        mockEp.expectedBodiesReceived(createExpectedReport())
        mockEp.resultMinimumWaitTime = 500

        // This will actually write the file out to the inbound directory
        template.sendBodyAndHeaders('direct:reportInventory', this.items,
                [(Exchange.FILE_NAME) : TEST_INPUT_FILE_NAME,
                 'INVENTORY_COUNT' : this.items.size(),
                 'INVENTORY_TAXABLE_VALUATION' :new BigDecimal("650.00"),
                 'INVENTORY_NONTAXABLE_VALUATION' : new BigDecimal("400.00")])

        assert notifier.matchesMockWaitTime()
        assertMockEndpointsSatisfied()
    }

    // more ...

Testing

    // ... more

    private String createInput() {
        '''SKU,Qty,Price,Taxable
101,30,20.00,Y
102,40,10.00,N
103,100,0.50,Y'''
    }

    private List<StockItem> createStockItems() {
        [
                new StockItem('101', 30, new BigDecimal("20.00"), true),
                new StockItem('102', 40, new BigDecimal("10.00"), false),
                new StockItem('103', 100, new BigDecimal("0.50"), true)
        ]
    }

    // more ...

    

Testing

    // ... more

    private String createExpectedReport() {
"""Inventory Report - ${InventoryReportGenerator.createReportDate()}

Summary
----------------------------------------------

Total SKUs in inventory: 3
Total Taxable Value in inventory: 650.00
Total Non-taxable Value in inventory: 400.00
----------------------------------------------

Inventory Details
----------------------------------------------
Item #        SKU   Qty   Price   Value   Tax?
------ ---------- ----- ------- -------   ----
     1        101    30   20.00  600.00      Y
     2        102    40   10.00  400.00      N
     3        103   100    0.50   50.00      Y
----------------------------------------------

--End Report--"""
    }

    // more ...

Testing

    // ... more

    @Override
    protected RouteBuilder createRouteBuilder() {
        new InventoryReporterRouteBuilder()
    }

    private NotifyBuilder createNotifier(String fromRouteId, String toRouteUri) {
        new NotifyBuilder(context).fromRoute(fromRouteId)
                .wereSentTo(toRouteUri)
                .whenCompleted(1)
                .create()
    }

    private RouteDefinition mockToRoute(final String fromRouteId, 
                                        final String oldToRouteUri, 
                                        final String mockToRouteUri) {
        context.getRouteDefinition(fromRouteId).adviceWith(context, 
                                                    new AdviceWithRouteBuilder() {
            void configure() throws Exception {
                interceptSendToEndpoint(oldToRouteUri)
                        .skipSendToOriginalEndpoint()
                        .to(mockToRouteUri)
            }
        })
    }
}

Data Formats

CSV

class InventoryReporterRouteBuilder extends RouteBuilder {
    @Override
    void configure() throws Exception {
        getContext().setTracing(true);

        CsvDataFormat csv = new CsvDataFormat()
        csv.skipHeaderRecord = true

        from("file:/tmp/camel-demo/inventory/in?delay=1s&move=../archive") // polling consumer
                .routeId("inventoryReporterEntry")
                .unmarshal(csv)
                .process(new InventoryProcessor())
                .to("direct:valueInventory");

        from("direct:valueInventory")
                .routeId("valueInventory")
                .process(new InventoryValuator())
                .to("direct:reportInventory");

        from("direct:reportInventory")
                .routeId("reportInventory")
                .process(new InventoryReportGenerator())
                .to("file:///tmp/camel-demo/inventory/out");                   //  producer

    }
}

Data Formats

CSV

class InventoryProcessor implements Processor {
    @Override
    void process(Exchange exchange) throws Exception {
        Message inMsg = exchange.getIn()
        List<List<String>> records = (List<List<String>>) inMsg.body

        List<StockItem> items = parseInput(records)
        inMsg.setBody(items)
        inMsg.setHeader("INVENTORY_COUNT", items.size())
    }

    protected List<StockItem> parseInput(List<List<String>> records) {
        records.collect { List<String> fields -> createStockItem(fields) }
    }

    private StockItem createStockItem(List<String> fields) {
        new StockItem(fields[0], Integer.valueOf(fields[1]), 
                        new BigDecimal(fields[2]), "Y".equals(fields[3]))
    }
}