FixtureConfiguration (Axon Framework 4.10.2 API)

All Known Implementing Classes:

SagaTestFixture
```
public interface FixtureConfiguration
```
Interface describing action to perform on a Saga Test Fixture during the configuration phase.

Since:

1.1

Author:

Allard Buijze

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`Instant`	`currentTime()` Returns the time as "known" by the fixture.
`CommandBus`	`getCommandBus()` Returns the command bus used by this fixture.
`EventBus`	`getEventBus()` Returns the event bus used by this fixture.
`GivenAggregateEventPublisher`	`givenAggregate(String 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.
`ContinuedGivenState`	`givenCurrentTime(Instant currentTime)` Use this method to indicate a specific moment as the initial current time "known" by the fixture at the start of the given state.
`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`	`registerDeadlineDispatchInterceptor(MessageDispatchInterceptor<? super DeadlineMessage<?>> deadlineDispatchInterceptor)` Registers a deadline dispatch interceptor which will always be invoked before a deadline is dispatched (scheduled) on the `DeadlineManager` to perform a task specified in the interceptor.
`FixtureConfiguration`	`registerDeadlineHandlerInterceptor(MessageHandlerInterceptor<? super DeadlineMessage<?>> deadlineHandlerInterceptor)` Registers a deadline handler interceptor which will always be invoked before a deadline is handled to perform a task specified in the interceptor.
`default FixtureConfiguration`	`registerEventHandlerInterceptor(MessageHandlerInterceptor<? super EventMessage<?>> eventHandlerInterceptor)` Registers a `MessageHandlerInterceptor` for `EventMessages`.
`FixtureConfiguration`	`registerFieldFilter(FieldFilter fieldFilter)` Registers the given `fieldFilter`, which is used to define which Fields are used when comparing objects.
`FixtureConfiguration`	`registerHandlerDefinition(HandlerDefinition handlerDefinition)` Registers a `HandlerDefinition` within this fixture.
`FixtureConfiguration`	`registerHandlerEnhancerDefinition(HandlerEnhancerDefinition handlerEnhancerDefinition)` Registers a `HandlerEnhancerDefinition` within this fixture.
`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.
`FixtureConfiguration`	`registerListenerInvocationErrorHandler(ListenerInvocationErrorHandler listenerInvocationErrorHandler)` Registers a `ListenerInvocationErrorHandler` to be set for the Saga to deal with exceptions being thrown from within Saga Event Handlers.
`FixtureConfiguration`	`registerParameterResolverFactory(ParameterResolverFactory parameterResolverFactory)` Registers a `ParameterResolverFactory` within this fixture.
`void`	`registerResource(Object resource)` Registers the given `resource`.
`FixtureConfiguration`	`registerResourceInjector(ResourceInjector resourceInjector)` Registers a `ResourceInjector` within this fixture.
`FixtureConfiguration`	`registerStartRecordingCallback(Runnable onStartRecordingCallback)` Registers a callback to be invoked when the fixture execution starts recording.
`void`	`setCallbackBehavior(CallbackBehavior callbackBehavior)` Sets the instance that defines the behavior of the Command Bus when a command is dispatched with a callback.
`default FixtureConfiguration`	`suppressExceptionInGivenPhase(boolean suppress)` Configure whether the fixture should suppress exceptions thrown during the given-phase.
`FixtureConfiguration`	`withTransienceCheckDisabled()` Disables the check that injected resources are stored in fields that are marked 'transient'.

- Method Detail
  - withTransienceCheckDisabled
```
FixtureConfiguration withTransienceCheckDisabled()
```
    Disables the check that injected resources are stored in fields that are marked 'transient'.
    By default, Saga fixtures check for the transient modifier on fields that hold injected resources. These resources are generally not means to be serialized as part of the Saga.
    When the transience check reports false positives, this method allows this check to be skipped.
    
    Returns:
    
    this instance for fluent interfacing.
  - registerResource
```
void registerResource(Object resource)
```
    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.
    
    Parameters:
    
    resource - the resource to register.
  - registerParameterResolverFactory
```
FixtureConfiguration registerParameterResolverFactory(ParameterResolverFactory parameterResolverFactory)
```
    Registers a ParameterResolverFactory within this fixture. The given parameterResolverFactory will be added to the other parameter resolver factories introduced through ClasspathParameterResolverFactory.forClass(Class) and the SimpleResourceParameterResolverFactory adding the registered resources (with registerResource(Object). The type of the saga under test is used as input for the ClasspathParameterResolverFactory#forClass(Class) operation.
    
    Parameters:
    
    parameterResolverFactory - the ParameterResolver to register within this fixture
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
    
    See Also:
    
    registerResource(Object)
  - registerCommandGateway
```
<T> T registerCommandGateway(Class<T> gatewayInterface)
```
    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.expectDispatchedCommands(Object...) and FixtureExecutionResult.expectDispatchedCommandsMatching(org.hamcrest.Matcher).
    Note that you need to use setCallbackBehavior(org.axonframework.test.utils.CallbackBehavior) to defined the behavior of commands when expecting return values. Alternatively, you can use registerCommandGateway(Class, Object) to define behavior using a stub implementation.
    
    Type Parameters:
    
    T - The gateway type
    
    Parameters:
    
    gatewayInterface - The interface describing the gateway
    
    Returns:
    
    the gateway implementation being registered as a resource.
  - registerCommandGateway
```
<T> T registerCommandGateway(Class<T> gatewayInterface,
                             T stubImplementation)
```
    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.expectDispatchedCommands(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.
    
    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
```
FixtureConfiguration registerFieldFilter(FieldFilter fieldFilter)
```
    Registers the given fieldFilter, which is used to define which Fields are used when comparing objects. The ResultValidator.expectEvents(Object...) and ResultValidator.expectResultMessage(CommandResultMessage), 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.
    
    Parameters:
    
    fieldFilter - The FieldFilter that defines which fields to include in the comparison
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerIgnoredField
```
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.
    
    Parameters:
    
    declaringClass - The class declaring the field
    
    fieldName - The name of the field
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
    
    Throws:
    
    FixtureExecutionException - when no such field is declared
  - registerHandlerDefinition
```
FixtureConfiguration registerHandlerDefinition(HandlerDefinition handlerDefinition)
```
    Registers a HandlerDefinition within this fixture. The given handlerDefinition is added to the handler definitions introduced through ClasspathHandlerDefinition.forClass(Class). The type of the saga under test is used as input for the ClasspathHandlerDefinition#forClass(Class) operation.
    
    Parameters:
    
    handlerDefinition - used to create concrete handlers
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerHandlerEnhancerDefinition
```
FixtureConfiguration registerHandlerEnhancerDefinition(HandlerEnhancerDefinition handlerEnhancerDefinition)
```
    Registers a HandlerEnhancerDefinition within this fixture. This given handlerEnhancerDefinition is added to the handler enhancer definitions introduced through ClasspathHandlerEnhancerDefinition.forClass(Class). The type of the saga under test is used as input for the ClasspathHandlerEnhancerDefinition#forClass(Class) operation.
    
    Parameters:
    
    handlerEnhancerDefinition - the HandlerEnhancerDefinition to register within this fixture
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerDeadlineDispatchInterceptor
```
FixtureConfiguration registerDeadlineDispatchInterceptor(MessageDispatchInterceptor<? super DeadlineMessage<?>> deadlineDispatchInterceptor)
```
    Registers a deadline dispatch interceptor which will always be invoked before a deadline is dispatched (scheduled) on the DeadlineManager to perform a task specified in the interceptor.
    
    Parameters:
    
    deadlineDispatchInterceptor - the interceptor for dispatching (scheduling) deadlines
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerDeadlineHandlerInterceptor
```
FixtureConfiguration registerDeadlineHandlerInterceptor(MessageHandlerInterceptor<? super DeadlineMessage<?>> deadlineHandlerInterceptor)
```
    Registers a deadline handler interceptor which will always be invoked before a deadline is handled to perform a task specified in the interceptor.
    
    Parameters:
    
    deadlineHandlerInterceptor - the interceptor for handling deadlines
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerEventHandlerInterceptor
```
default FixtureConfiguration registerEventHandlerInterceptor(MessageHandlerInterceptor<? super EventMessage<?>> eventHandlerInterceptor)
```
    Registers a MessageHandlerInterceptor for EventMessages.
    Will always be invoked before an event is handled to perform a task specified in the interceptor. Interceptors are invoked in the order they have been registered in.
    
    Parameters:
    
    eventHandlerInterceptor - the interceptor for handling EventMessages
    
    Returns:
    
    The current FixtureConfiguration, for fluent interfacing.
  - registerStartRecordingCallback
```
FixtureConfiguration registerStartRecordingCallback(Runnable onStartRecordingCallback)
```
    Registers a callback to be invoked when the fixture execution starts recording. This happens right before invocation of the 'when' step (stimulus) of the fixture.
    Use this to manage Saga dependencies which are not an Axon first class citizen, but do require monitoring of their interactions. For example, register the callback to set a mock in recording mode.
    
    Parameters:
    
    onStartRecordingCallback - callback to invoke
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerListenerInvocationErrorHandler
```
FixtureConfiguration registerListenerInvocationErrorHandler(ListenerInvocationErrorHandler listenerInvocationErrorHandler)
```
    Registers a ListenerInvocationErrorHandler to be set for the Saga to deal with exceptions being thrown from within Saga Event Handlers. Will be given to the AnnotatedSagaManager for the defined Saga type. Defaults to a LoggingErrorHandler wrapped inside a RecordingListenerInvocationErrorHandler.
    
    Parameters:
    
    listenerInvocationErrorHandler - to be set for the Saga to deal with exceptions being thrown from within Saga Event Handlers
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - suppressExceptionInGivenPhase
```
default FixtureConfiguration suppressExceptionInGivenPhase(boolean suppress)
```
    Configure whether the fixture should suppress exceptions thrown during the given-phase. When suppress is true, the fixture moves on to the when-phase regardless of any exceptions thrown during the given-phase.
    Note that setting this to true means the registered ListenerInvocationErrorHandler is not invoked during exception in the given-phase. Defaults to suppressing during given-phase exceptions.
    
    Parameters:
    
    suppress - A boolean describing whether the fixture should suppress failures during the given-phase.
    
    Returns:
    
    The current fixture, for fluent interfacing.
  - registerResourceInjector
```
FixtureConfiguration registerResourceInjector(ResourceInjector resourceInjector)
```
    Registers a ResourceInjector within this fixture. This approach can be used if a custom ResourceInjector has been built for a project which the user wants to take into account when testing it's sagas.
    The provided resourceInjector will be paired with the fixture's default ResourceInjector to keep support for the registerResource(Object) and withTransienceCheckDisabled() methods. Note that first the default injector is called, and after that the given resourceInjector. This approach ensures the fixture's correct workings for default provided resources, like the EventBus and CommandBus}, whilst allowing the capability to append and/or override with the given resourceInjector.
    Care should be taken if the custom resourceInjector overrides default resources like the EventBus and CommandBus, as the fixture uses specialized versions of the default sources to support all testing functionality.
    
    Parameters:
    
    resourceInjector - the ResourceInjector to register within this fixture
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - setCallbackBehavior
```
void setCallbackBehavior(CallbackBehavior callbackBehavior)
```
    Sets the instance that defines the behavior of the Command Bus when a command is dispatched with a callback.
    
    Parameters:
    
    callbackBehavior - The instance deciding to how the callback should be invoked.
  - givenAggregate
```
GivenAggregateEventPublisher givenAggregate(String aggregateIdentifier)
```
    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)
    
    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
  - givenCurrentTime
```
ContinuedGivenState givenCurrentTime(Instant currentTime)
```
    Use this method to indicate a specific moment as the initial current time "known" by the fixture at the start of the given state.
    
    Parameters:
    
    currentTime - The simulated "current time" at which the given state is initialized
    
    Returns:
    
    an object that allows chaining of more given state
  - givenAPublished
```
ContinuedGivenState givenAPublished(Object event)
```
    Indicates that the given applicationEvent has been published in the past. This event is sent to the associated sagas.
    
    Parameters:
    
    event - The event to publish
    
    Returns:
    
    an object that allows chaining of more given state
  - givenNoPriorActivity
```
WhenState givenNoPriorActivity()
```
    Indicates that no relevant activity has occurred in the past.
    
    Returns:
    
    an object that allows the definition of the activity to measure Saga behavior
    
    Since:
    
    2.1.1
  - currentTime
```
Instant currentTime()
```
    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.
    
    Returns:
    
    the simulated "current time" of the fixture.
  - getEventBus
```
EventBus getEventBus()
```
    Returns the event bus used by this fixture. The event bus is provided for wiring purposes only, for example to allow command handlers to publish events other than Domain Events. Events published on the returned event bus are recorded an evaluated in the ResultValidator operations.
    
    Returns:
    
    the event bus used by this fixture
  - getCommandBus
```
CommandBus getCommandBus()
```
    Returns the command bus used by this fixture. The command bus is provided for wiring purposes only, for example to support composite commands (a single command that causes the execution of one or more others).
    
    Returns:
    
    the command bus used by this fixture

Interface FixtureConfiguration

Method Summary

Method Detail

withTransienceCheckDisabled

registerResource

registerParameterResolverFactory

registerCommandGateway

registerCommandGateway

registerFieldFilter

registerIgnoredField

registerHandlerDefinition

registerHandlerEnhancerDefinition

registerDeadlineDispatchInterceptor

registerDeadlineHandlerInterceptor

registerEventHandlerInterceptor

registerStartRecordingCallback

registerListenerInvocationErrorHandler

suppressExceptionInGivenPhase

registerResourceInjector

setCallbackBehavior

givenAggregate

givenCurrentTime

givenAPublished

givenNoPriorActivity

currentTime

getEventBus

getCommandBus