Examples of org.axonframework.domain.DomainEventMessage

org.axonframework.domain.DomainEventMessage
Represents a Message that wraps a DomainEvent and an Event representing an important change in the Domain. In contrast to a regular EventMessage, a DomainEventMessages contains the identifier of the Aggregate that reported it. The DomainEventMessage's sequence number allows Messages to be placed in their order of generation. @param < T> The type of payload contained in this Message @author Allard Buijze @since 2.0

        }


        @Override
        public DomainEventStream readEvents(String type, Object identifier) {
            loadCounter.incrementAndGet();
            DomainEventMessage message = storedEvents.get(identifier.toString());
            if (message == null) {
                throw new EventStreamNotFoundException(type, identifier);
            }
            return new SimpleDomainEventStream(Collections.singletonList(message));
        }

View Full Code Here

        if (expectedEvents.length != storedEvents.size()) {
            reporter.reportWrongEvent(storedEvents, Arrays.asList(expectedEvents), actualException);
        }
        Iterator<DomainEventMessage> iterator = storedEvents.iterator();
        for (Object expectedEvent : expectedEvents) {
            DomainEventMessage actualEvent = iterator.next();
            if (!verifyEventEquality(expectedEvent, actualEvent.getPayload())) {
                reporter.reportWrongEvent(storedEvents, Arrays.asList(expectedEvents), actualException);
            }
        }
        return this;
    }

View Full Code Here

    private class RecordingEventStore implements EventStore {


        @Override
        public void appendEvents(String type, DomainEventStream events) {
            while (events.hasNext()) {
                DomainEventMessage next = events.next();
                validateIdentifier(next.getAggregateIdentifier().getClass());
                if (!storedEvents.isEmpty()) {
                    DomainEventMessage lastEvent = storedEvents.peekLast();
                    if (!lastEvent.getAggregateIdentifier().equals(next.getAggregateIdentifier())) {
                        throw new EventStoreException("Writing events for an unexpected aggregate. This could "
                                                              + "indicate that a wrong aggregate is being triggered.");
                    } else if (lastEvent.getSequenceNumber() != next.getSequenceNumber() - 1) {
                        throw new EventStoreException(format("Unexpected sequence number on stored event. "
                                                                     + "Expected %s, but got %s.",
                                                             lastEvent.getSequenceNumber() + 1,
                                                             next.getSequenceNumber()));
                    }
                }
                if (aggregateIdentifier == null) {
                    aggregateIdentifier = next.getAggregateIdentifier();

View Full Code Here

        commandBus.dispatch(asCommandMessage("command"));


        verify(eventStore).appendEvents(eq("StubAggregate"), argThat(new TypeSafeMatcher<DomainEventStream>() {
            @Override
            public boolean matchesSafely(DomainEventStream item) {
                DomainEventMessage first = item.peek();
                return "data".equals(first.getMetaData().get("audit"));
            }


            @Override
            public void describeTo(Description description) {
                description.appendText("An event with audit data");

View Full Code Here

    public void testLoopBackKeepsProperEventOrder_PessimisticLocking() {
        initializeRepository(new PessimisticLockManager());
        EventListener el = new EventListener() {
            @Override
            public void handle(EventMessage event) {
                DomainEventMessage domainEvent = (DomainEventMessage) event;
                if (event.getPayload() instanceof CounterChangedEvent) {
                    CounterChangedEvent counterChangedEvent = (CounterChangedEvent) event.getPayload();
                    if (counterChangedEvent.getCounter() == 1) {
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 1)), reportErrorCallback);
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 2)), reportErrorCallback);
                    }
                }
            }
        };
        eventBus.subscribe(el);


        commandBus.dispatch(asCommandMessage(new ChangeCounterCommand(aggregateIdentifier, 1)), reportErrorCallback);


        DomainEventStream storedEvents = eventStore.readEvents("CountingAggregate", aggregateIdentifier);
        assertTrue(storedEvents.hasNext());
        while (storedEvents.hasNext()) {
            DomainEventMessage next = storedEvents.next();
            if (next.getPayload() instanceof CounterChangedEvent) {
                CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
                assertEquals(event.getCounter(), next.getSequenceNumber());
            }
        }


        verify(eventStore, times(3)).appendEvents(eq("CountingAggregate"), isA(DomainEventStream.class));
    }

View Full Code Here

    public void testLoopBackKeepsProperEventOrder_OptimisticLocking() throws Throwable {
        initializeRepository(new OptimisticLockManager());
        EventListener el = new EventListener() {
            @Override
            public void handle(EventMessage event) {
                DomainEventMessage domainEvent = (DomainEventMessage) event;
                if (event.getPayload() instanceof CounterChangedEvent) {
                    CounterChangedEvent counterChangedEvent = (CounterChangedEvent) event.getPayload();
                    if (counterChangedEvent.getCounter() == 1) {
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 1)), reportErrorCallback);
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 2)), reportErrorCallback);
                    }
                }
            }
        };
        eventBus.subscribe(el);


        commandBus.dispatch(asCommandMessage(new ChangeCounterCommand(aggregateIdentifier, 1)), reportErrorCallback);


        DomainEventStream storedEvents = eventStore.readEvents("CountingAggregate", aggregateIdentifier);
        assertTrue(storedEvents.hasNext());
        while (storedEvents.hasNext()) {
            DomainEventMessage next = storedEvents.next();
            if (next.getPayload() instanceof CounterChangedEvent) {
                CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
                assertEquals(event.getCounter(), next.getSequenceNumber());
            }
        }


        verify(eventStore, times(3)).appendEvents(eq("CountingAggregate"), isA(DomainEventStream.class));
    }

View Full Code Here

    public void testLoopBackKeepsProperEventOrder_OptimisticLocking_ProcessingFails() throws Throwable {
        initializeRepository(new OptimisticLockManager());
        EventListener el = new EventListener() {
            @Override
            public void handle(EventMessage event) {
                DomainEventMessage domainEvent = (DomainEventMessage) event;
                if (event.getPayload() instanceof CounterChangedEvent) {
                    CounterChangedEvent counterChangedEvent = (CounterChangedEvent) event.getPayload();
                    if (counterChangedEvent.getCounter() == 1) {
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 1)), reportErrorCallback);
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 2)),
                                            reportErrorCallback);
                    } else if (counterChangedEvent.getCounter() == 2) {
                        throw new RuntimeException("Mock exception");
                    }
                }
            }
        };
        eventBus.subscribe(el);


        commandBus.dispatch(asCommandMessage(new ChangeCounterCommand(aggregateIdentifier, 1)), expectErrorCallback);


        DomainEventStream storedEvents = eventStore.readEvents("CountingAggregate", aggregateIdentifier);
        assertTrue(storedEvents.hasNext());
        while (storedEvents.hasNext()) {
            DomainEventMessage next = storedEvents.next();
            if (next.getPayload() instanceof CounterChangedEvent) {
                CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
                assertEquals(event.getCounter(), next.getSequenceNumber());
            }
        }


        verify(eventStore, times(3)).appendEvents(eq("CountingAggregate"), isA(DomainEventStream.class));
    }

View Full Code Here

    public void testLoopBackKeepsProperEventOrder_PessimisticLocking_ProcessingFails() throws Throwable {
        initializeRepository(new PessimisticLockManager());
        EventListener el = new EventListener() {
            @Override
            public void handle(EventMessage event) {
                DomainEventMessage domainEvent = (DomainEventMessage) event;
                if (event.getPayload() instanceof CounterChangedEvent) {
                    CounterChangedEvent counterChangedEvent = (CounterChangedEvent) event.getPayload();
                    if (counterChangedEvent.getCounter() == 1) {
                        commandBus.dispatch(asCommandMessage(
                                new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                         counterChangedEvent.getCounter() + 1)),
                                            reportErrorCallback);
                        commandBus.dispatch(
                                asCommandMessage(new ChangeCounterCommand((UUID) domainEvent.getAggregateIdentifier(),
                                                                          counterChangedEvent.getCounter() + 2)),
                                reportErrorCallback);
                    } else if (counterChangedEvent.getCounter() == 2) {
                        throw new RuntimeException("Mock exception");
                    }
                }
            }
        };
        eventBus.subscribe(el);


        commandBus.dispatch(asCommandMessage(new ChangeCounterCommand(aggregateIdentifier, 1)), expectErrorCallback);


        DomainEventStream storedEvents = eventStore.readEvents("CountingAggregate", aggregateIdentifier);
        assertTrue(storedEvents.hasNext());
        while (storedEvents.hasNext()) {
            DomainEventMessage next = storedEvents.next();
            if (next.getPayload() instanceof CounterChangedEvent) {
                CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
                assertEquals(event.getCounter(), next.getSequenceNumber());
            }
        }


        verify(eventStore, times(3)).appendEvents(eq("CountingAggregate"), isA(DomainEventStream.class));
    }

View Full Code Here

        private Map<Object, List<DomainEventMessage>> store = new HashMap<Object, List<DomainEventMessage>>();


        @Override
        public void appendEvents(String identifier, DomainEventStream events) {
            while (events.hasNext()) {
                DomainEventMessage next = events.next();
                if (!store.containsKey(next.getAggregateIdentifier())) {
                    store.put(next.getAggregateIdentifier(), new ArrayList<DomainEventMessage>());
                }
                List<DomainEventMessage> eventList = store.get(next.getAggregateIdentifier());
                eventList.add(next);
            }
        }

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of org.axonframework.domain.DomainEventMessage

org.axonframework.auditing.AuditingInterceptorTest

org.axonframework.commandhandling.disruptor.DisruptorCommandBusTest

org.axonframework.commandhandling.disruptor.DisruptorCommandBusTest$InMemoryEventStore

org.axonframework.commandhandling.disruptor.DisruptorCommandBusTest_MultiThreaded$InMemoryEventStore

org.axonframework.contextsupport.spring.DisruptorContextConfigurationTest$InMemoryEventStore

org.axonframework.eventhandling.io.EventMessageWriter

org.axonframework.eventhandling.io.MessageStreamTest

org.axonframework.eventhandling.replay.ReplayingClusterTest

org.axonframework.eventsourcing.AbstractEventSourcedAggregateRoot

org.axonframework.eventsourcing.AbstractSnapshotter$CreateSnapshotTask

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.