2020-12-23 00:34:10 -05:00
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
|
|
// Licensed under the MIT License.
|
|
|
|
using RulesEngine.Models;
|
2020-11-01 22:55:43 -05:00
|
|
|
using System;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
using System.Threading.Tasks;
|
|
|
|
using Xunit;
|
|
|
|
|
2020-12-23 00:34:10 -05:00
|
|
|
namespace RulesEngine.UnitTest
|
|
|
|
{
|
2020-11-01 22:55:43 -05:00
|
|
|
|
|
|
|
[ExcludeFromCodeCoverage]
|
2020-12-23 00:34:10 -05:00
|
|
|
public class RulesEngineWithActionsTests
|
|
|
|
{
|
2020-11-01 22:55:43 -05:00
|
|
|
|
|
|
|
[Fact]
|
2020-12-23 00:34:10 -05:00
|
|
|
public async Task WhenExpressionIsSuccess_OutputExpressionAction_ReturnsExpressionEvaluation()
|
|
|
|
{
|
2020-11-01 22:55:43 -05:00
|
|
|
var engine = new RulesEngine(GetWorkflowWithActions());
|
|
|
|
var result = await engine.ExecuteActionWorkflowAsync("ActionWorkflow", "ExpressionOutputRuleTest", new RuleParameter[0]);
|
|
|
|
Assert.NotNull(result);
|
2020-12-23 00:34:10 -05:00
|
|
|
Assert.Equal(2 * 2, result.Output);
|
2020-11-01 22:55:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
[Fact]
|
|
|
|
public async Task WhenExpressionIsSuccess_EvaluateRuleAction_ReturnsExpressionEvaluation()
|
|
|
|
{
|
|
|
|
var engine = new RulesEngine(GetWorkflowWithActions());
|
|
|
|
var result = await engine.ExecuteActionWorkflowAsync("ActionWorkflow", "EvaluateRuleTest", new RuleParameter[0]);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
Assert.Equal(2 * 2, result.Output);
|
|
|
|
Assert.Contains(result.Results, c => c.Rule.RuleName == "ExpressionOutputRuleTest");
|
|
|
|
}
|
|
|
|
|
|
|
|
[Fact]
|
|
|
|
public async Task ExecuteActionWorkflowAsync_CalledWithIncorrectWorkflowOrRuleName_ThrowsArgumentException()
|
|
|
|
{
|
|
|
|
var engine = new RulesEngine(GetWorkflowWithActions());
|
|
|
|
await Assert.ThrowsAsync<ArgumentException>(async () => await engine.ExecuteActionWorkflowAsync("WrongWorkflow", "ExpressionOutputRuleTest", new RuleParameter[0]));
|
|
|
|
await Assert.ThrowsAsync<ArgumentException>(async () => await engine.ExecuteActionWorkflowAsync("ActionWorkflow", "WrongRule", new RuleParameter[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
[Fact]
|
|
|
|
public async Task ExecuteActionWorkflowAsync_CalledWithNoActionsInWorkflow_ExecutesSuccessfully()
|
|
|
|
{
|
|
|
|
|
2021-08-13 00:34:47 -04:00
|
|
|
var engine = new RulesEngine(GetWorkflowsWithoutActions());
|
2020-11-01 22:55:43 -05:00
|
|
|
var result = await engine.ExecuteActionWorkflowAsync("NoActionWorkflow", "NoActionTest", new RuleParameter[0]);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
Assert.Null(result.Output);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-08-13 00:34:47 -04:00
|
|
|
private Workflow[] GetWorkflowsWithoutActions()
|
2020-12-23 00:34:10 -05:00
|
|
|
{
|
2021-08-13 00:34:47 -04:00
|
|
|
var workflow1 = new Workflow {
|
2020-11-01 22:55:43 -05:00
|
|
|
WorkflowName = "NoActionWorkflow",
|
|
|
|
Rules = new List<Rule>{
|
|
|
|
new Rule{
|
|
|
|
RuleName = "NoActionTest",
|
|
|
|
RuleExpressionType = RuleExpressionType.LambdaExpression,
|
|
|
|
Expression = "1 == 1",
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
};
|
2020-12-23 00:34:10 -05:00
|
|
|
return new[] { workflow1 };
|
2020-11-01 22:55:43 -05:00
|
|
|
}
|
|
|
|
|
2021-08-13 00:34:47 -04:00
|
|
|
private Workflow[] GetWorkflowWithActions()
|
2020-12-23 00:34:10 -05:00
|
|
|
{
|
|
|
|
|
2021-08-13 00:34:47 -04:00
|
|
|
var workflow1 = new Workflow {
|
2020-11-01 22:55:43 -05:00
|
|
|
WorkflowName = "ActionWorkflow",
|
|
|
|
Rules = new List<Rule>{
|
|
|
|
new Rule{
|
|
|
|
RuleName = "ExpressionOutputRuleTest",
|
|
|
|
RuleExpressionType = RuleExpressionType.LambdaExpression,
|
|
|
|
Expression = "1 == 1",
|
2021-07-20 07:24:32 -04:00
|
|
|
Actions = new RuleActions{
|
|
|
|
OnSuccess = new ActionInfo{
|
2020-11-01 22:55:43 -05:00
|
|
|
Name = "OutputExpression",
|
|
|
|
Context = new Dictionary<string, object>{
|
|
|
|
{"expression", "2*2"}
|
|
|
|
}
|
2021-07-20 07:24:32 -04:00
|
|
|
}
|
2020-11-01 22:55:43 -05:00
|
|
|
}
|
|
|
|
},
|
|
|
|
new Rule{
|
|
|
|
RuleName = "EvaluateRuleTest",
|
|
|
|
RuleExpressionType = RuleExpressionType.LambdaExpression,
|
|
|
|
Expression = "1 == 1",
|
2021-07-20 07:24:32 -04:00
|
|
|
Actions = new RuleActions{
|
|
|
|
OnSuccess = new ActionInfo{
|
2020-11-01 22:55:43 -05:00
|
|
|
Name = "EvaluateRule",
|
|
|
|
Context = new Dictionary<string, object>{
|
|
|
|
{"workflowName", "ActionWorkflow"},
|
|
|
|
{"ruleName","ExpressionOutputRuleTest"}
|
|
|
|
}
|
2021-07-20 07:24:32 -04:00
|
|
|
}
|
2020-11-01 22:55:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
};
|
2020-12-23 00:34:10 -05:00
|
|
|
return new[] { workflow1 };
|
2020-11-01 22:55:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|