Implements the other side of the merged pipeline simulation for bulk …

…request -> single non bulk requests also triggering xMultiple plugins steps DynamicsValue/fake-xrm-easy#122

src/FakeXrmEasy.Plugins/Extensions/OrganizationRequestExtensions.cs

@@ -21,6 +21,13 @@ public static bool IsBulkOperation(this OrganizationRequest request)
                    IsUpsertMultipleRequest(request);
         }
 
+        public static bool IsNonBulkOperation(this OrganizationRequest request)
+        {
+            return IsCreateRequest(request) ||
+                   IsUpdateRequest(request) ||
+                   IsUpsertRequest(request);
+        }
+
         public static bool IsCreateMultipleRequest(this OrganizationRequest request)
         {
             return CreateMultipleRequestName.Equals(request.RequestName);
@@ -36,6 +43,21 @@ public static bool IsUpsertMultipleRequest(this OrganizationRequest request)
             return UpsertMultipleRequestName.Equals(request.RequestName);
         }
 
+        public static bool IsCreateRequest(this OrganizationRequest request)
+        {
+            return CreateRequestName.Equals(request.RequestName);
+        }
+
+        public static bool IsUpdateRequest(this OrganizationRequest request)
+        {
+            return UpdateRequestName.Equals(request.RequestName);
+        }
+
+        public static bool IsUpsertRequest(this OrganizationRequest request)
+        {
+            return UpsertRequestName.Equals(request.RequestName);
+        }
+
         /// <summary>
         /// Returns a request name for a non-bulk request from the current bulk request
         /// </summary>

src/FakeXrmEasy.Plugins/Pipeline/PipelineStageExecutionParameters.cs

@@ -60,5 +60,20 @@ internal PipelineStageExecutionParameters[] ToNonBulkPipelineExecutionParameters
 
             return pipelineParameters.ToArray();
         }
+
+        /// <summary>
+        /// Converts the current non-bulk operation pipeline request parameter into another pipeline execution parameter with a bulk operation and a single record
+        /// </summary>
+        /// <returns></returns>
+        internal PipelineStageExecutionParameters ToBulkPipelineExecutionParameters()
+        {
+            var request = Request.ToBulkOrganizationRequest();
+            return new PipelineStageExecutionParameters()
+            {
+                Stage = Stage,
+                Mode = Mode,
+                Request = request
+            };
+        }
     }
 }

src/FakeXrmEasy.Plugins/Pipeline/RegisteredPluginStepsRetriever.cs

@@ -38,7 +38,12 @@ internal static IEnumerable<PluginStepDefinition> GetPluginStepsForOrganizationR
                     steps.AddRange(nonBulkSteps);
                 }
             }
-
+            else if (parameters.Request.IsNonBulkOperation())
+            {
+                var bulkPipelineParameters = parameters.ToBulkPipelineExecutionParameters();
+                var bulkSteps = GetStepsForStage(context, bulkPipelineParameters);
+                steps.AddRange(bulkSteps);
+            }
             return steps;
         }
 

tests/FakeXrmEasy.Plugins.Tests/Extensions/OrganizationRequestExtensionsTests.cs

@@ -47,6 +47,16 @@ public void Should_return_true_when_its_a_bulk_operation(string requestName)
             Assert.True(_request.IsBulkOperation());
         }
 
+        [Theory]
+        [InlineData("Create")]
+        [InlineData("Update")]
+        [InlineData("Upsert")]
+        public void Should_return_true_when_its_a_non_bulk_operation(string requestName)
+        {
+            _request.RequestName = requestName;
+            Assert.True(_request.IsNonBulkOperation());
+        }
+
         [Theory]
         [InlineData("Create")]
         [InlineData("Assign")]
@@ -56,6 +66,15 @@ public void Should_return_false_when_it_is_not_a_bulk_operation(string requestNa
             Assert.False(_request.IsBulkOperation());
         }
 
+        [Theory]
+        [InlineData("CreateMultiple")]
+        [InlineData("Assign")]
+        public void Should_return_false_when_it_is_not_a_non_a_bulk_operation(string requestName)
+        {
+            _request.RequestName = requestName;
+            Assert.False(_request.IsNonBulkOperation());
+        }
+
         [Theory]
         [InlineData("CreateMultiple", "Create")]
         [InlineData("UpdateMultiple", "Update")]

tests/FakeXrmEasy.Plugins.Tests/Pipeline/BulkOperations/CreateMultipleRequestTests.cs

@@ -64,13 +64,13 @@ public void Should_trigger_registered_bulk_step(ProcessingStepStage stage, Proce
             Assert.Equal(stage, auditedStep.Stage);
             Assert.Equal(mode, auditedStep.Mode);
         }
-        
+
         [Theory]
         [InlineData(ProcessingStepStage.Prevalidation, ProcessingStepMode.Synchronous)]
         [InlineData(ProcessingStepStage.Preoperation, ProcessingStepMode.Synchronous)]
         [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Synchronous)]
         [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Asynchronous)]
-        public void Should_trigger_registered_bulk_step_and_single_step_if_both_are_registered(ProcessingStepStage stage, ProcessingStepMode mode)
+        public void Should_trigger_registered_bulk_step_and_then_single_step_if_both_are_registered(ProcessingStepStage stage, ProcessingStepMode mode)
         {
             _context.RegisterPluginStep<TracerPlugin>(new PluginStepDefinition()
             {
@@ -109,6 +109,50 @@ public void Should_trigger_registered_bulk_step_and_single_step_if_both_are_regi
             Assert.Equal(mode, singleAuditedStep.Mode);
         }
 
+        [Theory]
+        [InlineData(ProcessingStepStage.Prevalidation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Preoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Asynchronous)]
+        public void Should_trigger_registered_single_step_and_then_bulk_step_if_both_are_registered(ProcessingStepStage stage, ProcessingStepMode mode)
+        {
+            _context.RegisterPluginStep<TracerPlugin>(new PluginStepDefinition()
+            {
+                MessageName = "CreateMultiple",
+                EntityLogicalName = Account.EntityLogicalName,
+                Stage = stage,
+                Mode = mode
+            });
+
+            _context.RegisterPluginStep<TracerPlugin>(new PluginStepDefinition()
+            {
+                MessageName = "Create",
+                EntityLogicalName = Account.EntityLogicalName,
+                Stage = stage,
+                Mode = mode
+            });
+
+            var response = _service.Execute(new CreateRequest() { Target = _account });
+            Assert.IsType<CreateResponse>(response);
+
+            var pluginStepAudit = _context.GetPluginStepAudit();
+            var auditedSteps = pluginStepAudit.CreateQuery().ToList();
+
+            Assert.Equal(2, auditedSteps.Count);
+
+            var bulkAuditedStep = auditedSteps[0];
+            Assert.Equal("Create", bulkAuditedStep.MessageName);
+            Assert.Equal(typeof(TracerPlugin), bulkAuditedStep.PluginAssemblyType);
+            Assert.Equal(stage, bulkAuditedStep.Stage);
+            Assert.Equal(mode, bulkAuditedStep.Mode);
+
+            var singleAuditedStep = auditedSteps[1];
+            Assert.Equal("CreateMultiple", singleAuditedStep.MessageName);
+            Assert.Equal(typeof(TracerPlugin), singleAuditedStep.PluginAssemblyType);
+            Assert.Equal(stage, singleAuditedStep.Stage);
+            Assert.Equal(mode, singleAuditedStep.Mode);
+        }
+
     }
 }
 #endif

tests/FakeXrmEasy.Plugins.Tests/Pipeline/PipelineStageExecutionParametersTests.cs

@@ -13,7 +13,8 @@ public class PipelineStageExecutionParametersTests
     {
         private readonly PipelineStageExecutionParameters _parameters;
         private readonly OrganizationRequest _bulkRequest;
-
+        private readonly OrganizationRequest _nonBulkRequest;
+
         private readonly Account _account1;
         private readonly Account _account2;
 
@@ -31,6 +32,11 @@ public PipelineStageExecutionParametersTests()
             {
                 Targets = entityCollection
             };
+
+            _nonBulkRequest = new CreateRequest()
+            {
+                Target = _account1
+            };
 
             _parameters = new PipelineStageExecutionParameters()
             {
@@ -57,6 +63,24 @@ public void Should_convert_bulk_operation_pipeline_stage_execution_parameters_in
             AssertNonBulkPipelineParameters(pipelineParameters[0], stage, mode, _account1);
             AssertNonBulkPipelineParameters(pipelineParameters[1], stage, mode, _account2);
         }
+
+        [Theory]
+        [InlineData(ProcessingStepStage.Prevalidation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Preoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Asynchronous)]
+        public void Should_convert_non_bulk_operation_pipeline_stage_execution_parameters_into_a_bulk_pipeline_stage_execution_parameter_with_a_single_request
+            (ProcessingStepStage stage, ProcessingStepMode mode)
+        {
+            _parameters.Request = _nonBulkRequest;
+            _parameters.Stage = stage;
+            _parameters.Mode = mode;
+
+            var pipelineParameters = _parameters.ToBulkPipelineExecutionParameters();
+            Assert.NotNull(pipelineParameters);
+
+            AssertBulkPipelineParameters(pipelineParameters, stage, mode, _account1);
+        }
 
         private void AssertNonBulkPipelineParameters(PipelineStageExecutionParameters parameters, ProcessingStepStage stage,
             ProcessingStepMode mode,
@@ -66,6 +90,17 @@ public void Should_convert_bulk_operation_pipeline_stage_execution_parameters_in
             Assert.Equal(mode, parameters.Mode);
             Assert.Equal(record, parameters.Request["Target"]);
         }
+
+        private void AssertBulkPipelineParameters(PipelineStageExecutionParameters parameters, ProcessingStepStage stage,
+            ProcessingStepMode mode,
+            Entity record)
+        {
+            var entityCollection = parameters.Request["Targets"] as EntityCollection;
+
+            Assert.Equal(stage, parameters.Stage);
+            Assert.Equal(mode, parameters.Mode);
+            Assert.Equal(record, entityCollection.Entities[0]);
+        }
     }
 }
 #endif