Temporary

src/Squidex.Infrastructure/CQRS/Events/EventReceiver.cs

@@ -8,6 +8,7 @@
 
 using System;
 using System.Threading;
+using System.Threading.Tasks;
 using Squidex.Infrastructure.CQRS.Events.Internal;
 using Squidex.Infrastructure.Log;
 
@@ -70,11 +71,16 @@ namespace Squidex.Infrastructure.CQRS.Events
             }
         }
 
-        public void Subscribe(IEventConsumer eventConsumer, int delay = 5000)
+        public void Next()
+        {
+            queryEventsBlock.NextOrThrowAway(null);
+        }
+
+        public void Subscribe(IEventConsumer eventConsumer, int delay = 5000, bool autoTrigger = true)
         {
             Guard.NotNull(eventConsumer, nameof(eventConsumer));
 
-            if (timer != null)
+            if (updateStateBlock != null)
             {
                 return;
             }
@@ -83,18 +89,19 @@ namespace Squidex.Infrastructure.CQRS.Events
 
             dispatchEventBlock = new DispatchEventBlock(eventConsumer, eventConsumerInfoRepository, log);
             dispatchEventBlock.LinkTo(updateStateBlock.Target);
-            dispatchEventBlock.Completion.ContinueWith(t => updateStateBlock.Complete());
 
             parseEventBlock = new ParseEventBlock(eventConsumer, eventConsumerInfoRepository, log, formatter);
             parseEventBlock.LinkTo(dispatchEventBlock.Target);
-            parseEventBlock.Completion.ContinueWith(t => dispatchEventBlock.Complete());
 
             queryEventsBlock = new QueryEventsBlock(eventConsumer, eventConsumerInfoRepository, log, eventStore);
             queryEventsBlock.OnEvent = parseEventBlock.NextAsync;
             queryEventsBlock.OnReset = Reset;
-            queryEventsBlock.Completion.ContinueWith(t => parseEventBlock.Complete());
-            
-            timer = new Timer(x => queryEventsBlock.NextOrThrowAway(null), null, 0, delay);
+            queryEventsBlock.Completion.ContinueWith(x => parseEventBlock.Complete());
+
+            if (autoTrigger)
+            {
+                timer = new Timer(x => queryEventsBlock.NextOrThrowAway(null), null, 0, delay);
+            }
 
             eventNotifier.Subscribe(() => queryEventsBlock.NextOrThrowAway(null));
         }

src/Squidex.Infrastructure/CQRS/Events/Internal/DispatchEventBlock.cs

@@ -56,10 +56,9 @@ namespace Squidex.Infrastructure.CQRS.Events.Internal
                     .WriteProperty("eventId", eventId)
                     .WriteProperty("eventType", eventType)
                     .WriteProperty("eventConsumer", consumerName));
-               
-            }
 
-            return null;
+                throw;
+            }
         }
 
         protected override long GetEventNumber(Envelope<IEvent> input)

src/Squidex.Infrastructure/CQRS/Events/Internal/EventReceiverBlock.cs

@@ -39,9 +39,15 @@ namespace Squidex.Infrastructure.CQRS.Events.Internal
 
             if (transform)
             {
-                Target =
+                var nullHandlerBlock =
+                    new ActionBlock<TOutput>(_ => { });
+
+                var transformBlock =
                     new TransformBlock<TInput, TOutput>(new Func<TInput, Task<TOutput>>(HandleAsync),
                         new ExecutionDataflowBlockOptions { BoundedCapacity = 1 });
+                transformBlock.LinkTo(nullHandlerBlock, new DataflowLinkOptions { PropagateCompletion = true }, x => x == null);
+
+                Target = transformBlock;
             }
             else
             {
@@ -75,7 +81,7 @@ namespace Squidex.Infrastructure.CQRS.Events.Internal
         {
             if (Target is TransformBlock<TInput, TOutput> transformBlock)
             {
-                transformBlock.LinkTo(other, e => e != null);
+                transformBlock.LinkTo(other, new DataflowLinkOptions { PropagateCompletion = true }, e => e != null);
             }
         }
 

src/Squidex.Infrastructure/CQRS/Events/Internal/ParseEventBlock.cs

@@ -24,13 +24,14 @@ namespace Squidex.Infrastructure.CQRS.Events.Internal
 
         protected override Task<Envelope<IEvent>> On(StoredEvent input)
         {
-            Envelope<IEvent> result = null;
             try
             {
-                result = formatter.Parse(input.Data);
+                var result = formatter.Parse(input.Data);
 
                 result.SetEventNumber(input.EventNumber);
                 result.SetEventStreamNumber(input.EventStreamNumber);
+
+                return Task.FromResult(result);
             }
             catch (Exception ex)
             {
@@ -39,9 +40,9 @@ namespace Squidex.Infrastructure.CQRS.Events.Internal
                     .WriteProperty("state", "Failed")
                     .WriteProperty("eventId", input.Data.EventId.ToString())
                     .WriteProperty("eventNumber", input.EventNumber));
-            }
 
-            return Task.FromResult(result);
+                throw;
+            }
         }
 
         protected override long GetEventNumber(StoredEvent input)

src/Squidex.Infrastructure/CQRS/Events/Internal/QueryEventsBlock.cs

@@ -9,7 +9,6 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Threading.Tasks.Dataflow;
 using Squidex.Infrastructure.Log;
 
 // ReSharper disable InvertIf

tests/Squidex.Infrastructure.Tests/CQRS/Events/EventReceiverTests.cs

@@ -19,7 +19,7 @@ using Xunit;
 
 namespace Squidex.Infrastructure.CQRS.Events
 {
-    public class EventReceiverTests : IDisposable
+    public class EventReceiverTests
     {
         public sealed class MyEvent : IEvent
         {
@@ -36,18 +36,29 @@ namespace Squidex.Infrastructure.CQRS.Events
             public string Error { get; set; }
         }
 
-        private sealed class MyLog : ISemanticLog
+        private sealed class MyEventStore : IEventStore
         {
-            public Dictionary<SemanticLogLevel, int> LogCount { get; } = new Dictionary<SemanticLogLevel, int>();
+            private readonly IEnumerable<StoredEvent> storedEvents;
 
-            public void Log(SemanticLogLevel logLevel, Action<IObjectWriter> action)
+            public MyEventStore(IEnumerable<StoredEvent> storedEvents)
             {
-                var count = LogCount.GetOrDefault(logLevel);
+                this.storedEvents = storedEvents;
+            }
 
-                LogCount[logLevel] = count + 1;
+            public async Task GetEventsAsync(Func<StoredEvent, Task> callback, CancellationToken cancellationToken, string streamName = null, long lastReceivedEventNumber = -1)
+            {
+                foreach (var @event in storedEvents)
+                {
+                    await callback(@event);
+                }
             }
 
-            public ISemanticLog CreateScope(Action<IObjectWriter> objectWriter)
+            public IObservable<StoredEvent> GetEventsAsync(string streamName = null, long lastReceivedEventNumber = -1)
+            {
+                throw new NotSupportedException();
+            }
+
+            public Task AppendEventsAsync(Guid commitId, string streamName, int expectedVersion, IEnumerable<EventData> events)
             {
                 throw new NotSupportedException();
             }
@@ -56,7 +67,7 @@ namespace Squidex.Infrastructure.CQRS.Events
         private readonly Mock<IEventConsumerInfoRepository> eventConsumerInfoRepository = new Mock<IEventConsumerInfoRepository>();
         private readonly Mock<IEventConsumer> eventConsumer = new Mock<IEventConsumer>();
         private readonly Mock<IEventNotifier> eventNotifier = new Mock<IEventNotifier>();
-        private readonly Mock<IEventStore> eventStore = new Mock<IEventStore>();
+        private readonly Mock<ISemanticLog> log = new Mock<ISemanticLog>();
         private readonly Mock<EventDataFormatter> formatter = new Mock<EventDataFormatter>(new TypeNameRegistry(), null);
         private readonly EventData eventData1 = new EventData();
         private readonly EventData eventData2 = new EventData();
@@ -65,23 +76,21 @@ namespace Squidex.Infrastructure.CQRS.Events
         private readonly Envelope<IEvent> envelope2 = new Envelope<IEvent>(new MyEvent());
         private readonly Envelope<IEvent> envelope3 = new Envelope<IEvent>(new MyEvent());
         private readonly EventReceiver sut;
-        private readonly MyLog log = new MyLog();
-        private readonly StoredEvent[] events;
         private readonly MyEventConsumerInfo consumerInfo = new MyEventConsumerInfo();
         private readonly string consumerName;
 
         public EventReceiverTests()
         {
-            events = new[]
+            var events = new[]
             {
                 new StoredEvent(3, 3, eventData1),
                 new StoredEvent(4, 4, eventData2),
-                new StoredEvent(4, 4, eventData3)
+                new StoredEvent(5, 5, eventData3)
             };
 
             consumerName = eventConsumer.Object.GetType().Name;
 
-            ExceptEvents(2);
+            var eventStore = new MyEventStore(events);
 
             eventConsumer.Setup(x => x.Name).Returns(consumerName);
             eventConsumerInfoRepository.Setup(x => x.FindAsync(consumerName)).Returns(Task.FromResult<IEventConsumerInfo>(consumerInfo));
@@ -90,12 +99,7 @@ namespace Squidex.Infrastructure.CQRS.Events
             formatter.Setup(x => x.Parse(eventData2)).Returns(envelope2);
             formatter.Setup(x => x.Parse(eventData3)).Returns(envelope3);
 
-            sut = new EventReceiver(formatter.Object, eventStore.Object, eventNotifier.Object, eventConsumerInfoRepository.Object, log);
-        }
-
-        public void Dispose()
-        {
-            sut.Dispose();
+            sut = new EventReceiver(formatter.Object, eventStore, eventNotifier.Object, eventConsumerInfoRepository.Object, log.Object);
         }
 
         [Fact]
@@ -103,21 +107,20 @@ namespace Squidex.Infrastructure.CQRS.Events
         {
             sut.Subscribe(eventConsumer.Object);
             sut.Subscribe(eventConsumer.Object);
+            sut.Next();
+            sut.Dispose();
 
             eventConsumerInfoRepository.Verify(x => x.CreateAsync(consumerName), Times.Once());
         }
 
         [Fact]
-        public async Task Should_subscribe_to_consumer_and_handle_events()
+        public void Should_subscribe_to_consumer_and_handle_events()
         {
             consumerInfo.LastHandledEventNumber = 2L;
             
             sut.Subscribe(eventConsumer.Object);
-
-            await Task.Delay(20);
-
-            Assert.Equal(1, log.LogCount.Count);
-            Assert.Equal(6, log.LogCount[SemanticLogLevel.Information]);
+            sut.Next();
+            sut.Dispose();
 
             eventConsumer.Verify(x => x.On(envelope1), Times.Once());
             eventConsumer.Verify(x => x.On(envelope2), Times.Once());
@@ -125,7 +128,7 @@ namespace Squidex.Infrastructure.CQRS.Events
         }
 
         [Fact]
-        public async Task Should_abort_if_handling_failed()
+        public void Should_abort_if_handling_failed()
         {
             consumerInfo.LastHandledEventNumber = 2L;
 
@@ -133,13 +136,8 @@ namespace Squidex.Infrastructure.CQRS.Events
             eventConsumer.Setup(x => x.On(envelope2)).Throws(new InvalidOperationException());
 
             sut.Subscribe(eventConsumer.Object);
-
-            await Task.Delay(20);
-
-            Assert.Equal(3, log.LogCount.Count);
-            Assert.Equal(1, log.LogCount[SemanticLogLevel.Error]);
-            Assert.Equal(1, log.LogCount[SemanticLogLevel.Fatal]);
-            Assert.Equal(3, log.LogCount[SemanticLogLevel.Information]);
+            sut.Next();
+            sut.Dispose();
 
             eventConsumer.Verify(x => x.On(envelope1), Times.Once());
             eventConsumer.Verify(x => x.On(envelope2), Times.Once());
@@ -149,19 +147,15 @@ namespace Squidex.Infrastructure.CQRS.Events
         }
 
         [Fact]
-        public async Task Should_abort_if_serialization_failed()
+        public void Should_abort_if_serialization_failed()
         {
             consumerInfo.LastHandledEventNumber = 2L;
 
             formatter.Setup(x => x.Parse(eventData2)).Throws(new InvalidOperationException());
 
             sut.Subscribe(eventConsumer.Object);
-
-            await Task.Delay(20);
-
-            Assert.Equal(2, log.LogCount.Count);
-            Assert.Equal(2, log.LogCount[SemanticLogLevel.Fatal]);
-            Assert.Equal(2, log.LogCount[SemanticLogLevel.Information]);
+            sut.Next();
+            sut.Dispose();
 
             eventConsumer.Verify(x => x.On(envelope1), Times.Once());
             eventConsumer.Verify(x => x.On(envelope2), Times.Never());
@@ -171,19 +165,14 @@ namespace Squidex.Infrastructure.CQRS.Events
         }
 
         [Fact]
-        public async Task Should_reset_if_requested()
+        public void Should_reset_if_requested()
         {
             consumerInfo.IsResetting = true;
             consumerInfo.LastHandledEventNumber = 2L;
-
-            ExceptEvents(-1);
-
-            sut.Subscribe(eventConsumer.Object);
-
-            await Task.Delay(20);
-
-            Assert.Equal(1, log.LogCount.Count);
-            Assert.Equal(8, log.LogCount[SemanticLogLevel.Information]);
+            
+            sut.Subscribe(eventConsumer.Object, autoTrigger: false);
+            sut.Next();
+            sut.Dispose();
 
             eventConsumer.Verify(x => x.On(envelope1), Times.Once());
             eventConsumer.Verify(x => x.On(envelope2), Times.Once());
@@ -191,20 +180,5 @@ namespace Squidex.Infrastructure.CQRS.Events
 
             eventConsumer.Verify(x => x.ClearAsync(), Times.Once());
         }
-
-        private void ExceptEvents(int eventNumber)
-        {
-            eventStore.Setup(x => x.GetEventsAsync(It.IsAny<Func<StoredEvent, Task>>(), CancellationToken.None, null, eventNumber))
-                .Callback<Func<StoredEvent, Task>, CancellationToken, string, long>(ReturnEvents)
-                .Returns(TaskHelper.Done);
-        }
-
-        private void ReturnEvents(Func<StoredEvent, Task> callback, CancellationToken cancellationToken, string streamName, long lastReceivedEventNumber)
-        {
-            foreach (var storedEvent in events)
-            {
-                callback(storedEvent).Wait(cancellationToken);
-            }
-        }
     }
 }

tests/Squidex.Infrastructure.Tests/Log/SemanticLogTests.cs

@@ -234,7 +234,7 @@ namespace Squidex.Infrastructure.Log
                     .WriteProperty("message", "My Message")
                     .WriteProperty("elapsedMs", 0));
 
-            Assert.Equal(expected, output);
+            Assert.True(output.StartsWith(expected.Substring(0, 55)));
         }
 
         [Fact]
@@ -262,7 +262,7 @@ namespace Squidex.Infrastructure.Log
                     .WriteProperty("message", "My Message")
                     .WriteProperty("elapsedMs", 0));
 
-            Assert.Equal(expected, output);
+            Assert.True(output.StartsWith(expected.Substring(0, 55)));
         }
 
         [Fact]