org.axonframework.test.saga
Class AnnotatedSagaTestFixture

java.lang.Object
  extended by org.axonframework.test.saga.AnnotatedSagaTestFixture
All Implemented Interfaces:
ContinuedGivenState, FixtureConfiguration, WhenState

public class AnnotatedSagaTestFixture
extends Object
implements FixtureConfiguration, ContinuedGivenState

Fixture for testing Annotated Sagas based on events and time passing. This fixture allows resources to be configured for the sagas to use.

Since:
1.1
Author:
Allard Buijze

Constructor Summary
AnnotatedSagaTestFixture(Class<? extends AbstractAnnotatedSaga> sagaType)
          Creates an instance of the AnnotatedSagaTestFixture to test sagas of the given sagaType.
 
Method Summary
 GivenAggregateEventPublisher andThenAggregate(Object aggregateIdentifier)
          Use this method to indicate that an aggregate with given identifier published certain events.
 ContinuedGivenState andThenAPublished(Object event)
          Indicates that the given event has been published in the past.
 ContinuedGivenState andThenTimeAdvancesTo(org.joda.time.DateTime newDateTime)
          Simulate time shifts in the current given state.
 ContinuedGivenState andThenTimeElapses(org.joda.time.Duration elapsedTime)
          Simulate time shifts in the current given state.
 org.joda.time.DateTime currentTime()
          Returns the time as "known" by the fixture.
 GivenAggregateEventPublisher givenAggregate(Object aggregateIdentifier)
          Use this method to indicate that an aggregate with given identifier published certain events.
 ContinuedGivenState givenAPublished(Object event)
          Indicates that the given applicationEvent has been published in the past.
 WhenState givenNoPriorActivity()
          Indicates that no relevant activity has occurred in the past.
<T> T
registerCommandGateway(Class<T> gatewayInterface)
          Creates a Command Gateway for the given gatewayInterface and registers that as a resource.
<T> T
registerCommandGateway(Class<T> gatewayInterface, T stubImplementation)
          Creates a Command Gateway for the given gatewayInterface and registers that as a resource.
 FixtureConfiguration registerFieldFilter(FieldFilter fieldFilter)
          Registers the given fieldFilter, which is used to define which Fields are used when comparing objects.
 FixtureConfiguration registerIgnoredField(Class<?> declaringClass, String fieldName)
          Indicates that a field with given fieldName, which is declared in given declaringClass is ignored when performing deep equality checks.
 void registerResource(Object resource)
          Registers the given resource.
 void setCallbackBehavior(CallbackBehavior callbackBehavior)
          Sets the instance that defines the behavior of the Command Bus when a command is dispatched with a callback.
 WhenAggregateEventPublisher whenAggregate(Object aggregateIdentifier)
          Use this method to indicate that an aggregate with given identifier should publish certain events, while recording the outcome.
 FixtureExecutionResult whenPublishingA(Object event)
          Use this method to indicate an application is published, while recording the outcome.
 FixtureExecutionResult whenTimeAdvancesTo(org.joda.time.DateTime newDateTime)
          Mimic an elapsed time with no relevant activity for the Saga.
 FixtureExecutionResult whenTimeElapses(org.joda.time.Duration elapsedTime)
          Mimic an elapsed time with no relevant activity for the Saga.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

AnnotatedSagaTestFixture

public AnnotatedSagaTestFixture(Class<? extends AbstractAnnotatedSaga> sagaType)
Creates an instance of the AnnotatedSagaTestFixture to test sagas of the given sagaType.

Parameters:
sagaType - The type of saga under test
Method Detail

whenTimeElapses

public FixtureExecutionResult whenTimeElapses(org.joda.time.Duration elapsedTime)
Description copied from interface: WhenState
Mimic an elapsed time with no relevant activity for the Saga. If any Events are scheduled to be published within this time frame, they are published. All activity by the Saga on the CommandBus and EventBus (meaning that scheduled events are excluded) is recorded.

Note that if you inject resources using FixtureConfiguration.registerResource(Object), you may need to reset them yourself if they are manipulated by the Saga in the "given" stage of the test.

Specified by:
whenTimeElapses in interface WhenState
Parameters:
elapsedTime - The amount of time to elapse
Returns:
an object allowing you to verify the test results

whenTimeAdvancesTo

public FixtureExecutionResult whenTimeAdvancesTo(org.joda.time.DateTime newDateTime)
Description copied from interface: WhenState
Mimic an elapsed time with no relevant activity for the Saga. If any Events are scheduled to be published within this time frame, they are published. All activity by the Saga on the CommandBus and EventBus (meaning that scheduled events are excluded) is recorded.

Note that if you inject resources using FixtureConfiguration.registerResource(Object), you may need to reset them yourself if they are manipulated by the Saga in the "given" stage of the test.

Specified by:
whenTimeAdvancesTo in interface WhenState
Parameters:
newDateTime - The time to advance the clock to
Returns:
an object allowing you to verify the test results

registerResource

public void registerResource(Object resource)
Description copied from interface: FixtureConfiguration
Registers the given resource. When a Saga is created, all resources are injected on that instance before any Events are passed onto it.

Note that a CommandBus, EventBus and EventScheduler are already registered as resources, and need not be registered again.

Also note that you might need to reset the resources manually if you want to isolate behavior during the "when" stage of the test.

Specified by:
registerResource in interface FixtureConfiguration
Parameters:
resource - the resource to register.

setCallbackBehavior

public void setCallbackBehavior(CallbackBehavior callbackBehavior)
Description copied from interface: FixtureConfiguration
Sets the instance that defines the behavior of the Command Bus when a command is dispatched with a callback.

Specified by:
setCallbackBehavior in interface FixtureConfiguration
Parameters:
callbackBehavior - The instance deciding to how the callback should be invoked.

givenAggregate

public GivenAggregateEventPublisher givenAggregate(Object aggregateIdentifier)
Description copied from interface: FixtureConfiguration
Use this method to indicate that an aggregate with given identifier published certain events.

Can be chained to build natural sentences:
andThenAggregate(someIdentifier).published(someEvents)

Specified by:
givenAggregate in interface FixtureConfiguration
Parameters:
aggregateIdentifier - The identifier of the aggregate the events should appear to come from
Returns:
an object that allows registration of the actual events to send

givenAPublished

public ContinuedGivenState givenAPublished(Object event)
Description copied from interface: FixtureConfiguration
Indicates that the given applicationEvent has been published in the past. This event is sent to the associated sagas.

Specified by:
givenAPublished in interface FixtureConfiguration
Parameters:
event - The event to publish
Returns:
an object that allows chaining of more given state

givenNoPriorActivity

public WhenState givenNoPriorActivity()
Description copied from interface: FixtureConfiguration
Indicates that no relevant activity has occurred in the past.

Specified by:
givenNoPriorActivity in interface FixtureConfiguration
Returns:
an object that allows the definition of the activity to measure Saga behavior

andThenAggregate

public GivenAggregateEventPublisher andThenAggregate(Object aggregateIdentifier)
Description copied from interface: ContinuedGivenState
Use this method to indicate that an aggregate with given identifier published certain events.

Can be chained to build natural sentences:
andThenAggregate(someIdentifier).published(someEvents)

Specified by:
andThenAggregate in interface ContinuedGivenState
Parameters:
aggregateIdentifier - The identifier of the aggregate the events should appear to come from
Returns:
an object that allows registration of the actual events to send

andThenTimeElapses

public ContinuedGivenState andThenTimeElapses(org.joda.time.Duration elapsedTime)
Description copied from interface: ContinuedGivenState
Simulate time shifts in the current given state. This can be useful when the time between given events is of importance.

Specified by:
andThenTimeElapses in interface ContinuedGivenState
Parameters:
elapsedTime - The amount of time that will elapse
Returns:
an object that allows registration of the actual events to send

andThenTimeAdvancesTo

public ContinuedGivenState andThenTimeAdvancesTo(org.joda.time.DateTime newDateTime)
Description copied from interface: ContinuedGivenState
Simulate time shifts in the current given state. This can be useful when the time between given events is of importance.

Specified by:
andThenTimeAdvancesTo in interface ContinuedGivenState
Parameters:
newDateTime - The time to advance the clock to
Returns:
an object that allows registration of the actual events to send

andThenAPublished

public ContinuedGivenState andThenAPublished(Object event)
Description copied from interface: ContinuedGivenState
Indicates that the given event has been published in the past. This event is sent to the associated sagas.

Specified by:
andThenAPublished in interface ContinuedGivenState
Parameters:
event - The event to publish
Returns:
an object that allows chaining of more given state

whenAggregate

public WhenAggregateEventPublisher whenAggregate(Object aggregateIdentifier)
Description copied from interface: WhenState
Use this method to indicate that an aggregate with given identifier should publish certain events, while recording the outcome. In contrast to the FixtureConfiguration.givenAggregate(Object) given} and ContinuedGivenState.andThenAggregate(Object) andThen} methods, this method will start recording activity on the EventBus and CommandBus.

Can be chained to build natural sentences:
whenAggregate(someIdentifier).publishes(anEvent)

Note that if you inject resources using FixtureConfiguration.registerResource(Object), you may need to reset them yourself if they are manipulated by the Saga in the "given" stage of the test.

Specified by:
whenAggregate in interface WhenState
Parameters:
aggregateIdentifier - The identifier of the aggregate the events should appear to come from
Returns:
an object that allows registration of the actual events to send

whenPublishingA

public FixtureExecutionResult whenPublishingA(Object event)
Description copied from interface: WhenState
Use this method to indicate an application is published, while recording the outcome.

Note that if you inject resources using FixtureConfiguration.registerResource(Object), you may need to reset them yourself if they are manipulated by the Saga in the "given" stage of the test.

Specified by:
whenPublishingA in interface WhenState
Parameters:
event - the event to publish
Returns:
an object allowing you to verify the test results

currentTime

public org.joda.time.DateTime currentTime()
Description copied from interface: FixtureConfiguration
Returns the time as "known" by the fixture. This is the time at which the fixture was created, plus the amount of time the fixture was told to simulate a "wait".

This time can be used to predict calculations that the saga may have made based on timestamps from the events it received.

Specified by:
currentTime in interface FixtureConfiguration
Returns:
the simulated "current time" of the fixture.

registerCommandGateway

public <T> T registerCommandGateway(Class<T> gatewayInterface)
Description copied from interface: FixtureConfiguration
Creates a Command Gateway for the given gatewayInterface and registers that as a resource. The gateway will dispatch commands on the Command Bus contained in this Fixture, so that you can validate commands using FixtureExecutionResult.expectDispatchedCommandsEqualTo(Object...) and FixtureExecutionResult.expectDispatchedCommandsMatching(org.hamcrest.Matcher).

Note that you need to use FixtureConfiguration.setCallbackBehavior(org.axonframework.test.utils.CallbackBehavior) to defined the behavior of commands when expecting return values. Alternatively, you can use FixtureConfiguration.registerCommandGateway(Class, Object) to define behavior using a stub implementation.

Specified by:
registerCommandGateway in interface FixtureConfiguration
Type Parameters:
T - The gateway type
Parameters:
gatewayInterface - The interface describing the gateway
Returns:
the gateway implementation being registered as a resource.

registerCommandGateway

public <T> T registerCommandGateway(Class<T> gatewayInterface,
                                    T stubImplementation)
Description copied from interface: FixtureConfiguration
Creates a Command Gateway for the given gatewayInterface and registers that as a resource. The gateway will dispatch commands on the Command Bus contained in this Fixture, so that you can validate commands using FixtureExecutionResult.expectDispatchedCommandsEqualTo(Object...) and FixtureExecutionResult.expectDispatchedCommandsMatching(org.hamcrest.Matcher).

The behavior of the created gateway is defined by the given stubImplementation, if not null. Dispatched Commands are still recorded for verification. Note that only commands executed in the "when" phase are recorded, while the stub implementation may record activity during the "given" phase as well.

Specified by:
registerCommandGateway in interface FixtureConfiguration
Type Parameters:
T - The gateway type
Parameters:
gatewayInterface - The interface describing the gateway
stubImplementation - The stub or mock implementation defining behavior of the gateway
Returns:
the gateway implementation being registered as a resource.

registerFieldFilter

public FixtureConfiguration registerFieldFilter(FieldFilter fieldFilter)
Description copied from interface: FixtureConfiguration
Registers the given fieldFilter, which is used to define which Fields are used when comparing objects. The ResultValidator.expectEvents(Object...) and ResultValidator.expectReturnValue(Object), for example, use this filter.

When multiple filters are registered, a Field must be accepted by all registered filters in order to be accepted.

By default, all Fields are included in the comparison.

Specified by:
registerFieldFilter in interface FixtureConfiguration
Parameters:
fieldFilter - The FieldFilter that defines which fields to include in the comparison
Returns:
the current FixtureConfiguration, for fluent interfacing

registerIgnoredField

public FixtureConfiguration registerIgnoredField(Class<?> declaringClass,
                                                 String fieldName)
Description copied from interface: FixtureConfiguration
Indicates that a field with given fieldName, which is declared in given declaringClass is ignored when performing deep equality checks.

Specified by:
registerIgnoredField in interface FixtureConfiguration
Parameters:
declaringClass - The class declaring the field
fieldName - The name of the field
Returns:
the current FixtureConfiguration, for fluent interfacing


Copyright © 2010-2016. All Rights Reserved.