Merge pull request #24 from thygesteffensen/issue/18/dountil

Issue/18/dountil

Close #18

Author: thygesteffensen

PowerAutomateMockUp/ExpressionParser/Functions/Base/FlowRunnerDependencyExtension.cs

@@ -36,11 +36,13 @@ public static void AddFlowRunner(this IServiceCollection services)
 
             services.AddTransient<IFunction, TrimFunction>();
             services.AddTransient<IFunction, LengthFunction>();
+            services.AddTransient<IFunction, GreaterFunction>();
 
             services.AddFlowActionByFlowType<IfActionExecutor>("If");
             services.AddFlowActionByFlowType<ScopeActionExecutor>("Scope");
             services.AddFlowActionByFlowType<TerminateActionExecutor>("Terminate");
             services.AddFlowActionByFlowType<ForEachActionExecutor>("Foreach");
+            services.AddFlowActionByFlowType<DoUntilActionExecutor>("Until");
             services.AddFlowActionByFlowType<SwitchActionExecutor>("Switch");
 
             services.AddLogging();

PowerAutomateMockUp/ExpressionParser/Functions/Implementations/GreaterFunction.cs

@@ -0,0 +1,22 @@
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Implementations
+{
+    public class GreaterFunction : Function
+    {
+        public GreaterFunction() : base("greater")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length < 2)
+            {
+                throw new ArgumentError("Too few arguments");
+            }
+            
+            return new ValueContainer(parameters[0].CompareTo(parameters[1]) > 0);
+        }
+    }
+}

PowerAutomateMockUp/ExpressionParser/ValueContainer.cs

@@ -7,7 +7,7 @@
 namespace Parser.ExpressionParser
 {
     [JsonConverter(typeof(ValueContainerConverter))]
-    public class ValueContainer
+    public class ValueContainer : IComparable, IEquatable<ValueContainer>
     {
         private readonly dynamic _value;
         private readonly ValueType _type;
@@ -254,7 +254,7 @@ private ValueContainer JsonToValueContainer(JToken json)
         private ValueContainer JArrayToValueContainer(JArray json)
         {
             var list = new List<ValueContainer>();
-            
+
             foreach (var jToken in json)
             {
                 if (jToken.GetType() != typeof(JValue))
@@ -311,6 +311,61 @@ public bool IsNull()
         {
             return _type == ValueType.Null;
         }
+
+        public int CompareTo(object? obj)
+        {
+            if (obj == null || obj.GetType() != GetType()) throw new InvalidOperationException("Cannot compare these two...");
+
+            var other = (ValueContainer) obj;
+            if (other.Type() != _type)
+            {
+                // TODO: Fix comparison
+
+                throw new InvalidOperationException("Cannot compare two different ValueContainers");
+            }
+            else
+            {
+                switch (_value)
+                {
+                    case bool b:
+                        return b.CompareTo(other._value);
+                    case int i:
+                        return i.CompareTo(other._value);
+                    case float f:
+                        return f.CompareTo(other._value);
+                    case string s:
+                        return s.CompareTo(other._value);
+                    case Dictionary<string, ValueContainer> d:
+                        var d2 = (Dictionary<string, ValueContainer>) other._value;
+                        return d.Count - d2.Count;
+                    case IEnumerable<ValueContainer> l:
+                        var l2 = (IEnumerable<ValueContainer>) other._value;
+                        return l.Count() - l2.Count();
+                    default:
+                        return -1;
+                }
+            }
+        }
+
+        public bool Equals(ValueContainer other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Equals(_value, other._value) && _type == other._type;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != GetType()) return false;
+            return Equals((ValueContainer) obj);
+        }
+
+        /*public override int GetHashCode()
+        {
+            return HashCode.Combine(_value, (int) _type);
+        }*/
     }
 
     static class ValueContainerExtensions

PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/DoUntilActionExecutor.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
+using Parser.ExpressionParser;
+
+namespace Parser.FlowParser.ActionExecutors.Implementations
+{
+    public class DoUntilActionExecutor : DefaultBaseActionExecutor, IScopeActionExecutor
+    {
+        private readonly IScopeDepthManager _scopeDepthManager;
+        private readonly ILogger<DoUntilActionExecutor> _logger;
+        private readonly IExpressionEngine _expressionEngine;
+
+        private JProperty[] _actionDescriptions;
+        private string _firstScopeActionName;
+        private string _expressionString;
+        private int _countLimit;
+        private int _counts = 0;
+
+        public DoUntilActionExecutor(
+            IScopeDepthManager scopeDepthManager,
+            ILogger<DoUntilActionExecutor> logger,
+            IExpressionEngine expressionEngine)
+        {
+            _scopeDepthManager = scopeDepthManager ?? throw new ArgumentNullException(nameof(scopeDepthManager));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _expressionEngine = expressionEngine ?? throw new ArgumentNullException(nameof(expressionEngine));
+        }
+
+        public override Task<ActionResult> Execute()
+        {
+            _logger.LogInformation("Entered do until...");
+
+            if (Json == null)
+            {
+                throw new PowerAutomateMockUpException($"Json cannot be null - cannot execute {ActionName}.");
+            }
+
+            SetupDoUntil();
+
+            if (!EvaluateExpressionResult())
+            {
+                return Task.FromResult(new ActionResult());
+            }
+
+            PushActions();
+
+            return Task.FromResult(new ActionResult {NextAction = _firstScopeActionName});
+        }
+
+        private void SetupDoUntil()
+        {
+            _expressionString = (Json.SelectToken("$..expression") ??
+                                 throw new InvalidOperationException("Json must contain expression token."))
+                .Value<string>();
+
+            _countLimit = (Json.SelectToken("$..count")
+                           ?? throw new InvalidOperationException("Json must contain count token.")
+                ).Value<int>();
+
+            var scopeActionDescriptions = (Json.SelectToken("$..actions") ??
+                                           throw new InvalidOperationException("Json must contain actions token."))
+                .OfType<JProperty>();
+            _actionDescriptions = scopeActionDescriptions as JProperty[] ?? scopeActionDescriptions.ToArray();
+            _firstScopeActionName = _actionDescriptions.First(ad =>
+                !(ad.Value.SelectToken("$.runAfter") ??
+                  throw new InvalidOperationException("Json must contain runAfter token.")).Any()).Name;
+        }
+
+        private void PushActions()
+        {
+            _scopeDepthManager.Push(ActionName, _actionDescriptions, this);
+        }
+
+        public Task<ActionResult> ExitScope(ActionStatus scopeStatus)
+        {
+            _counts++;
+            if (_counts >= _countLimit)
+            {
+                _logger.LogInformation($"Exited do until loop due to count limit of {_counts}...");
+                return Task.FromResult(new ActionResult());
+            }
+
+            if (EvaluateExpressionResult())
+            {
+                _logger.LogInformation("Continuing do until loop.");
+
+                PushActions();
+
+                return Task.FromResult(new ActionResult {NextAction = _firstScopeActionName});
+            }
+            else
+            {
+                _logger.LogInformation("Exited do until loop...");
+                return Task.FromResult(new ActionResult());
+            }
+        }
+
+        private bool EvaluateExpressionResult()
+        {
+            var expressionResult = _expressionEngine.ParseToValueContainer(_expressionString);
+            if (expressionResult.Type() != ValueContainer.ValueType.Boolean)
+            {
+                throw new PowerAutomateMockUpException("Do until expression did not resolve to boolean type.");
+            }
+
+            return expressionResult.GetValue<bool>();
+        }
+    }
+}

Test/ActionTests/DoUntilActionExecutorTest.cs

@@ -0,0 +1,122 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Moq;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using Parser;
+using Parser.ExpressionParser;
+using Parser.FlowParser.ActionExecutors;
+using Parser.FlowParser.ActionExecutors.Implementations;
+
+namespace Test.ActionTests
+{
+    [TestFixture]
+    public class DoUntilActionExecutorTest
+    {
+        string DoUntilAction =
+            "{\"Do_until\": {" +
+            "\"actions\": {" +
+            "\"Increment_variable\": {" +
+            "\"runAfter\": {}," +
+            "\"type\": \"IncrementVariable\"," +
+            "\"inputs\": {" +
+            "\"name\": \"Variable\"," +
+            "\"value\": 1" +
+            "}}}," +
+            "\"runAfter\": { \"Initialize_variable\": [ \"Succeeded\" ] }," +
+            "\"expression\": \"@greater(variables('Variable'), 10)\"," +
+            "\"limit\": {" +
+            "\"count\": 3," +
+            "\"timeout\": \"PT1H\"" +
+            "}," +
+            "\"type\": \"Until\"" +
+            "}," +
+            "\"Initialize_variable\": {" +
+            "\"runAfter\": {}," +
+            "\"type\": \"InitializeVariable\"," +
+            "\"inputs\": {" +
+            "\"variables\": [" +
+            "{" +
+            "\"name\": \"Variable\"," +
+            "\"type\": \"integer\"" +
+            "}]}}}";
+
+        [Test]
+        public async Task TestDoUntilLimit()
+        {
+            var loggerMock = TestLogger.Create<DoUntilActionExecutor>();
+
+            var sdm = new Mock<IScopeDepthManager>();
+
+            var expr = new Mock<IExpressionEngine>();
+            expr.Setup(x => x.ParseToValueContainer(It.IsAny<string>())).Returns(new ValueContainer(true));
+
+            var doUntil = new DoUntilActionExecutor(sdm.Object, loggerMock, expr.Object);
+            doUntil.InitializeActionExecutor("DoUntil", JToken.Parse(DoUntilAction));
+
+            var result = await doUntil.Execute();
+            Assert.AreEqual(ActionStatus.Succeeded, result.ActionStatus);
+            Assert.NotNull(result.NextAction);
+
+            sdm.Verify(
+                x => x.Push(
+                    It.IsAny<string>(),
+                    It.IsAny<IEnumerable<JProperty>>(),
+                    It.IsAny<IScopeActionExecutor>()),
+                Times.Once);
+
+            var exit1 = await doUntil.ExitScope(ActionStatus.Succeeded);
+            Assert.NotNull(exit1.NextAction);
+            sdm.Verify(
+                x => x.Push(
+                    It.IsAny<string>(),
+                    It.IsAny<IEnumerable<JProperty>>(),
+                    It.IsAny<IScopeActionExecutor>()),
+                Times.Exactly(2));
+            
+            
+            var exit2 = await doUntil.ExitScope(ActionStatus.Succeeded);
+            Assert.NotNull(exit2.NextAction);
+            sdm.Verify(
+                x => x.Push(
+                    It.IsAny<string>(),
+                    It.IsAny<IEnumerable<JProperty>>(),
+                    It.IsAny<IScopeActionExecutor>()),
+                Times.Exactly(3));
+            
+            var exit3 = await doUntil.ExitScope(ActionStatus.Succeeded);
+            Assert.IsNull(exit3.NextAction);
+            sdm.Verify(
+                x => x.Push(
+                    It.IsAny<string>(),
+                    It.IsAny<IEnumerable<JProperty>>(),
+                    It.IsAny<IScopeActionExecutor>()),
+                Times.Exactly(3));
+        }
+
+        [Test]
+        public async Task TestDoUntilNone()
+        {
+            var loggerMock = TestLogger.Create<DoUntilActionExecutor>();
+
+            var sdm = new Mock<IScopeDepthManager>();
+
+            var expr = new Mock<IExpressionEngine>();
+            expr.Setup(x => x.ParseToValueContainer(It.IsAny<string>())).Returns(new ValueContainer(false));
+
+            var doUntil = new DoUntilActionExecutor(sdm.Object, loggerMock, expr.Object);
+            doUntil.InitializeActionExecutor("DoUntil", JToken.Parse(DoUntilAction));
+
+            var result = await doUntil.Execute();
+            Assert.AreEqual(ActionStatus.Succeeded, result.ActionStatus);
+            Assert.IsNull(result.NextAction);
+
+            sdm.Verify(
+                x => x.Push(
+                    It.IsAny<string>(),
+                    It.IsAny<IEnumerable<JProperty>>(),
+                    It.IsAny<IScopeActionExecutor>()),
+                Times.Never);
+        }
+    }
+}

Test/ParserTest.cs

@@ -304,6 +304,15 @@ public void TestInternalsFlowStorageValueContainer(TestInput input)
                 VariableKey = "dictionary",
                 ValueContainers = BigValue,
                 StorageOption = StorageOption.Variables
+            },
+            new TestInput
+            (
+                "@greater(variables('Variable'), 10)",
+                ValueContainer.ValueType.Boolean)
+            {
+                VariableKey = "Variable",
+                ValueContainers = new[] {new ValueContainer(11)},
+                StorageOption = StorageOption.Variables
             }
         };