Tweak database implementation and retrieval of project list

build.cake

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

src/Evelyn.Core.Tests/ReadModel/AccountProjects/AccountProjectsDtoSpecs.cs

@@ -0,0 +1,17 @@
+namespace Evelyn.Core.Tests.ReadModel.AccountProjects
+{
+    using AutoFixture;
+    using Core.ReadModel.AccountProjects;
+    using Xunit;
+
+    public class AccountProjectsDtoSpecs : DtoSpecs<AccountProjectsDto>
+    {
+        [Fact]
+        public void Serialization()
+        {
+            var accountProjects = DataFixture.Create<AccountProjectsDto>();
+
+            AssertSerializationOf(accountProjects);
+        }
+    }
+}

src/Evelyn.Core.Tests/ReadModel/ProjectList/ProjectListHandlerSpecs.cs → src/Evelyn.Core.Tests/ReadModel/AccountProjects/AccountProjectsHandlerSpecs.cs

@@ -1,31 +1,33 @@
-namespace Evelyn.Core.Tests.ReadModel.ProjectList
+namespace Evelyn.Core.Tests.ReadModel.AccountProjects
 {
     using System.Collections.Generic;
-    using System.Linq;
     using System.Threading.Tasks;
     using AutoFixture;
+    using Core.ReadModel.AccountProjects;
+    using Core.ReadModel.Events;
     using Core.ReadModel.ProjectList;
     using CQRSlite.Events;
     using CQRSlite.Routing;
-    using Evelyn.Core.ReadModel.Events;
     using FluentAssertions;
     using TestStack.BDDfy;
     using Xunit;
 
-    public class ProjectListHandlerSpecs : HandlerSpecs
+    public class AccountProjectsHandlerSpecs : HandlerSpecs
     {
-        private List<IEvent> _eventsProject1;
-        private List<IEvent> _eventsProject2;
+        private readonly List<IEvent> _eventsProject1;
+        private readonly List<IEvent> _eventsProject2;
+        private readonly string _accountId;
 
         private ProjectCreated _event1;
         private ProjectCreated _event2;
 
-        private List<ProjectListDto> _retrievedProjectList;
+        private AccountProjectsDto _retrievedAccountProjects;
 
-        public ProjectListHandlerSpecs()
+        public AccountProjectsHandlerSpecs()
         {
             _eventsProject1 = new List<IEvent>();
             _eventsProject2 = new List<IEvent>();
+            _accountId = DataFixture.Create<string>();
         }
 
         [Fact]
@@ -49,52 +51,56 @@ public void MultipleProjectsCreated()
 
         protected override void RegisterHandlers(Router router)
         {
-            var handler = new ProjectListHandler(ProjectsStore);
+            var handler = new AccountProjectsHandler(AccountProjectsStore);
             router.RegisterHandler<ProjectCreated>(handler.Handle);
         }
 
         private void GivenAnProjectIsCreated()
         {
-            _event1 = DataFixture.Create<ProjectCreated>();
-            _event1.Version = _eventsProject1.Count + 1;
+            _event1 = DataFixture.Build<ProjectCreated>()
+                .With(pc => pc.AccountId, _accountId)
+                .With(pc => pc.Version, _eventsProject1.Count + 1)
+                .Create();
 
             _eventsProject1.Add(_event1);
             GivenWePublish(_event1);
         }
 
         private void GivenAnotherProjectIsCreated()
         {
-            _event2 = DataFixture.Create<ProjectCreated>();
-            _event2.Version = _eventsProject2.Count + 1;
+            _event2 = DataFixture.Build<ProjectCreated>()
+                .With(pc => pc.AccountId, _accountId)
+                .With(pc => pc.Version, _eventsProject2.Count + 1)
+                .Create();
 
             _eventsProject2.Add(_event2);
             GivenWePublish(_event2);
         }
 
         private async Task WhenWeGetTheProjectList()
         {
-            _retrievedProjectList = (await ReadModelFacade.GetProjects()).ToList();
+            _retrievedAccountProjects = await ReadModelFacade.GetProjects(_accountId);
         }
 
         private void ThenTheProjectIsAddedToTheProjectList()
         {
-            _retrievedProjectList.Count.Should().Be(1);
+            _retrievedAccountProjects.Projects.Count.Should().Be(1);
             ThenThereIsAnProjectInTheListFor(_event1);
         }
 
         private void ThenBothProjectsAreInTheProjectList()
         {
-            _retrievedProjectList.Count().Should().Be(2);
+            _retrievedAccountProjects.Projects.Count.Should().Be(2);
 
             ThenThereIsAnProjectInTheListFor(_event1);
             ThenThereIsAnProjectInTheListFor(_event2);
         }
 
         private void ThenThereIsAnProjectInTheListFor(ProjectCreated ev)
         {
-            ProjectsStore.Get().GetAwaiter().GetResult().Should().Contain(project =>
-                project.Id == ev.Id &&
-                project.Name == ev.Name);
+            AccountProjectsStore.Get(_accountId)
+                .GetAwaiter().GetResult()
+                .Projects[ev.Id].Name.Should().Be(ev.Name);
         }
     }
 }

src/Evelyn.Core.Tests/ReadModel/HandlerSpecs.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using AutoFixture;
+    using Core.ReadModel.AccountProjects;
     using Core.ReadModel.ProjectDetails;
     using Core.ReadModel.ProjectList;
     using Core.ReadModel.ToggleDetails;
@@ -19,13 +20,13 @@ protected HandlerSpecs()
         {
             DataFixture = new Fixture();
 
-            ProjectsStore = new InMemoryDatabase<ProjectListDto>();
-            ProjectDetailsStore = new InMemoryDatabase<ProjectDetailsDto>();
-            EnvironmentDetailsStore = new InMemoryDatabase<EnvironmentDetailsDto>();
-            ToggleDetailsStore = new InMemoryDatabase<ToggleDetailsDto>();
+            AccountProjectsStore = new InMemoryDatabase<string, AccountProjectsDto>();
+            ProjectDetailsStore = new InMemoryDatabase<Guid, ProjectDetailsDto>();
+            EnvironmentDetailsStore = new InMemoryDatabase<Guid, EnvironmentDetailsDto>();
+            ToggleDetailsStore = new InMemoryDatabase<Guid, ToggleDetailsDto>();
 
             ReadModelFacade = new DatabaseReadModelFacade(
-                ProjectsStore,
+                AccountProjectsStore,
                 ProjectDetailsStore,
                 EnvironmentDetailsStore,
                 ToggleDetailsStore);
@@ -39,13 +40,13 @@ protected HandlerSpecs()
 
         protected IReadModelFacade ReadModelFacade { get; }
 
-        protected IDatabase<ProjectListDto> ProjectsStore { get; }
+        protected IDatabase<string, AccountProjectsDto> AccountProjectsStore { get; }
 
-        protected IDatabase<ProjectDetailsDto> ProjectDetailsStore { get; }
+        protected IDatabase<Guid, ProjectDetailsDto> ProjectDetailsStore { get; }
 
-        protected IDatabase<EnvironmentDetailsDto> EnvironmentDetailsStore { get; set; }
+        protected IDatabase<Guid, EnvironmentDetailsDto> EnvironmentDetailsStore { get; set; }
 
-        protected IDatabase<ToggleDetailsDto> ToggleDetailsStore { get; set; }
+        protected IDatabase<Guid, ToggleDetailsDto> ToggleDetailsStore { get; set; }
 
         protected Exception ThrownException { get; set; }
 

src/Evelyn.Core/DependencyInjection/ConfigureInProcessHandlerOptions.cs

@@ -16,7 +16,7 @@ public void Configure(HandlerOptions options)
             {
                 typeof(ProjectCommandHandler),
                 typeof(ProjectDetailsHandler),
-                typeof(ProjectListHandler),
+                typeof(AccountProjectsHandler),
                 typeof(EnvironmentDetailsHandler),
                 typeof(ToggleDetailsHandler)
             });

src/Evelyn.Core/DependencyInjection/InMemoryReadCache.cs

@@ -14,7 +14,7 @@ public static class InMemoryReadCache
         public static void InMemoryCache(this ReadModelCacheOptions parentOptions)
 #pragma warning restore SA1614 // Element parameter documentation must have text
         {
-            parentOptions.Services.TryAddSingleton(typeof(IDatabase<>), typeof(InMemoryDatabase<>));
+            parentOptions.Services.TryAddSingleton(typeof(IDatabase<,>), typeof(InMemoryDatabase<,>));
         }
     }
 }

src/Evelyn.Core/DependencyInjection/InProcessHandlers.cs

@@ -22,7 +22,7 @@ public static void SynchronouslyInProcess(this EventPublisherOptions parentOptio
 #pragma warning restore SA1614 // Element parameter documentation must have text
         {
             parentOptions.Services.TryAddSingleton<ProjectDetailsHandler>();
-            parentOptions.Services.TryAddSingleton<ProjectListHandler>();
+            parentOptions.Services.TryAddSingleton<AccountProjectsHandler>();
             parentOptions.Services.TryAddSingleton<EnvironmentDetailsHandler>();
             parentOptions.Services.TryAddSingleton<ToggleDetailsHandler>();
 

src/Evelyn.Core/ReadModel/AccountProjects/AccountProjectsDto.cs

@@ -0,0 +1,19 @@
+namespace Evelyn.Core.ReadModel.AccountProjects
+{
+    using System;
+    using System.Collections.Generic;
+    using ProjectList;
+
+    public class AccountProjectsDto
+    {
+        public AccountProjectsDto(string accountId)
+        {
+            AccountId = accountId;
+            Projects = new Dictionary<Guid, ProjectListDto>();
+        }
+
+        public string AccountId { get; private set; }
+
+        public Dictionary<Guid, ProjectListDto> Projects { get; private set; }
+    }
+}

src/Evelyn.Core/ReadModel/AccountProjects/AccountProjectsHandler.cs

@@ -0,0 +1,36 @@
+namespace Evelyn.Core.ReadModel.ProjectList
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using CQRSlite.Events;
+    using Evelyn.Core.ReadModel.AccountProjects;
+    using Events;
+    using Infrastructure;
+
+    public class AccountProjectsHandler
+        : ICancellableEventHandler<ProjectCreated>
+    {
+        private readonly IDatabase<string, AccountProjectsDto> _db;
+
+        public AccountProjectsHandler(IDatabase<string, AccountProjectsDto> db)
+        {
+            _db = db;
+        }
+
+        public async Task Handle(ProjectCreated message, CancellationToken token)
+        {
+            AccountProjectsDto accountProjects;
+            try
+            {
+                accountProjects = await _db.Get(message.AccountId);
+            }
+            catch (NotFoundException)
+            {
+                accountProjects = new AccountProjectsDto(message.AccountId);
+            }
+
+            accountProjects.Projects.Add(message.Id, new ProjectListDto(message.Id, message.Name));
+            await _db.AddOrUpdate(accountProjects.AccountId, accountProjects);
+        }
+    }
+}

src/Evelyn.Core/ReadModel/ProjectList/ProjectListDto.cs → src/Evelyn.Core/ReadModel/AccountProjects/ProjectListDto.cs

@@ -10,8 +10,8 @@ public ProjectListDto(Guid id, string name)
             Name = name;
         }
 
-        public Guid Id { get; }
+        public Guid Id { get; private set; }
 
-        public string Name { get; }
+        public string Name { get; private set; }
     }
 }

src/Evelyn.Core/ReadModel/DatabaseReadModelFacade.cs

@@ -1,39 +1,46 @@
 namespace Evelyn.Core.ReadModel
 {
     using System;
-    using System.Collections.Generic;
     using System.Threading.Tasks;
+    using AccountProjects;
     using Evelyn.Core.ReadModel.EnvironmentDetails;
     using Evelyn.Core.ReadModel.Infrastructure;
     using Evelyn.Core.ReadModel.ToggleDetails;
     using ProjectDetails;
-    using ProjectList;
 
     public class DatabaseReadModelFacade : IReadModelFacade
     {
-        private readonly IDatabase<ProjectListDto> _projects;
+        private readonly IDatabase<string, AccountProjectsDto> _accountProjects;
 
-        private readonly IDatabase<ProjectDetailsDto> _projectDetails;
+        private readonly IDatabase<Guid, ProjectDetailsDto> _projectDetails;
 
-        private readonly IDatabase<EnvironmentDetailsDto> _environmentDetails;
+        private readonly IDatabase<Guid, EnvironmentDetailsDto> _environmentDetails;
 
-        private readonly IDatabase<ToggleDetailsDto> _toggleDetails;
+        private readonly IDatabase<Guid, ToggleDetailsDto> _toggleDetails;
 
         public DatabaseReadModelFacade(
-            IDatabase<ProjectListDto> projects,
-            IDatabase<ProjectDetailsDto> projectDetails,
-            IDatabase<EnvironmentDetailsDto> environmentDetails,
-            IDatabase<ToggleDetailsDto> toggleDetails)
+            IDatabase<string, AccountProjectsDto> accountProjects,
+            IDatabase<Guid, ProjectDetailsDto> projectDetails,
+            IDatabase<Guid, EnvironmentDetailsDto> environmentDetails,
+            IDatabase<Guid, ToggleDetailsDto> toggleDetails)
         {
-            _projects = projects;
+            _accountProjects = accountProjects;
             _projectDetails = projectDetails;
             _environmentDetails = environmentDetails;
             _toggleDetails = toggleDetails;
         }
 
-        public async Task<IEnumerable<ProjectListDto>> GetProjects()
+        public async Task<AccountProjectsDto> GetProjects(string accountId)
         {
-            return await _projects.Get();
+            try
+            {
+                return await _accountProjects.Get(accountId);
+            }
+            catch (NotFoundException)
+            {
+                // hack! Remove this
+                return new AccountProjectsDto(accountId);
+            }
         }
 
         public async Task<ProjectDetailsDto> GetProjectDetails(Guid projectId)

src/Evelyn.Core/ReadModel/EnvironmentDetails/EnvironmentDetailsHandler.cs

@@ -1,5 +1,6 @@
 namespace Evelyn.Core.ReadModel.EnvironmentDetails
 {
+    using System;
     using System.Threading;
     using System.Threading.Tasks;
     using CQRSlite.Events;
@@ -9,16 +10,16 @@
     public class EnvironmentDetailsHandler
         : ICancellableEventHandler<EnvironmentAdded>
     {
-        private readonly IDatabase<EnvironmentDetailsDto> _environments;
+        private readonly IDatabase<Guid, EnvironmentDetailsDto> _db;
 
-        public EnvironmentDetailsHandler(IDatabase<EnvironmentDetailsDto> environments)
+        public EnvironmentDetailsHandler(IDatabase<Guid, EnvironmentDetailsDto> db)
         {
-            _environments = environments;
+            _db = db;
         }
 
         public Task Handle(EnvironmentAdded message, CancellationToken token)
         {
-            _environments.Add(message.EnvironmentId, new EnvironmentDetailsDto(message.Id, message.EnvironmentId, message.Name, message.TimeStamp));
+            _db.AddOrUpdate(message.EnvironmentId, new EnvironmentDetailsDto(message.Id, message.EnvironmentId, message.Name, message.TimeStamp));
             return Task.CompletedTask;
         }
     }