예제 #1
0
        public async Task HandleAsync()
        {
            var message = (IEventMessage <Event2>)EventMessage.FromEvent(new Event2(), new Dictionary <string, string>());
            await sut.HandleAsync(message, CancellationToken.None);

            easyNetQBus.Received(1).PublishAsync <Event1>(message);
        }
예제 #2
0
        public void UpgradeSequenceNumbers_PreservesAggregateVersion()
        {
            var originalEvent1 = (IEventMessage <IEvent>)EventMessage.FromEvent(new TestEvent1(), new Dictionary <string, string>()
            {
                { BasicEventMetadataNames.StreamSequenceNumber, "1" },
                { BasicEventMetadataNames.AggregateVersion, "2" }
            });

            var events = new[]
            {
                (IEventMessage <DomainAggregateEvent>)UpgradedEventMessage.Create(originalEvent1, new TestEvent1()),
                (IEventMessage <DomainAggregateEvent>)UpgradedEventMessage.Create(originalEvent1, new TestEvent1())
            };

            var result = sut.UpgradeSequenceNumbers(events).ToArray();

            result.Should().HaveCount(2);
            result[0].Event.Should().Be(events[0].Event);
            result[0].Metadata.Should().Contain(new KeyValuePair <string, string>(BasicEventMetadataNames.StreamSequenceNumber, "1"));
            result[0].Metadata.Should().Contain(new KeyValuePair <string, string>(BasicEventMetadataNames.AggregateVersion, "2"));

            result[1].Event.Should().Be(events[1].Event);
            result[1].Metadata.Should().Contain(new KeyValuePair <string, string>(BasicEventMetadataNames.StreamSequenceNumber, "2"));
            result[1].Metadata.Should().Contain(new KeyValuePair <string, string>(BasicEventMetadataNames.AggregateVersion, "2"));
        }
        public void ConstructAndLoadEntityFromEvents_UpgradesEvents()
        {
            Guid entityId          = Guid.Parse("571BCB87-49C7-44AE-A96F-CEBA645A8E6D");
            var  eventStoreRecords = new List <IEventStoreRecord>()
            {
                new FakeEventStoreRecord()
                {
                    Event = new SetFooEvent()
                    {
                        AggregateId = entityId
                    },
                    StreamSequenceNumber = 1
                }
            };

            var upgradedMessages = new[]
            {
                (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(new SetFooEventV2()
                {
                    AggregateId = entityId
                },
                                                                             new Dictionary <string, string>()
                {
                    { BasicEventMetadataNames.StreamSequenceNumber, "1" }
                }),
                (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(new SetBarEvent()
                {
                    AggregateId = entityId
                },
                                                                             new Dictionary <string, string>()
                {
                    { BasicEventMetadataNames.StreamSequenceNumber, "2" }
                })
            };

            eventStreamUpgradeFunc = (events, metadata) =>
            {
                if (events.Count() == eventStoreRecords.Count &&
                    events.Select((x, i) => new { x, i }).All(x => x.x.Event == eventStoreRecords[x.i].Event))
                {
                    return(upgradedMessages);
                }

                return(events);
            };

            var result = sut.ConstructAndLoadEntityFromEvents(entityId,
                                                              new Dictionary <string, string>()
            {
                { AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
            },
                                                              eventStoreRecords);

            result.Should().BeOfType <MyEntity2>();
            var typedResult = (MyEntity2)result;

            typedResult.LoadedEvents.Should().Equal(upgradedMessages.Select(x => x.Event));
            typedResult.Version.Should().Be(1);
        }
예제 #4
0
        public async Task PublishAsync <TEvent>(IEventMessage <TEvent> message, Action <IPublishConfiguration> publishConfiguration) where TEvent : IEvent
        {
            if (!message.GetType().IsConstructedGenericType ||
                message.GetType().GetGenericTypeDefinition() != typeof(EventMessage <>))
            {
                message = (IEventMessage <TEvent>)EventMessage.FromEvent(message.Event, message.Metadata);
            }

            await bus.PublishAsync(message, publishConfiguration);
        }
예제 #5
0
        public async Task HandleMessage()
        {
            var eventMessage = EventMessage.FromEvent(new Event1(), new Dictionary <string, string>());

            var         prevTaskContext    = TaskContext.Current;
            TaskContext currentTaskContext = null;

            eventBus.When(x => x.PublishAsync(eventMessage)).Do(ci => currentTaskContext = TaskContext.Current);

            await sut.HandleMessage(eventMessage);

            eventBus.Received(1).PublishAsync(eventMessage);
            currentTaskContext.Should().NotBeNull();
            currentTaskContext.Should().NotBe(prevTaskContext);
        }
예제 #6
0
        public async Task CatchUpAsync()
        {
            var nondispatchedEvents = (await readRepository
                                       .Where <ExternalEventRecord>(x => !x.IsDispatchedToAsyncQueues)
                                       .ToListAsync(readRepository));

            if (nondispatchedEvents.Count > 0)
            {
                var messages = nondispatchedEvents.Select(x =>
                {
                    var @event = eventSerializer.DeserializeEvent(x.EventJson,
                                                                  new VersionedTypeId(x.EventName, x.EventVersion));
                    var metadata = eventSerializer.DeserializeEventMetadata(x.MetadataJson);
                    return(EventMessage.FromEvent(@event, metadata));
                });

                await asyncEventQueueDispatcher.DispatchToQueuesAsync(messages, null, null);
            }
        }
예제 #7
0
        public void UpgradeStream_RunsAllUpgrades()
        {
            IEventUpgrade[] eventUpgrades  = null;
            var             eventStream    = new[] { (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(Substitute.ForPartsOf <DomainAggregateEvent>(), null) };
            var             eventStream1   = new[] { (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(Substitute.ForPartsOf <DomainAggregateEvent>(), null) };
            var             eventStream2   = new[] { (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(Substitute.ForPartsOf <DomainAggregateEvent>(), null) };
            var             eventStream3   = new[] { (IEventMessage <DomainAggregateEvent>)EventMessage.FromEvent(Substitute.ForPartsOf <DomainAggregateEvent>(), null) };
            var             streamMetadata = new Dictionary <string, string>();

            Func <IEventUpgrade[]> eventUpgradesFunc = () =>
            {
                eventUpgrades = new[]
                {
                    Substitute.For <IEventUpgrade>(),
                    Substitute.For <IEventUpgrade>()
                };

                eventUpgrades[0].UpgradeStream(eventStream, streamMetadata).Returns(eventStream1);
                eventUpgrades[1].UpgradeStream(eventStream1, streamMetadata).Returns(eventStream2);

                return(eventUpgrades);
            };

            sequenceNumbersUpgrade.UpgradeSequenceNumbers(eventStream2).Returns(eventStream3);

            sut = new EventStreamUpgrader(eventUpgradesFunc, sequenceNumbersUpgrade);
            var result = sut.UpgradeStream(eventStream, streamMetadata);

            result.Should().BeSameAs(eventStream3);
        }