Decouple id types (#19)

Tomas Lycken · web-flow · commit d3bf1cef533d · 2017-10-04T10:46:58.000+02:00
* Add type argument for stream id

* Add tests for querying for events + adjust to genericity

* Increment next version
diff --git a/GitVersion.yml b/GitVersion.yml
@@ -1,5 +1,5 @@
 mode: ContinuousDelivery
-next-version: 0.2.0
+next-version: 0.3.0
 branches:
   master:
     tag: beta
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/EventStoreTests/QueryEventsTests.cs b/src/RdbmsEventStore.EntityFramework.Tests/EventStoreTests/QueryEventsTests.cs
@@ -0,0 +1,44 @@
+﻿using System.Linq;
+using System.Threading.Tasks;
+using RdbmsEventStore.EntityFramework.Tests.Infrastructure;
+using RdbmsEventStore.EntityFramework.Tests.TestData;
+using Xunit;
+
+namespace RdbmsEventStore.EntityFramework.Tests.EventStoreTests
+{
+    public class QueryEventsTests : EventStoreTestBase<long, string, LongStringEvent>
+    {
+        public QueryEventsTests(EventStoreFixture<long, string, LongStringEvent> fixture, AssemblyInitializerFixture initializer) : base(fixture, initializer)
+        {
+            _dbContext.Events.AddRange(_fixture.EventFactory.Create("stream-1", 0, 
+                new FooEvent{Foo = "Foo"},
+                new BarEvent{Bar = "Bar"},
+                new FooEvent{Foo = "Baz"}));
+            _dbContext.Events.AddRange(_fixture.EventFactory.Create("stream-2", 0,
+                new FooEvent {Foo = "Boo"},
+                new BarEvent {Bar = "Far"}));
+            _dbContext.SaveChanges();
+        }
+        
+        [Theory]
+        [InlineData("stream-1", 3)]
+        [InlineData("stream-2", 2)]
+        public async Task ReturnsEventsFromCorrectStreamOnly(string streamId, long expectedCount)
+        {
+            var store = _fixture.BuildEventStore(_dbContext);
+            var events = await store.Events(streamId);
+            Assert.Equal(expectedCount, events.Count());
+        }
+
+        [Theory]
+        [InlineData("stream-1", 2)]
+        [InlineData("stream-2", 1)]
+        public async Task ReturnsEventsAccordingToQuery(string streamId, long expectedCount)
+        {
+            var store = _fixture.BuildEventStore(_dbContext);
+            var events = await store.Events(streamId, es => es.Where(e => e.Type == "FooEvent"));
+            Assert.Equal(expectedCount, events.Count());
+        }
+
+    }
+}
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/EventStoreTests/WriteEventTests.cs b/src/RdbmsEventStore.EntityFramework.Tests/EventStoreTests/WriteEventTests.cs
@@ -9,9 +9,9 @@
 
 namespace RdbmsEventStore.EntityFramework.Tests.EventStoreTests
 {
-    public class WriteEventTests : EventStoreTestBase
+    public class WriteEventTests : EventStoreTestBase<Guid, Guid, GuidGuidEvent>
     {
-        public WriteEventTests(EventStoreFixture fixture, AssemblyInitializerFixture initializer) : base(fixture, initializer)
+        public WriteEventTests(EventStoreFixture<Guid, Guid, GuidGuidEvent> fixture, AssemblyInitializerFixture initializer) : base(fixture, initializer)
         {
         }
 
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/EventStoreFixture.cs b/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/EventStoreFixture.cs
@@ -1,25 +1,27 @@
 ﻿using System;
-using RdbmsEventStore.EntityFramework.Tests.TestData;
 using RdbmsEventStore.EventRegistry;
 
 namespace RdbmsEventStore.EntityFramework.Tests.Infrastructure
 {
-    public class EventStoreFixture
+    public class EventStoreFixture<TId, TStreamId, TEvent>
+        where TId : IEquatable<TId>
+        where TStreamId : IEquatable<TStreamId>
+        where TEvent : Event<TId, TStreamId>, new()
     {
         public EventStoreFixture()
         {
-            EventRegistry = new AssemblyEventRegistry(typeof(TestEvent), type => type.Name, type => !type.Name.StartsWith("<>"));
+            EventRegistry = new AssemblyEventRegistry(typeof(TEvent), type => type.Name, type => !type.Name.StartsWith("<>"));
             EventSerializer = new DefaultEventSerializer();
-            EventFactory = new DefaultEventFactory<Guid, TestEvent>(EventRegistry, EventSerializer);
+            EventFactory = new DefaultEventFactory<TId, TStreamId, TEvent>(EventRegistry, EventSerializer);
             WriteLock = new WriteLock();
         }
 
         public IEventRegistry EventRegistry { get; }
         public IEventSerializer EventSerializer { get; }
-        public IEventFactory<Guid, TestEvent> EventFactory { get; }
+        public DefaultEventFactory<TId, TStreamId, TEvent> EventFactory { get; }
         public IWriteLock WriteLock { get; }
 
-        public EntityFrameworkEventStore<Guid, EventStoreContext<TestEvent>, TestEvent> BuildEventStore(EventStoreContext<TestEvent> dbContext)
-            => new EntityFrameworkEventStore<Guid, EventStoreContext<TestEvent>, TestEvent>(dbContext, EventFactory, WriteLock);
+        public EntityFrameworkEventStore<TId, TStreamId, EventStoreContext<TEvent>, TEvent> BuildEventStore(EventStoreContext<TEvent> dbContext)
+            => new EntityFrameworkEventStore<TId, TStreamId, EventStoreContext<TEvent>, TEvent>(dbContext, EventFactory, WriteLock);
     }
 }
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/EventStoreTestBase.cs b/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/EventStoreTestBase.cs
@@ -1,22 +1,22 @@
 ﻿using System;
-using RdbmsEventStore.EntityFramework.Tests.TestData;
 using Xunit;
 
 namespace RdbmsEventStore.EntityFramework.Tests.Infrastructure
 {
     [Collection(nameof(InMemoryDatabaseCollection))]
-    public class EventStoreTestBase :
-        IClassFixture<EventStoreFixture>,
-        IDisposable
+    public class EventStoreTestBase<TId, TStreamId, TEvent> : IClassFixture<EventStoreFixture<TId, TStreamId, TEvent>>, IDisposable
+        where TId : IEquatable<TId>
+        where TStreamId : IEquatable<TStreamId>
+        where TEvent : Event<TId, TStreamId>, new()
     {
-        protected readonly EventStoreFixture _fixture;
-        protected readonly EventStoreContext<TestEvent> _dbContext;
+        protected readonly EventStoreFixture<TId, TStreamId, TEvent> _fixture;
+        protected readonly EventStoreContext<TEvent> _dbContext;
 
-        public EventStoreTestBase(EventStoreFixture fixture, AssemblyInitializerFixture initializer)
+        public EventStoreTestBase(EventStoreFixture<TId, TStreamId, TEvent> fixture, AssemblyInitializerFixture initializer)
         {
             EffortProviderFactory.ResetDb();
             _fixture = fixture;
-            _dbContext = new EventStoreContext<TestEvent>();
+            _dbContext = new EventStoreContext<TEvent>();
         }
 
         public void Dispose()
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/SmokeTest.cs b/src/RdbmsEventStore.EntityFramework.Tests/Infrastructure/SmokeTest.cs
@@ -1,10 +1,11 @@
-﻿using Xunit;
+﻿using RdbmsEventStore.EntityFramework.Tests.TestData;
+using Xunit;
 
 namespace RdbmsEventStore.EntityFramework.Tests.Infrastructure
 {
-    public class SmokeTest : EventStoreTestBase
+    public class SmokeTest : EventStoreTestBase<long, long, LongLongEvent>
     {
-        public SmokeTest(EventStoreFixture fixture, AssemblyInitializerFixture assemblyInitializer)
+        public SmokeTest(EventStoreFixture<long, long, LongLongEvent> fixture, AssemblyInitializerFixture assemblyInitializer)
             : base(fixture, assemblyInitializer)
         {
         }
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/TestData/EventTypes.cs b/src/RdbmsEventStore.EntityFramework.Tests/TestData/EventTypes.cs
@@ -0,0 +1,18 @@
+﻿using System;
+
+namespace RdbmsEventStore.EntityFramework.Tests.TestData
+{
+    public class GuidGuidEvent : Event<Guid, Guid> { }
+    public class LongStringEvent : Event<long, string> { }
+    public class LongLongEvent : Event<long, long> { }
+
+    public class FooEvent
+    {
+        public string Foo { get; set; }
+    }
+
+    public class BarEvent
+    {
+        public string Bar { get; set; }
+    }
+}
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/TestData/FooEvent.cs b/src/RdbmsEventStore.EntityFramework.Tests/TestData/FooEvent.cs
diff --git a/src/RdbmsEventStore.EntityFramework.Tests/TestData/TestEvent.cs b/src/RdbmsEventStore.EntityFramework.Tests/TestData/TestEvent.cs
diff --git a/src/RdbmsEventStore.EntityFramework/EntityFrameworkEventStore.cs b/src/RdbmsEventStore.EntityFramework/EntityFrameworkEventStore.cs
@@ -6,32 +6,33 @@
 
 namespace RdbmsEventStore.EntityFramework
 {
-    public class EntityFrameworkEventStore<TId, TContext, TEvent> : IEventStore<TId, TEvent>
+    public class EntityFrameworkEventStore<TId, TStreamId, TContext, TEvent> : IEventStore<TId, TStreamId, TEvent>
         where TId : IEquatable<TId>
+        where TStreamId : IEquatable<TStreamId>
         where TContext : DbContext, IEventDbContext<TEvent>
-        where TEvent : Event<TId>, IEvent<TId>, new()
+        where TEvent : Event<TId, TStreamId>, IEvent<TId, TStreamId>, new()
     {
         private readonly TContext context;
-        private readonly IEventFactory<TId, TEvent> _eventFactory;
+        private readonly IEventFactory<TId, TStreamId, TEvent> _eventFactory;
         private readonly IWriteLock _writeLock;
 
-        public EntityFrameworkEventStore(TContext context, IEventFactory<TId, TEvent> eventFactory, IWriteLock writeLock)
+        public EntityFrameworkEventStore(TContext context, IEventFactory<TId, TStreamId, TEvent> eventFactory, IWriteLock writeLock)
         {
             this.context = context;
             _eventFactory = eventFactory;
             _writeLock = writeLock;
         }
 
-        public Task<IEnumerable<TEvent>> Events(TId streamId) => Events(streamId, query => query);
+        public Task<IEnumerable<TEvent>> Events(TStreamId streamId) => Events(streamId, query => query);
 
-        public async Task<IEnumerable<TEvent>> Events(TId streamId, Func<IQueryable<TEvent>, IQueryable<TEvent>> query)
+        public async Task<IEnumerable<TEvent>> Events(TStreamId streamId, Func<IQueryable<TEvent>, IQueryable<TEvent>> query)
             => await context.Events
                 .Where(e => e.StreamId.Equals(streamId))
                 .Apply(query)
                 .AsNoTracking()
                 .ToListAsync();
 
-        public async Task Commit(TId streamId, long versionBefore, params object[] payloads)
+        public async Task Commit(TStreamId streamId, long versionBefore, params object[] payloads)
         {
             using (await _writeLock.Aquire())
             {
diff --git a/src/RdbmsEventStore.EntityFramework/Event.cs b/src/RdbmsEventStore.EntityFramework/Event.cs
@@ -4,7 +4,7 @@
 
 namespace RdbmsEventStore.EntityFramework
 {
-    public class Event<TId> : IEvent<TId>, IMutableEvent<TId>
+    public class Event<TId, TStreamId> : IEvent<TId, TStreamId>, IMutableEvent<TId, TStreamId>
     {
         [Key]
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
@@ -15,7 +15,7 @@ public class Event<TId> : IEvent<TId>, IMutableEvent<TId>
 
         [Index(Order = 1)]
         [Required]
-        public TId StreamId { get; set; }
+        public TStreamId StreamId { get; set; }
 
         [Required]
         [Index(Order = 2)]
diff --git a/src/RdbmsEventStore.Tests/EventCollectionTests.cs b/src/RdbmsEventStore.Tests/EventCollectionTests.cs
@@ -8,7 +8,7 @@ namespace RdbmsEventStore.Tests
 {
     public class EventCollectionTests
     {
-        private class TestEvent : IEvent<Guid>
+        private class TestEvent : IEvent<Guid, Guid>
         {
             public DateTimeOffset Timestamp { get; set; }
             public Guid EventId { get; set; }
@@ -29,12 +29,12 @@ private static TestEvent Factory(Guid stream, long version, object payload)
                 Payload = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload))
             };
 
-        private readonly EventCollection<Guid, TestEvent> _collection;
+        private readonly EventCollection<Guid, Guid, TestEvent> _collection;
 
         public EventCollectionTests()
         {
             var streamId = Guid.NewGuid();
-            _collection = new EventCollection<Guid, TestEvent>(streamId, 0, Factory, new { Foo = "Foo" }, new { Bar = "Bar" });
+            _collection = new EventCollection<Guid, Guid, TestEvent>(streamId, 0, Factory, new { Foo = "Foo" }, new { Bar = "Bar" });
         }
 
         [Fact]
diff --git a/src/RdbmsEventStore/DefaultEventFactory.cs b/src/RdbmsEventStore/DefaultEventFactory.cs
@@ -3,8 +3,8 @@
 
 namespace RdbmsEventStore
 {
-    public class DefaultEventFactory<TId, TEvent> : IEventFactory<TId, TEvent>
-        where TEvent : IMutableEvent<TId>, new()
+    public class DefaultEventFactory<TId, TStreamId, TEvent> : IEventFactory<TId, TStreamId, TEvent>
+        where TEvent : IMutableEvent<TId, TStreamId>, new()
     {
         private readonly IEventRegistry _registry;
         private readonly IEventSerializer _serializer;
@@ -15,12 +15,12 @@ public DefaultEventFactory(IEventRegistry registry, IEventSerializer serializer)
             _serializer = serializer;
         }
 
-        public virtual IEnumerable<TEvent> Create(TId streamId, long version, params object[] payloads)
+        public virtual IEnumerable<TEvent> Create(TStreamId streamId, long version, params object[] payloads)
         {
-            return new EventCollection<TId, TEvent>(streamId, version, CreateSingle, payloads);
+            return new EventCollection<TId, TStreamId, TEvent>(streamId, version, CreateSingle, payloads);
         }
 
-        protected virtual TEvent CreateSingle(TId streamId, long version, object payload)
+        protected virtual TEvent CreateSingle(TStreamId streamId, long version, object payload)
         {
             return new TEvent
             {
diff --git a/src/RdbmsEventStore/DefaultMaterializer.cs b/src/RdbmsEventStore/DefaultMaterializer.cs
@@ -16,7 +16,7 @@ public DefaultMaterializer(IEventRegistry registry, IEventSerializer serializer)
             _serializer = serializer;
         }
 
-        public TState Unfold<TState, TId>(TState initialState, IEnumerable<IEvent<TId>> events, Func<TState, object, TState> applicator)
+        public TState Unfold<TState, TId, TStreamId>(TState initialState, IEnumerable<IEvent<TId, TStreamId>> events, Func<TState, object, TState> applicator)
             => events
                 .Select(@event =>
                 {
diff --git a/src/RdbmsEventStore/EventCollection.cs b/src/RdbmsEventStore/EventCollection.cs
@@ -5,11 +5,11 @@
 
 namespace RdbmsEventStore
 {
-    public class EventCollection<TId, TEvent> : IEnumerable<TEvent> where TEvent : IEvent<TId>
+    public class EventCollection<TId, TStreamId, TEvent> : IEnumerable<TEvent> where TEvent : IEvent<TId, TStreamId>
     {
         private readonly IEnumerable<TEvent> _events;
 
-        public EventCollection(TId streamId, long currentVersion, Func<TId, long, object, TEvent> factory, params object[] payloads)
+        public EventCollection(TStreamId streamId, long currentVersion, Func<TStreamId, long, object, TEvent> factory, params object[] payloads)
         {
             _events = payloads.Select((payload, i) => factory(streamId, currentVersion + 1 + i, payload));
         }
diff --git a/src/RdbmsEventStore/IEvent.cs b/src/RdbmsEventStore/IEvent.cs
@@ -2,13 +2,13 @@
 
 namespace RdbmsEventStore
 {
-    public interface IEvent<out TId>
+    public interface IEvent<out TId, out TStreamId>
     {
         DateTimeOffset Timestamp { get; }
 
         TId EventId { get; }
 
-        TId StreamId { get; }
+        TStreamId StreamId { get; }
 
         long Version { get; }
 
@@ -17,13 +17,13 @@ public interface IEvent<out TId>
         byte[] Payload { get; }
     }
 
-    public interface IMutableEvent<TId> : IEvent<TId>
+    public interface IMutableEvent<TId, TStreamId> : IEvent<TId, TStreamId>
     {
         new DateTimeOffset Timestamp { get; set; }
 
         new TId EventId { get; set; }
 
-        new TId StreamId { get; set; }
+        new TStreamId StreamId { get; set; }
 
         new long Version { get; set; }
 
diff --git a/src/RdbmsEventStore/IEventFactory.cs b/src/RdbmsEventStore/IEventFactory.cs
@@ -2,8 +2,8 @@
 
 namespace RdbmsEventStore
 {
-    public interface IEventFactory<in TId, out TEvent> where TEvent : IEvent<TId>
+    public interface IEventFactory<in TId, in TStreamId, out TEvent> where TEvent : IEvent<TId, TStreamId>
     {
-        IEnumerable<TEvent> Create(TId streamId, long version, params object[] payloads);
+        IEnumerable<TEvent> Create(TStreamId streamId, long version, params object[] payloads);
     }
 }
diff --git a/src/RdbmsEventStore/IEventStore.cs b/src/RdbmsEventStore/IEventStore.cs
diff --git a/src/RdbmsEventStore/IMaterializer.cs b/src/RdbmsEventStore/IMaterializer.cs

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@`
`9`	`9`
`10`	`10`	`namespace RdbmsEventStore.EntityFramework.Tests.EventStoreTests`
`11`	`11`	`{`
`12`		`- public class WriteEventTests : EventStoreTestBase`
	`12`	`+ public class WriteEventTests : EventStoreTestBase<Guid, Guid, GuidGuidEvent>`
`13`	`13`	`{`
`14`		`- public WriteEventTests(EventStoreFixture fixture, AssemblyInitializerFixture initializer) : base(fixture, initializer)`
	`14`	`+ public WriteEventTests(EventStoreFixture<Guid, Guid, GuidGuidEvent> fixture, AssemblyInitializerFixture initializer) : base(fixture, initializer)`
`15`	`15`	`{`
`16`	`16`	`}`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,27 @@`
`1`	`1`	`using System;`
`2`		`-using RdbmsEventStore.EntityFramework.Tests.TestData;`
`3`	`2`	`using RdbmsEventStore.EventRegistry;`
`4`	`3`
`5`	`4`	`namespace RdbmsEventStore.EntityFramework.Tests.Infrastructure`
`6`	`5`	`{`
`7`		`- public class EventStoreFixture`
	`6`	`+ public class EventStoreFixture<TId, TStreamId, TEvent>`
	`7`	`+ where TId : IEquatable<TId>`
	`8`	`+ where TStreamId : IEquatable<TStreamId>`
	`9`	`+ where TEvent : Event<TId, TStreamId>, new()`
`8`	`10`	`{`
`9`	`11`	`public EventStoreFixture()`
`10`	`12`	`{`
`11`		`- EventRegistry = new AssemblyEventRegistry(typeof(TestEvent), type => type.Name, type => !type.Name.StartsWith("<>"));`
	`13`	`+ EventRegistry = new AssemblyEventRegistry(typeof(TEvent), type => type.Name, type => !type.Name.StartsWith("<>"));`
`12`	`14`	`EventSerializer = new DefaultEventSerializer();`
`13`		`- EventFactory = new DefaultEventFactory<Guid, TestEvent>(EventRegistry, EventSerializer);`
	`15`	`+ EventFactory = new DefaultEventFactory<TId, TStreamId, TEvent>(EventRegistry, EventSerializer);`
`14`	`16`	`WriteLock = new WriteLock();`
`15`	`17`	`}`
`16`	`18`
`17`	`19`	`public IEventRegistry EventRegistry { get; }`
`18`	`20`	`public IEventSerializer EventSerializer { get; }`
`19`		`- public IEventFactory<Guid, TestEvent> EventFactory { get; }`
	`21`	`+ public DefaultEventFactory<TId, TStreamId, TEvent> EventFactory { get; }`
`20`	`22`	`public IWriteLock WriteLock { get; }`
`21`	`23`
`22`		`- public EntityFrameworkEventStore<Guid, EventStoreContext<TestEvent>, TestEvent> BuildEventStore(EventStoreContext<TestEvent> dbContext)`
`23`		`- => new EntityFrameworkEventStore<Guid, EventStoreContext<TestEvent>, TestEvent>(dbContext, EventFactory, WriteLock);`
	`24`	`+ public EntityFrameworkEventStore<TId, TStreamId, EventStoreContext<TEvent>, TEvent> BuildEventStore(EventStoreContext<TEvent> dbContext)`
	`25`	`+ => new EntityFrameworkEventStore<TId, TStreamId, EventStoreContext<TEvent>, TEvent>(dbContext, EventFactory, WriteLock);`
`24`	`26`	`}`
`25`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`		`-using Xunit;`
	`1`	`+using RdbmsEventStore.EntityFramework.Tests.TestData;`
	`2`	`+using Xunit;`
`2`	`3`
`3`	`4`	`namespace RdbmsEventStore.EntityFramework.Tests.Infrastructure`
`4`	`5`	`{`
`5`		`- public class SmokeTest : EventStoreTestBase`
	`6`	`+ public class SmokeTest : EventStoreTestBase<long, long, LongLongEvent>`
`6`	`7`	`{`
`7`		`- public SmokeTest(EventStoreFixture fixture, AssemblyInitializerFixture assemblyInitializer)`
	`8`	`+ public SmokeTest(EventStoreFixture<long, long, LongLongEvent> fixture, AssemblyInitializerFixture assemblyInitializer)`
`8`	`9`	`: base(fixture, assemblyInitializer)`
`9`	`10`	`{`
`10`	`11`	`}`