AggregateTestFixture (Axon Framework 4.10.2 API)

java.lang.Object
- org.axonframework.test.aggregate.AggregateTestFixture<T>

Type Parameters:

T - The type of Aggregate tested in this Fixture

All Implemented Interfaces:

FixtureConfiguration<T>, TestExecutor<T>
```
public class AggregateTestFixture<T>
extends Object
implements FixtureConfiguration<T>, TestExecutor<T>
```
A test fixture that allows the execution of given-when-then style test cases. For detailed usage information, see FixtureConfiguration.

Since:

0.6

Author:

Allard Buijze

Constructor Summary

Constructors
Constructor and Description

AggregateTestFixture(Class<T> aggregateType)
Initializes a new given-when-then style test fixture for the given aggregateType.

Constructors
Constructor and Description
`AggregateTestFixture(Class<T> aggregateType)` Initializes a new given-when-then style test fixture for the given `aggregateType`.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`TestExecutor<T>`	`andGiven(List<?> domainEvents)` Configures the given `domainEvents` as the "given" events.
`TestExecutor<T>`	`andGiven(Object... domainEvents)` Configures the given `domainEvents` as the "given" events.
`TestExecutor<T>`	`andGivenCommands(List<?> commands)` Configures the given `commands` as the command that will provide the "given" events.
`TestExecutor<T>`	`andGivenCommands(Object... commands)` Configures the given `commands` as the command that will provide the "given" events.
`TestExecutor<T>`	`andGivenCurrentTime(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.
`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.
`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 to execute against the aggregate under test to initiate the given-phase.
`TestExecutor<T>`	`givenCommands(Object... commands)` Configures the given `commands` as to execute against the aggregate under test to initiate the given-phase.
`TestExecutor<T>`	`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.
`TestExecutor<T>`	`givenNoPriorActivity()` Indicates that no relevant activities like commands or events have occurred in the past.
`TestExecutor<T>`	`givenState(Supplier<T> aggregate)` Sets the aggregate instance as supplied by given `aggregateState` as the initial state for a test case.
`protected void`	`handleDeadline(ScopeDescriptor aggregateDescriptor, DeadlineMessage<?> deadlineMessage)` Handles the given `deadlineMessage` in the aggregate described by the given `aggregateDescriptor`.
`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<? super CommandMessage<?>> commandDispatchInterceptor)` Register a `MessageDispatchInterceptor` for `CommandMessage`s which will be invoked before any command is dispatched on the `CommandBus` 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<? super CommandMessage<?>> commandHandlerInterceptor)` Register a `MessageHandlerInterceptor` for `CommandMessage`s which will be invoked before or after the command has been dispatched on the `CommandBus` to perform a task specified in the interceptor.
`FixtureConfiguration<T>`	`registerCommandTargetResolver(CommandTargetResolver commandTargetResolver)` Registers the `CommandTargetResolver` within this fixture.
`FixtureConfiguration<T>`	`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<T>`	`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.
`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 a `HandlerDefinition` within this fixture.
`FixtureConfiguration<T>`	`registerHandlerEnhancerDefinition(HandlerEnhancerDefinition handlerEnhancerDefinition)` Registers a `HandlerEnhancerDefinition` 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>`	`registerParameterResolverFactory(ParameterResolverFactory parameterResolverFactory)` Registers a `ParameterResolverFactory` within this fixture.
`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.
`FixtureConfiguration<T>`	`useStateStorage()` Configures the fixture for state stored aggregates.
`ResultValidator<T>`	`when(Object command)` Dispatches the given command to the appropriate command handler and records all activity in the fixture for result validation.
`ResultValidator<T>`	`when(Object command, Map<String,?> metaData)` Dispatches the given command and meta-data to the appropriate command handler and records all activity in the fixture for result validation.
`ResultValidator<T>`	`whenConstructing(Callable<T> aggregateFactory)` Invokes the given `aggregateFactory` expecting an aggregate instance of type `T` to be returned.
`ResultValidator<T>`	`whenInvoking(String aggregateId, Consumer<T> aggregateSupplier)` Invokes the given `aggregateConsumer` after loading an aggregate of type `T` based on the given `aggregateIdentifier`.
`ResultValidator<T>`	`whenThenTimeAdvancesTo(Instant newPointInTime)` Deprecated.
`ResultValidator<T>`	`whenThenTimeElapses(Duration elapsedTime)` Deprecated.
`ResultValidator<T>`	`whenTimeAdvancesTo(Instant newPointInTime)` Simulates the time advancing in the current given state using an `Instant` as the unit of time.
`ResultValidator<T>`	`whenTimeElapses(Duration elapsedTime)` Simulates the time elapsing in the current given state using a `Duration` as the unit of time.
`FixtureConfiguration<T>`	`withSubtypes(Class<? extends T>... subtypes)` Registers subtypes of this aggregate to support aggregate polymorphism.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.axonframework.test.aggregate.FixtureConfiguration
registerInjectableResources

Methods inherited from interface org.axonframework.test.aggregate.TestExecutor
andThenTimeAdvancesTo, andThenTimeElapses

- Constructor Detail
  - AggregateTestFixture
```
public AggregateTestFixture(Class<T> aggregateType)
```
    Initializes a new given-when-then style test fixture for the given aggregateType.
    
    Parameters:
    
    aggregateType - the aggregate to initialize the test fixture for
- Method Detail
  - withSubtypes
```
@SafeVarargs
public final FixtureConfiguration<T> withSubtypes(Class<? extends T>... subtypes)
```
    Description copied from interface: FixtureConfiguration
    
    Registers subtypes of this aggregate to support aggregate polymorphism. Command Handlers defined on this subtype will be considered part of this aggregate's handlers.
    
    Specified by:
    
    withSubtypes in interface FixtureConfiguration<T>
    
    Parameters:
    
    subtypes - subtypes in this polymorphic hierarchy
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - useStateStorage
```
public FixtureConfiguration<T> useStateStorage()
```
    Description copied from interface: FixtureConfiguration
    
    Configures the fixture for state stored aggregates. This will register an in-memory org.axonframework.commandhandling.model.Repository with this fixture. Should be used before calling FixtureConfiguration.givenState(Supplier) or FixtureConfiguration.givenCommands(List) (Supplier)}.
    
    Specified by:
    
    useStateStorage in interface FixtureConfiguration<T>
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerRepository
```
public FixtureConfiguration<T> registerRepository(Repository<T> repository)
```
    Description copied from interface: FixtureConfiguration
    
    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 FixtureConfiguration.registerAggregateFactory(org.axonframework.eventsourcing.AggregateFactory), as that will overwrite any repository previously registered.
    
    Specified by:
    
    registerRepository in interface FixtureConfiguration<T>
    
    Parameters:
    
    repository - The repository to use in the test case
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerRepositoryProvider
```
public FixtureConfiguration<T> registerRepositoryProvider(RepositoryProvider repositoryProvider)
```
    Description copied from interface: FixtureConfiguration
    
    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.
    
    Specified by:
    
    registerRepositoryProvider in interface FixtureConfiguration<T>
    
    Parameters:
    
    repositoryProvider - provides repositories for specified aggregate types
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerAggregateFactory
```
public FixtureConfiguration<T> registerAggregateFactory(AggregateFactory<T> aggregateFactory)
```
    Description copied from interface: FixtureConfiguration
    
    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 FixtureConfiguration.registerRepository(Repository), as that will overwrite any aggregate factory previously registered.
    
    Specified by:
    
    registerAggregateFactory in interface FixtureConfiguration<T>
    
    Parameters:
    
    aggregateFactory - The Aggregate Factory to create empty aggregates with
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerAnnotatedCommandHandler
```
public FixtureConfiguration<T> registerAnnotatedCommandHandler(Object annotatedCommandHandler)
```
    Description copied from interface: FixtureConfiguration
    
    Registers an annotatedCommandHandler with this fixture. This will register this command handler with the command bus used in this fixture.
    
    Specified by:
    
    registerAnnotatedCommandHandler in interface FixtureConfiguration<T>
    
    Parameters:
    
    annotatedCommandHandler - The command handler to register for this test
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandler
```
public FixtureConfiguration<T> registerCommandHandler(Class<?> payloadType,
                                                      MessageHandler<CommandMessage<?>> commandHandler)
```
    Description copied from interface: FixtureConfiguration
    
    Registers a commandHandler to handle commands of the given commandType with the command bus used by this fixture.
    
    Specified by:
    
    registerCommandHandler in interface FixtureConfiguration<T>
    
    Parameters:
    
    payloadType - The type of command to register the handler for
    
    commandHandler - The handler to register
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandler
```
public FixtureConfiguration<T> registerCommandHandler(String commandName,
                                                      MessageHandler<CommandMessage<?>> commandHandler)
```
    Description copied from interface: FixtureConfiguration
    
    Registers a commandHandler to handle commands of the given commandType with the command bus used by this fixture.
    
    Specified by:
    
    registerCommandHandler in interface FixtureConfiguration<T>
    
    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
```
public FixtureConfiguration<T> registerInjectableResource(Object resource)
```
    Description copied from interface: FixtureConfiguration
    
    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.
    
    Specified by:
    
    registerInjectableResource in interface FixtureConfiguration<T>
    
    Parameters:
    
    resource - the resource eligible for injection
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerParameterResolverFactory
```
public FixtureConfiguration<T> registerParameterResolverFactory(ParameterResolverFactory parameterResolverFactory)
```
    Description copied from interface: FixtureConfiguration
    
    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 FixtureConfiguration.registerInjectableResource(Object). The generic T is used as input for the ClasspathParameterResolverFactory#forClass(Class) operation.
    
    Specified by:
    
    registerParameterResolverFactory in interface FixtureConfiguration<T>
    
    Parameters:
    
    parameterResolverFactory - the ParameterResolver to register within this fixture
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
    
    See Also:
    
    FixtureConfiguration.registerInjectableResource(Object)
  - registerCommandDispatchInterceptor
```
public FixtureConfiguration<T> registerCommandDispatchInterceptor(MessageDispatchInterceptor<? super CommandMessage<?>> commandDispatchInterceptor)
```
    Description copied from interface: FixtureConfiguration
    
    Register a MessageDispatchInterceptor for CommandMessages which will be invoked before any command is dispatched on the CommandBus to perform a task specified in the interceptor. For example by adding MetaData or throwing an exception based on the command.
    
    Specified by:
    
    registerCommandDispatchInterceptor in interface FixtureConfiguration<T>
    
    Parameters:
    
    commandDispatchInterceptor - the MessageDispatchInterceptor for CommandMessages to be added to this fixture's CommandBus
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandHandlerInterceptor
```
public FixtureConfiguration<T> registerCommandHandlerInterceptor(MessageHandlerInterceptor<? super CommandMessage<?>> commandHandlerInterceptor)
```
    Description copied from interface: FixtureConfiguration
    
    Register a MessageHandlerInterceptor for CommandMessages which will be invoked before or after the command has been dispatched on the CommandBus 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
    
    Specified by:
    
    registerCommandHandlerInterceptor in interface FixtureConfiguration<T>
    
    Parameters:
    
    commandHandlerInterceptor - the MessageHandlerInterceptor for CommandMessages to be added to this fixture's CommandBus
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerDeadlineDispatchInterceptor
```
public FixtureConfiguration<T> registerDeadlineDispatchInterceptor(MessageDispatchInterceptor<? super DeadlineMessage<?>> deadlineDispatchInterceptor)
```
    Description copied from interface: FixtureConfiguration
    
    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.
    
    Specified by:
    
    registerDeadlineDispatchInterceptor in interface FixtureConfiguration<T>
    
    Parameters:
    
    deadlineDispatchInterceptor - the interceptor for dispatching (scheduling) deadlines
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerDeadlineHandlerInterceptor
```
public FixtureConfiguration<T> registerDeadlineHandlerInterceptor(MessageHandlerInterceptor<? super DeadlineMessage<?>> deadlineHandlerInterceptor)
```
    Description copied from interface: FixtureConfiguration
    
    Registers a deadline handler interceptor which will always be invoked before a deadline is handled to perform a task specified in the interceptor.
    
    Specified by:
    
    registerDeadlineHandlerInterceptor in interface FixtureConfiguration<T>
    
    Parameters:
    
    deadlineHandlerInterceptor - the interceptor for handling deadlines
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerFieldFilter
```
public FixtureConfiguration<T> 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.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.
    
    Specified by:
    
    registerFieldFilter in interface FixtureConfiguration<T>
    
    Parameters:
    
    fieldFilter - The FieldFilter that defines which fields to include in the comparison
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerIgnoredField
```
public FixtureConfiguration<T> 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<T>
    
    Parameters:
    
    declaringClass - The class declaring the field
    
    fieldName - The name of the field
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerHandlerDefinition
```
public FixtureConfiguration<T> registerHandlerDefinition(HandlerDefinition handlerDefinition)
```
    Description copied from interface: FixtureConfiguration
    
    Registers a HandlerDefinition within this fixture. The given handlerDefinition is added to the handler definitions introduced through ClasspathHandlerDefinition.forClass(Class). The generic T is used as input for the ClasspathHandlerDefinition#forClass(Class) operation.
    
    Specified by:
    
    registerHandlerDefinition in interface FixtureConfiguration<T>
    
    Parameters:
    
    handlerDefinition - used to create concrete handlers
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerHandlerEnhancerDefinition
```
public FixtureConfiguration<T> registerHandlerEnhancerDefinition(HandlerEnhancerDefinition handlerEnhancerDefinition)
```
    Description copied from interface: FixtureConfiguration
    
    Registers a HandlerEnhancerDefinition within this fixture. This given handlerEnhancerDefinition is added to the handler enhancer definitions introduced through ClasspathHandlerEnhancerDefinition.forClass(Class). The generic T is used as input for the ClasspathHandlerEnhancerDefinition#forClass(Class) operation.
    
    Specified by:
    
    registerHandlerEnhancerDefinition in interface FixtureConfiguration<T>
    
    Parameters:
    
    handlerEnhancerDefinition - the HandlerEnhancerDefinition to register within this fixture
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - registerCommandTargetResolver
```
public FixtureConfiguration<T> registerCommandTargetResolver(CommandTargetResolver commandTargetResolver)
```
    Description copied from interface: FixtureConfiguration
    
    Registers the CommandTargetResolver within this fixture. The commandTargetResolver will replace the default implementation (defined by the AggregateAnnotationCommandHandler within this fixture.
    
    Specified by:
    
    registerCommandTargetResolver in interface FixtureConfiguration<T>
    
    Parameters:
    
    commandTargetResolver - the CommandTargetResolver used to resolve an Aggregate for a given command
    
    Returns:
    
    the current FixtureConfiguration, for fluent interfacing
  - given
```
public TestExecutor<T> given(Object... domainEvents)
```
    Description copied from interface: FixtureConfiguration
    
    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 MetaData from that Message are copied into a newly created DomainEventMessage. Otherwise, a DomainEventMessage with the item as payload and empty MetaData is created.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    given in interface FixtureConfiguration<T>
    
    Parameters:
    
    domainEvents - The domain events the event store should return.
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - andGiven
```
public TestExecutor<T> andGiven(Object... domainEvents)
```
    Description copied from interface: TestExecutor
    
    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.
    
    Specified by:
    
    andGiven in interface TestExecutor<T>
    
    Parameters:
    
    domainEvents - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenNoPriorActivity
```
public TestExecutor<T> givenNoPriorActivity()
```
    Description copied from interface: FixtureConfiguration
    
    Indicates that no relevant activities like commands or events have occurred in the past. This also means that no previous state is present in the repository.
    
    Specified by:
    
    givenNoPriorActivity in interface FixtureConfiguration<T>
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - givenState
```
public TestExecutor<T> givenState(Supplier<T> aggregate)
```
    Description copied from interface: FixtureConfiguration
    
    Sets the aggregate instance as supplied by given aggregateState as the initial state for a test case.
    Usage of this method is highly discouraged for event sourced aggregates. In that case, use FixtureConfiguration.given(Object...) to specify historic events.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    givenState in interface FixtureConfiguration<T>
    
    Parameters:
    
    aggregate - 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.
  - given
```
public TestExecutor<T> given(List<?> domainEvents)
```
    Description copied from interface: FixtureConfiguration
    
    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 MetaData from that Message are copied into a newly created DomainEventMessage. Otherwise, a DomainEventMessage with the item as payload and empty MetaData is created.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    given in interface FixtureConfiguration<T>
    
    Parameters:
    
    domainEvents - The domain events the event store should return.
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - andGiven
```
public TestExecutor<T> andGiven(List<?> domainEvents)
```
    Description copied from interface: TestExecutor
    
    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.
    
    Specified by:
    
    andGiven in interface TestExecutor<T>
    
    Parameters:
    
    domainEvents - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenCommands
```
public TestExecutor<T> givenCommands(Object... commands)
```
    Description copied from interface: FixtureConfiguration
    
    Configures the given commands as to execute against the aggregate under test to initiate the given-phase. The commands are executed, and the resulting stored events are captured.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    givenCommands in interface FixtureConfiguration<T>
    
    Parameters:
    
    commands - The commands to execute against the aggregate under test to initiate the given-phase.
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - andGivenCommands
```
public TestExecutor<T> andGivenCommands(Object... commands)
```
    Description copied from interface: TestExecutor
    
    Configures the given commands as the command that will provide the "given" events. The commands are executed, and the resulting stored events are captured.
    
    Specified by:
    
    andGivenCommands in interface TestExecutor<T>
    
    Parameters:
    
    commands - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenCommands
```
public TestExecutor<T> givenCommands(List<?> commands)
```
    Description copied from interface: FixtureConfiguration
    
    Configures the given commands as to execute against the aggregate under test to initiate the given-phase. The commands are executed, and the resulting stored events are captured.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    givenCommands in interface FixtureConfiguration<T>
    
    Parameters:
    
    commands - The commands to execute against the aggregate under test to initiate the given-phase.
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - andGivenCommands
```
public TestExecutor<T> andGivenCommands(List<?> commands)
```
    Description copied from interface: TestExecutor
    
    Configures the given commands as the command that will provide the "given" events. The commands are executed, and the resulting stored events are captured.
    
    Specified by:
    
    andGivenCommands in interface TestExecutor<T>
    
    Parameters:
    
    commands - the domain events the event store should return
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - givenCurrentTime
```
public TestExecutor<T> givenCurrentTime(Instant currentTime)
```
    Description copied from interface: FixtureConfiguration
    
    Use this method to indicate a specific moment as the initial current time "known" by the fixture at the start of the given state.
    Note that transitioning to the returned TestExecutor will clear any previously defined "given" state to ensure the fixture can run a clean test environment.
    
    Specified by:
    
    givenCurrentTime in interface FixtureConfiguration<T>
    
    Parameters:
    
    currentTime - An Instant defining the simulated "current time" at which the given state is initialized.
    
    Returns:
    
    A TestExecutor instance that can execute the test with this configuration.
  - andGivenCurrentTime
```
public TestExecutor<T> andGivenCurrentTime(Instant currentTime)
```
    Description copied from interface: TestExecutor
    
    Use this method to indicate a specific moment as the initial current time "known" by the fixture at the start of the given state.
    
    Specified by:
    
    andGivenCurrentTime in interface TestExecutor<T>
    
    Parameters:
    
    currentTime - The simulated "current time" at which the given state is initialized
    
    Returns:
    
    a TestExecutor instance that can execute the test with this configuration
  - currentTime
```
public Instant currentTime()
```
    Description copied from interface: TestExecutor
    
    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".
    
    Specified by:
    
    currentTime in interface TestExecutor<T>
    
    Returns:
    
    the simulated "current time" of the fixture.
  - whenTimeElapses
```
public ResultValidator<T> whenTimeElapses(Duration elapsedTime)
```
    Description copied from interface: TestExecutor
    
    Simulates the time elapsing in the current given state using a Duration as the unit of time. This can be useful when the time between given events is of importance, for example when leveraging the DeadlineManager to schedule deadlines in the context of a given Aggregate.
    Note: As this method is added to the interface as a replacement for the deprecated TestExecutor.whenThenTimeAdvancesTo(Instant) method, and in case there are other implementations by 3rd party libraries, this method is changed to a default method that rely on the deprecated method so that there is no breaking changes in the API in case an external implementation of this interface. Nevertheless, the recommended approach is to override this implementation.
    
    Specified by:
    
    whenTimeElapses in interface TestExecutor<T>
    
    Parameters:
    
    elapsedTime - a Duration specifying the amount of time that will elapse
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - whenThenTimeElapses
```
@Deprecated
public ResultValidator<T> whenThenTimeElapses(Duration elapsedTime)
```
    Deprecated.
    
    Description copied from interface: TestExecutor
    
    Simulates the time elapsing in the current given state using a Duration as the unit of time. This can be useful when the time between given events is of importance, for example when leveraging the DeadlineManager to schedule deadlines in the context of a given Aggregate.
    
    Specified by:
    
    whenThenTimeElapses in interface TestExecutor<T>
    
    Parameters:
    
    elapsedTime - a Duration specifying the amount of time that will elapse
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - whenTimeAdvancesTo
```
public ResultValidator<T> whenTimeAdvancesTo(Instant newPointInTime)
```
    Description copied from interface: TestExecutor
    
    Simulates the time advancing in the current given state using an Instant as the unit of time. This can be useful when the time between given events is of importance, for example when leveraging the DeadlineManager to schedule deadlines in the context of a given Aggregate.
    Note: As this method is added to the interface as a replacement for the deprecated TestExecutor.whenThenTimeAdvancesTo(Instant) method, and in case there are other implementations by 3rd party libraries, this method is changed to a default method that rely on the deprecated method so that there is no breaking changes in the API in case an external implementation of this interface. Nevertheless, the recommended approach is to override this implementation.
    
    Specified by:
    
    whenTimeAdvancesTo in interface TestExecutor<T>
    
    Parameters:
    
    newPointInTime - an Instant specifying the amount of time to advance the clock to
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - whenThenTimeAdvancesTo
```
@Deprecated
public ResultValidator<T> whenThenTimeAdvancesTo(Instant newPointInTime)
```
    Deprecated.
    
    Description copied from interface: TestExecutor
    
    Simulates the time advancing in the current given state using an Instant as the unit of time. This can be useful when the time between given events is of importance, for example when leveraging the DeadlineManager to schedule deadlines in the context of a given Aggregate.
    
    Specified by:
    
    whenThenTimeAdvancesTo in interface TestExecutor<T>
    
    Parameters:
    
    newPointInTime - an Instant specifying the amount of time to advance the clock to
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - when
```
public ResultValidator<T> when(Object command)
```
    Description copied from interface: TestExecutor
    
    Dispatches the given command to the appropriate command handler and records all activity in the fixture for result validation. If the given command is a CommandMessage instance, it will be dispatched as-is. Any other object will cause the given command to be wrapped in a CommandMessage as its payload.
    
    Specified by:
    
    when in interface TestExecutor<T>
    
    Parameters:
    
    command - The command to execute
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - when
```
public ResultValidator<T> when(Object command,
                               Map<String,?> metaData)
```
    Description copied from interface: TestExecutor
    
    Dispatches the given command and meta-data to the appropriate command handler and records all activity in the fixture for result validation. If the given command is a CommandMessage instance, it will be dispatched as-is, with given additional metaData. Any other object will cause the given command to be wrapped in a CommandMessage as its payload.
    
    Specified by:
    
    when in interface TestExecutor<T>
    
    Parameters:
    
    command - The command to execute
    
    metaData - The meta-data to attach to the
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of the command execution
  - whenConstructing
```
public ResultValidator<T> whenConstructing(Callable<T> aggregateFactory)
```
    Description copied from interface: TestExecutor
    
    Invokes the given aggregateFactory expecting an aggregate instance of type T to be returned.
    All activity is recorded in the fixture for result validation. The aggregateFactory typically refers to one of the aggregate's constructors.
    You should use this when-phase operation whenever you do not use the CommandHandler annotation on the aggregate's methods, nor have registered an external command handler invoking the Repository.
    
    Specified by:
    
    whenConstructing in interface TestExecutor<T>
    
    Parameters:
    
    aggregateFactory - A callable operation expecting an aggregate instance of type T to be returned. This typically is an aggregate constructor invocation.
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of executing the given aggregateFactory.
  - whenInvoking
```
public ResultValidator<T> whenInvoking(String aggregateId,
                                       Consumer<T> aggregateSupplier)
```
    Description copied from interface: TestExecutor
    
    Invokes the given aggregateConsumer after loading an aggregate of type T based on the given aggregateIdentifier.
    All activity is recorded in the fixture for result validation.
    You should use this when-phase operation whenever you do not use the CommandHandler annotation on the aggregate's methods, nor have registered an external command handler invoking the Repository.
    
    Specified by:
    
    whenInvoking in interface TestExecutor<T>
    
    Parameters:
    
    aggregateId - The identifier of the aggregate to Repository.load(String).
    
    aggregateSupplier - A lambda providing an aggregate instance of type T based on the given aggregateIdentifier.
    
    Returns:
    
    a ResultValidator that can be used to validate the resulting actions of executing the given aggregateConsumer.
  - handleDeadline
```
protected void handleDeadline(ScopeDescriptor aggregateDescriptor,
                              DeadlineMessage<?> deadlineMessage)
                       throws Exception
```
    Handles the given deadlineMessage in the aggregate described by the given aggregateDescriptor. Deadline message is handled in the scope of a UnitOfWork. If handling the deadline results in an exception, the exception will be wrapped in a FixtureExecutionException.
    
    Parameters:
    
    aggregateDescriptor - A ScopeDescriptor describing the aggregate under test
    
    deadlineMessage - The DeadlineMessage to be handled
    
    Throws:
    
    Exception
  - setReportIllegalStateChange
```
public void setReportIllegalStateChange(boolean reportIllegalStateChange)
```
    Description copied from interface: FixtureConfiguration
    
    Sets whether or not the fixture should detect and report state changes that occur outside of Event Handler methods.
    
    Specified by:
    
    setReportIllegalStateChange in interface FixtureConfiguration<T>
    
    Parameters:
    
    reportIllegalStateChange - whether or not to detect and report state changes outside of Event Handler methods.
  - getCommandBus
```
public CommandBus getCommandBus()
```
    Description copied from interface: FixtureConfiguration
    
    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).
    
    Specified by:
    
    getCommandBus in interface FixtureConfiguration<T>
    
    Returns:
    
    the command bus used by this fixture
  - getEventBus
```
public EventBus getEventBus()
```
    Description copied from interface: FixtureConfiguration
    
    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.
    
    Specified by:
    
    getEventBus in interface FixtureConfiguration<T>
    
    Returns:
    
    the event bus used by this fixture
  - getEventStore
```
public EventStore getEventStore()
```
    Description copied from interface: FixtureConfiguration
    
    Returns the event store used by this fixture. This event store is provided for wiring purposes only.
    
    Specified by:
    
    getEventStore in interface FixtureConfiguration<T>
    
    Returns:
    
    the event store used by this fixture
  - getRepository
```
public Repository<T> getRepository()
```
    Description copied from interface: FixtureConfiguration
    
    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.
    
    Specified by:
    
    getRepository in interface FixtureConfiguration<T>
    
    Returns:
    
    the repository used by this fixture

Class AggregateTestFixture<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.axonframework.test.aggregate.FixtureConfiguration

Methods inherited from interface org.axonframework.test.aggregate.TestExecutor

Constructor Detail

AggregateTestFixture

Method Detail

withSubtypes

useStateStorage

registerRepository

registerRepositoryProvider

registerAggregateFactory

registerAnnotatedCommandHandler

registerCommandHandler

registerCommandHandler

registerInjectableResource

registerParameterResolverFactory

registerCommandDispatchInterceptor

registerCommandHandlerInterceptor

registerDeadlineDispatchInterceptor

registerDeadlineHandlerInterceptor

registerFieldFilter

registerIgnoredField

registerHandlerDefinition

registerHandlerEnhancerDefinition

registerCommandTargetResolver

given

andGiven

givenNoPriorActivity

givenState

given

andGiven

givenCommands

andGivenCommands

givenCommands

andGivenCommands

givenCurrentTime

andGivenCurrentTime

currentTime

whenTimeElapses

whenThenTimeElapses

whenTimeAdvancesTo

whenThenTimeAdvancesTo

when

when

whenConstructing

whenInvoking

handleDeadline

setReportIllegalStateChange

getCommandBus

getEventBus

getEventStore

getRepository