public void ShouldExecuteRuleEngineOnSeveralTargets()
{
var ruleBase = new RuleBase<Target>();
var ruleSet = new RuleSet<Target>();
var rule = new Rule<Target>("rule 1", "", t => t.Number == 0, t => t.Number = 1);
ruleSet.AddRule(rule);
ruleBase.AddRuleSet(ruleSet);
var ruleEngine = new RuleEngine<Target>(ruleBase);
var target = new Target();
ruleEngine.Execute(target);
Assert.Equal(1, target.Number);
var newTarget = new Target();
ruleEngine.Execute(newTarget);
Assert.Equal(1, newTarget.Number);
}
public void VerifySendEmailCalledOnce()
{
#region Arrange
PaymentContext payment = new PaymentContext()
{
Amount = 1000,
Type = PaymentType.UpgradeMembership,
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
};
var mockPayment = new Mock <IRuleAction>();
mockPayment.Setup(m => m.SendEmail(It.IsAny <PaymentContext>())).Returns(true);
var rules = new List <IRule>()
{
new UpgradeMembershipRule(mockPayment.Object)
};
RuleEngine ruleEngine = new RuleEngine(rules);
#endregion
#region Act
ruleEngine.Execute(payment);
#endregion
#region Assert
mockPayment.Verify(m => m.SendEmail(It.IsAny <PaymentContext>()), Times.Once);
#endregion
}
public void VerifyUppgradeMemberShipCalledNeverIfRuleIsNotApplicable()
{
#region Arrange
PaymentContext payment = new PaymentContext()
{
Amount = 1000,
Type = PaymentType.Book,
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
};
var mockPayment = new Mock <IRuleAction>();
mockPayment.Setup(m => m.AddFirstAidVideo(It.IsAny <PaymentContext>())).Returns(true);
var rules = new List <IRule>()
{
new UpgradeMembershipRule(mockPayment.Object)
};
RuleEngine ruleEngine = new RuleEngine(rules);
#endregion
#region Act
ruleEngine.Execute(payment);
#endregion
#region Assert
mockPayment.Verify(m => m.UppgradeMemberShip(It.IsAny <PaymentContext>()), Times.Never);
#endregion
}
public void VerifyAddFirstAidVideoCalledOnce()
{
#region Arrange
PaymentContext payment = new PaymentContext()
{
Amount = 1000,
Type = PaymentType.Learning,
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
};
var mockPayment = new Mock <IRuleAction>();
mockPayment.Setup(m => m.AddFirstAidVideo(It.IsAny <PaymentContext>())).Returns(true);
var rules = new List <IRule>()
{
new LearningRule(mockPayment.Object)
};
RuleEngine ruleEngine = new RuleEngine(rules);
#endregion
#region Act
ruleEngine.Execute(payment);
#endregion
#region Assert
mockPayment.Verify(m => m.AddFirstAidVideo(It.IsAny <PaymentContext>()), Times.Once);
#endregion
}
public void VerifyGenerateCommisionPaymentCalledNeverIfRuleIsNotApplicable()
{
#region Arrange
PaymentContext payment = new PaymentContext()
{
Amount = 1000,
Type = PaymentType.Learning,
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
};
var mockPayment = new Mock <IRuleAction>();
mockPayment.Setup(m => m.GenerateCommisionPayment(It.IsAny <PaymentContext>())).Returns(true);
var rules = new List <IRule>()
{
new PhysicalProductRule(mockPayment.Object)
};
RuleEngine ruleEngine = new RuleEngine(rules);
#endregion
#region Act
ruleEngine.Execute(payment);
#endregion
#region Assert
mockPayment.Verify(m => m.GenerateCommisionPayment(It.IsAny <PaymentContext>()), Times.Never);
#endregion
}
public void VerifyDuplicatePackagingSlipCalledOnce()
{
#region Arrange
PaymentContext payment = new PaymentContext()
{
Amount = 1000,
Type = PaymentType.Book,
CustomerId = Guid.NewGuid(),
OrderId = Guid.NewGuid(),
};
var mockPayment = new Mock <IRuleAction>();
mockPayment.Setup(m => m.DuplicatePackagingSlip(It.IsAny <PaymentContext>())).Returns(true);
var rules = new List <IRule>()
{
new PhysicalProductRule(mockPayment.Object),
new LearningRule(mockPayment.Object),
new BookRule(mockPayment.Object)
};
RuleEngine ruleEngine = new RuleEngine(rules);
#endregion
#region Act
ruleEngine.Execute(payment);
#endregion
#region Assert
mockPayment.Verify(m => m.DuplicatePackagingSlip(It.IsAny <PaymentContext>()), Times.Once);
#endregion
}
public void Test_Rule_constructor_invocation_with_missing_optional_parameters_succeeds()
{
//Arrange
RuleSet ruleSet = new RuleSet {
Name = "MyRuleSet", ChainingBehavior = RuleChainingBehavior.Full
};
ruleSet.Rules.Add(BuildRule());
RuleEngine ruleEngine = CreateRuleEngine(ruleSet);
SampleFlow.FlowEntity entity = new SampleFlow.FlowEntity
{
State = "NC"
};
//Act
ruleEngine.Execute(entity);
//Assert
Assert.Equal("AAA", entity.FirstValue);
Assert.Equal("BBB", entity.SecondValue);
Assert.Equal("", entity.ThirdValue);
Assert.Equal(0, entity.FourthValue);
Assert.Null(entity.TheParams);
Rule BuildRule()
{
// define first predicate: this.State == "MA"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("NC")
};
//action SampleFlow.FlowEntity.SetDefaultState("NH")
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression
(
new CodeThisReferenceExpression(),
"SetValues",
new CodeObjectCreateExpression
(
new CodeTypeReference("SampleFlow.OtherEntity"),
new CodeExpression[]
{
new CodePrimitiveExpression("AAA"),
new CodePrimitiveExpression("BBB")
}
)
);
return(new Rule("Rule1")
{
Condition = new RuleExpressionCondition(ruleStateTest),
ThenActions = { new RuleStatementAction(methodInvoke) }
});
}
}
public void ShouldExecuteRuleEngineOnSeveralTargets()
{
var ruleBase = new RuleBase <Target>();
var ruleSet = new RuleSet <Target>();
var rule = new Rule <Target>("rule 1", "", t => t.Number == 0, t => t.Number = 1);
ruleSet.AddRule(rule);
ruleBase.AddRuleSet(ruleSet);
var ruleEngine = new RuleEngine <Target>(ruleBase);
var target = new Target();
ruleEngine.Execute(target);
Assert.Equal(1, target.Number);
var newTarget = new Target();
ruleEngine.Execute(newTarget);
Assert.Equal(1, newTarget.Number);
}
private void _executeRulesEngine()
{
UpdateProgressList();
RuleEngine ruleEngine = RulesCache.GetRuleEngine(_moduleBeginName);
if (ruleEngine == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.moduleNotFoundFormat, _moduleBeginName));
}
ruleEngine.Execute(this.FlowActivity);
}
public void ShouldForwardChainRules()
{
var ruleBase = new RuleBase<Target>();
var ruleSet = new RuleSet<Target>();
var rule = new Rule<Target>("rule 1", "description of rule 1", t => t.Number == 0, t => t.Number = 1);
var rule2 = new Rule<Target>("rule 2", "", t => t.Number == 1, t => t.Number = 2);
ruleSet.AddRule(rule);
ruleSet.AddRule(rule2);
ruleBase.AddRuleSet(ruleSet);
var target = new Target();
var ruleEngine = new RuleEngine<Target>(ruleBase);
ruleEngine.Execute(target);
Assert.Equal(2, target.Number);
}
public void ShouldForwardChainRules()
{
var ruleBase = new RuleBase <Target>();
var ruleSet = new RuleSet <Target>();
var rule = new Rule <Target>("rule 1", "description of rule 1", t => t.Number == 0, t => t.Number = 1);
var rule2 = new Rule <Target>("rule 2", "", t => t.Number == 1, t => t.Number = 2);
ruleSet.AddRule(rule);
ruleSet.AddRule(rule2);
ruleBase.AddRuleSet(ruleSet);
var target = new Target();
var ruleEngine = new RuleEngine <Target>(ruleBase);
ruleEngine.Execute(target);
Assert.Equal(2, target.Number);
}
protected override void Execute(CodeActivityContext context)
{
if (RulesFilePath == null || RuleSetName == null)
{
throw new InvalidOperationException("Rules File path and RuleSet Name need to be configured");
}
if (!File.Exists(RulesFilePath))
{
throw new InvalidOperationException("Rules File " + RulesFilePath + " did not exist");
}
// Get the RuleSet from the .rules file
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlTextReader reader = new XmlTextReader(RulesFilePath);
RuleDefinitions rules = serializer.Deserialize(reader) as RuleDefinitions;
RuleSet ruleSet = rules.RuleSets[RuleSetName];
if (ruleSet == null)
{
throw new InvalidOperationException("RuleSet " + RuleSetName + " not found in " + RulesFilePath);
}
// Validate before running
Type targetType = this.TargetObject.Get(context).GetType();
RuleValidation validation = new RuleValidation(targetType, null);
if (!ruleSet.Validate(validation))
{
// Set the ValidationErrors OutArgument
this.ValidationErrors.Set(context, validation.Errors);
// Throw exception
throw new ValidationException(string.Format("The ruleset is not valid. {0} validation errors found (check the ValidationErrors property for more information).", validation.Errors.Count));
}
// Execute the ruleset
object evaluatedTarget = this.TargetObject.Get(context);
RuleEngine engine = new RuleEngine(ruleSet, validation);
engine.Execute(evaluatedTarget);
// Update the Result object
this.ResultObject.Set(context, evaluatedTarget);
}
private void _startInitialFlow(string module)
{
if (string.IsNullOrEmpty(module))
{
throw new ArgumentException(Strings.ruleSetCannotBeNull);
}
ClearFlowVariables();
UpdateProgressList(module);
RuleEngine ruleEngine = RulesCache.GetRuleEngine(module);
if (ruleEngine == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.moduleNotFoundFormat, module));
}
ruleEngine.Execute(this.FlowActivity);
}
private ValidationErrorCollection ApplyRuleSet(T target,
String path, String setName)
{
ValidationErrorCollection errors = null;
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
RuleSet rs = null;
if (File.Exists(path))
{
using (XmlTextReader reader = new XmlTextReader(path))
{
RuleDefinitions rules =
serializer.Deserialize(reader) as RuleDefinitions;
if (rules != null && rules.RuleSets.Contains(setName))
{
rs = rules.RuleSets[setName];
}
}
}
if (rs == null)
{
throw new ArgumentException(String.Format(
"Unable to retrieve RuleSet {0} from {1}", setName, path));
}
RuleValidation val = new RuleValidation(target.GetType(), null);
if (!rs.Validate(val))
{
errors = val.Errors;
return(errors);
}
RuleEngine rulesEngine = new RuleEngine(rs, val);
rulesEngine.Execute(target);
return(errors);
}
protected override TResult Execute(CodeActivityContext context)
{
// validate before running
Type targetType = this.Input.Get(context).GetType();
RuleValidation validation = new RuleValidation(targetType, null);
if (!this.RuleSet.Validate(validation))
{
// set the validation error out argument
this.ValidationErrors.Set(context, validation.Errors);
// throw a validation exception
throw new ValidationException(string.Format("The ruleset is not valid. {0} validation errors found (check the ValidationErrors property for more information).", validation.Errors.Count));
}
// execute the ruleset
TResult evaluatedTarget = this.Input.Get(context);
RuleEngine engine = new RuleEngine(this.RuleSet, validation);
engine.Execute(evaluatedTarget);
return(evaluatedTarget);
}
public static void RunRules <T>(T target, string rulesName)
{
//RuleSet rules = GetRules(rulesName);
////validate rules
//RuleValidation validation = new RuleValidation(typeof(T), null);
//rules.Validate(validation);
//if (validation.Errors.Any(e => !e.IsWarning))
//{
// Console.WriteLine("Errors: {0}", validation.Errors.FirstOrDefault());
// return;
//}
////warnings are errors
//RuleEngine engine = new RuleEngine(rules, validation);
//engine.Execute(target);
//OR
RuleSet rules = GetRules(rulesName);
RuleEngine engine = new RuleEngine(rules, typeof(T));
engine.Execute(target);
}
