org.apache.camel.component.mock
Class MockEndpoint

java.lang.Object
  org.apache.camel.impl.DefaultEndpoint<Exchange>
      org.apache.camel.component.mock.MockEndpoint

All Implemented Interfaces:

CamelContextAware, Endpoint<Exchange>, BrowsableEndpoint<Exchange>

Direct Known Subclasses:

DataSetEndpoint

public class MockEndpoint
extends DefaultEndpoint<Exchange>
implements BrowsableEndpoint<Exchange>

A Mock endpoint which provides a literate, fluent API for testing routes using a JMock style API.

Version:

$Revision: 765501 $

Constructor Summary

MockEndpoint(String endpointUri)

MockEndpoint(String endpointUri, Component component)

Method Summary

void	addPropertyChangeListener(PropertyChangeListener listener)
AssertionClause	allMessages() Adds an assertion to all the received messages
protected void	assertEquals(String message, Object expectedValue, Object actualValue)
Exchange	assertExchangeReceived(int index) Asserts that the given index of message is received (starting at zero)
void	assertIsNotSatisfied() Validates that the assertions fail on this endpoint
void	assertIsSatisfied() Validates that all the available expectations on this endpoint are satisfied; or throw an exception
static void	assertIsSatisfied(CamelContext context) Asserts that all the expectations on any MockEndpoint instances registered in the given context are valid
void	assertIsSatisfied(long timeoutForEmptyEndpoints) Validates that all the available expectations on this endpoint are satisfied; or throw an exception
static void	assertIsSatisfied(long timeout, TimeUnit unit, MockEndpoint... endpoints)
static void	assertIsSatisfied(MockEndpoint... endpoints)
void	assertMessagesAscending(Expression<Exchange> expression) Asserts that the messages have ascending values of the given expression
void	assertMessagesDescending(Expression<Exchange> expression) Asserts that the messages have descending values of the given expression
protected void	assertMessagesSorted(Expression<Exchange> expression, boolean ascending)
void	assertNoDuplicates(Expression<Exchange> expression)
protected void	assertTrue(String message, boolean predicate)
static void	assertWait(long timeout, TimeUnit unit, MockEndpoint... endpoints)
void	await()
boolean	await(long timeout, TimeUnit unit)
Consumer<Exchange>	createConsumer(Processor processor) Creates a new Event Driven Consumer which consumes messages from the endpoint using the given processor
Producer<Exchange>	createProducer() Creates a new producer which is used send messages into the endpoint
void	expectedBodiesReceived(List bodies) Adds an expectation that the given body values are received by this endpoint in the specified order
void	expectedBodiesReceived(Object... bodies) Adds an expectation that the given body values are received by this endpoint
void	expectedBodiesReceivedInAnyOrder(List bodies) Adds an expectation that the given body values are received by this endpoint in any order
void	expectedBodiesReceivedInAnyOrder(Object... bodies) Adds an expectation that the given body values are received by this endpoint in any order
void	expectedHeaderReceived(String name, String value) Adds an expectation that the given header name & value are received by this endpoint
void	expectedMessageCount(int expectedCount) Specifies the expected number of message exchanges that should be received by this endpoint
void	expectedMinimumMessageCount(int expectedCount) Specifies the minimum number of expected message exchanges that should be received by this endpoint
void	expects(Runnable runnable) Adds the expectation which will be invoked when enough messages are received
void	expectsAscending(Expression<Exchange> expression) Adds an expectation that messages received should have ascending values of the given expression such as a user generated counter value
void	expectsDescending(Expression<Exchange> expression) Adds an expectation that messages received should have descending values of the given expression such as a user generated counter value
static void	expectsMessageCount(int count, MockEndpoint... endpoints)
void	expectsNoDuplicates(Expression<Exchange> expression) Adds an expectation that no duplicate messages should be received using the expression to determine the message ID
protected void	fail(Object message)
List<Exchange>	getExchanges() Return the exchanges available on this endpoint
int	getExpectedCount()
int	getExpectedMinimumCount()
List<Throwable>	getFailures()
int	getReceivedCounter()
List<Exchange>	getReceivedExchanges()
Processor	getReporter()
long	getResultWaitTime()
long	getSleepForEmptyTest()
boolean	isSingleton() Returns if the endpoint should be a CamelContext singleton.
AssertionClause	message(int messageIndex) Adds an assertion to the given message index
protected void	onExchange(Exchange exchange)
protected void	performAssertions(Exchange exchange)
void	removePropertyChangeListener(PropertyChangeListener listener)
void	reset()
static MockEndpoint	resolve(CamelContext context, String uri) A helper method to resolve the mock endpoint of the given URI on the given context
void	setExpectedMessageCount(int expectedCount) Specifies the expected number of message exchanges that should be received by this endpoint
void	setMinimumExpectedMessageCount(int expectedCount) Specifies the minimum number of expected message exchanges that should be received by this endpoint
void	setMinimumResultWaitTime(long resultMinimumWaitTime) Sets the minimum expected amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied
void	setReporter(Processor reporter) Allows a processor to added to the endpoint to report on progress of the test
void	setResultWaitTime(long resultWaitTime) Sets the maximum amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied
void	setSleepForEmptyTest(long sleepForEmptyTest) Allows a sleep to be specified to wait to check that this endpoint really is empty when expectedMessageCount(int) is called with zero
protected void	waitForCompleteLatch()
void	whenAnyExchangeReceived(Processor processor) Set the processor that will be invoked when the some message is received.
void	whenExchangeReceived(int index, Processor processor) Set the processor that will be invoked when the index message is received.

Methods inherited from class org.apache.camel.impl.DefaultEndpoint

configureProperties, convertTo, createEndpointUri, createExchange, createExchange, createExchange, createExecutorService, createPollingConsumer, equals, getCamelContext, getComponent, getContext, getEndpointUri, getExchangePattern, getExchangeType, getExecutorService, hashCode, isLenientProperties, setCamelContext, setContext, setEndpointUri, setEndpointUriIfNotSpecified, setExchangePattern, setExecutorService, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.camel.Endpoint

configureProperties, createExchange, createExchange, createExchange, createPollingConsumer, getCamelContext, getContext, getEndpointUri, isLenientProperties, setCamelContext, setContext

Constructor Detail

MockEndpoint

public MockEndpoint(String endpointUri,
                    Component component)

MockEndpoint

public MockEndpoint(String endpointUri)

Method Detail

resolve

public static MockEndpoint resolve(CamelContext context,
                                   String uri)

A helper method to resolve the mock endpoint of the given URI on the given context

Parameters:

context - the camel context to try resolve the mock endpoint from

uri - the uri of the endpoint to resolve

Returns:

the endpoint

assertWait

public static void assertWait(long timeout,
                              TimeUnit unit,
                              MockEndpoint... endpoints)
                       throws InterruptedException

Throws:

InterruptedException

assertIsSatisfied

public static void assertIsSatisfied(long timeout,
                                     TimeUnit unit,
                                     MockEndpoint... endpoints)
                              throws InterruptedException

Throws:

InterruptedException

assertIsSatisfied

public static void assertIsSatisfied(MockEndpoint... endpoints)
                              throws InterruptedException

Throws:

InterruptedException

assertIsSatisfied

public static void assertIsSatisfied(CamelContext context)
                              throws InterruptedException

Asserts that all the expectations on any MockEndpoint instances registered in the given context are valid

Parameters:

context - the camel context used to find all the available endpoints to be asserted

Throws:

InterruptedException

expectsMessageCount

public static void expectsMessageCount(int count,
                                       MockEndpoint... endpoints)
                                throws InterruptedException

Throws:

InterruptedException

getExchanges

public List<Exchange> getExchanges()

Description copied from interface: BrowsableEndpoint

Return the exchanges available on this endpoint

Specified by:

getExchanges in interface BrowsableEndpoint<Exchange>

Returns:

the exchanges on this endpoint

addPropertyChangeListener

public void addPropertyChangeListener(PropertyChangeListener listener)

removePropertyChangeListener

public void removePropertyChangeListener(PropertyChangeListener listener)

createConsumer

public Consumer<Exchange> createConsumer(Processor processor)
                                  throws Exception

Description copied from interface: Endpoint

Creates a new Event Driven Consumer which consumes messages from the endpoint using the given processor

Specified by:

createConsumer in interface Endpoint<Exchange>

Returns:

a newly created consumer

Throws:

Exception

createProducer

public Producer<Exchange> createProducer()
                                  throws Exception

Description copied from interface: Endpoint

Creates a new producer which is used send messages into the endpoint

Specified by:

createProducer in interface Endpoint<Exchange>

Returns:

a newly created producer

Throws:

Exception

reset

public void reset()

whenExchangeReceived

public void whenExchangeReceived(int index,
                                 Processor processor)

Set the processor that will be invoked when the index message is received.

Parameters:

index -

processor -

whenAnyExchangeReceived

public void whenAnyExchangeReceived(Processor processor)

Set the processor that will be invoked when the some message is received. This processor could be overwritten by whenExchangeReceived(int, Processor) method.

Parameters:

processor -

assertIsSatisfied

public void assertIsSatisfied()
                       throws InterruptedException

Validates that all the available expectations on this endpoint are satisfied; or throw an exception

Throws:

InterruptedException

assertIsSatisfied

public void assertIsSatisfied(long timeoutForEmptyEndpoints)
                       throws InterruptedException

Validates that all the available expectations on this endpoint are satisfied; or throw an exception

Parameters:

timeoutForEmptyEndpoints - the timeout in milliseconds that we should wait for the test to be true

Throws:

InterruptedException

assertIsNotSatisfied

public void assertIsNotSatisfied()
                          throws InterruptedException

Validates that the assertions fail on this endpoint

Throws:

InterruptedException

expectedMessageCount

public void expectedMessageCount(int expectedCount)

Specifies the expected number of message exchanges that should be received by this endpoint

Parameters:

expectedCount - the number of message exchanges that should be expected by this endpoint

expectedMinimumMessageCount

public void expectedMinimumMessageCount(int expectedCount)

Specifies the minimum number of expected message exchanges that should be received by this endpoint

Parameters:

expectedCount - the number of message exchanges that should be expected by this endpoint

expectedHeaderReceived

public void expectedHeaderReceived(String name,
                                   String value)

Adds an expectation that the given header name & value are received by this endpoint

expectedBodiesReceived

public void expectedBodiesReceived(List bodies)

Adds an expectation that the given body values are received by this endpoint in the specified order

expectedBodiesReceived

public void expectedBodiesReceived(Object... bodies)

Adds an expectation that the given body values are received by this endpoint

expectedBodiesReceivedInAnyOrder

public void expectedBodiesReceivedInAnyOrder(List bodies)

Adds an expectation that the given body values are received by this endpoint in any order

expectedBodiesReceivedInAnyOrder

public void expectedBodiesReceivedInAnyOrder(Object... bodies)

Adds an expectation that the given body values are received by this endpoint in any order

expectsAscending

public void expectsAscending(Expression<Exchange> expression)

Adds an expectation that messages received should have ascending values of the given expression such as a user generated counter value

Parameters:

expression -

expectsDescending

public void expectsDescending(Expression<Exchange> expression)

Adds an expectation that messages received should have descending values of the given expression such as a user generated counter value

Parameters:

expression -

expectsNoDuplicates

public void expectsNoDuplicates(Expression<Exchange> expression)

Adds an expectation that no duplicate messages should be received using the expression to determine the message ID

Parameters:

expression - the expression used to create a unique message ID for message comparison (which could just be the message payload if the payload can be tested for uniqueness using Object.equals(Object) and Object.hashCode()

assertMessagesAscending

public void assertMessagesAscending(Expression<Exchange> expression)

Asserts that the messages have ascending values of the given expression

assertMessagesDescending

public void assertMessagesDescending(Expression<Exchange> expression)

Asserts that the messages have descending values of the given expression

assertMessagesSorted

protected void assertMessagesSorted(Expression<Exchange> expression,
                                    boolean ascending)

assertNoDuplicates

public void assertNoDuplicates(Expression<Exchange> expression)

expects

public void expects(Runnable runnable)

Adds the expectation which will be invoked when enough messages are received

message

public AssertionClause message(int messageIndex)

Adds an assertion to the given message index

Parameters:

messageIndex - the number of the message

Returns:

the assertion clause

allMessages

public AssertionClause allMessages()

Adds an assertion to all the received messages

Returns:

the assertion clause

assertExchangeReceived

public Exchange assertExchangeReceived(int index)

Asserts that the given index of message is received (starting at zero)

getFailures

public List<Throwable> getFailures()

getReceivedCounter

public int getReceivedCounter()

getReceivedExchanges

public List<Exchange> getReceivedExchanges()

getExpectedCount

public int getExpectedCount()

getSleepForEmptyTest

public long getSleepForEmptyTest()

setSleepForEmptyTest

public void setSleepForEmptyTest(long sleepForEmptyTest)

Allows a sleep to be specified to wait to check that this endpoint really is empty when expectedMessageCount(int) is called with zero

Parameters:

sleepForEmptyTest - the milliseconds to sleep for to determine that this endpoint really is empty

getResultWaitTime

public long getResultWaitTime()

setResultWaitTime

public void setResultWaitTime(long resultWaitTime)

Sets the maximum amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied

setMinimumResultWaitTime

public void setMinimumResultWaitTime(long resultMinimumWaitTime)

Sets the minimum expected amount of time (in millis) the assertIsSatisfied() will wait on a latch until it is satisfied

setExpectedMessageCount

public void setExpectedMessageCount(int expectedCount)

Specifies the expected number of message exchanges that should be received by this endpoint

Parameters:

expectedCount - the number of message exchanges that should be expected by this endpoint

setMinimumExpectedMessageCount

public void setMinimumExpectedMessageCount(int expectedCount)

Specifies the minimum number of expected message exchanges that should be received by this endpoint

Parameters:

expectedCount - the number of message exchanges that should be expected by this endpoint

getReporter

public Processor getReporter()

setReporter

public void setReporter(Processor reporter)

Allows a processor to added to the endpoint to report on progress of the test

onExchange

protected void onExchange(Exchange exchange)

performAssertions

protected void performAssertions(Exchange exchange)
                          throws Exception

Throws:

Exception

waitForCompleteLatch

protected void waitForCompleteLatch()
                             throws InterruptedException

Throws:

InterruptedException

assertEquals

protected void assertEquals(String message,
                            Object expectedValue,
                            Object actualValue)

assertTrue

protected void assertTrue(String message,
                          boolean predicate)

fail

protected void fail(Object message)

getExpectedMinimumCount

public int getExpectedMinimumCount()

await

public void await()
           throws InterruptedException

Throws:

InterruptedException

await

public boolean await(long timeout,
                     TimeUnit unit)
              throws InterruptedException

Throws:

InterruptedException

isSingleton

public boolean isSingleton()

Description copied from interface: Endpoint

Returns if the endpoint should be a CamelContext singleton. If the endpoint is a Singleton, then a single Endpoint instance will be shared by all routes with the same URI. Because the endpoint is shared, it should be treated as an immutable.

Specified by:

isSingleton in interface Endpoint<Exchange>