ExternalCallComponentTest.java

/*
 * Copyright (C) 2015
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.cleverbus.component.externalcall;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeThat;
import static org.junit.Assume.assumeTrue;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import javax.annotation.Nullable;

import org.cleverbus.api.asynch.AsynchConstants;
import org.cleverbus.api.entity.ExternalCall;
import org.cleverbus.api.entity.ExternalCallStateEnum;
import org.cleverbus.api.entity.Message;
import org.cleverbus.api.exception.IntegrationException;
import org.cleverbus.api.exception.InternalErrorEnum;
import org.cleverbus.api.exception.LockFailureException;
import org.cleverbus.api.extcall.ExtCallComponentParams;
import org.cleverbus.common.log.Log;
import org.cleverbus.component.AbstractComponentsDbTest;
import org.cleverbus.core.common.asynch.AsynchMessageRoute;
import org.cleverbus.core.common.dao.ExternalCallDao;
import org.cleverbus.test.ActiveRoutes;
import org.cleverbus.test.ExternalSystemTestEnum;
import org.cleverbus.test.ServiceTestEnum;

import org.apache.camel.EndpointInject;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.Produce;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.component.mock.MockEndpoint;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

/**
 * Test suite for {@link ExternalCallComponent}.
 */
@ActiveRoutes(classes = {AsynchMessageRoute.class})
public class ExternalCallComponentTest extends AbstractComponentsDbTest {

    private static final String REQUEST_XML =
            "  <cus:setCustomerRequest xmlns=\"http://cleverbus.org/ws/Customer-v1\""
                    + "         xmlns:cus=\"http://cleverbus.org/ws/CustomerService-v1\">"
                    + "         <cus:customer>"
                    + "            <externalCustomerID>12</externalCustomerID>"
                    + "            <customerNo>23</customerNo>"
                    + "            <customerTypeID>2</customerTypeID>"
                    + "            <lastName>Juza</lastName>"
                    + "            <firstName>Petr</firstName>"
                    + "         </cus:customer>"
                    + "  </cus:setCustomerRequest>";

    @Autowired
    private ExternalCallDao externalCallDao;

    @Produce
    private ProducerTemplate producer;

    @EndpointInject(uri = "mock:test")
    private MockEndpoint mockEndpoint;

    private Long extCallId;

    @Value("${asynch.externalCall.skipUriPattern}")
    private String skipUriPattern;

    @Before
    public void resetExtCallId() {
        extCallId = null;
    }

    @Test
    public void testExternalCallOK() throws Exception {
        final Message msg = messages(1)[0];

        // mock response and in-process asserts
        mockEndpoint.whenAnyExchangeReceived(
                recordCallIdAndAnswer("external call reply body", "mock:test", "ok123456"));

        // send message
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg, "mock:test", "ok123456", "external call original body");
        mockEndpoint.assertIsSatisfied();

        // verify result
        assertEquals("external call reply body", reply);

        // check the call is now in DB as OK and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg);
    }

    @Test
    public void testExternalCallObjectEntityIdOK() throws Exception {
        final Message msg = messages(1)[0];

        // mock response and in-process asserts
        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndAnswer("external call reply body", "mock:test",
                        "CRM_" + msg.getCorrelationId() + "_[CustomEntityId]:123654"));

        // send message
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg, ExternalCallKeyType.MESSAGE, "mock:test",
                new CustomEntityId("123654"), "external call original body");
        mockEndpoint.assertIsSatisfied();

        // verify result
        assertEquals("external call reply body", reply);

        // check the call is now in DB as OK and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg);
    }

    @Test
    public void testExternalCallFailedIOException() throws Exception {
        Message msg = messages(1)[0];

        // simulate failure
        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndThrow(
                new IOException("test exception to simulate failure"), "mock:test", "fail123456"));

        // send message
        mockEndpoint.expectedMessageCount(1);
        try {
            requestViaExternalCall(msg, "mock:test", "fail123456", "external call original body");
            fail("Should've gotten an exception by now");
        } catch (Exception exc) {
            // verify failure
            assertThat(exc, is(instanceOf(IOException.class)));
        }
        mockEndpoint.assertIsSatisfied();

        // check the call is now in DB as FAILED and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg);
    }

    @Test
    public void testExternalCallFailedIntegrationException() throws Exception {
        Message msg = messages(1)[0];

        // simulate failure
        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndThrow(
                new IntegrationException(InternalErrorEnum.E100, "test exception to simulate failure"), "mock:test", "fail123456"));

        // send message
        mockEndpoint.expectedMessageCount(1);
        try {
            requestViaExternalCall(msg, "mock:test", "fail123456", "external call original body");
            fail("Should've gotten an exception by now");
        } catch (Exception exc) {
            // verify failure
            assertThat(exc, is(instanceOf(IntegrationException.class)));
        }
        mockEndpoint.assertIsSatisfied();

        // check the call is now in DB as FAILED and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg);
    }

    @Test
    public void testExternalCallDuplicate() throws Exception {
        Message msg = messages(1)[0];

        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndAnswer("external call reply body", "mock:test", "dupe123456"));

        // send first message
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg, "mock:test", "dupe123456", "external call original body");
        mockEndpoint.assertIsSatisfied();

        // verify result
        assertEquals("external call reply body", reply); // 1st reply is as expected

        // check the call is now in DB as OK and with the correct timestamp
        ExternalCallStateEnum state = ExternalCallStateEnum.OK;
        Long callId = extCallId;
        assertExtCallStateInDB(callId, state, msg);

        // send a duplicate message
        reply = requestViaExternalCall(msg, "mock:test", "dupe123456", "external call original body");
        mockEndpoint.assertIsSatisfied();

        assertEquals("external call original body", reply); // 2nd returned original body unchanged -- no call, no reply

        // check the call is in DB completely unchanged
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg);
    }

    @Test
    public void testExternalCallDuplicateFail() throws Exception {
        Message msg = messages(1)[0];

        mockEndpoint.whenExchangeReceived(1, recordCallIdAndThrow(
                new IOException("Simulated Failure for Testing Duplicate of Failure"), "mock:test", "dupeFail123456"));


        mockEndpoint.whenExchangeReceived(2, recordCallIdAndAnswer("external call reply body", "mock:test", "dupeFail123456"));

        // send first message
        mockEndpoint.expectedMessageCount(1);
        try {
            requestViaExternalCall(msg, "mock:test", "dupeFail123456", "external call original body");
            // verify result
            fail("Should've failed due to exception by now");
        } catch (Exception exc) {
            // verify failure
            assertThat(exc, is(instanceOf(IOException.class)));
        }
        mockEndpoint.assertIsSatisfied();

        // check the call is now in DB as OK and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg);

        // send a duplicate message
        mockEndpoint.expectedMessageCount(2);
        String reply = requestViaExternalCall(msg, "mock:test", "dupeFail123456", "external call original body");
        mockEndpoint.assertIsSatisfied();

        assertEquals("external call reply body", reply); // 2nd returned reply, since it was called again after 1st fail

        // check the call is in DB now as OK
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg);
    }

    @Test
    public void testExternalCallNewer() throws Exception {
        Message[] msg = messages(2);
        assumeTrue("For this test the 2nd message must be older",
                msg[0].getMsgTimestamp().compareTo(msg[1].getMsgTimestamp()) < 0);

        mockEndpoint.whenAnyExchangeReceived(
                recordCallIdAndAnswer("external call reply body", "mock:test", "twiceKey"));

        // send 1st message
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg[0], "mock:test", "twiceKey", "external call original body");
        mockEndpoint.assertIsSatisfied();

        // verify result
        assertEquals("external call reply body", reply); // 1st reply is as expected

        // check the call is now in DB as OK and with the correct timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg[0]);

        // send 2nd message
        mockEndpoint.expectedMessageCount(2);
        reply = requestViaExternalCall(msg[1], "mock:test", "twiceKey", "external call original body 2");
        mockEndpoint.assertIsSatisfied();

        // verify the call worked, since the 2nd message is newer
        assertEquals("external call reply body", reply); // 2nd reply is as expected too

        // check the call is in DB with the new timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg[1]);
    }

    @Test
    public void testExternalCallOlder() throws Exception {
        Message[] msg = messages(2);
        assumeTrue("For this test the 2nd message must be older",
                msg[0].getMsgTimestamp().compareTo(msg[1].getMsgTimestamp()) <= 0);

        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndAnswer("external call reply body", "mock:test", "older123456"));

        // send 2nd message - reverse order
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg[1], "mock:test", "older123456", "external call original body");
        mockEndpoint.assertIsSatisfied();

        // verify result
        assertEquals("external call reply body", reply); // 1st reply is as expected

        // check the call is now in DB as OK and with the correct msg1 NEWER timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg[1]);

        // send 1st message - reverse order
        reply = requestViaExternalCall(msg[0], "mock:test", "older123456", "external call original body 2");
        mockEndpoint.assertIsSatisfied();


        // verify the 2nd call was skipped, since the 2nd message is older
        assertEquals("external call original body 2", reply);

        // check the call is now in DB as OK, still with msg1 NEWER timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg[1]);
    }

    @Test
    public void testExternalCallOlderFail() throws Exception {
        Message[] msg = messages(2);
        assumeTrue("For this test the 2nd message must be newer",
                msg[0].getMsgTimestamp().compareTo(msg[1].getMsgTimestamp()) <= 0);

        mockEndpoint.whenExchangeReceived(1, recordCallIdAndThrow(new IOException("Simulated External Call Failure"), "mock:test", "olderFail123456"));
        mockEndpoint.whenExchangeReceived(2, recordCallIdAndAnswer("external call reply body", "mock:test", "olderFail123456"));

        // send 2nd message - reverse order
        mockEndpoint.expectedMessageCount(1);
        try {
            requestViaExternalCall(msg[1], "mock:test", "olderFail123456", "external call original body");
            fail("Should've failed due to an exception by now");
        } catch (Exception exc) {
            // verify failure
            assertThat(exc, is(instanceOf(IOException.class)));
        }
        mockEndpoint.assertIsSatisfied();

        // check the call is now in DB as FAILED and with the correct msg1 NEWER timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg[1]);

        // send 1st message - reverse order
        String reply = requestViaExternalCall(msg[0], "mock:test", "olderFail123456", "external call original body 2");
        mockEndpoint.assertIsSatisfied();

        // verify the 2nd call was NOT made, since the 1st failed call is newer
        assertEquals("external call original body 2", reply);

        // check the call remains unchanged
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg[1]);
    }

    @Test
    public void testExternalCallOlderFailBetween() throws Exception {
        Message[] msg = messages(3);
        assumeTrue("For this test the 2nd message must be newer than 1st",
                msg[0].getMsgTimestamp().compareTo(msg[1].getMsgTimestamp()) <= 0);
        assumeTrue("For this test the 3nd message must be newest - newer than 1st and 2nd",
                msg[1].getMsgTimestamp().compareTo(msg[2].getMsgTimestamp()) <= 0);

        mockEndpoint.whenExchangeReceived(1, recordCallIdAndThrow(new IOException("Simulated External Call Failure"), "mock:test", "olderFailBetween123456"));
        mockEndpoint.whenExchangeReceived(2, recordCallIdAndAnswer("external call reply body", "mock:test", "olderFailBetween123456"));

        // send 2nd message to fail, but trigger external call update
        mockEndpoint.expectedMessageCount(1);
        try {
            requestViaExternalCall(msg[1], "mock:test", "olderFailBetween123456", "external call original body");
            fail("Should've failed due to an exception by now");
        } catch (Exception exc) {
            // verify failure
            assertThat(exc, is(instanceOf(IOException.class)));
        }
        mockEndpoint.assertIsSatisfied();
        // check the call is now in DB as FAILED and with the correct msg1 NEWER timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg[1]);

        // send 1st (oldest) message - should be ignored
        mockEndpoint.expectedMessageCount(1);
        String reply = requestViaExternalCall(msg[0], "mock:test", "olderFailBetween123456", "external call original body 2");
        mockEndpoint.assertIsSatisfied();

        // verify the 2nd call was NOT made, since the 1st failed call is newer
        assertEquals("external call original body 2", reply);

        // check the call remains unchanged
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.FAILED, msg[1]);

        // send 3rd (latest) message - should be allowed
        mockEndpoint.expectedMessageCount(2);
        reply = requestViaExternalCall(msg[2], "mock:test", "olderFailBetween123456", "external call original body 3");
        mockEndpoint.assertIsSatisfied();

        // verify the 3rd call was made, since it's the newest call
        assertEquals("external call reply body", reply);

        // check the call remains unchanged
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, msg[2]);
    }

    @Test
    public void testExternalCallSkipUriPattern() throws Exception {
        // for this test the following must be set in application0.cfg:
        // asynch.externalCall.skipUriPattern = mock:(//)?ignoreTestEndpointUri.*
        assumeThat(skipUriPattern, equalTo("mock:(//)?ignoreTestEndpointUri.*"));

        final Message msg = messages(1)[0];

        MockEndpoint mockIgnore = getCamelContext().getEndpoint("mock://ignoreTestEndpointUri_something", MockEndpoint.class);
        mockIgnore.expectedMessageCount(0);

        // send message
        String reply = requestViaExternalCall(msg, "mock:ignoreTestEndpointUri_something", "skip123456", "external call original body");

        mockIgnore.assertIsSatisfied();

        // verify result
        assertEquals("external call original body", reply);
    }

    @Test(timeout = 60000)
    public void testExternalCallLockFailure() throws Exception {
        final int messageCount = 21; // how many messages total should be sent
        final int batchSize = 3; // how many messages should be sent together with verifications after each batch
        final int responseDelay = 10; // delay before mock responds, in millis
        boolean lockFailureEncountered = false; // test is pointless if it was never encountered

        Message[] messages = messages(messageCount);

        // set up mock to reply and to verify that the external call is reused
        mockEndpoint.whenAnyExchangeReceived(recordCallIdAndAnswer("external call reply body", responseDelay, "mock:test", "concurrentKey"));

        for (int batchStart = 0; batchStart < messages.length; batchStart += batchSize) {
            Message[] batch = Arrays.copyOfRange(messages, batchStart, Math.min(messages.length, batchStart + batchSize));
            lockFailureEncountered |= sendAndVerifyBatch(batch);
        }

        assumeTrue("This test is pointless if lock failure is never encountered", lockFailureEncountered);
    }

    private boolean sendAndVerifyBatch(Message[] messages) throws Exception {
        boolean lockFailureEncountered = false;
        HashMap<Message, Future<String>> replies = new HashMap<Message, Future<String>>();
        // send messages that have no reply, resend messages that have LockFailureException instead of a reply
        // verify results and re-send failures - test has timeout set because this is potentially endless
        Queue<Message> unverifiedMessages = new LinkedList<Message>(Arrays.asList(messages));
        while (!unverifiedMessages.isEmpty()) {
            Message message = unverifiedMessages.poll();
            boolean replyAvailable = replies.containsKey(message);
            if (replyAvailable) {
                Future<String> reply = replies.get(message);
                try {
                    reply.get(); // this will throw an exception if it occurred during processing
                } catch (Exception exc) {
                    if (ExceptionUtils.indexOfType(exc, LockFailureException.class) != -1) {
                        // expected cause - this test verifies that this scenario happens and is handled properly
                        lockFailureEncountered = true;
                        replyAvailable = false; // mark reply unavailable to resend the original message
                    } else {
                        // fail by rethrowing
                        Log.error("Unexpected failure for message {} --", message, exc);
                        throw exc;
                    }
                }
            }
            if (!replyAvailable) {
                unverifiedMessages.add(message); // mark message as still unverified
                replies.put(message,
                        requestViaExternalCallAsync(message, "mock:test", "concurrentKey", "external call original body"));
            }
        }
        // check the call is now in DB as OK and with the correct LAST msg timestamp
        assertExtCallStateInDB(extCallId, ExternalCallStateEnum.OK, messages[messages.length - 1]);
        return lockFailureEncountered;
    }

    private Future<String> requestViaExternalCallAsync(final Message msg, final String targetURI, final Object key, final String body) throws Exception {
        return getStringBodyFuture(producer.asyncSend("extcall:custom:" + targetURI,
                prepareExternalCallProcessor(msg, key, body)));

    }

    private String requestViaExternalCall(final Message msg, final String targetURI, final Object key, final String body) throws Exception {
        return requestViaExternalCall(msg, ExternalCallKeyType.CUSTOM, targetURI, key, body);
    }

    private String requestViaExternalCall(
                    final Message msg,
                    @Nullable final ExternalCallKeyType externalCallKeyType,
                    final String targetURI,
                    final Object key,
                    final String body) throws Exception {
        ExternalCallKeyType keyType = (externalCallKeyType == null) ? ExternalCallKeyType.CUSTOM : externalCallKeyType;
        Exchange reply = producer.request("extcall:" + keyType.toString() + ":" + targetURI,
                prepareExternalCallProcessor(msg, key, body));
        Exception exc = reply.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
        if (exc != null) {
            throw exc;
        }
        exc = reply.getException();
        if (exc != null) {
            throw exc;
        }
        return reply.hasOut() ? reply.getOut().getBody(String.class) : reply.getIn().getBody(String.class);
    }

    private Processor prepareExternalCallProcessor(final Message msg, final Object key, final String body) {
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getIn().setHeaders(headers(msg));
                exchange.getIn().setBody(body);
                exchange.setProperty(ExtCallComponentParams.EXTERNAL_CALL_KEY, key);
            }
        };
    }

    /**
     * Returns a processor that answers with the specified answer body.
     * The received exchange is verified to have {@link Message} in {@link AsynchConstants#MSG_HEADER}.
     * <p/>
     * It also records the external call ID into the instance field {@link #extCallId}
     * or verifies the new one matches the old one, if one is already recorded.
     *
     * @param answerBody    the body to set for the exchange IN message
     * @param operationName
     * @param entityId
     * @return processor, e.g. for use with mocks
     */
    private Processor recordCallIdAndAnswer(final Object answerBody, String operationName, String entityId) {
        return recordCallIdAndAnswer(answerBody, 0, operationName, entityId);
    }

    /**
     * Same as {@link #recordCallIdAndAnswer(Object, String, String)}, but throws an exception instead.
     *
     * @param answerException the exception to throw
     * @param operationName
     * @param entityId
     * @return processor, e.g. for use with mocks
     */
    private Processor recordCallIdAndThrow(final Exception answerException, final String operationName, final String entityId) {
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                verifyAndRecordCallId(exchange, operationName, entityId);
                throw answerException;
            }
        };
    }

    /**
     * Same as {@link #recordCallIdAndAnswer(Object, String, String)}, but waits for the specified delay before answering.
     *
     * @param answerBody    the body to set for the exchange IN message
     * @param responseDelay delay in milliseconds to wait before answering
     * @param operationName
     * @param entityId
     * @return processor, e.g. for use with mocks
     */
    private Processor recordCallIdAndAnswer(final Object answerBody, final int responseDelay, final String operationName, final String entityId) {
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                verifyAndRecordCallId(exchange, operationName, entityId);
                //simulate delay, then respond
                Thread.sleep(responseDelay);
                exchange.getIn().setBody(answerBody);
            }
        };
    }

    private void verifyAndRecordCallId(Exchange exchange, String operationName, String entityId) {
        Message msg = exchange.getIn().getHeader(AsynchConstants.MSG_HEADER, Message.class);
        ExternalCall extCall = externalCallDao.getExternalCall(operationName, entityId);
        Log.info("Processing ExternalCall={} for Message={}", extCall, msg);

        assertNotNull(extCall);
        assertEquals(extCall.getState(), ExternalCallStateEnum.PROCESSING);
        // check it's also in the DB in the correct state
        assertExtCallStateInDB(extCall.getId(), ExternalCallStateEnum.PROCESSING, msg);

        Long newExtCallId = extCall.getId();
        if (extCallId == null) {
            extCallId = newExtCallId;
        } else {
            assertEquals(extCallId, newExtCallId);
        }
    }

    /** Verifies there's an ExternalCall instance in DB with the specified ID, state and msgId + msgTimestamp. */
    private void assertExtCallStateInDB(Long callId, ExternalCallStateEnum state, Message message) {
        ExternalCall extCall = em.find(ExternalCall.class, callId);
        assertNotNull(String.format("ExternalCall with ID [%s] doesn't exist in the DB", callId),
                extCall);
        assertEquals(String.format("ExternalCall [%s]%ndoesn't have the expected state [%s]", extCall, state),
                state, extCall.getState());
        assertEquals(String.format("ExternalCall [%s]%ndoesn't reference the expected message [%s]", extCall, message),
                message.getMsgId(), extCall.getMsgId());
        assertEquals(
                String.format(
                        "ExternalCall msgTimestamp [%s] doesn't match expected msgTimestamp [%s] of message [%s]",
                        extCall.getMsgTimestamp(), message.getMsgTimestamp(), message),
                message.getMsgTimestamp().getTime(), extCall.getMsgTimestamp().getTime());
    }

    private Message[] messages(final int messageCount) throws Exception {
        return createAndSaveMessages(messageCount, ExternalSystemTestEnum.CRM, ServiceTestEnum.CUSTOMER, "setCustomer",
                REQUEST_XML);
    }

    private Map<String, Object> headers(Message msg) {
        Map<String, Object> headers = new HashMap<String, Object>();
        headers.put(AsynchConstants.MSG_HEADER, msg);
        headers.put(AsynchConstants.ASYNCH_MSG_HEADER, true);
        return headers;
    }

    private Future<String> getStringBodyFuture(final Future<Exchange> reply) {
        return new Future<String>() {
            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                return reply.cancel(mayInterruptIfRunning);
            }

            @Override
            public boolean isCancelled() {
                return reply.isCancelled();
            }

            @Override
            public boolean isDone() {
                return reply.isDone();
            }

            @Override
            public String get() throws InterruptedException, ExecutionException {
                return getReplyString(reply.get());
            }

            @Override
            public String get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                return getReplyString(reply.get(timeout, unit));
            }

            private String getReplyString(Exchange exchange) throws InterruptedException, ExecutionException {
                throwExceptionOptionally(exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class));
                throwExceptionOptionally(exchange.getException());
                return exchange.getOut().getBody(String.class);
            }

            private void throwExceptionOptionally(Exception exc) throws InterruptedException, ExecutionException {
                if (exc != null) {
                    if (exc instanceof InterruptedException) {
                        throw (InterruptedException) exc;
                    } else if (exc instanceof ExecutionException) {
                        throw (ExecutionException) exc;
                    } else {
                        throw new ExecutionException(exc);
                    }
                }
            }
        };
    }

    private class CustomEntityId {

        private String entityId;

        public CustomEntityId(String entityId) {
            this.entityId = entityId;
        }

        @Override
        public String toString() {
            return "[CustomEntityId]:" + entityId;
        }
    }
}