fix #32 initial commandexectiontype change at runtime

src/InterAppConnector/CommandOutput.cs

@@ -1,4 +1,5 @@
-using System.Text.Json;
+using System.Collections;
+using System.Text.Json;
 using InterAppConnector.DataModels;
 using InterAppConnector.Enumerations;
 using InterAppConnector.Exceptions;
@@ -28,6 +29,61 @@ public class CommandOutput
         internal static event StatusEventHandler WarningMessageEmitted;
         internal static event StatusEventHandler ErrorMessageEmitted;
 
+        /// <summary>
+        /// Check if the method in event <paramref name="eventToAttach"/> is already added in <paramref name="targetEvent"/> invocation list.
+        /// </summary>
+        /// <param name="targetEvent">The target event</param>
+        /// <param name="eventToAttach">The event to add</param>
+        /// <returns><see langword="true"/> if the event is already attached, otherwise <see langword="false"/></returns>
+        public static bool IsEventAlreadyAttached(Delegate targetEvent, Delegate eventToAttach)
+        {
+            bool isEventFound = false;
+            if (targetEvent != null && eventToAttach != null)
+            {
+                /*
+                 * It's important to compare the parameters used by targetEvent and eventToAdd.
+                 * If the parameters and the name are the same, it is possible to say that 
+                 * it is using the same delegate that is already added. The comparison between arrays should be done
+                 * via IStructuralEquatable because this method check if the structure of the array is equal, and not
+                 * the reference
+                 */
+                IStructuralEquatable eventToCompare = eventToAttach.Method.GetParameters();
+
+                isEventFound = (from item in targetEvent.GetInvocationList()
+                                where item.Method.Name == eventToAttach.Method.Name
+                                && eventToCompare.Equals(item.Method.GetParameters(), StructuralComparisons.StructuralEqualityComparer)
+                                select item).Any();
+            }
+            return isEventFound;
+        }
+
+        public static bool IsSuccessEventAlreadyAttached(Delegate eventToFind)
+        {
+            return IsEventAlreadyAttached(SuccessMessageEmitted, eventToFind);
+        }
+
+        public static bool IsWarningEventAlreadyAttached(Delegate eventToFind)
+        {
+            return IsEventAlreadyAttached(WarningMessageEmitted, eventToFind);
+        }
+        public static bool IsErrorEventAlreadyAttached(Delegate eventToFind)
+        {
+            return IsEventAlreadyAttached(ErrorMessageEmitted, eventToFind);
+        }
+
+        public static bool IsInfoEventAlreadyAttached(Delegate eventToFind)
+        {
+            return IsEventAlreadyAttached(InfoMessageEmitted, eventToFind);
+        }
+
+        internal static void ClearEvents()
+        {
+            SuccessMessageEmitted = null!;
+            WarningMessageEmitted = null!;
+            ErrorMessageEmitted = null!;
+            InfoMessageEmitted = null!;
+        }
+
         /// <summary>
         /// Return a positive message that an operation has been completed successfully
         /// </summary>

src/InterAppConnector/InterAppCommunication.cs

@@ -64,12 +64,32 @@ public InterAppCommunication(CommandManager commandManager)
         /// <param name="arguments">Arguments passed to the CLI</param>
         public void ExecuteAsInteractiveCLI(string[] arguments, CommandOutputFormat commandOutputFormat = CommandOutputFormat.Text)
         {
+            CommandExecutionType currentCommandExecutionType = _commandExecutionType;
+            CommandOutputFormat currentCommandOutputFormat = CommandOutputFormat;
+
             _commandExecutionType = CommandExecutionType.Interactive;
             CommandOutputFormat = commandOutputFormat;
-            CommandOutput.ErrorMessageEmitted += CommandOutput_ErrorMessageEmitted;
-            CommandOutput.SuccessMessageEmitted += CommandOutput_SuccessMessageEmitted;
-            CommandOutput.InfoMessageEmitted += CommandOutput_InfoMessageEmitted;
-            CommandOutput.WarningMessageEmitted += CommandOutput_WarningMessageEmitted;
+
+            if (!IsErrorEventAlreadyAttached(CommandOutput_ErrorMessageEmitted))
+            {
+                CommandOutput.ErrorMessageEmitted += CommandOutput_ErrorMessageEmitted;
+            }
+
+            if (!IsSuccessEventAlreadyAttached(CommandOutput_SuccessMessageEmitted))
+            {
+                CommandOutput.SuccessMessageEmitted += CommandOutput_SuccessMessageEmitted;
+            }
+
+            if (!IsInfoEventAlreadyAttached(CommandOutput_InfoMessageEmitted))
+            {
+                CommandOutput.InfoMessageEmitted += CommandOutput_InfoMessageEmitted;
+            }
+
+            if (!IsWarningEventAlreadyAttached(CommandOutput_WarningMessageEmitted))
+            {
+                CommandOutput.WarningMessageEmitted += CommandOutput_WarningMessageEmitted;
+            }
+
             string selectedAction = "";
             Argument argumentsParsed = Argument.Parse(arguments, "-");
 
@@ -115,6 +135,9 @@ public void ExecuteAsInteractiveCLI(string[] arguments, CommandOutputFormat comm
             {
                 Console.Write(CommandUtil.DescribeCommands(_commandManager));
             }
+
+            _commandExecutionType = currentCommandExecutionType;
+            CommandOutputFormat = currentCommandOutputFormat;
         }
 
         /// <summary>
@@ -129,13 +152,32 @@ public void ExecuteAsInteractiveCLI(string[] arguments, CommandOutputFormat comm
         /// <returns>The raw string returned by the requested command</returns>
         public string ExecuteAsBatch(string action, dynamic parameters, CommandOutputFormat commandOutputFormat = CommandOutputFormat.Json)
         {
+            CommandExecutionType currentCommandExecutionType = _commandExecutionType;
+            CommandOutputFormat currentCommandOutputFormat = CommandOutputFormat;
+
             string output = "";
             _commandExecutionType = CommandExecutionType.Batch;
             CommandOutputFormat = commandOutputFormat;
-            CommandOutput.ErrorMessageEmitted += CommandOutput_ErrorMessageEmitted;
-            CommandOutput.SuccessMessageEmitted += CommandOutput_SuccessMessageEmitted;
-            CommandOutput.InfoMessageEmitted += CommandOutput_InfoMessageEmitted;
-            CommandOutput.WarningMessageEmitted += CommandOutput_WarningMessageEmitted;
+
+            if (!IsErrorEventAlreadyAttached(CommandOutput_ErrorMessageEmitted))
+            {
+                CommandOutput.ErrorMessageEmitted += CommandOutput_ErrorMessageEmitted;
+            }
+
+            if (!IsSuccessEventAlreadyAttached(CommandOutput_SuccessMessageEmitted))
+            {
+                CommandOutput.SuccessMessageEmitted += CommandOutput_SuccessMessageEmitted;
+            }
+
+            if (!IsInfoEventAlreadyAttached(CommandOutput_InfoMessageEmitted))
+            {
+                CommandOutput.InfoMessageEmitted += CommandOutput_InfoMessageEmitted;
+            }
+
+            if (!IsWarningEventAlreadyAttached(CommandOutput_WarningMessageEmitted))
+            {
+                CommandOutput.WarningMessageEmitted += CommandOutput_WarningMessageEmitted;
+            }
 
             Argument argumentsParsed = Argument.Parse(parameters, "-");
             argumentsParsed.Action.AddRange(action.Split(" ", StringSplitOptions.RemoveEmptyEntries));
@@ -171,6 +213,10 @@ public string ExecuteAsBatch(string action, dynamic parameters, CommandOutputFor
                     output = Error("Cannot execute the selected action because this action does not exist." + Environment.NewLine + CommandUtil.DescribeCommands(_commandManager, false));
                 }
             }
+
+            _commandExecutionType = currentCommandExecutionType;
+            CommandOutputFormat = currentCommandOutputFormat;
+
             return output;
         }
 

tests/InterAppConnector.Test.Library/CommandManagerTest.cs

@@ -378,7 +378,6 @@ public void SetArgument_WithAnotherValidatorCustomInputStringAndValueNotInRange_
         [TestCase("ab")]
         //
         [TestCase("")]
-        [TestCase(" ")]
         //
         public void SetArgument_ParameterWithWrongCustomString_ReturnArgumentException(string value)
         {

tests/InterAppConnector.Test.Library/CommandOutputTest.cs

@@ -1,17 +1,91 @@
 using InterAppConnector.DataModels;
 using InterAppConnector.Enumerations;
 using InterAppConnector.Exceptions;
-using InterAppConnector.Interfaces;
 using InterAppConnector.Test.Library.DataModels;
 using Newtonsoft.Json;
 using NUnit.Framework;
-using System.Collections.Generic;
 using System.Dynamic;
 
 namespace InterAppConnector.Test.Library
 {
     public class CommandOutputTest
     {
+        private delegate void TestDelegate();
+
+        private event TestDelegate TestEvent;
+
+        [Test]
+        public void IsEventAlreadyAttached_CompareWithTwoSameEvent_ShouldReturnTrue()
+        {
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+
+            TestEvent.Invoke();
+
+            Assert.That(CommandOutput.IsEventAlreadyAttached(TestEvent, CommandOutputTest_TestEvent2), Is.True);
+        }
+
+        [Test]
+        public void IsEventAlreadyAttached_CompareWithDifferentEventsWithTheSameName_ShouldReturnTrue()
+        {
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+
+            TestEvent.Invoke();
+
+            Assert.That(CommandOutput.IsEventAlreadyAttached(TestEvent, CommandOutputTest_TestEvent2), Is.True);
+        }
+
+        [Test]
+        public void IsEventAlreadyAttached_CompareWitANullEvent_ShouldReturnFalse()
+        {
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+
+            TestEvent.Invoke();
+
+            Assert.That(CommandOutput.IsEventAlreadyAttached(TestEvent, null), Is.False);
+        }
+
+        [Test]
+        public void IsEventAlreadyAttached_CompareWitANullTarget_ShouldReturnFalse()
+        {
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+
+            TestEvent.Invoke();
+
+            Assert.That(CommandOutput.IsEventAlreadyAttached(null, CommandOutputTest_TestEvent2), Is.False);
+        }
+
+        [Test]
+        public void IsEventAlreadyAttached_CompareAllNull_ShouldReturnFalse()
+        {
+            TestEvent += CommandOutputTest_TestEvent;
+            TestEvent += CommandOutputTest_TestEvent2;
+
+            TestEvent.Invoke();
+
+            Assert.That(CommandOutput.IsEventAlreadyAttached(null, null), Is.False);
+        }
+
+        private void CommandOutputTest_TestEvent()
+        {
+            Assert.That(CommandOutput.IsEventAlreadyAttached(TestEvent, CommandOutputTest_TestEvent1), Is.False);
+        }
+
+        private void CommandOutputTest_TestEvent1()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void CommandOutputTest_TestEvent2()
+        {
+            Assert.That(CommandOutput.IsEventAlreadyAttached(TestEvent, CommandOutputTest_TestEvent1), Is.False);
+        }
+
         [Test]
         public void Parse_ParseSuccessMessage_ReturnSuccessMessage()
         {