Merge pull request #157 from binarymash/feature/#89-add-toggle-states…

…-projection

Feature/#89 add toggle states projection

build.cake

@@ -30,7 +30,7 @@ var netFrameworkUnitTestAssemblies = new []
 	@"./src/Evelyn.Storage.EventStore.Tests/bin/"+compileConfig+"/net461/Evelyn.Storage.EventStore.Tests.dll",
 };
 var openCoverSettings = new OpenCoverSettings();
-var minCodeCoverage =87d;
+var minCodeCoverage =89d;
 var coverallsRepoToken = "coveralls-repo-token-evelyn";
 
 // integration testing

src/Evelyn.Core.Tests/ReadModel/Projections/ToggleState/ProjectEvents/ToggleStateAddedSpecs.cs

@@ -0,0 +1,85 @@
+namespace Evelyn.Core.Tests.ReadModel.Projections.ToggleState.ProjectEvents
+{
+    using System.Linq;
+    using System.Threading.Tasks;
+    using AutoFixture;
+    using Evelyn.Core.WriteModel.Project.Events;
+    using FluentAssertions;
+    using TestStack.BDDfy;
+    using Xunit;
+    using Projections = Evelyn.Core.ReadModel.Projections;
+
+    public class ToggleStateAddedSpecs : ProjectionBuilderHarness<ToggleStateAdded>
+    {
+        [Fact]
+        public void ProjectionDoesNotExist()
+        {
+            this.Given(_ => GivenThereIsNoProjection())
+                .When(_ => WhenWeHandleAToggleStateAddedEvent())
+                .Then(_ => ThenTheProjectionIsCreatedWithTheNewToggleState())
+                .Then(_ => ThenTheProjectionAuditIsSet())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void Nominal()
+        {
+            this.Given(_ => GivenTheProjectionExists())
+                .And(_ => GivenTheProjectAlreadyHasAToggleState())
+                .When(_ => WhenWeHandleAToggleStateAddedEvent())
+                .Then(_ => ThenTheNewToggleStateIsAdded())
+                .And(_ => ThenTheProjectionAuditIsSet())
+                .BDDfy();
+        }
+
+        protected override async Task HandleEventImplementation()
+        {
+            await ProjectionBuilder.Handle(StreamPosition, Event, StoppingToken);
+        }
+
+        private void GivenTheProjectAlreadyHasAToggleState()
+        {
+            OriginalProjection.ToggleState.AddEnvironmentState(
+                DataFixture.Create<Projections.EventAudit>(),
+                DataFixture.Create<string>(),
+                DataFixture.Create<string>());
+        }
+
+        private async Task WhenWeHandleAToggleStateAddedEvent()
+        {
+            Event = DataFixture.Build<ToggleStateAdded>()
+                .With(pc => pc.Id, ProjectId)
+                .With(pc => pc.EnvironmentKey, EnvironmentKey)
+                .Create();
+
+            await WhenTheEventIsHandled();
+        }
+
+        private void ThenTheProjectionIsCreatedWithTheNewToggleState()
+        {
+            var environmentStates = UpdatedProjection.ToggleState.EnvironmentStates.ToList();
+            environmentStates.Count.Should().Be(1);
+
+            environmentStates.Should().Contain(ts =>
+                ts.Key == Event.EnvironmentKey &&
+                ts.Value == Event.Value);
+        }
+
+        private void ThenTheNewToggleStateIsAdded()
+        {
+            var environmentStates = UpdatedProjection.ToggleState.EnvironmentStates.ToList();
+            environmentStates.Count.Should().Be(OriginalProjection.ToggleState.EnvironmentStates.Count() + 1);
+
+            foreach (var environmentState in OriginalProjection.ToggleState.EnvironmentStates)
+            {
+                environmentStates.Should().Contain(ts =>
+                    ts.Key == environmentState.Key &&
+                    ts.Value == environmentState.Value);
+            }
+
+            environmentStates.Should().Contain(ts =>
+                ts.Key == Event.EnvironmentKey &&
+                ts.Value == Event.Value);
+        }
+    }
+}

src/Evelyn.Core.Tests/ReadModel/Projections/ToggleState/ProjectEvents/ToggleStateChangedSpecs.cs

@@ -0,0 +1,68 @@
+namespace Evelyn.Core.Tests.ReadModel.Projections.ToggleState.ProjectEvents
+{
+    using System.Linq;
+    using System.Threading.Tasks;
+    using AutoFixture;
+    using Evelyn.Core.WriteModel.Project.Events;
+    using FluentAssertions;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class ToggleStateChangedSpecs : ProjectionBuilderHarness<ToggleStateChanged>
+    {
+        [Fact]
+        public void ProjectionDoesNotExist()
+        {
+            this.Given(_ => GivenThereIsNoProjection())
+                .When(_ => WhenWeHandleAToggleStateChangedEvent())
+                .Then(_ => ThenAnExceptionIsThrown())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void Nominal()
+        {
+            this.Given(_ => GivenTheProjectionExists())
+                .And(_ => GivenOurToggleStateIsOnTheProjection())
+                .And(_ => GivenTheProjectionHasOtherToggleStates())
+                .When(_ => WhenWeHandleAToggleStateChangedEvent())
+                .Then(_ => ThenOurToggleStateIsChanged())
+                .And(_ => ThenTheProjectionAuditIsSet())
+                .BDDfy();
+        }
+
+        protected override async Task HandleEventImplementation()
+        {
+            await ProjectionBuilder.Handle(StreamPosition, Event, StoppingToken);
+        }
+
+        private async Task WhenWeHandleAToggleStateChangedEvent()
+        {
+            Event = DataFixture.Build<ToggleStateChanged>()
+                .With(pc => pc.Id, ProjectId)
+                .With(pc => pc.EnvironmentKey, EnvironmentKey)
+                .With(pc => pc.ToggleKey, ToggleKey)
+                .Create();
+
+            await WhenTheEventIsHandled();
+        }
+
+        private void ThenOurToggleStateIsChanged()
+        {
+            var updatedEnvironmentStates = UpdatedProjection.ToggleState.EnvironmentStates.ToList();
+            updatedEnvironmentStates.Count.Should().Be(OriginalProjection.ToggleState.EnvironmentStates.Count());
+
+            foreach (var originalEnvironmentState in OriginalProjection.ToggleState.EnvironmentStates)
+            {
+                var expectedEnvironmentStateValue =
+                    (originalEnvironmentState.Key == Event.EnvironmentKey)
+                    ? Event.Value
+                    : originalEnvironmentState.Value;
+
+                updatedEnvironmentStates.Should().Contain(ts =>
+                    ts.Key == originalEnvironmentState.Key &&
+                    ts.Value == expectedEnvironmentStateValue);
+            }
+        }
+    }
+}

src/Evelyn.Core.Tests/ReadModel/Projections/ToggleState/ProjectEvents/ToggleStateDeletedSpecs.cs

@@ -0,0 +1,83 @@
+namespace Evelyn.Core.Tests.ReadModel.Projections.ToggleState.ProjectEvents
+{
+    using System.Linq;
+    using System.Threading.Tasks;
+    using AutoFixture;
+    using Evelyn.Core.ReadModel.Projections.ToggleState;
+    using Evelyn.Core.WriteModel.Project.Events;
+    using FluentAssertions;
+    using NSubstitute;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class ToggleStateDeletedSpecs : ProjectionBuilderHarness<ToggleStateDeleted>
+    {
+        [Fact]
+        public void ProjectionDoesNotExist()
+        {
+            this.Given(_ => GivenThereIsNoProjection())
+                .When(_ => WhenWeHandleAToggleStateDeletedEvent())
+                .Then(_ => ThenAnExceptionIsThrown())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void MultipleToggleStatesExist()
+        {
+            this.Given(_ => GivenTheProjectionExists())
+                .And(_ => GivenOurToggleStateIsOnTheProjection())
+                .And(_ => GivenTheProjectionHasOtherToggleStates())
+                .When(_ => WhenWeHandleAToggleStateDeletedEvent())
+                .Then(_ => ThenOurToggleStateIsRemoved())
+                .And(_ => ThenTheProjectionAuditIsSet())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void LastToggleStateIsDeleted()
+        {
+            this.Given(_ => GivenTheProjectionExists())
+                .And(_ => GivenOurToggleStateIsOnTheProjection())
+                .When(_ => WhenWeHandleAToggleStateDeletedEvent())
+                .Then(_ => ThenTheProjectionIsDeleted())
+                .BDDfy();
+        }
+
+        protected override async Task HandleEventImplementation()
+        {
+            await ProjectionBuilder.Handle(StreamPosition, Event, StoppingToken);
+        }
+
+        private async Task WhenWeHandleAToggleStateDeletedEvent()
+        {
+            Event = DataFixture.Build<ToggleStateDeleted>()
+                .With(pc => pc.Id, ProjectId)
+                .With(pc => pc.EnvironmentKey, EnvironmentKey)
+                .With(pc => pc.ToggleKey, ToggleKey)
+                .Create();
+
+            await WhenTheEventIsHandled();
+        }
+
+        private void ThenOurToggleStateIsRemoved()
+        {
+            var updatedEnvironmentStates = UpdatedProjection.ToggleState.EnvironmentStates.ToList();
+            updatedEnvironmentStates.Count.Should().Be(OriginalProjection.ToggleState.EnvironmentStates.Count() - 1);
+
+            foreach (var originalEnvironmentState in OriginalProjection.ToggleState.EnvironmentStates)
+            {
+                if (originalEnvironmentState.Key != Event.EnvironmentKey)
+                {
+                    updatedEnvironmentStates.Should().Contain(ts =>
+                        ts.Key == originalEnvironmentState.Key &&
+                        ts.Value == originalEnvironmentState.Value);
+                }
+            }
+        }
+
+        private void ThenTheProjectionIsDeleted()
+        {
+            ProjectionStore.Received().Delete(Projection.StoreKey(ProjectId, EnvironmentKey));
+        }
+    }
+}

src/Evelyn.Core.Tests/ReadModel/Projections/ToggleState/ProjectionBuilderHarness.cs

@@ -0,0 +1,57 @@
+namespace Evelyn.Core.Tests.ReadModel.Projections.ToggleState
+{
+    using System;
+    using AutoFixture;
+    using Evelyn.Core.WriteModel;
+    using NSubstitute;
+    using Projections = Evelyn.Core.ReadModel.Projections;
+
+    public abstract class ProjectionBuilderHarness<TEvent> : ProjectionBuilderHarness<Projections.ToggleState.Projection, Projections.ToggleState.ProjectionBuilder, TEvent>
+        where TEvent : Event
+    {
+        public ProjectionBuilderHarness()
+        {
+            ProjectionBuilder = new Projections.ToggleState.ProjectionBuilder(ProjectionStore);
+        }
+
+        protected Guid ProjectId { get; set; }
+
+        protected string ToggleKey { get; private set; }
+
+        protected string EnvironmentKey { get; set; }
+
+        protected void GivenThereIsNoProjection()
+        {
+            ProjectId = DataFixture.Create<Guid>();
+            ToggleKey = DataFixture.Create<string>();
+
+            ProjectionStore.WhenForAnyArgs(ps => ps.Get(Arg.Any<string>()))
+                .Do(ci => throw new Evelyn.Core.ReadModel.ProjectionNotFoundException());
+        }
+
+        protected void GivenTheProjectionExists()
+        {
+            OriginalProjection = DataFixture.Create<Projections.ToggleState.Projection>();
+            ProjectId = DataFixture.Create<Guid>();
+            ToggleKey = DataFixture.Create<string>();
+        }
+
+        protected void GivenTheProjectionHasOtherToggleStates()
+        {
+            OriginalProjection.ToggleState.AddEnvironmentState(
+                DataFixture.Create<Projections.EventAudit>(),
+                DataFixture.Create<string>(),
+                DataFixture.Create<string>());
+        }
+
+        protected void GivenOurToggleStateIsOnTheProjection()
+        {
+            EnvironmentKey = DataFixture.Create<string>();
+
+            OriginalProjection.ToggleState.AddEnvironmentState(
+                DataFixture.Create<Projections.EventAudit>(),
+                EnvironmentKey,
+                DataFixture.Create<string>());
+        }
+    }
+}

src/Evelyn.Core.Tests/ReadModel/Projections/ToggleState/ProjectionSpecs.cs

@@ -0,0 +1,16 @@
+namespace Evelyn.Core.Tests.ReadModel.Projections.ToggleState
+{
+    using AutoFixture;
+    using Xunit;
+    using Projections = Core.ReadModel.Projections;
+
+    public class ProjectionSpecs : ProjectionHarness<Projections.ToggleState.Projection>
+    {
+        [Fact]
+        public void Serialization()
+        {
+            var dto = DataFixture.Create<Projections.ToggleState.Projection>();
+            AssertSerializationOf(dto);
+        }
+    }
+}

src/Evelyn.Core/DependencyInjection/ConfigureEventStreamHandlerOptions.cs

@@ -14,6 +14,7 @@ public void Configure(EventStreamHandlerOptions options)
                 typeof(Evelyn.Core.ReadModel.Projections.EnvironmentState.ProjectionBuilder),
                 typeof(Evelyn.Core.ReadModel.Projections.ProjectDetails.ProjectionBuilder),
                 typeof(Evelyn.Core.ReadModel.Projections.ToggleDetails.ProjectionBuilder),
+                typeof(Evelyn.Core.ReadModel.Projections.ToggleState.ProjectionBuilder),
                 typeof(Evelyn.Core.ReadModel.Projections.ClientEnvironmentState.ProjectionBuilder),
             });
         }

src/Evelyn.Core/DependencyInjection/InProcessHandlers.cs

@@ -31,6 +31,7 @@ public static void SynchronouslyInProcess(this EventPublisherOptions parentOptio
             parentOptions.Services.TryAddSingleton<Evelyn.Core.ReadModel.Projections.EnvironmentState.ProjectionBuilder>();
             parentOptions.Services.TryAddSingleton<Evelyn.Core.ReadModel.Projections.ProjectDetails.ProjectionBuilder>();
             parentOptions.Services.TryAddSingleton<Evelyn.Core.ReadModel.Projections.ToggleDetails.ProjectionBuilder>();
+            parentOptions.Services.TryAddSingleton<Evelyn.Core.ReadModel.Projections.ToggleState.ProjectionBuilder>();
             parentOptions.Services.TryAddSingleton<Evelyn.Core.ReadModel.Projections.ClientEnvironmentState.ProjectionBuilder>();
         }
     }

src/Evelyn.Core/ReadModel/DatabaseReadModelFacade.cs

@@ -7,15 +7,11 @@
     public class DatabaseReadModelFacade : IReadModelFacade
     {
         private readonly IProjectionStore<Projections.AccountProjects.Projection> _accountProjects;
-
         private readonly IProjectionStore<Projections.ProjectDetails.Projection> _projectDetails;
-
         private readonly IProjectionStore<Projections.EnvironmentDetails.Projection> _environmentDetails;
-
         private readonly IProjectionStore<Projections.ToggleDetails.Projection> _toggleDetails;
-
         private readonly IProjectionStore<Projections.EnvironmentState.Projection> _environmentStates;
-
+        private readonly IProjectionStore<Projections.ToggleState.Projection> _toggleStates;
         private readonly IProjectionStore<Projections.ClientEnvironmentState.Projection> _clientEnvironmentStates;
 
         public DatabaseReadModelFacade(
@@ -24,13 +20,15 @@ public class DatabaseReadModelFacade : IReadModelFacade
             IProjectionStore<Projections.EnvironmentDetails.Projection> environmentDetails,
             IProjectionStore<Projections.ToggleDetails.Projection> toggleDetails,
             IProjectionStore<Projections.EnvironmentState.Projection> environmentStates,
+            IProjectionStore<Projections.ToggleState.Projection> toggleStates,
             IProjectionStore<Projections.ClientEnvironmentState.Projection> clientEnvironmentStates)
         {
             _accountProjects = accountProjects;
             _projectDetails = projectDetails;
             _environmentDetails = environmentDetails;
             _toggleDetails = toggleDetails;
             _environmentStates = environmentStates;
+            _toggleStates = toggleStates;
             _clientEnvironmentStates = clientEnvironmentStates;
         }
 
@@ -59,6 +57,11 @@ public async Task<Projections.EnvironmentState.Projection> GetEnvironmentState(G
             return await _environmentStates.Get(Projections.EnvironmentState.Projection.StoreKey(projectId, environmentName));
         }
 
+        public async Task<Projections.ToggleState.Projection> GetToggleState(Guid projectId, string toggleKey)
+        {
+            return await _toggleStates.Get(Projections.ToggleState.Projection.StoreKey(projectId, toggleKey));
+        }
+
         public async Task<Projections.ClientEnvironmentState.Projection> GetClientEnvironmentState(Guid projectId, string environmentName)
         {
             return await _clientEnvironmentStates.Get(Projections.ClientEnvironmentState.Projection.StoreKey(projectId, environmentName));

src/Evelyn.Core/ReadModel/IReadModelFacade.cs

@@ -15,6 +15,8 @@ public interface IReadModelFacade
 
         Task<Projections.EnvironmentState.Projection> GetEnvironmentState(Guid projectId, string environmentName);
 
+        Task<Projections.ToggleState.Projection> GetToggleState(Guid projectId, string toggleKey);
+
         Task<Projections.ClientEnvironmentState.Projection> GetClientEnvironmentState(Guid projectId, string environmentName);
     }
 }