|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
T
- The type of the aggregate under testpublic interface FixtureConfiguration<T extends EventSourcedAggregateRoot>
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 CommandHandler
interace), you must register the command handler using registerAnnotatedCommandHandler(Object)
or registerCommandHandler(Class, org.axonframework.commandhandling.CommandHandler)
, 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(org.axonframework.eventsourcing.EventSourcingRepository)
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 = Fixtures.newGivenWhenThenFixture(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())
.expectReturnValue(Void.TYPE)
.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.
Method Summary | |
---|---|
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 |
given(List<?> domainEvents)
Configures the given domainEvents as the "given" events. |
TestExecutor |
given(Object... domainEvents)
Configures the given domainEvents as the "given" events. |
TestExecutor |
givenCommands(List<?> commands)
Configures the given commands as the command that will provide the "given" events. |
TestExecutor |
givenCommands(Object... commands)
Configures the given commands as the command that will provide the "given" events. |
TestExecutor |
givenNoPriorActivity()
Indicates that no relevant activity has occurred in the past. |
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> |
registerCommandHandler(Class<?> payloadType,
CommandHandler commandHandler)
Registers a commandHandler to handle commands of the given commandType with the
command bus used by this fixture. |
FixtureConfiguration<T> |
registerCommandHandler(String commandName,
CommandHandler commandHandler)
Registers a commandHandler to handle commands of the given commandType with the
command bus used by this fixture. |
FixtureConfiguration<T> |
registerFieldFilter(FieldFilter fieldFilter)
Registers the given fieldFilter , which is used to define which Fields are used when comparing
objects. |
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(EventSourcingRepository<T> repository)
Registers an arbitrary event sourcing repository 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 |
---|
FixtureConfiguration<T> registerRepository(EventSourcingRepository<T> repository)
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.
repository
- The repository to use in the test case
FixtureConfiguration<T> registerAggregateFactory(AggregateFactory<T> aggregateFactory)
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(org.axonframework.eventsourcing.EventSourcingRepository)
, as that will overwrite any
aggregate factory previously registered.
aggregateFactory
- The Aggregate Factory to create empty aggregates with
FixtureConfiguration<T> registerAnnotatedCommandHandler(Object annotatedCommandHandler)
annotatedCommandHandler
with this fixture. This will register this command handler
with the command bus used in this fixture.
annotatedCommandHandler
- The command handler to register for this test
FixtureConfiguration<T> registerCommandHandler(Class<?> payloadType, CommandHandler commandHandler)
commandHandler
to handle commands of the given commandType
with the
command bus used by this fixture.
payloadType
- The type of command to register the handler forcommandHandler
- The handler to register
FixtureConfiguration<T> registerCommandHandler(String commandName, CommandHandler commandHandler)
commandHandler
to handle commands of the given commandType
with the
command bus used by this fixture.
commandName
- The name of the command to register the handler forcommandHandler
- The handler to register
FixtureConfiguration<T> registerInjectableResource(Object resource)
@CommandHandler
, @EventSourcingHandler
and @EventHandler
. These resource must be
registered before registering any command handler.
resource
- The resource eligible for injection
FixtureConfiguration<T> registerFieldFilter(FieldFilter fieldFilter)
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.
fieldFilter
- The FieldFilter that defines which fields to include in the comparison
FixtureConfiguration<T> registerIgnoredField(Class<?> declaringClass, String fieldName)
fieldName
, which is declared in given declaringClass
is ignored when performing deep equality checks.
declaringClass
- The class declaring the fieldfieldName
- The name of the field
FixtureExecutionException
- when no such field is declaredTestExecutor given(Object... domainEvents)
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.
domainEvents
- the domain events the event store should return
TestExecutor givenNoPriorActivity()
given(java.util.List)
method.
TestExecutor given(List<?> domainEvents)
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.
domainEvents
- the domain events the event store should return
TestExecutor givenCommands(Object... commands)
commands
as the command that will provide the "given" events. The commands are
executed, and the resulting stored events are captured.
commands
- the domain events the event store should return
TestExecutor givenCommands(List<?> commands)
commands
as the command that will provide the "given" events. The commands are
executed, and the resulting stored events are captured.
commands
- the domain events the event store should return
CommandBus getCommandBus()
EventBus getEventBus()
ResultValidator
operations.
EventStore getEventStore()
Repository<T> getRepository()
void setReportIllegalStateChange(boolean reportIllegalStateChange)
reportIllegalStateChange
- whether or not to detect and report state changes outside of Event Handler
methods.
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |