@Test
public void testLoadAndSaveAggregate() {
UUID identifier = UUID.randomUUID();
DomainEventMessage event1 =
new GenericDomainEventMessage<String>(
identifier, (long) 1, "Mock contents", MetaData.emptyInstance());
DomainEventMessage event2 =
new GenericDomainEventMessage<String>(
identifier, (long) 2, "Mock contents", MetaData.emptyInstance());
when(mockEventStore.readEvents("test", identifier))
.thenReturn(new SimpleDomainEventStream(event1, event2));
TestAggregate aggregate = testSubject.load(identifier, null);
assertEquals(0, aggregate.getUncommittedEventCount());
assertEquals(2, aggregate.getHandledEvents().size());
assertSame(event1, aggregate.getHandledEvents().get(0));
assertSame(event2, aggregate.getHandledEvents().get(1));
// now the aggregate is loaded (and hopefully correctly locked)
StubDomainEvent event3 = new StubDomainEvent();
aggregate.apply(event3);
CurrentUnitOfWork.commit();
verify(mockEventBus).publish(isA(DomainEventMessage.class));
verify(mockEventBus, never()).publish(event1);
verify(mockEventBus, never()).publish(event2);
verify(mockEventStore, times(1)).appendEvents(eq("test"), isA(DomainEventStream.class));
assertEquals(0, aggregate.getUncommittedEventCount());
}
@Test
public void testLoadEventsWithDecorators() {
UUID identifier = UUID.randomUUID();
SpyEventPreprocessor decorator1 = new SpyEventPreprocessor();
SpyEventPreprocessor decorator2 = new SpyEventPreprocessor();
testSubject.setEventStreamDecorators(Arrays.asList(decorator1, decorator2));
when(mockEventStore.readEvents("test", identifier))
.thenReturn(
new SimpleDomainEventStream(
new GenericDomainEventMessage<String>(
identifier, (long) 1, "Mock contents", MetaData.emptyInstance()),
new GenericDomainEventMessage<String>(
identifier, (long) 2, "Mock contents", MetaData.emptyInstance()),
new GenericDomainEventMessage<String>(
identifier, (long) 3, "Mock contents", MetaData.emptyInstance())));
TestAggregate aggregate = testSubject.load(identifier);
// loading them in...
InOrder inOrder = Mockito.inOrder(decorator1.lastSpy, decorator2.lastSpy);
inOrder.verify(decorator2.lastSpy).next();
inOrder.verify(decorator1.lastSpy).next();
inOrder.verify(decorator2.lastSpy).next();
inOrder.verify(decorator1.lastSpy).next();
inOrder.verify(decorator2.lastSpy).next();
inOrder.verify(decorator1.lastSpy).next();
aggregate.apply(new StubDomainEvent());
aggregate.apply(new StubDomainEvent());
}
@Test
public void testLoadAndSaveWithConflictingChanges() {
ConflictResolver conflictResolver = mock(ConflictResolver.class);
UUID identifier = UUID.randomUUID();
DomainEventMessage event2 =
new GenericDomainEventMessage<String>(
identifier, (long) 2, "Mock contents", MetaData.emptyInstance());
DomainEventMessage event3 =
new GenericDomainEventMessage<String>(
identifier, (long) 3, "Mock contents", MetaData.emptyInstance());
when(mockEventStore.readEvents("test", identifier))
.thenReturn(
new SimpleDomainEventStream(
new GenericDomainEventMessage<String>(
identifier, (long) 1, "Mock contents", MetaData.emptyInstance()),
event2,
event3));
testSubject.setConflictResolver(conflictResolver);
TestAggregate actual = testSubject.load(identifier, 1L);
verify(conflictResolver, never())
.resolveConflicts(anyListOf(DomainEventMessage.class), anyListOf(DomainEventMessage.class));
final StubDomainEvent appliedEvent = new StubDomainEvent();
actual.apply(appliedEvent);
CurrentUnitOfWork.commit();
verify(conflictResolver)
.resolveConflicts(payloadsEqual(appliedEvent), eq(Arrays.asList(event2, event3)));
}
@Test
public void testLoadWithConflictingChanges_NoConflictResolverSet() {
UUID identifier = UUID.randomUUID();
DomainEventMessage event2 =
new GenericDomainEventMessage<String>(
identifier, (long) 2, "Mock contents", MetaData.emptyInstance());
DomainEventMessage event3 =
new GenericDomainEventMessage<String>(
identifier, (long) 3, "Mock contents", MetaData.emptyInstance());
when(mockEventStore.readEvents("test", identifier))
.thenReturn(
new SimpleDomainEventStream(
new GenericDomainEventMessage<String>(
identifier, (long) 1, "Mock contents", MetaData.emptyInstance()),
event2,
event3));
try {
testSubject.load(identifier, 1L);
fail("Expected ConflictingAggregateVersionException");
} catch (ConflictingAggregateVersionException e) {
assertEquals(identifier, e.getAggregateIdentifier());
assertEquals(1L, e.getExpectedVersion());
assertEquals(3L, e.getActualVersion());
}
}
@Test
public void testWithMetaData() {
Map<String, Object> metaDataMap = Collections.singletonMap("key", (Object) "value");
MetaData metaData = MetaData.from(metaDataMap);
when(serializer.deserialize(serializedMetaData)).thenReturn(metaData);
SerializedEventMessage<Object> message =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
EventMessage<Object> message1 = message.withMetaData(MetaData.emptyInstance());
EventMessage<Object> message2 =
message.withMetaData(MetaData.from(Collections.singletonMap("key", (Object) "otherValue")));
assertEquals(0, message1.getMetaData().size());
assertEquals(1, message2.getMetaData().size());
}
@Test
public void testConstructor() {
SerializedEventMessage<Object> message1 =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
assertSame(MetaData.emptyInstance(), message1.getMetaData());
assertEquals(Object.class, message1.getPayloadType());
assertFalse(message1.isPayloadDeserialized());
assertEquals(Object.class, message1.getPayload().getClass());
assertTrue(message1.isPayloadDeserialized());
}
@Test
public void testSaveEventsWithDecorators() {
SpyEventPreprocessor decorator1 = new SpyEventPreprocessor();
SpyEventPreprocessor decorator2 = new SpyEventPreprocessor();
testSubject.setEventStreamDecorators(Arrays.asList(decorator1, decorator2));
testSubject.setEventStore(
new EventStore() {
@Override
public void appendEvents(String type, DomainEventStream events) {
while (events.hasNext()) {
events.next();
}
}
@Override
public DomainEventStream readEvents(String type, Object identifier) {
return mockEventStore.readEvents(type, identifier);
}
});
UUID identifier = UUID.randomUUID();
when(mockEventStore.readEvents("test", identifier))
.thenReturn(
new SimpleDomainEventStream(
new GenericDomainEventMessage<String>(
identifier, (long) 3, "Mock contents", MetaData.emptyInstance())));
TestAggregate aggregate = testSubject.load(identifier);
aggregate.apply(new StubDomainEvent());
aggregate.apply(new StubDomainEvent());
CurrentUnitOfWork.commit();
InOrder inOrder = Mockito.inOrder(decorator1.lastSpy, decorator2.lastSpy);
inOrder.verify(decorator1.lastSpy).next();
inOrder.verify(decorator2.lastSpy).next();
inOrder.verify(decorator1.lastSpy).next();
inOrder.verify(decorator2.lastSpy).next();
}
private CommandMessage createCommandMessage(Object command) {
CommandMessage<?> message = asCommandMessage(command);
return message.withMetaData(
MetaData.from(CorrelationDataHolder.getCorrelationData())
.mergedWith(message.getMetaData()));
}
/** @author Allard Buijze */
public class SerializedEventMessageTest {
private SerializedObject<String> serializedPayload =
new SimpleSerializedObject<String>("serialized", String.class, "java.lang.Object", "1");
private SerializedObject<String> serializedMetaData =
new SerializedMetaData<String>("serialized", String.class);
private Object deserializedPayload = new Object();
private MetaData deserializedMetaData = MetaData.emptyInstance();
private Serializer serializer = mock(Serializer.class);
private String eventId = "eventId";
private DateTime timestamp = new DateTime();
@Before
public void setUp() {
when(serializer.deserialize(serializedMetaData)).thenReturn(deserializedMetaData);
when(serializer.deserialize(serializedPayload)).thenReturn(deserializedPayload);
when(serializer.classForType(isA(SerializedType.class))).thenReturn(Object.class);
}
@Test
public void testConstructor() {
SerializedEventMessage<Object> message1 =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
assertSame(MetaData.emptyInstance(), message1.getMetaData());
assertEquals(Object.class, message1.getPayloadType());
assertFalse(message1.isPayloadDeserialized());
assertEquals(Object.class, message1.getPayload().getClass());
assertTrue(message1.isPayloadDeserialized());
}
@Test
public void testWithMetaData() {
Map<String, Object> metaDataMap = Collections.singletonMap("key", (Object) "value");
MetaData metaData = MetaData.from(metaDataMap);
when(serializer.deserialize(serializedMetaData)).thenReturn(metaData);
SerializedEventMessage<Object> message =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
EventMessage<Object> message1 = message.withMetaData(MetaData.emptyInstance());
EventMessage<Object> message2 =
message.withMetaData(MetaData.from(Collections.singletonMap("key", (Object) "otherValue")));
assertEquals(0, message1.getMetaData().size());
assertEquals(1, message2.getMetaData().size());
}
@Test
public void testAndMetaData() {
Map<String, Object> metaDataMap = Collections.singletonMap("key", (Object) "value");
MetaData metaData = MetaData.from(metaDataMap);
when(serializer.deserialize(serializedMetaData)).thenReturn(metaData);
EventMessage<Object> message =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
EventMessage<Object> message1 = message.andMetaData(MetaData.emptyInstance());
EventMessage<Object> message2 =
message.andMetaData(MetaData.from(Collections.singletonMap("key", (Object) "otherValue")));
assertEquals(1, message1.getMetaData().size());
assertEquals("value", message1.getMetaData().get("key"));
assertEquals(1, message2.getMetaData().size());
assertEquals("otherValue", message2.getMetaData().get("key"));
}
}
/**
* Initialize a new AggregateSnapshot for the given <code>aggregate</code>. Note that the
* aggregate may not contain uncommitted modifications.
*
* @param aggregate The aggregate containing the state to capture in the snapshot
* @throws IllegalArgumentException if the aggregate contains uncommitted modifications
*/
public AggregateSnapshot(T aggregate) {
this(aggregate, MetaData.emptyInstance());
}
@Override
public DomainEventMessage<T> withMetaData(Map<String, Object> newMetaDataEntries) {
return new AggregateSnapshot<T>(this, MetaData.from(newMetaDataEntries));
}
/**
* Apply the provided event. Applying events means they are added to the uncommitted event queue
* and forwarded to the {@link #handle(org.axonframework.domain.DomainEventMessage)} event handler
* method} for processing.
*
* <p>The event is applied on all entities part of this aggregate.
*
* @param eventPayload The payload of the event to apply
*/
protected void apply(Object eventPayload) {
apply(eventPayload, MetaData.emptyInstance());
}