FixtureConfiguration (Axon Framework 4.0 API)

Type Parameters:

T - The type of the aggregate under test

All Known Implementing Classes:

AggregateTestFixture
```
public interface FixtureConfiguration<T>
```
Interface describing the operations available on a test fixture in the configuration stage. This stage allows a test case to prepare the fixture for test execution.
The fixture is initialized using a Command Handler that expects an @CommandHandler aggregate. If you have implemented your own command handler (either using annotations, or by implementing the MessageHandler interface), you must register the command handler using registerAnnotatedCommandHandler(Object) or registerCommandHandler(Class, MessageHandler), respectively. A typical command handler will require a repository. The test fixture initializes an Event Sourcing Repository, which can be obtained using getRepository(). Alternatively, you can register your own repository using the registerRepository(Repository) method. Registering the repository will cause the fixture to configure the correct EventBus and EventStore implementations required by the test.
Typical usage example:
```
 public class MyCommandHandlerTest() {
 
       private FixtureConfiguration fixture;
 
       @Before
     public void setUp() {
         fixture = new AggregateTestFixture(MyAggregate.class);
         MyCommandHandler commandHandler = new MyCommandHandler();
         commandHandler.setRepository(fixture.getRepository());
         fixture.registerAnnotatedCommandHandler(commandHandler);
     }
 
       @Test
     public void testCommandHandlerCase() {
         fixture.given(new MyEvent(1), new MyEvent(2))
                .when(new TestCommand())
                .expectResultMessagePayload(null)
                .expectEvents(new MyEvent(3));
     }
 
  }
 
```
If you use @CommandHandler annotations on the aggregate, you do not need to configure any additional command handlers. In that case, no configuration is required:
Providing the "given" events using the given(Object...) or given(List<DomainEvent>) methods must be the last operation in the configuration stage. To indicate that no "given" events are available, just call given() with no parameters.
Besides setting configuration, you can also use the FixtureConfiguration to get access to the configured components. This allows you to (manually) inject the EventBus or any other component into you command handler, for example.
Since:

0.6

Author:

Allard Buijze

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`CommandBus`	`getCommandBus()` Returns the command bus used by this fixture.
`EventBus`	`getEventBus()` Returns the event bus used by this fixture.
`EventStore`	`getEventStore()` Returns the event store used by this fixture.
`Repository<T>`	`getRepository()` Returns the repository used by this fixture.
`TestExecutor<T>`	`given(List<?> domainEvents)` Configures the given `domainEvents` as the "given" events.
`TestExecutor<T>`	`given(Object... domainEvents)` Configures the given `domainEvents` as the "given" events.
`TestExecutor<T>`	`givenCommands(List<?> commands)` Configures the given `commands` as the command that will provide the "given" events.
`TestExecutor<T>`	`givenCommands(Object... commands)` Configures the given `commands` as the command that will provide the "given" events.
`TestExecutor<T>`	`givenNoPriorActivity()` Indicates that no relevant activity has occurred in the past.
`TestExecutor<T>`	`givenState(Supplier<T> aggregateState)` Sets the aggregate instance as supplied by given `aggregateState` as the initial state for a test case.
`FixtureConfiguration<T>`	`registerAggregateFactory(AggregateFactory<T> aggregateFactory)` Registers the given `aggregateFactory` with the fixture.
`FixtureConfiguration<T>`	`registerAnnotatedCommandHandler(Object annotatedCommandHandler)` Registers an `annotatedCommandHandler` with this fixture.
`FixtureConfiguration<T>`	`registerCommandDispatchInterceptor(MessageDispatchInterceptor<CommandMessage<?>> commandDispatchInterceptor)` Register a command dispatch interceptor which will always be invoked before a command is dispatched on the command bus to perform a task specified in the interceptor.
`FixtureConfiguration<T>`	`registerCommandHandler(Class<?> payloadType, MessageHandler<CommandMessage<?>> commandHandler)` Registers a `commandHandler` to handle commands of the given `commandType` with the command bus used by this fixture.
`FixtureConfiguration<T>`	`registerCommandHandler(String commandName, MessageHandler<CommandMessage<?>> commandHandler)` Registers a `commandHandler` to handle commands of the given `commandType` with the command bus used by this fixture.
`FixtureConfiguration<T>`	`registerCommandHandlerInterceptor(MessageHandlerInterceptor<CommandMessage<?>> commandHandlerInterceptor)` Register a command handler interceptor which may be invoked before or after the command has been dispatched on the command bus to perform a task specified in the interceptor.
`FixtureConfiguration<T>`	`registerDeadlineDispatchInterceptor(MessageDispatchInterceptor<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<T>`	`registerDeadlineHandlerInterceptor(MessageHandlerInterceptor<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.
`FixtureConfiguration<T>`	`registerFieldFilter(FieldFilter fieldFilter)` Registers the given `fieldFilter`, which is used to define which Fields are used when comparing objects.
`FixtureConfiguration<T>`	`registerHandlerDefinition(HandlerDefinition handlerDefinition)` Registers handler definition within this fixture.
`FixtureConfiguration<T>`	`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<T>`	`registerInjectableResource(Object resource)` Registers a resource that is eligible for injection in handler method (e.g.
`FixtureConfiguration<T>`	`registerRepository(Repository<T> repository)` Registers an arbitrary `repository` with the fixture.
`FixtureConfiguration<T>`	`registerRepositoryProvider(RepositoryProvider repositoryProvider)` Registers repository provider with the fixture.
`void`	`setReportIllegalStateChange(boolean reportIllegalStateChange)` Sets whether or not the fixture should detect and report state changes that occur outside of Event Handler methods.

- Method Detail
  - registerRepository
```
FixtureConfiguration<T> registerRepository(Repository<T> repository)
```
    Registers an arbitrary repository with the fixture. The repository must be wired with the Event Store of this test fixture.
    Should not be used in combination with registerAggregateFactory(org.axonframework.eventsourcing.AggregateFactory), as that will overwrite any repository previously registered.
    
    Parameters:
    
    repository - The repository to use in the test case
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerRepositoryProvider
```
FixtureConfiguration<T> registerRepositoryProvider(RepositoryProvider repositoryProvider)
```
    Registers repository provider with the fixture. If an aggregate being tested spawns new aggregates, this provider should be registered. Otherwise, it is not going to be invoked.
    
    Parameters:
    
    repositoryProvider - provides repositories for specified aggregate types
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerAggregateFactory
```
FixtureConfiguration<T> registerAggregateFactory(AggregateFactory<T> aggregateFactory)
```
    Registers the given aggregateFactory with the fixture. The repository used by the fixture will use the given factory to create new aggregate instances. Defaults to an Aggregate Factory that uses the no-arg constructor to create new instances.
    Should not be used in combination with registerRepository(Repository), as that will overwrite any aggregate factory previously registered.
    
    Parameters:
    
    aggregateFactory - The Aggregate Factory to create empty aggregates with
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerAnnotatedCommandHandler
```
FixtureConfiguration<T> registerAnnotatedCommandHandler(Object annotatedCommandHandler)
```
    Registers an annotatedCommandHandler with this fixture. This will register this command handler with the command bus used in this fixture.
    
    Parameters:
    
    annotatedCommandHandler - The command handler to register for this test
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandler
```
FixtureConfiguration<T> registerCommandHandler(Class<?> payloadType,
                                               MessageHandler<CommandMessage<?>> commandHandler)
```
    Registers a commandHandler to handle commands of the given commandType with the command bus used by this fixture.
    
    Parameters:
    
    payloadType - The type of command to register the handler for
    
    commandHandler - The handler to register
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandler
```
FixtureConfiguration<T> registerCommandHandler(String commandName,
                                               MessageHandler<CommandMessage<?>> commandHandler)
```
    Registers a commandHandler to handle commands of the given commandType with the command bus used by this fixture.
    
    Parameters:
    
    commandName - The name of the command to register the handler for
    
    commandHandler - The handler to register
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerInjectableResource
```
FixtureConfiguration<T> registerInjectableResource(Object resource)
```
    Registers a resource that is eligible for injection in handler method (e.g. methods annotated with @CommandHandler, @EventSourcingHandler and @EventHandler. These resource must be registered before registering any command handler.
    
    Parameters:
    
    resource - The resource eligible for injection
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandDispatchInterceptor
```
FixtureConfiguration<T> registerCommandDispatchInterceptor(MessageDispatchInterceptor<CommandMessage<?>> commandDispatchInterceptor)
```
    Register a command dispatch interceptor which will always be invoked before a command is dispatched on the command bus to perform a task specified in the interceptor. For example by adding MetaData or throwing an exception based on the command.
    
    Parameters:
    
    commandDispatchInterceptor - the command dispatch interceptor to be added to the commandbus
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandlerInterceptor
```
FixtureConfiguration<T> registerCommandHandlerInterceptor(MessageHandlerInterceptor<CommandMessage<?>> commandHandlerInterceptor)
```
    Register a command handler interceptor which may be invoked before or after the command has been dispatched on the command bus to perform a task specified in the interceptor. It could for example block the command for security reasons or add auditing to the command bus
    
    Parameters:
    
    commandHandlerInterceptor - the command handler interceptor to be added to the commandbus
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerDeadlineDispatchInterceptor
```
FixtureConfiguration<T> registerDeadlineDispatchInterceptor(MessageDispatchInterceptor<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<T> registerDeadlineHandlerInterceptor(MessageHandlerInterceptor<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
  - registerFieldFilter
```
FixtureConfiguration<T> 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.expectResultMessagePayload(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.
    
    Parameters:
    
    fieldFilter - The FieldFilter that defines which fields to include in the comparison
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerIgnoredField
```
FixtureConfiguration<T> 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<T> registerHandlerDefinition(HandlerDefinition handlerDefinition)
```
    Registers handler definition within this fixture. This handlerDefinition will replace existing one within this fixture.
    
    Parameters:
    
    handlerDefinition - used to create concrete handlers
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - given
```
TestExecutor<T> given(Object... domainEvents)
```
    Configures the given domainEvents as the "given" events. These are the events returned by the event store when an aggregate is loaded.
    If an item in the given domainEvents implements Message, the payload and meta data from that message are copied into a newly created Domain Event Message. Otherwise, a Domain Event Message with the item as payload and empty meta data is created.
    
    Parameters:
    
    domainEvents - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenState
```
TestExecutor<T> givenState(Supplier<T> aggregateState)
```
    Sets the aggregate instance as supplied by given aggregateState as the initial state for a test case.
    Note that usage of this method is highly discouraged for event sourced aggregates. In that case, use given(Object...) to specify historic events.
    
    Parameters:
    
    aggregateState - a supplier providing the state to use as starting point for this fixture.
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenNoPriorActivity
```
TestExecutor<T> givenNoPriorActivity()
```
    Indicates that no relevant activity has occurred in the past. The behavior of this method is identical to giving no events in the given(java.util.List) method.
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
    
    Since:
    
    2.1.1
  - given
```
TestExecutor<T> given(List<?> domainEvents)
```
    Configures the given domainEvents as the "given" events. These are the events returned by the event store when an aggregate is loaded.
    If an item in the list implements Message, the payload and meta data from that message are copied into a newly created Domain Event Message. Otherwise, a Domain Event Message with the item as payload and empty meta data is created.
    
    Parameters:
    
    domainEvents - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenCommands
```
TestExecutor<T> givenCommands(Object... commands)
```
    Configures the given commands as the command that will provide the "given" events. The commands are executed, and the resulting stored events are captured.
    
    Parameters:
    
    commands - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenCommands
```
TestExecutor<T> givenCommands(List<?> commands)
```
    Configures the given commands as the command that will provide the "given" events. The commands are executed, and the resulting stored events are captured.
    
    Parameters:
    
    commands - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - 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
  - 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
  - getEventStore
```
EventStore getEventStore()
```
    Returns the event store used by this fixture. This event store is provided for wiring purposes only.
    
    Returns:
    
    the event store used by this fixture
  - getRepository
```
Repository<T> getRepository()
```
    Returns the repository used by this fixture. This repository is provided for wiring purposes only. The repository is configured to use the fixture's event store to load events.
    
    Returns:
    
    the repository used by this fixture
  - setReportIllegalStateChange
```
void setReportIllegalStateChange(boolean reportIllegalStateChange)
```
    Sets whether or not the fixture should detect and report state changes that occur outside of Event Handler methods.
    
    Parameters:
    
    reportIllegalStateChange - whether or not to detect and report state changes outside of Event Handler methods.

Interface FixtureConfiguration<T>

Method Summary

Method Detail

registerRepository

registerRepositoryProvider

registerAggregateFactory

registerAnnotatedCommandHandler

registerCommandHandler

registerCommandHandler

registerInjectableResource

registerCommandDispatchInterceptor

registerCommandHandlerInterceptor

registerDeadlineDispatchInterceptor

registerDeadlineHandlerInterceptor

registerFieldFilter

registerIgnoredField

registerHandlerDefinition

given

givenState

givenNoPriorActivity

given

givenCommands

givenCommands

getCommandBus

getEventBus

getEventStore

getRepository

setReportIllegalStateChange