Merge pull request #16 from thygesteffensen/fix/tryparseparameters

thygesteffensen · web-flow · commit c2d0479b2d5f · 2020-12-21T09:49:47.000+01:00
Fix/tryparseparameters
diff --git a/.github/workflows/todo.yml b/.github/workflows/todo.yml
@@ -0,0 +1,19 @@
+﻿name: "Create issues from todo"
+
+on:
+  push:
+    branches:
+      - dev
+
+jobs:
+  build:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: "actions/checkout@master"
+      - name: "TODO to Issue"
+        uses: "alstr/todo-to-issue-action@v2.4"
+        id: "todo"
+        with:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COMMENT_MARKER: "//"
+          LABEL: "// TODO"
diff --git a/PowerAutomateMockUp/ExpressionParser/ValueContainer.cs b/PowerAutomateMockUp/ExpressionParser/ValueContainer.cs
@@ -205,7 +205,7 @@ public ValueContainer this[string key]
             }
         }
 
-        private Dictionary<string, ValueContainer> AsDict()
+        public Dictionary<string, ValueContainer> AsDict()
         {
             if (_type == ValueType.Object)
             {
diff --git a/PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ScopeActionExecutor.cs b/PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ScopeActionExecutor.cs
@@ -16,17 +16,19 @@ public ScopeActionExecutor(ScopeDepthManager scopeDepthManager)
 
         public override Task<ActionResult> Execute()
         {
-            var scopeActionJson = Json.Parent;
-            var scopeName = ((JProperty) scopeActionJson).Name;
-
             var scopeActionDescriptions = Json.SelectToken("$.actions").OfType<JProperty>();
             var actionDescriptions = scopeActionDescriptions as JProperty[] ?? scopeActionDescriptions.ToArray();
-            
-            _scopeDepthManager.Push(scopeName, actionDescriptions);
+
+            _scopeDepthManager.Push(ActionName, actionDescriptions, null);
 
             var firstScopeAction = actionDescriptions.First(ad => !ad.Value.SelectToken("$.runAfter").Any());
 
             return Task.FromResult(new ActionResult {NextAction = firstScopeAction.Name});
         }
     }
+
+    public interface IScopeActionExecutor
+    {
+        public Task<ActionResult> ExitScope(ActionStatus scopeStatus);
+    }
 }
diff --git a/PowerAutomateMockUp/FlowParser/ActionExecutors/OpenApiConnectionBaseActionExecutor.cs b/PowerAutomateMockUp/FlowParser/ActionExecutors/OpenApiConnectionBaseActionExecutor.cs
@@ -31,7 +31,7 @@ protected override void ProcessJson()
             foreach (var keyValuePar in content.Parameters)
             {
                 // TODO: Here is an use case where the engine could have just returned a Value Container instead!
-                Parameters[keyValuePar.Key] = new ValueContainer(_expressionEngine.Parse(keyValuePar.Value));
+                Parameters[keyValuePar.Key] = new ValueContainer(_expressionEngine.Parse(keyValuePar.Value), true);
             }
         }
 
diff --git a/PowerAutomateMockUp/FlowParser/FlowRunner.cs b/PowerAutomateMockUp/FlowParser/FlowRunner.cs
@@ -40,7 +40,7 @@ public void InitializeFlowRunner(in string path)
             var flowJson = JToken.ReadFrom(jsonTextReader);
             var flowDefinition = flowJson.SelectToken("$.*.definition");
             _trigger = flowDefinition.SelectToken("$.triggers").First as JProperty;
-            _scopeManager.Push("root", flowDefinition.SelectToken("$.actions").OfType<JProperty>());
+            _scopeManager.Push("root", flowDefinition.SelectToken("$.actions").OfType<JProperty>(), null);
         }
 
         public async Task<object> Trigger(ValueContainer triggerOutputs)
@@ -56,7 +56,7 @@ public async Task Trigger()
         {
             var trigger = GetActionExecutor(_trigger);
 
-            trigger.InitializeActionExecutor(_trigger.Name ,_trigger.Value);
+            trigger.InitializeActionExecutor(_trigger.Name, _trigger.Value);
             await trigger.Execute();
 
             await RunFlow();
@@ -72,9 +72,8 @@ private async Task RunFlow()
                 if (_flowRunnerSettings.IgnoreActions.Contains(currentAd.Name))
                 {
                     currentAd = _scopeManager.CurrentActionDescriptions.FirstOrDefault(a =>
-                        a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name ==
-                        currentAd.Name &&
-                        a.Value.SelectToken("$.runAfter.*").Values().Any(
+                        a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name == currentAd.Name
+                        && a.Value.SelectToken("$.runAfter.*").Values().Any(
                             x => x?.Value<string>() == ActionStatus.Succeeded.ToString()));
                     continue;
                 }
@@ -87,30 +86,43 @@ private async Task RunFlow()
                     break;
                 }
 
+                // If an action failes inside a scope, and a suitable action isn't found inside the given scope, that 
+                // actions status is transferred to be the scope status. This isn't the case atm
+                
+                // TODO: Figure out how to get actionResult from
                 var actionDescName = currentAd.Name;
-                while (!DetermineNextAction(actionResult, out currentAd, actionDescName))
+                var nextAction = actionResult.NextAction;
+                var actionResultStatus = actionResult.ActionStatus;
+                while (!DetermineNextAction(nextAction, actionResultStatus, out currentAd, actionDescName))
                 {
-                    if (!_scopeManager.TryPopScope(out actionDescName))
+                    nextAction = null;
+                    var t = await _scopeManager.TryPopScope(actionResultStatus);
+                    if (t == null)
                     {
+                        currentAd = null;
                         break;
                     }
+
+                    actionResultStatus = t.ActionStatus;
+                    actionDescName = t.NextAction;
                 }
             }
         }
 
-        private bool DetermineNextAction(ActionResult actionResult, out JProperty currentActionDesc, string adName)
+        private bool DetermineNextAction(string nextAction, ActionStatus actionResultStatus,
+            out JProperty currentActionDesc, string adName)
         {
-            if (actionResult?.NextAction == null)
+            if (nextAction == null)
             {
                 currentActionDesc = _scopeManager.CurrentActionDescriptions.FirstOrDefault(a =>
                     a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name == adName &&
                     a.Value.SelectToken("$.runAfter.*").Values().Any(
-                        x => x?.Value<string>() == actionResult?.ActionStatus.ToString()));
+                        x => x?.Value<string>() == actionResultStatus.ToString()));
             }
             else
             {
                 currentActionDesc =
-                    _scopeManager.CurrentActionDescriptions.First(a => a.Name == actionResult.NextAction);
+                    _scopeManager.CurrentActionDescriptions.First(a => a.Name == nextAction);
             }
 
             return currentActionDesc != null;
@@ -121,7 +133,7 @@ private static async Task<ActionResult> ExecuteAction(ActionExecutorBase actionE
         {
             if (actionExecutor == null) return null;
 
-            actionExecutor.InitializeActionExecutor(currentAction.Name ,currentAction.First);
+            actionExecutor.InitializeActionExecutor(currentAction.Name, currentAction.First);
             return await actionExecutor.Execute();
         }
 
diff --git a/PowerAutomateMockUp/PowerAutomateMockUp.csproj b/PowerAutomateMockUp/PowerAutomateMockUp.csproj
@@ -19,11 +19,11 @@
     <ItemGroup>
         <!--<FrameworkReference Include="Microsoft.AspNetCore.App" />-->
         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
-        <PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.9" />
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.9" />
-        <PackageReference Include="Microsoft.Extensions.Options" Version="3.1.9" />
-        <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.9" />
-        <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
+        <PackageReference Include="Microsoft.Extensions.Configuration" Version="5.0.0" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
+        <PackageReference Include="Microsoft.Extensions.Options" Version="5.0.0" />
+        <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
+        <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
         <PackageReference Include="Sprache" Version="2.3.1" />
     </ItemGroup>
     
diff --git a/PowerAutomateMockUp/ScopeDepthManager.cs b/PowerAutomateMockUp/ScopeDepthManager.cs
@@ -1,26 +1,38 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
-using Parser.ExpressionParser.Functions.CustomException;
+using Parser.FlowParser.ActionExecutors;
+using Parser.FlowParser.ActionExecutors.Implementations;
 
 namespace Parser
 {
     public class ScopeDepthManager
     {
+        private readonly ILogger<ScopeDepthManager> _logger;
         public IEnumerable<JProperty> CurrentActionDescriptions { get; private set; }
 
         private readonly Stack<string> _scopes;
+        private readonly Stack<IScopeActionExecutor> _scopeActionExecutors;
         private readonly Stack<IEnumerable<JProperty>> _actionDescriptions;
 
-        public ScopeDepthManager()
+        public ScopeDepthManager(ILogger<ScopeDepthManager> logger)
         {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _actionDescriptions = new Stack<IEnumerable<JProperty>>();
             _scopes = new Stack<string>();
+            _scopeActionExecutors = new Stack<IScopeActionExecutor>();
         }
 
-        public void Push(string scopeName, IEnumerable<JProperty> scopeActionDescriptions)
+        public void Push(
+            string scopeName,
+            IEnumerable<JProperty> scopeActionDescriptions,
+            IScopeActionExecutor scopeActionExecutor)
         {
+            _logger.LogInformation("Entered a scope ({scopeName}).", scopeName);
+
             var scopeActionDescriptionsAsList =
                 scopeActionDescriptions as JProperty[] ?? scopeActionDescriptions.ToArray();
 
@@ -34,14 +46,20 @@ public void Push(string scopeName, IEnumerable<JProperty> scopeActionDescription
                 CurrentActionDescriptions = scopeActionDescriptionsAsList;
 
                 _scopes.Push(scopeName);
+
+                _scopeActionExecutors.Push(scopeActionExecutor);
             }
         }
 
-        public bool TryPopScope(out string scopeName)
+        public async Task<ActionResult> TryPopScope(ActionStatus scopeStatus)
         {
+            _logger.LogInformation("Exiting scope.");
+
 #if DOT_NET_CORE
-            var scopePopSuccessful = _scopes.TryPop(out scopeName);
+            var scopePopSuccessful = _scopes.TryPop(out var scopeName);
 #else
+            string scopeName;
+
             var scopePopSuccessful = true;
             try
             {
@@ -54,12 +72,34 @@ public bool TryPopScope(out string scopeName)
             }
 #endif
 
-            if (scopePopSuccessful)
+            // Todo: Finish the State Machine and figure out how this should be handled properly
+
+
+            if (!scopePopSuccessful)
+            {
+                return null;
+            }
+
+            CurrentActionDescriptions = _actionDescriptions.Pop();
+
+            var t = _scopeActionExecutors.Pop();
+
+            ActionResult exitScopeResult = null;
+            if (t == null)
+            {
+                _logger.LogInformation("Scope action does not have a exit scope action.");
+            }
+            else
             {
-                CurrentActionDescriptions = _actionDescriptions.Pop();
+                exitScopeResult = await t.ExitScope(scopeStatus);
             }
 
-            return scopePopSuccessful;
+
+            return await Task.FromResult(new ActionResult
+            {
+                ActionStatus = exitScopeResult?.ActionStatus ?? scopeStatus,
+                NextAction = scopeName
+            });
         }
     }
 }
diff --git a/Test/ActionTests/ScopeActionExecutorTest.cs b/Test/ActionTests/ScopeActionExecutorTest.cs
@@ -0,0 +1,37 @@
+﻿using System.Collections.Generic;
+using System.Threading.Tasks;
+using Moq;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using Parser;
+using Parser.FlowParser.ActionExecutors;
+using Parser.FlowParser.ActionExecutors.Implementations;
+
+namespace Test.ActionTests
+{
+    [TestFixture]
+    public class ScopeActionExecutorTest
+    {
+        [Test]
+        public async Task TestBasicScopeUseCase()
+        {
+            var logger = TestLogger.Create<ScopeDepthManager>();
+
+            var scopeDepthManager = new ScopeDepthManager(logger);
+            scopeDepthManager.Push("rootScope", new List<JProperty>(), null);
+
+            var t = new Mock<IScopeActionExecutor>();
+            t.Setup(x => x.ExitScope(ActionStatus.Succeeded)).Returns(Task.FromResult(new ActionResult()));
+
+            scopeDepthManager.Push("testScope", new List<JProperty>(), t.Object);
+
+            var t1 = await scopeDepthManager.TryPopScope(ActionStatus.Succeeded);
+
+            t.Verify(x => x.ExitScope(ActionStatus.Succeeded));
+            
+            Assert.AreEqual(t1.ActionStatus, ActionStatus.Succeeded);
+            Assert.AreEqual(t1.NextAction, "testScope");
+            Assert.AreEqual(t1.ContinueExecution, true);
+        }
+    }
+}
diff --git a/Test/ParserTest.cs b/Test/ParserTest.cs
@@ -136,17 +136,17 @@ public void TestTriggerOutputs(TestInput testInput)
 
         private static object[] _triggerOutputTest =
         {
-            new TestInput("@triggerOutputs()['body/dca_entrytype']", "OCR payment")
+            new TestInput("@triggerOutputs()['body/entrytype']", "OCR payment")
             {
                 ValueContainers = new[]
                 {
                     new ValueContainer(new Dictionary<string, ValueContainer>
                     {
-                        {"body/dca_entrytype", new ValueContainer("OCR payment")}
+                        {"body/entrytype", new ValueContainer("OCR payment")}
                     })
                 }
             },
-            /*new TestInput("@triggerOutputs()?['body/dca_entrytype']", null)
+            /*new TestInput("@triggerOutputs()?['body/entrytype']", null)
             {
                 ValueContainers = new[]
                 {
diff --git a/Test/Test.csproj b/Test/Test.csproj
@@ -13,12 +13,15 @@
 
     <ItemGroup>
         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.9" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
         <PackageReference Include="Moq" Version="4.15.2" />
-        <PackageReference Include="MSTest.TestAdapter" Version="2.1.0" />
-        <PackageReference Include="MSTest.TestFramework" Version="2.1.0" />
-        <PackageReference Include="coverlet.collector" Version="1.2.0" />
+        <PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
+        <PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
+        <PackageReference Include="coverlet.collector" Version="1.3.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
         <PackageReference Include="NUnit" Version="3.12.0" />
         <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     </ItemGroup>

Original file line number	Diff line number	Diff line change
`@@ -205,7 +205,7 @@ public ValueContainer this[string key]`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`208`		`- private Dictionary<string, ValueContainer> AsDict()`
	`208`	`+ public Dictionary<string, ValueContainer> AsDict()`
`209`	`209`	`{`
`210`	`210`	`if (_type == ValueType.Object)`
`211`	`211`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,19 @@ public ScopeActionExecutor(ScopeDepthManager scopeDepthManager)`
`16`	`16`
`17`	`17`	`public override Task<ActionResult> Execute()`
`18`	`18`	`{`
`19`		`- var scopeActionJson = Json.Parent;`
`20`		`- var scopeName = ((JProperty) scopeActionJson).Name;`
`21`		`-`
`22`	`19`	`var scopeActionDescriptions = Json.SelectToken("$.actions").OfType<JProperty>();`
`23`	`20`	`var actionDescriptions = scopeActionDescriptions as JProperty[] ?? scopeActionDescriptions.ToArray();`
`24`		`-`
`25`		`- _scopeDepthManager.Push(scopeName, actionDescriptions);`
	`21`	`+`
	`22`	`+ _scopeDepthManager.Push(ActionName, actionDescriptions, null);`
`26`	`23`
`27`	`24`	`var firstScopeAction = actionDescriptions.First(ad => !ad.Value.SelectToken("$.runAfter").Any());`
`28`	`25`
`29`	`26`	`return Task.FromResult(new ActionResult {NextAction = firstScopeAction.Name});`
`30`	`27`	`}`
`31`	`28`	`}`
	`29`	`+`
	`30`	`+ public interface IScopeActionExecutor`
	`31`	`+ {`
	`32`	`+ public Task<ActionResult> ExitScope(ActionStatus scopeStatus);`
	`33`	`+ }`
`32`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ protected override void ProcessJson()`
`31`	`31`	`foreach (var keyValuePar in content.Parameters)`
`32`	`32`	`{`
`33`	`33`	`// TODO: Here is an use case where the engine could have just returned a Value Container instead!`
`34`		`- Parameters[keyValuePar.Key] = new ValueContainer(_expressionEngine.Parse(keyValuePar.Value));`
	`34`	`+ Parameters[keyValuePar.Key] = new ValueContainer(_expressionEngine.Parse(keyValuePar.Value), true);`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public void InitializeFlowRunner(in string path)`
`40`	`40`	`var flowJson = JToken.ReadFrom(jsonTextReader);`
`41`	`41`	`var flowDefinition = flowJson.SelectToken("$.*.definition");`
`42`	`42`	`_trigger = flowDefinition.SelectToken("$.triggers").First as JProperty;`
`43`		`- _scopeManager.Push("root", flowDefinition.SelectToken("$.actions").OfType<JProperty>());`
	`43`	`+ _scopeManager.Push("root", flowDefinition.SelectToken("$.actions").OfType<JProperty>(), null);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public async Task<object> Trigger(ValueContainer triggerOutputs)`
`@@ -56,7 +56,7 @@ public async Task Trigger()`
`56`	`56`	`{`
`57`	`57`	`var trigger = GetActionExecutor(_trigger);`
`58`	`58`
`59`		`- trigger.InitializeActionExecutor(_trigger.Name ,_trigger.Value);`
	`59`	`+ trigger.InitializeActionExecutor(_trigger.Name, _trigger.Value);`
`60`	`60`	`await trigger.Execute();`
`61`	`61`
`62`	`62`	`await RunFlow();`
`@@ -72,9 +72,8 @@ private async Task RunFlow()`
`72`	`72`	`if (_flowRunnerSettings.IgnoreActions.Contains(currentAd.Name))`
`73`	`73`	`{`
`74`	`74`	`currentAd = _scopeManager.CurrentActionDescriptions.FirstOrDefault(a =>`
`75`		`- a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name ==`
`76`		`- currentAd.Name &&`
`77`		`- a.Value.SelectToken("$.runAfter.*").Values().Any(`
	`75`	`+ a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name == currentAd.Name`
	`76`	`+ && a.Value.SelectToken("$.runAfter.*").Values().Any(`
`78`	`77`	`x => x?.Value<string>() == ActionStatus.Succeeded.ToString()));`
`79`	`78`	`continue;`
`80`	`79`	`}`
`@@ -87,30 +86,43 @@ private async Task RunFlow()`
`87`	`86`	`break;`
`88`	`87`	`}`
`89`	`88`
	`89`	`+ // If an action failes inside a scope, and a suitable action isn't found inside the given scope, that`
	`90`	`+ // actions status is transferred to be the scope status. This isn't the case atm`
	`91`	`+`
	`92`	`+ // TODO: Figure out how to get actionResult from`
`90`	`93`	`var actionDescName = currentAd.Name;`
`91`		`- while (!DetermineNextAction(actionResult, out currentAd, actionDescName))`
	`94`	`+ var nextAction = actionResult.NextAction;`
	`95`	`+ var actionResultStatus = actionResult.ActionStatus;`
	`96`	`+ while (!DetermineNextAction(nextAction, actionResultStatus, out currentAd, actionDescName))`
`92`	`97`	`{`
`93`		`- if (!_scopeManager.TryPopScope(out actionDescName))`
	`98`	`+ nextAction = null;`
	`99`	`+ var t = await _scopeManager.TryPopScope(actionResultStatus);`
	`100`	`+ if (t == null)`
`94`	`101`	`{`
	`102`	`+ currentAd = null;`
`95`	`103`	`break;`
`96`	`104`	`}`
	`105`	`+`
	`106`	`+ actionResultStatus = t.ActionStatus;`
	`107`	`+ actionDescName = t.NextAction;`
`97`	`108`	`}`
`98`	`109`	`}`
`99`	`110`	`}`
`100`	`111`
`101`		`- private bool DetermineNextAction(ActionResult actionResult, out JProperty currentActionDesc, string adName)`
	`112`	`+ private bool DetermineNextAction(string nextAction, ActionStatus actionResultStatus,`
	`113`	`+ out JProperty currentActionDesc, string adName)`
`102`	`114`	`{`
`103`		`- if (actionResult?.NextAction == null)`
	`115`	`+ if (nextAction == null)`
`104`	`116`	`{`
`105`	`117`	`currentActionDesc = _scopeManager.CurrentActionDescriptions.FirstOrDefault(a =>`
`106`	`118`	`a.Value.SelectToken("$.runAfter").First?.ToObject<JProperty>().Name == adName &&`
`107`	`119`	`a.Value.SelectToken("$.runAfter.*").Values().Any(`
`108`		`- x => x?.Value<string>() == actionResult?.ActionStatus.ToString()));`
	`120`	`+ x => x?.Value<string>() == actionResultStatus.ToString()));`
`109`	`121`	`}`
`110`	`122`	`else`
`111`	`123`	`{`
`112`	`124`	`currentActionDesc =`
`113`		`- _scopeManager.CurrentActionDescriptions.First(a => a.Name == actionResult.NextAction);`
	`125`	`+ _scopeManager.CurrentActionDescriptions.First(a => a.Name == nextAction);`
`114`	`126`	`}`
`115`	`127`
`116`	`128`	`return currentActionDesc != null;`
`@@ -121,7 +133,7 @@ private static async Task<ActionResult> ExecuteAction(ActionExecutorBase actionE`
`121`	`133`	`{`
`122`	`134`	`if (actionExecutor == null) return null;`
`123`	`135`
`124`		`- actionExecutor.InitializeActionExecutor(currentAction.Name ,currentAction.First);`
	`136`	`+ actionExecutor.InitializeActionExecutor(currentAction.Name, currentAction.First);`
`125`	`137`	`return await actionExecutor.Execute();`
`126`	`138`	`}`
`127`	`139`
Original file line number	Diff line number	Diff line change
`@@ -136,17 +136,17 @@ public void TestTriggerOutputs(TestInput testInput)`
`136`	`136`
`137`	`137`	`private static object[] _triggerOutputTest =`
`138`	`138`	`{`
`139`		`- new TestInput("@triggerOutputs()['body/dca_entrytype']", "OCR payment")`
	`139`	`+ new TestInput("@triggerOutputs()['body/entrytype']", "OCR payment")`
`140`	`140`	`{`
`141`	`141`	`ValueContainers = new[]`
`142`	`142`	`{`
`143`	`143`	`new ValueContainer(new Dictionary<string, ValueContainer>`
`144`	`144`	`{`
`145`		`- {"body/dca_entrytype", new ValueContainer("OCR payment")}`
	`145`	`+ {"body/entrytype", new ValueContainer("OCR payment")}`
`146`	`146`	`})`
`147`	`147`	`}`
`148`	`148`	`},`
`149`		`- /*new TestInput("@triggerOutputs()?['body/dca_entrytype']", null)`
	`149`	`+ /*new TestInput("@triggerOutputs()?['body/entrytype']", null)`
`150`	`150`	`{`
`151`	`151`	`ValueContainers = new[]`
`152`	`152`	`{`