Test

src/Squidex.Infrastructure/TypeNameRegistry.cs

@@ -10,6 +10,8 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 
+// ReSharper disable InvertIf
+
 namespace Squidex.Infrastructure
 {
     public sealed class TypeNameRegistry
@@ -17,7 +19,7 @@ namespace Squidex.Infrastructure
         private readonly Dictionary<Type, string> namesByType = new Dictionary<Type, string>();
         private readonly Dictionary<string, Type> typesByName = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
 
-        public void Map(Type type)
+        public TypeNameRegistry Map(Type type)
         {
             Guard.NotNull(type, nameof(type));
 
@@ -27,9 +29,11 @@ namespace Squidex.Infrastructure
             {
                 Map(type, typeNameAttribute.TypeName);
             }
+
+            return this;
         }
 
-        public void Map(Type type, string name)
+        public TypeNameRegistry Map(Type type, string name)
         {
             Guard.NotNull(type, nameof(type));
             Guard.NotNull(name, nameof(name));
@@ -64,9 +68,11 @@ namespace Squidex.Infrastructure
                     }
                 }
             }
+
+            return this;
         }
 
-        public void Map(Assembly assembly)
+        public TypeNameRegistry Map(Assembly assembly)
         {
             foreach (var type in assembly.GetTypes())
             {
@@ -77,6 +83,8 @@ namespace Squidex.Infrastructure
                     Map(type, typeNameAttribute.TypeName);
                 }
             }
+
+            return this;
         }
 
         public string GetName<T>()

src/Squidex.Write/Schemas/SchemaDomainObject.cs

@@ -55,6 +55,8 @@ namespace Squidex.Write.Schemas
 
         protected void On(SchemaCreated @event)
         {
+            totalFields += @event?.Fields.Count ?? 0;
+
             schema = SchemaEventDispatcher.Dispatch(@event, registry);
         }
 

tests/Benchmarks/Program.cs

@@ -19,12 +19,13 @@ namespace Benchmarks
         private static readonly List<IBenchmark> Benchmarks = new List<IBenchmark>
         {
             new AppendToEventStore(),
-            new AppendToEventStoreParallel()
+            new AppendToEventStoreParallel(),
+            new HandleEvents()
         };
 
         public static void Main(string[] args)
         {
-            var id = args.Length > 0 ? args[0] : string.Empty;
+            var id = args.Length > 0 ? args[0] : "handleEvents";
 
             var benchmark = Benchmarks.Find(x => x.Id == id);
 
@@ -70,10 +71,10 @@ namespace Benchmarks
                         }
                     }
 
-                    var totalElapsed = TimeSpan.FromMilliseconds(elapsed);
+                    var averageElapsed = TimeSpan.FromMilliseconds(elapsed / numRuns);
-                    var totalPerSecond = Math.Round(count / totalElapsed.TotalSeconds, 2);
+                    var averageSeconds = Math.Round(count / (numRuns * averageElapsed.TotalSeconds), 2);
 
-                    Console.WriteLine($"{benchmark.Name} completed after {totalElapsed}, {totalPerSecond} items/s");
+                    Console.WriteLine($"{benchmark.Name} completed after {averageElapsed}, {averageSeconds} items/s");
                 }
                 catch (Exception e)
                 {

tests/Benchmarks/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "Benchmarks": {
       "commandName": "Project",
-      "commandLineArgs": "appendToEventStoreParallel"
+      "commandLineArgs": "handleEvents"
     }
   }
 }

tests/Benchmarks/Tests/AppendToEventStore.cs

@@ -19,6 +19,7 @@ namespace Benchmarks.Tests
     {
         private IMongoClient mongoClient;
         private IMongoDatabase mongoDatabase;
+        private IEventStore eventStore;
 
         public string Id
         {
@@ -38,6 +39,8 @@ namespace Benchmarks.Tests
         public void RunInitialize()
         {
             mongoDatabase = mongoClient.GetDatabase(Guid.NewGuid().ToString());
+
+            eventStore = new MongoEventStore(mongoDatabase, new DefaultEventNotifier(new InMemoryPubSub()));
         }
 
         public long Run()
@@ -45,8 +48,6 @@ namespace Benchmarks.Tests
             const long numCommits = 200;
             const long eventStreams = 10;
 
-            var eventStore = new MongoEventStore(mongoDatabase, new DefaultEventNotifier(new InMemoryPubSub()));
-
             for (var streamId = 0; streamId < eventStreams; streamId++)
             {
                 var eventOffset = -1;

tests/Benchmarks/Tests/AppendToEventStoreParallel.cs

@@ -20,6 +20,7 @@ namespace Benchmarks.Tests
     {
         private IMongoClient mongoClient;
         private IMongoDatabase mongoDatabase;
+        private IEventStore eventStore;
 
         public string Id
         {
@@ -39,6 +40,8 @@ namespace Benchmarks.Tests
         public void RunInitialize()
         {
             mongoDatabase = mongoClient.GetDatabase(Guid.NewGuid().ToString());
+
+            eventStore = new MongoEventStore(mongoDatabase, new DefaultEventNotifier(new InMemoryPubSub()));
         }
 
         public long Run()
@@ -46,8 +49,6 @@ namespace Benchmarks.Tests
             const long numCommits = 200;
             const long eventStreams = 10;
 
-            var eventStore = new MongoEventStore(mongoDatabase, new DefaultEventNotifier(new InMemoryPubSub()));
-
             Parallel.For(0, eventStreams, streamId =>
             {
                 var eventOffset = -1;

tests/Benchmarks/Tests/HandleEvents.cs

@@ -0,0 +1,173 @@
+// ==========================================================================
+//  HandleEvents.cs
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex Group
+//  All rights reserved.
+// ==========================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MongoDB.Driver;
+using Newtonsoft.Json;
+using Squidex.Infrastructure;
+using Squidex.Infrastructure.CQRS.Events;
+using Squidex.Infrastructure.Json;
+using Squidex.Infrastructure.Log;
+using Squidex.Infrastructure.MongoDb;
+using Squidex.Infrastructure.MongoDb.EventStore;
+using Squidex.Infrastructure.Tasks;
+
+// ReSharper disable InvertIf
+
+namespace Benchmarks.Tests
+{
+    public sealed class HandleEvents : IBenchmark
+    {
+        [TypeName("MyEvent")]
+        public sealed class MyEvent : IEvent
+        {
+            public int EventNumber { get; set; }
+        }
+
+        public sealed class MyEventConsumer : IEventConsumer
+        {
+            private readonly TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
+            private readonly int numEvents;
+
+            public List<int> EventNumbers { get; } = new List<int>();
+
+            public string Name
+            {
+                get { return typeof(MyEventConsumer).Name; }
+            }
+
+            public string EventsFilter
+            {
+                get { return string.Empty; }
+            }
+
+            public MyEventConsumer(int numEvents)
+            {
+                this.numEvents = numEvents;
+            }
+
+            public Task ClearAsync()
+            {
+                return TaskHelper.Done;
+            }
+
+            public void Wait()
+            {
+                completion.Task.Wait();
+            }
+
+            public Task On(Envelope<IEvent> @event)
+            {
+                if (@event.Payload is MyEvent myEvent)
+                {
+                    EventNumbers.Add(myEvent.EventNumber);
+
+                    if (myEvent.EventNumber == numEvents)
+                    {
+                        completion.SetResult(true);
+                    }
+                }
+
+                return TaskHelper.Done;
+            }
+        }
+
+        private readonly TypeNameRegistry typeNameRegistry = new TypeNameRegistry().Map(typeof(MyEvent));
+        private readonly EventDataFormatter formatter;
+        private readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings();
+        private const int NumEvents = 1000;
+        private IMongoClient mongoClient;
+        private IMongoDatabase mongoDatabase;
+        private IEventStore eventStore;
+        private IEventNotifier eventNotifier;
+        private IEventConsumerInfoRepository eventConsumerInfos;
+        private EventReceiver eventReceiver;
+        private MyEventConsumer eventConsumer;
+
+        public string Id
+        {
+            get { return "handleEvents"; }
+        }
+
+        public string Name
+        {
+            get { return "HandleEvents"; }
+        }
+
+        public HandleEvents()
+        {
+            serializerSettings.Converters.Add(new PropertiesBagConverter());
+
+            formatter = new EventDataFormatter(typeNameRegistry, serializerSettings);
+        }
+
+        public void Initialize()
+        {
+            mongoClient = new MongoClient("mongodb://localhost");
+        }
+
+        public void RunInitialize()
+        {
+            mongoDatabase = mongoClient.GetDatabase(Guid.NewGuid().ToString());
+
+            var log = new SemanticLog(new ILogChannel[0], new ILogAppender[0], () => new JsonLogWriter(Formatting.Indented, true));
+
+            eventConsumerInfos = new MongoEventConsumerInfoRepository(mongoDatabase);
+            eventNotifier = new DefaultEventNotifier(new InMemoryPubSub());
+            eventStore = new MongoEventStore(mongoDatabase, eventNotifier);
+            eventConsumer = new MyEventConsumer(NumEvents);
+
+            eventReceiver = new EventReceiver(formatter, eventStore, eventNotifier, eventConsumerInfos, log);
+            eventReceiver.Subscribe(eventConsumer);
+        }
+
+        public long Run()
+        {
+            var streamName = Guid.NewGuid().ToString();
+
+            for (var eventId = 0; eventId < NumEvents; eventId++)
+            {
+                var eventData = formatter.ToEventData(new Envelope<IEvent>(new MyEvent { EventNumber = eventId + 1 }), Guid.NewGuid());
+
+                eventStore.AppendEventsAsync(Guid.NewGuid(), streamName, eventId - 1, new [] { eventData }).Wait();
+            }
+
+            eventConsumer.Wait();
+
+            if (eventConsumer.EventNumbers.Count != NumEvents)
+            {
+                throw new InvalidOperationException($"Only {eventConsumer.EventNumbers.Count} have been handled");
+            }
+
+            for (var i = 0; i < eventConsumer.EventNumbers.Count; i++)
+            {
+                var value = eventConsumer.EventNumbers[i];
+
+                if (value != i + 1)
+                {
+                    throw new InvalidOperationException($"Event[{i}] != value");
+                }
+            }
+
+            return NumEvents;
+        }
+
+        public void RunCleanup()
+        {
+            mongoClient.DropDatabase(mongoDatabase.DatabaseNamespace.DatabaseName);
+
+            eventReceiver.Dispose();
+        }
+
+        public void Cleanup()
+        {
+        }
+    }
+}