Merge branch 'Events_replay'

# Conflicts:
#	GridDomain.Logging/DefaultLoggerConfiguration.cs

Author: andrey.leskov

GridDomain.CQRS.Messaging/MessageRouting/IMessagesRouter.cs

@@ -1,13 +1,26 @@
 using System;
 using System.Collections.Generic;
 using CommonDomain.Core;
+using GridDomain.EventSourcing;
 using GridDomain.EventSourcing.Sagas;
 using GridDomain.EventSourcing.Sagas.InstanceSagas;
 
 namespace GridDomain.CQRS.Messaging.MessageRouting
 {
 
-   
+    //class ReplayEnvelop
+    //{
+    //    public DomainEvent Message;
+    //    public Guid Id;
+    //}
+
+    //public interface IEventsReplayer
+    //{
+    //    void RegisterHandler<TMessage, THandler>(string correlationField) where THandler : IHandler<TMessage>;
+
+    //    void RegisterProjectionGroup<T>(T group) where T : IProjectionGroup;
+    //}
+
     public interface IMessagesRouter
     {
         [Obsolete("Use RegisterHandler instead")]

GridDomain.Domain.Tests/EventsUpgrade/BalanceChangedEventAdapter1.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain.Events;
+
+namespace GridDomain.Tests.Acceptance.EventsUpgrade.SampleDomain
+{
+    class BalanceChangedDomainEventAdapter1 : DomainEventAdapter<BalanceChangedEvent_V0, BalanceChangedEvent_V1>
+    {
+        public override IEnumerable<BalanceChangedEvent_V1> ConvertEvent(BalanceChangedEvent_V0 evt)
+        {
+            yield return new BalanceChangedEvent_V1(evt.AmplifiedAmountChange, evt.SourceId);
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Chain/EventUpdater1.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain;
+
+namespace GridDomain.Tests.EventsUpgrade
+{
+    class DomainEventUpdater1 : DomainEventAdapter<TestEvent, TestEvent_V1>
+    {
+        public override IEnumerable<TestEvent_V1> ConvertEvent(TestEvent evt)
+        {
+            yield return new TestEvent_V1(evt.SourceId) { Field2 = evt.Field };
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Chain/EventUpdater2.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain;
+
+namespace GridDomain.Tests.EventsUpgrade
+{
+    class DomainEventUpdater2 : DomainEventAdapter<TestEvent_V1, TestEvent_V2>
+    {
+        public override IEnumerable<TestEvent_V2> ConvertEvent(TestEvent_V1 evt)
+        {
+            yield return new TestEvent_V2(evt.SourceId) { Field3 = evt.Field2 };
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Chain/EventUpdater3.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain;
+
+namespace GridDomain.Tests.EventsUpgrade
+{
+    class DomainEventUpdater3 : DomainEventAdapter<TestEvent_V2, TestEvent_V3>
+    {
+        public override IEnumerable<TestEvent_V3> ConvertEvent(TestEvent_V2 evt)
+        {
+            yield return new TestEvent_V3(evt.SourceId) { Field4 = evt.Field3 };
+            yield return new TestEvent_V3(evt.SourceId) { Field4 = evt.Field3 };
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Chain/Given_DomainEventUpgradeChain_When_updating_events_split_Tests.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain;
+using NUnit.Framework;
+
+namespace GridDomain.Tests.EventsUpgrade
+{
+    [TestFixture]
+    public class Given_DomainEventUpgradeChain_When_updating_events_split_Tests
+    {
+        private IEnumerable<TestEvent_V3> _resultEvent;
+        private TestEvent_V2 _initialEvent;
+
+        [TestFixtureSetUp]
+        public void When_updating_single_event_Tests()
+        {
+            var chain = new EventAdaptersCatalog();
+            chain.Register(new DomainEventUpdater3());
+            var balanceAggregate = new BalanceAggregate(Guid.NewGuid(), 10);
+            _initialEvent = new TestEvent_V2(balanceAggregate.Id);
+            _resultEvent = chain.Update(_initialEvent).OfType<TestEvent_V3>();
+        }
+
+        [Then]
+        public void Events_type_was_updated()
+        {
+            Assert.IsInstanceOf<TestEvent_V3>(_resultEvent.FirstOrDefault());
+        }
+
+        [Then]
+        public void All_events_were_produced()
+        {
+            Assert.AreEqual(2, _resultEvent.Count());
+        }
+
+        [Then]
+        public void Event_id_was_remained()
+        {
+            Assert.True(_resultEvent.All(e => e.SourceId == _initialEvent.SourceId));
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Chain/Given_DomainEventUpgradeChain_When_updating_single_event_Tests.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Linq;
+using GridDomain.EventSourcing.VersionedTypeSerialization;
+using GridDomain.Tests.EventsUpgrade.Domain;
+using NUnit.Framework;
+
+namespace GridDomain.Tests.EventsUpgrade
+{
+    [TestFixture]
+    public class Given_DomainEventUpgradeChain_When_updating_single_event_Tests
+    {
+        private TestEvent_V2 _resultEvent;
+        private TestEvent _initialEvent;
+
+        [TestFixtureSetUp]
+        public void When_updating_single_event_Tests()
+        {
+            var chain = new EventAdaptersCatalog();
+            chain.Register(new DomainEventUpdater1());
+            chain.Register(new DomainEventUpdater2());
+
+            var balanceAggregate = new BalanceAggregate(Guid.NewGuid(), 10);
+            _initialEvent = new TestEvent(balanceAggregate.Id);
+            _resultEvent = chain.Update(_initialEvent).FirstOrDefault() as TestEvent_V2;
+        }
+
+        [Then]
+        public void Event_type_was_updated()
+        {
+            Assert.IsInstanceOf<TestEvent_V2>(_resultEvent);
+        }
+
+        [Then]
+        public void Event_id_was_remained()
+        {
+            Assert.AreEqual(_initialEvent.SourceId,_resultEvent.SourceId);
+        }
+
+        [Then]
+        public void Event_Field_was_remained()
+        {
+            Assert.AreEqual(_initialEvent.Field,_resultEvent.Field3);
+        }
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Domain/BalanceAggregate.cs

@@ -0,0 +1,38 @@
+using System;
+using GridDomain.EventSourcing.Sagas.FutureEvents;
+using GridDomain.Tests.EventsUpgrade.Domain.Events;
+
+namespace GridDomain.Tests.EventsUpgrade.Domain
+{
+    public class BalanceAggregate : Aggregate
+    {
+        private BalanceAggregate(Guid id) : base(id)
+        {
+            
+        }
+
+        public  BalanceAggregate(Guid id, decimal value):this(id)
+        {
+            RaiseEvent(new AggregateCreatedEvent(value,id));
+        }
+
+        public void ChangeState(int number)
+        {
+            RaiseEvent(new BalanceChangedEvent_V1(number, Id));
+        }
+
+        private void Apply(AggregateCreatedEvent e)
+        {
+            Id = e.SourceId;
+            Amount = e.Value;
+        }
+        
+        private void Apply(BalanceChangedEvent_V1 e)
+        {
+            Amount += e.AmountChange;
+        }
+
+        public decimal Amount;
+
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Domain/BalanceAggregatesCommandHandler.cs

@@ -0,0 +1,24 @@
+using System;
+using GridDomain.CQRS.Messaging.MessageRouting;
+using GridDomain.Tests.EventsUpgrade.Domain.Commands;
+
+namespace GridDomain.Tests.EventsUpgrade.Domain
+{
+    public class BalanceAggregatesCommandHandler: AggregateCommandsHandler<BalanceAggregate>,
+                                                        IAggregateCommandsHandlerDesriptor
+
+    {
+        //TODO: refactor to separate class
+        public static readonly IAggregateCommandsHandlerDesriptor Descriptor = new BalanceAggregatesCommandHandler();
+        public BalanceAggregatesCommandHandler() : base(null)
+        {
+            Map<ChangeBalanceCommand>(c => c.AggregateId,
+                                       (c, a) => a.ChangeState(c.Parameter));
+
+            Map<CreateBalanceCommand>(c => c.AggregateId,
+                                        c => new BalanceAggregate(c.AggregateId, c.Parameter));
+        }
+
+        public Type AggregateType => typeof(BalanceAggregate);
+    }
+}

GridDomain.Domain.Tests/EventsUpgrade/Domain/BalanceRouteMap.cs

@@ -0,0 +1,20 @@
+using GridDomain.CQRS.Messaging;
+using GridDomain.CQRS.Messaging.MessageRouting;
+using GridDomain.Tests.EventsUpgrade.Domain.Events;
+using GridDomain.Tests.EventsUpgrade.Domain.ProjectionBuilders;
+
+namespace GridDomain.Tests.EventsUpgrade.Domain
+{
+    public class BalanceRouteMap : IMessageRouteMap
+    {
+        public BalanceRouteMap()
+        {
+        }
+
+        public void Register(IMessagesRouter router)
+        {
+            router.RegisterAggregate(BalanceAggregatesCommandHandler.Descriptor);
+            router.RegisterHandler<BalanceChangedEvent_V0, SampleProjectionBuilder>(m => m.SourceId);
+        }
+    }
+}