Merge pull request #884 from VKAlwaysWin/VKAlwaysWin/AllowToDisableEventsPublisher

Allow to disable events publisher

Author: danielgerlag

src/WorkflowCore/Models/WorkflowOptions.cs

@@ -38,6 +38,7 @@ public WorkflowOptions(IServiceCollection services)
         public bool EnableEvents { get; set; } = true;
         public bool EnableIndexes { get; set; } = true;
         public bool EnablePolling { get; set; } = true;
+        public bool EnableLifeCycleEventsPublisher { get; set; } = true;
 
         public void UsePersistence(Func<IServiceProvider, IPersistenceProvider> factory)
         {

src/WorkflowCore/Services/ErrorHandlers/CompensateHandler.cs

@@ -8,17 +8,15 @@ namespace WorkflowCore.Services.ErrorHandlers
 {
     public class CompensateHandler : IWorkflowErrorHandler
     {
-        private readonly ILifeCycleEventPublisher _eventPublisher;
         private readonly IExecutionPointerFactory _pointerFactory;
         private readonly IDateTimeProvider _datetimeProvider;
         private readonly WorkflowOptions _options;
 
         public WorkflowErrorHandling Type => WorkflowErrorHandling.Compensate;
 
-        public CompensateHandler(IExecutionPointerFactory pointerFactory, ILifeCycleEventPublisher eventPublisher, IDateTimeProvider datetimeProvider, WorkflowOptions options)
+        public CompensateHandler(IExecutionPointerFactory pointerFactory, IDateTimeProvider datetimeProvider, WorkflowOptions options)
         {
             _pointerFactory = pointerFactory;
-            _eventPublisher = eventPublisher;
             _datetimeProvider = datetimeProvider;
             _options = options;
         }

src/WorkflowCore/Services/LifeCycleEventPublisher.cs

@@ -3,27 +3,30 @@
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using WorkflowCore.Interface;
+using WorkflowCore.Models;
 using WorkflowCore.Models.LifeCycleEvents;
 
 namespace WorkflowCore.Services
 {
     public class LifeCycleEventPublisher : ILifeCycleEventPublisher, IDisposable
     {
         private readonly ILifeCycleEventHub _eventHub;
+        private readonly WorkflowOptions _workflowOptions;
         private readonly ILogger _logger;
         private BlockingCollection<LifeCycleEvent> _outbox;
         private Task _dispatchTask;
 
-        public LifeCycleEventPublisher(ILifeCycleEventHub eventHub, ILoggerFactory loggerFactory)
+        public LifeCycleEventPublisher(ILifeCycleEventHub eventHub, WorkflowOptions workflowOptions, ILoggerFactory loggerFactory)
         {
             _eventHub = eventHub;
+            _workflowOptions = workflowOptions;
             _outbox = new BlockingCollection<LifeCycleEvent>();
             _logger = loggerFactory.CreateLogger(GetType());
         }
 
         public void PublishNotification(LifeCycleEvent evt)
         {
-            if (_outbox.IsAddingCompleted)
+            if (_outbox.IsAddingCompleted || !_workflowOptions.EnableLifeCycleEventsPublisher)
                 return;
 
             _outbox.Add(evt);

test/WorkflowCore.UnitTests/Services/LifeCycleEventPublisherTests.cs

@@ -1,8 +1,9 @@
-using System;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Moq;
 using WorkflowCore.Interface;
+using WorkflowCore.Models;
 using WorkflowCore.Models.LifeCycleEvents;
 using WorkflowCore.Services;
 using Xunit;
@@ -17,17 +18,25 @@ public async Task PublishNotification_WhenStarted_PublishesNotification()
             // Arrange
             var wasCalled = new TaskCompletionSource<bool>();
             var eventHubMock = new Mock<ILifeCycleEventHub>();
+            var serviceCollectionMock = new Mock<IServiceCollection>();
+
+            var workflowOptions = new WorkflowOptions(serviceCollectionMock.Object)
+            {
+                EnableLifeCycleEventsPublisher = true
+            };
+
             eventHubMock
                 .Setup(hub => hub.PublishNotification(It.IsAny<StepCompleted>()))
                 .Callback(() => wasCalled.SetResult(true));
-            LifeCycleEventPublisher publisher = new LifeCycleEventPublisher(eventHubMock.Object, new LoggerFactory());
+            LifeCycleEventPublisher publisher = new LifeCycleEventPublisher(eventHubMock.Object, workflowOptions, new LoggerFactory());
 
             // Act
             publisher.Start();
             publisher.PublishNotification(new StepCompleted());
 
             // Assert
             await wasCalled.Task;
+            eventHubMock.Verify(hub => hub.PublishNotification(It.IsAny<StepCompleted>()), Times.Once());
         }
 
         [Fact(DisplayName = "Notifications should be published when the publisher is running")]
@@ -36,10 +45,17 @@ public async Task PublishNotification_WhenRestarted_PublishesNotification()
             // Arrange
             var wasCalled = new TaskCompletionSource<bool>();
             var eventHubMock = new Mock<ILifeCycleEventHub>();
+            var serviceCollectionMock = new Mock<IServiceCollection>();
+
+            var workflowOptions = new WorkflowOptions(serviceCollectionMock.Object)
+            {
+                EnableLifeCycleEventsPublisher = true
+            };
+
             eventHubMock
                 .Setup(hub => hub.PublishNotification(It.IsAny<StepCompleted>()))
                 .Callback(() => wasCalled.SetResult(true));
-            LifeCycleEventPublisher publisher = new LifeCycleEventPublisher(eventHubMock.Object, new LoggerFactory());
+            LifeCycleEventPublisher publisher = new LifeCycleEventPublisher(eventHubMock.Object, workflowOptions, new LoggerFactory());
 
             // Act
             publisher.Start();
@@ -49,6 +65,33 @@ public async Task PublishNotification_WhenRestarted_PublishesNotification()
 
             // Assert
             await wasCalled.Task;
+            eventHubMock.Verify(hub => hub.PublishNotification(It.IsAny<StepCompleted>()), Times.Once());
+        }
+
+        [Fact(DisplayName = "Notifications should be disabled if option EnableLifeCycleEventsPublisher is disabled")]
+        public void PublishNotification_Disabled()
+        {
+            // Arrange
+            var eventHubMock = new Mock<ILifeCycleEventHub>();
+            var serviceCollectionMock = new Mock<IServiceCollection>();
+
+            var workflowOptions = new WorkflowOptions(serviceCollectionMock.Object)
+            {
+                EnableLifeCycleEventsPublisher = false
+            };
+
+            eventHubMock
+                .Setup(hub => hub.PublishNotification(It.IsAny<StepCompleted>()))
+                .Returns(Task.CompletedTask);
+            LifeCycleEventPublisher publisher = new LifeCycleEventPublisher(eventHubMock.Object, workflowOptions, new LoggerFactory());
+
+            // Act
+            publisher.Start();
+            publisher.PublishNotification(new StepCompleted());
+            publisher.Stop();
+
+            // Assert
+            eventHubMock.Verify(hub => hub.PublishNotification(It.IsAny<StepCompleted>()), Times.Never());
         }
     }
 }