Add pragma warning to disable deprecated warnings, add create multipl…

…e requests tests. Initiated merged pipeline simulation for bulk operations. DynamicsValue/fake-xrm-easy#122

src/FakeXrmEasy.Plugins/Audit/PluginStepAuditDetails.cs

@@ -24,6 +24,11 @@ public class PluginStepAuditDetails
         /// Stage that triggered this plugin execution
         /// </summary>
         public ProcessingStepStage Stage { get; set; }
+
+        /// <summary>
+        /// The mode the in which the plugin step was executed
+        /// </summary>
+        public ProcessingStepMode Mode { get; set; }
 
         /// <summary>
         /// Message that triggered this execution (i.e. Create, Update, and so on...)

src/FakeXrmEasy.Plugins/Extensions/GetAssociatedNonBulkRequestNameException.cs

@@ -0,0 +1,17 @@
+using System;
+using Microsoft.Xrm.Sdk;
+
+namespace FakeXrmEasy.Plugins.Extensions
+{
+    /// <summary>
+    /// Exception thrown when a method was invoked on an organization request that is not a bulk operation
+    /// </summary>
+    public class GetAssociatedNonBulkRequestNameException: Exception
+    {
+        public GetAssociatedNonBulkRequestNameException(OrganizationRequest request): 
+            base($"GetAssociatedNonBulkRequestName can not be called on a non-bulk organization request '{request.RequestName}'")
+        {
+
+        }
+    }
+}

src/FakeXrmEasy.Plugins/Extensions/OrganizationRequestExtensions.cs

@@ -1,9 +1,18 @@
 using Microsoft.Xrm.Sdk;
+using Microsoft.Xrm.Sdk.Messages;
 
 namespace FakeXrmEasy.Plugins.Extensions
 {
     public static class OrganizationRequestExtensions
     {
+        private const string CreateMultipleRequestName = "CreateMultiple";
+        private const string UpdateMultipleRequestName = "UpdateMultiple";
+        private const string UpsertMultipleRequestName = "UpsertMultiple";
+
+        private const string CreateRequestName = "Create";
+        private const string UpdateRequestName = "Update";
+        private const string UpsertRequestName = "Upsert";
+
         public static bool IsBulkOperation(this OrganizationRequest request)
         {
             return IsCreateMultipleRequest(request) ||
@@ -13,24 +22,51 @@ public static bool IsBulkOperation(this OrganizationRequest request)
 
         public static bool IsCreateMultipleRequest(this OrganizationRequest request)
         {
-            return "CreateMultiple".Equals(request.RequestName);
+            return CreateMultipleRequestName.Equals(request.RequestName);
         }
 
         public static bool IsUpdateMultipleRequest(this OrganizationRequest request)
         {
-            return "UpdateMultiple".Equals(request.RequestName);
+            return UpdateMultipleRequestName.Equals(request.RequestName);
         }
 
         public static bool IsUpsertMultipleRequest(this OrganizationRequest request)
         {
-            return "UpsertMultiple".Equals(request.RequestName);
+            return UpsertMultipleRequestName.Equals(request.RequestName);
         }
 
-        /*
-        public static bool IsDeleteMultipleRequest(this OrganizationRequest request)
+        /// <summary>
+        /// Returns a request name for a non-bulk request from the current bulk request
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public static string GetAssociatedNonBulkRequestName(this OrganizationRequest request)
         {
-            return "DeleteMultiple".Equals(request.RequestName);
+            if (CreateMultipleRequestName.Equals(request.RequestName))
+                return CreateRequestName;
+
+            if (UpdateMultipleRequestName.Equals(request.RequestName))
+                return UpdateRequestName;
+
+            if (UpsertMultipleRequestName.Equals(request.RequestName))
+                return UpsertRequestName;
+
+            throw new GetAssociatedNonBulkRequestNameException(request);
+        }
+
+        public static string GetAssociatedBulkRequestName(this OrganizationRequest request)
+        {
+            if (CreateRequestName.Equals(request.RequestName))
+                return CreateMultipleRequestName;
+
+            if (UpdateRequestName.Equals(request.RequestName))
+                return UpdateMultipleRequestName;
+
+            if (UpsertRequestName.Equals(request.RequestName))
+                return UpsertMultipleRequestName;
+
+            throw new GetAssociatedNonBulkRequestNameException(request);
         }
-        */
+
     }
 }

src/FakeXrmEasy.Plugins/Pipeline/PipelineProcessor.cs

@@ -223,6 +223,7 @@ private static MethodInfo GetPluginMethod(PluginStepDefinition pluginStepDefinit
                 PluginStepId = pluginStep.Id,
                 MessageName = pluginContext.MessageName,
                 Stage = (ProcessingStepStage)pluginContext.Stage,
+                Mode = (ProcessingStepMode)pluginContext.Mode,
                 InputParameters = pluginContext.InputParameters,
                 OutputParameters = pluginContext.OutputParameters,
                 PluginStepDefinition = pluginStep
@@ -353,7 +354,7 @@ private static Entity GetPostImageEntityForRequest(IXrmFakedContext context, Org
 
         private static void ProcessPreOperation(IXrmFakedContext context, 
             OrganizationRequest request) 
-        {
+        {  
             var preImagePreOperation = PreImage.IsAvailableFor(request.GetType(), ProcessingStepStage.Preoperation)
                 ? GetPreImageEntityForRequest(context, request)
                 : null;

src/FakeXrmEasy.Plugins/Pipeline/PluginStepRegistrationManager.cs

@@ -224,7 +224,8 @@ internal static void AddPipelineTypes(IXrmFakedContext context)
 
             return sdkMessage;
         }
-
+
+#pragma warning disable CS0618 
         internal static Entity AddSdkMessageFilter(IXrmFakedContext context,
             IPluginStepDefinition pluginStepDefinition)
         {
@@ -243,6 +244,7 @@ internal static void AddPipelineTypes(IXrmFakedContext context)
             return sdkFilter;
         }
 
+
         internal static void VerifyPluginStepDefinition(IXrmFakedContext context,
             IPluginStepDefinition pluginStepDefinition)
         {
@@ -271,5 +273,7 @@ internal static void AddPipelineTypes(IXrmFakedContext context)
                 pluginStepDefinition.EntityLogicalName = (string)reflectedType.GetField("EntityLogicalName")?.GetValue(null);
             }
         }
+
+#pragma warning restore CS0618
     }
 }

src/FakeXrmEasy.Plugins/PluginSteps/PluginStepValidator.cs

@@ -241,10 +241,12 @@ public bool IsValid(IPluginStepDefinition stepDefinition)
 
             string entityLogicalNameToCheck = stepDefinition.EntityLogicalName;
 
+#pragma warning disable CS0618
             if (stepDefinition.EntityTypeCode == null && string.IsNullOrWhiteSpace(stepDefinition.EntityLogicalName))
             {
                 entityLogicalNameToCheck = "*";
             }
+#pragma warning restore CS0618
 
             if (_combinations[messageNameToCheck].ContainsKey("*") && !_combinations[messageNameToCheck].ContainsKey(entityLogicalNameToCheck))
             {

tests/FakeXrmEasy.Plugins.Tests/Audit/PluginStepAuditTests.cs

@@ -25,17 +25,22 @@ public void Should_return_a_query_with_empty_collection_if_no_steps_were_execute
             Assert.Empty(pluginSteps);
         }
 
-        [Fact]
-        public void Should_return_a_plugin_step_audit_that_was_added()
+        [Theory]
+        [InlineData(ProcessingStepStage.Prevalidation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Preoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Synchronous)]
+        [InlineData(ProcessingStepStage.Postoperation, ProcessingStepMode.Asynchronous)]
+        public void Should_return_a_plugin_step_audit_that_was_added(ProcessingStepStage stage, ProcessingStepMode mode)
         {
             var pluginStepAuditDetails = new PluginStepAuditDetails()
             {
                 MessageName = "Create",
                 PluginAssemblyType = typeof(AccountNumberPlugin),
                 PluginStepId = Guid.NewGuid(),
-                Stage = ProcessingStepStage.Preoperation,
+                Stage = stage,
                 TargetEntity = new Entity(Contact.EntityLogicalName) { Id = Guid.NewGuid() },
-                TargetEntityReference = new EntityReference(Contact.EntityLogicalName, Guid.NewGuid())
+                TargetEntityReference = new EntityReference(Contact.EntityLogicalName, Guid.NewGuid()),
+                Mode = mode
             };
 
             _pluginStepAudit.Add(pluginStepAuditDetails);
@@ -48,6 +53,7 @@ public void Should_return_a_plugin_step_audit_that_was_added()
             Assert.Equal(pluginStepAuditDetails.PluginAssemblyType, first.PluginAssemblyType);
             Assert.Equal(pluginStepAuditDetails.PluginStepId, first.PluginStepId);
             Assert.Equal(pluginStepAuditDetails.Stage, first.Stage);
+            Assert.Equal(pluginStepAuditDetails.Mode, first.Mode);
             Assert.Equal(pluginStepAuditDetails.TargetEntity, first.TargetEntity);
             Assert.Equal(pluginStepAuditDetails.TargetEntityReference, first.TargetEntityReference);
             Assert.NotEqual(DateTime.MinValue, first.ExecutedOn); 

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

@@ -55,5 +55,27 @@ public void Should_return_false_when_it_is_not_a_bulk_operation(string requestNa
             _request.RequestName = requestName;
             Assert.False(_request.IsBulkOperation());
         }
+
+        [Theory]
+        [InlineData("CreateMultiple", "Create")]
+        [InlineData("UpdateMultiple", "Update")]
+        [InlineData("UpsertMultiple", "Upsert")]
+        public void Should_return_associated_non_bulk_request_name_for_bulk_operation(string bulkOperation, string nonBulkOperation)
+        {
+            _request.RequestName = bulkOperation;
+            var nonBulkRequestName = _request.GetAssociatedNonBulkRequestName();
+            Assert.Equal(nonBulkOperation, nonBulkRequestName);
+        }
+
+        [Theory]
+        [InlineData("Create", "CreateMultiple")]
+        [InlineData("Update", "UpdateMultiple")]
+        [InlineData("Upsert", "UpsertMultiple")]
+        public void Should_return_associated_bulk_request_name_for_non_bulk_operation(string nonBulkOperation, string bulkOperation)
+        {
+            _request.RequestName = nonBulkOperation;
+            var nonBulkRequestName = _request.GetAssociatedBulkRequestName();
+            Assert.Equal(bulkOperation, nonBulkRequestName);
+        }
     }
 }

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

@@ -33,15 +33,20 @@ public CreateMultipleRequestTests()
             _entities = new List<Entity>() { _account };
         }
 
-        /*
-        [Fact]
-        public void Should_trigger_registered_bulk_preoperation_preoperation_step()
+
+        [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(ProcessingStepStage stage, ProcessingStepMode mode)
         {
             _context.RegisterPluginStep<TracerPlugin>(new PluginStepDefinition()
             {
                 MessageName = "CreateMultiple",
                 EntityLogicalName = Account.EntityLogicalName,
-                Stage = ProcessingStepStage.Preoperation
+                Stage = stage,
+                Mode = mode
             });
 
             var response = _service.Execute(_entities.ToCreateMultipleRequest());
@@ -55,8 +60,53 @@ public void Should_trigger_registered_bulk_preoperation_preoperation_step()
             var auditedStep = auditedSteps[0];
             Assert.Equal("CreateMultiple", auditedStep.MessageName);
             Assert.Equal(typeof(TracerPlugin), auditedStep.PluginAssemblyType);
-            Assert.Equal(ProcessingStepStage.Preoperation, auditedStep.Stage);
+            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)
+        {
+            _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(_entities.ToCreateMultipleRequest());
+            Assert.IsType<CreateMultipleResponse>(response);
+
+            var pluginStepAudit = _context.GetPluginStepAudit();
+            var auditedSteps = pluginStepAudit.CreateQuery().ToList();
+
+            Assert.Equal(2, auditedSteps.Count);
+
+            var bulkAuditedStep = auditedSteps[0];
+            Assert.Equal("CreateMultiple", bulkAuditedStep.MessageName);
+            Assert.Equal(typeof(TracerPlugin), bulkAuditedStep.PluginAssemblyType);
+            Assert.Equal(stage, bulkAuditedStep.Stage);
+            Assert.Equal(mode, bulkAuditedStep.Mode);
+
+            var singleAuditedStep = auditedSteps[1];
+            Assert.Equal("Create", singleAuditedStep.MessageName);
+            Assert.Equal(typeof(TracerPlugin), singleAuditedStep.PluginAssemblyType);
+            Assert.Equal(stage, singleAuditedStep.Stage);
+            Assert.Equal(mode, singleAuditedStep.Mode);
         }
-        */
+
     }
 }