public void ExecuteRuleSetRules_GivenRuleSet_OnlyRulesInRuleSetAreRun()
{
var patient = new Patient {
Name = new Name()
};
var patientRuleCollection = new PatientRuleCollection();
var runRuleCount = 0;
foreach (var patientRule in patientRuleCollection)
{
var ruleBuilder = new RuleBuilder <RuleEngineContext <Patient>, Patient> (patientRule as Rule);
ruleBuilder.Then(p => runRuleCount++).ElseThen(p => runRuleCount++);
}
var ruleEngine = new RuleEngine <Patient> (patientRuleCollection);
var ruleEngineContext = new RuleEngineContext <Patient> (
patient, new SelectAllRulesInRuleSetSelector(patientRuleCollection.PatientNameRuleSet));
ruleEngineContext.WorkingMemory.AddContextObject(new Name());
ruleEngine.ExecuteRules(ruleEngineContext);
Assert.AreEqual(patientRuleCollection.PatientNameRuleSet.Count(), runRuleCount);
}
public void ExecuteShouldRecommendDastRuleThenClause_WorkflowMessageCreated()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
SetupServiceLocatorFixture(serviceLocatorFixture);
var assessmentDefKey = Guid.NewGuid();
var ruleCollection =
new NidaWorkflowRuleCollection(
BuildIAssessmentDefinitionRepositoryMock(assessmentDefKey).Object,
BuildIRepositoryMock(null).Object,
new Mock <IAssessmentInstanceRepository>().Object);
var assessmentDefinition = Substitute.For <AssessmentDefinition>();
var assessmentInstance = new AssessmentInstanceFactory().Create(assessmentDefinition, Guid.NewGuid(), "TestName");
assessmentInstance.ScoreComplete(new CodedConcept(new CodeSystem("", "", ""), "", ""), "test");
var messageCollector = new MessageCollector();
var ruleEngineContext = new RuleEngineContext <AssessmentInstance>(assessmentInstance);
ruleEngineContext.WorkingMemory.AddContextObject <IMessageCollector>(messageCollector, "MessageCollector");
foreach (var action in ruleCollection.ShouldRecommendDastRule.ThenClauses)
{
action(ruleEngineContext);
}
Assert.AreEqual(1, messageCollector.Messages.Count(), "Incorrect Number of messages.");
Assert.AreEqual(typeof(WorkflowMessage), messageCollector.Messages.First().GetType());
var workflowMessage = messageCollector.Messages.First() as WorkflowMessage;
Assert.AreEqual(assessmentInstance.Key, workflowMessage.InitiatingAssessmentKey);
Assert.AreEqual(DrugAbuseScreeningTest.AssessmentCodedConcept.Code, workflowMessage.RecommendedAssessmentDefinitionCode);
}
}
public void ExecuteRules_WithDisabledRule_DisabledRuleIsNotRun()
{
var patient = new Patient {
Name = new Name()
};
var patientRuleCollection = new PatientRuleCollection();
patientRuleCollection.FirstNameCannotBeNull.Disable();
var ruleRun = false;
var ruleBuilder = new RuleBuilder <RuleEngineContext <Patient>, Patient> (patientRuleCollection.FirstNameCannotBeNull as Rule);
ruleBuilder.Then(p => ruleRun = true).ElseThen(p => ruleRun = true);
var ruleEngine = new RuleEngine <Patient> (patientRuleCollection);
var ruleEngineContext = new RuleEngineContext <Patient> (patient);
ruleEngineContext.WorkingMemory.AddContextObject(new Name());
ruleEngine.ExecuteRules(ruleEngineContext);
Assert.IsFalse(ruleRun);
}
public void AddItemDefinition_Valid_ElseThenClauseUnSkipsItem()
{
var rule = new ItemSkippingRule <object>("1", "Rule");
var itemDefinition = new ItemDefinition(new CodedConcept(new CodeSystem("1", "1", "Test"), "1", "Test"), ItemType.Question, null)
{
ItemMetadata = new ItemMetadata
{
MetadataItems = new List <IMetadataItem>
{
new RequiredForCompletenessMetadataItem("Report")
}
}
};
rule.AddItemDefinitionToSkip(itemDefinition);
var itemInstance = new ItemInstance("1", "Test", true);
var assessmentInstance = Substitute.For <AssessmentInstance>();
assessmentInstance.AssessmentName.Returns("Test");
var skippingContext = new SkippingContext();
var context = new RuleEngineContext <AssessmentInstance>(assessmentInstance);
context.WorkingMemory.AddContextObject(itemInstance, itemInstance.ItemDefinitionCode);
context.WorkingMemory.AddContextObject(skippingContext);
rule.ElseThenClauses.First().Invoke(context);
CollectionAssert.Contains(skippingContext.UnSkippedItemDefinitions, itemDefinition);
}
public void Process_GivenNullRule_ThrowsArgumentException()
{
var customer = new Customer();
var ruleEngineContext = new RuleEngineContext <Customer> (customer);
var ruleProcessor = new RuleProcessor();
ruleProcessor.Process(ruleEngineContext, null);
}
public void AddConstraint_WithNotNullContraint_ConstraintIsAdded()
{
var rule = PropertyRule.CreatePropertyRule<Customer, string> ( c => c.FirstName, "Rule 1" );
rule.AddConstraint ( new NotNullConstraint () );
var customer = new Customer ();
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsFalse ( whenResult );
}
public void Run(AssessmentInstance assessmentInstance)
{
//TODO:If Required
//Need to update pillar to allow for named rule collections _ruleCollectionFactory.CreateRuleCollection<AssessmentInstance>("NidaWorkflow");
var ruleCollection = IoC.CurrentContainer.Resolve <NidaWorkflowRuleCollection>();
var ruleEngine = _ruleEngineFactory.CreateRuleEngine(assessmentInstance, ruleCollection);
var ruleEngineContext = new RuleEngineContext <AssessmentInstance>(assessmentInstance, new SelectAllRulesInRuleSetSelector(assessmentInstance.AssessmentName + "RuleSet"));
ruleEngineContext.WorkingMemory.AddContextObject(_messageCollector, "MessageCollector");
ruleEngine.ExecuteRules(ruleEngineContext);
}
public void Rule_WithWhenClause_WhenClauseIsCallable()
{
var customer = new Customer ();
var ruleEngineContext = new RuleEngineContext<Customer> ( customer );
Predicate<IRuleEngineContext> whenClause = e => string.IsNullOrWhiteSpace ( ( ( RuleEngineContext<Customer> )e ).Subject.FirstName );
var rule = new Rule ( "Name" ) { WhenClause = whenClause };
var isNullOrWhiteSpace = rule.WhenClause ( ruleEngineContext );
Assert.IsTrue ( isNullOrWhiteSpace );
}
/// <inheritdoc/>
public override bool IsCompliant(object propertyValue, IRuleEngineContext ruleEngineContext)
{
var propertyRuleEngineContext = new RuleEngineContext <TProperty> (
( TProperty )propertyValue, ruleEngineContext.RuleViolationReporter, _ruleSelector, ruleEngineContext.NameProvider, ruleEngineContext);
propertyRuleEngineContext.WorkingMemory.AddContextObject(ruleEngineContext.Subject);
var ruleEngine = new RuleEngine <TProperty> (_ruleCollection);
var result = ruleEngine.ExecuteRules(propertyRuleEngineContext);
return(!result.HasRuleViolation);
}
public void Process_GivenARule_CallsWhenClause()
{
var customer = new Customer();
var ruleEngineContext = new RuleEngineContext <Customer> (customer);
var mockRuleCollection = new MockRuleCollection();
var ruleProcessor = new RuleProcessor();
ruleProcessor.Process(ruleEngineContext, mockRuleCollection.MyMockRule);
Assert.IsTrue(mockRuleCollection.WhenClauseCalled);
}
public void CreateSpecificationRule_WithSpecification_SpecificationIsUsed()
{
var specification = new TestSpecification();
var rule = SpecificationRule.CreateSpecificationRule(specification, "Rule 1");
var customer = new Customer();
var context = new RuleEngineContext <Customer> (customer);
rule.WhenClause(context);
Assert.IsTrue(specification.IsSatisfiedByCalled);
}
public void DoNotRunIfHasRuleViolation_ShouldRunClauseAdded()
{
var rule = new Rule ( "Rule1" );
var ruleBuilder = new RuleBuilder<RuleEngineContext<Customer>, Customer> ( rule );
ruleBuilder.DoNotRunIfHasRuleViolation ();
var ruleEngineContext = new RuleEngineContext ( new Customer () );
ruleEngineContext.RuleViolationReporter.Report ( new RuleViolation ( rule, null, null ) );
var shouldRunResult = rule.ShouldRunRule ( ruleEngineContext );
Assert.IsFalse ( shouldRunResult );
}
public void InclusiveBetween_PropertyIsLessThenStartValue_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.InclusiveBetween ( 5, 15 );
var customer = new Customer { Age = 1 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsFalse ( whenResult );
}
public void InclusiveBetween_PropertyInBetweenValues_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.InclusiveBetween ( 5, 15 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void MatchesRegex_PropertyMatchesRegex_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.MatchesRegex ( "5" );
var customer = new Customer { Age = 5 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void LessThen_ValueIsGreaterThanProperty_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.LessThen ( 15 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void AddConstraint_WithNotNullContraint_ConstraintIsAdded()
{
var rule = PropertyRule.CreatePropertyRule <Customer, string> (c => c.FirstName, "Rule 1");
rule.AddConstraint(new NotNullConstraint());
var customer = new Customer();
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void MaxLength_PropertyLengthIsLessThenMaxLength_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule<Customer, string> ( c => c.FirstName, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, string> ( rule );
ruleBuilder.MaxLength ( 5 );
var customer = new Customer { FirstName = "Fred" };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void EqualTo_ValueNotEqualToProperty_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.GreaterThan ( 15 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsFalse ( whenResult );
}
public void EqualTo_ValueEqualToProperty_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.EqualTo ( 5 );
var customer = new Customer { Age = 5 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void LessThenOrEqualTo_ValueIsEqualToProperty_RulePasses ()
{
var rule = PropertyRule.CreatePropertyRule<Customer, int> ( c => c.Age, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, int> ( rule );
ruleBuilder.LessThenOrEqualTo ( 10 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsTrue ( whenResult );
}
public void MaxLength_PropertyLengthIsGreaterThanMaxLength_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule<Customer, string> ( c => c.FirstName, "Rule 1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, string> ( rule );
ruleBuilder.MaxLength ( 5 );
var customer = new Customer { FirstName = "123456" };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsFalse ( whenResult );
}
private void ExecuteThenClause(IRuleEngineContext ruleEngineContext)
{
var propertyValue = PropertyValueDelegate.DynamicInvoke(ruleEngineContext.Subject) as IEnumerable;
if (propertyValue != null)
{
foreach (var childSubject in propertyValue)
{
var subContext = new RuleEngineContext(
childSubject, ruleEngineContext.RuleViolationReporter, _ruleSelector, ruleEngineContext.NameProvider, ruleEngineContext);
_executeRules(subContext);
}
}
}
public void Rule_WithWhenClause_WhenClauseIsCallable()
{
var customer = new Customer();
var ruleEngineContext = new RuleEngineContext <Customer> (customer);
Predicate <IRuleEngineContext> whenClause = e => string.IsNullOrWhiteSpace(((RuleEngineContext <Customer>)e).Subject.FirstName);
var rule = new Rule("Name")
{
WhenClause = whenClause
};
var isNullOrWhiteSpace = rule.WhenClause(ruleEngineContext);
Assert.IsTrue(isNullOrWhiteSpace);
}
public void Process_WhenWhenClauseReturnsFalse_DoesNotCallThenClause()
{
var customer = new Customer();
var ruleEngineContext = new RuleEngineContext <Customer> (customer);
var mockRuleCollection = new MockRuleCollection {
WhenClauseReturns = false
};
var ruleProcessor = new RuleProcessor();
ruleProcessor.Process(ruleEngineContext, mockRuleCollection.MyMockRule);
Assert.IsFalse(mockRuleCollection.ThenClauseCalled);
}
public void Constrain_WithAConstraint_AssignsConstraintToRule()
{
var rule = PropertyRule.CreatePropertyRule<Customer, string> ( c => c.FirstName, "Rule1" );
var ruleBuilder = new PropertyRuleBuilder<RuleEngineContext<Customer>, Customer, string> ( rule );
ruleBuilder.Constrain ( new NotNullConstraint () );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var whenResult = rule.WhenClause ( context );
Assert.IsFalse ( whenResult );
}
public void DoNotRunIfHasRuleViolation_ShouldRunClauseAdded()
{
var rule = new Rule("Rule1");
var ruleBuilder = new RuleBuilder <RuleEngineContext <Customer>, Customer> (rule);
ruleBuilder.DoNotRunIfHasRuleViolation();
var ruleEngineContext = new RuleEngineContext(new Customer());
ruleEngineContext.RuleViolationReporter.Report(new RuleViolation(rule, null, null));
var shouldRunResult = rule.ShouldRunRule(ruleEngineContext);
Assert.IsFalse(shouldRunResult);
}
public void AddConstraint_ValidConstraint_RunsWhenRuleExecuted()
{
var rule = new ItemSkippingRule <object>("1", "Rule");
var constraint = Substitute.For <IConstraint> ();
rule.AddConstraint(constraint);
var itemInstance = new ItemInstance("1", "Test", true);
var context = new RuleEngineContext <object> (itemInstance);
context.WorkingMemory.AddContextObject(itemInstance, itemInstance.ItemDefinitionCode);
rule.WhenClause.Invoke(context);
constraint.Received().IsCompliant(Arg.Any <object> (), Arg.Any <IRuleEngineContext> ());
}
public void When_GivenAWhenPredicate_AssignsWhenPredicateToRule()
{
var rule = new Rule("Rule1");
var ruleBuilder = new RuleBuilder <RuleEngineContext <Customer>, Customer> (rule);
ruleBuilder.When(c => c.Age < 20);
var customer = new Customer {
Age = 10
};
var context = new RuleEngineContext <Customer> (customer);
var lessThan20 = rule.WhenClause(context);
Assert.IsTrue(lessThan20);
}
public void Then_ProvidingAThenClauseOverrideToTheBuilder_RuleShouldHaveAThenClauseOverride()
{
var rule = new Rule ( "Rule1" );
var ruleBuilder = new RuleBuilder<RuleEngineContext<Customer>, Customer> ( rule );
ruleBuilder.When ( ( cust, ctxt ) => true ).Then ( ( cust, ctxt ) => cust.Age++ );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
foreach ( var clause in rule.ThenClauses )
{
clause ( context );
}
Assert.AreEqual ( 11, customer.Age );
}
public void ExclusiveBetween_PropertyInBetweenValues_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule <Customer, int> (c => c.Age, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, int> (rule);
ruleBuilder.ExclusiveBetween(5, 15);
var customer = new Customer {
Age = 10
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsTrue(whenResult);
}
public void When_WithAWhenFunction_AssignsWhenFunctionToRule()
{
var rule = new Rule("Rule1");
var ruleBuilder = new RuleBuilder <RuleEngineContext <Customer>, Customer> (rule);
ruleBuilder.When((cust, ctxt) => cust.Age < 20);
var customer = new Customer {
Age = 10
};
var context = new RuleEngineContext <Customer> (customer);
var lessThan20 = rule.WhenClause(context);
Assert.IsTrue(lessThan20);
}
public void MinLength_PropertyLengthIsEqualToMaxLength_RulePasses()
{
var rule = PropertyRule.CreatePropertyRule <Customer, string> (c => c.FirstName, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, string> (rule);
ruleBuilder.MinLength(5);
var customer = new Customer {
FirstName = "12345"
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsTrue(whenResult);
}
public void Constrain_WithAConstraint_AssignsConstraintToRule()
{
var rule = PropertyRule.CreatePropertyRule <Customer, string> (c => c.FirstName, "Rule1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, string> (rule);
ruleBuilder.Constrain(new NotNullConstraint());
var customer = new Customer {
Age = 10
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void CheckNonResponse_NotANonResponseValue_WhenClauseReturnsFalse()
{
var nonResponseValue = "TestNonResponse";
var rule = new ItemSkippingRule <object>("1", "Rule");
rule.CheckNonResponse(new List <string> {
nonResponseValue
});
var itemInstance = new ItemInstance("1", "Test", true);
var context = new RuleEngineContext <object>(itemInstance);
context.WorkingMemory.AddContextObject(itemInstance, itemInstance.ItemDefinitionCode);
Assert.IsFalse(rule.WhenClause.Invoke(context));
}
public void ExclusiveBetween_PropertyIsGreaterThanEndValue_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule <Customer, int> (c => c.Age, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, int> (rule);
ruleBuilder.ExclusiveBetween(5, 15);
var customer = new Customer {
Age = 25
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void MatchesRegex_PropertyDoesNotMatchRegex_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule <Customer, int> (c => c.Age, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, int> (rule);
ruleBuilder.MatchesRegex("6");
var customer = new Customer {
Age = 5
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void WhenClause_ConstraintFails_ReturnsFalse()
{
var rule = new ItemSkippingRule <object>("1", "Rule");
var constraint = Substitute.For <IConstraint>();
constraint.IsCompliant(Arg.Any <object> (), Arg.Any <IRuleEngineContext> ()).Returns(false);
rule.AddConstraint(constraint);
var itemInstance = new ItemInstance("1", "Test", true);
var context = new RuleEngineContext <object>(itemInstance);
context.WorkingMemory.AddContextObject(itemInstance, itemInstance.ItemDefinitionCode);
Assert.IsFalse(rule.WhenClause.Invoke(context));
}
public void EqualTo_ValueNotEqualToProperty_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule <Customer, int> (c => c.Age, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, int> (rule);
ruleBuilder.GreaterThan(15);
var customer = new Customer {
Age = 10
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void MaxLength_PropertyLengthIsGreaterThanMaxLength_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule <Customer, string> (c => c.FirstName, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, string> (rule);
ruleBuilder.MaxLength(5);
var customer = new Customer {
FirstName = "123456"
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void MeetsSpecification_PropertyDoesNotMeetSpecification_RuleFails()
{
var rule = PropertyRule.CreatePropertyRule <Customer, int> (c => c.Age, "Rule 1");
var ruleBuilder = new PropertyRuleBuilder <RuleEngineContext <Customer>, Customer, int> (rule);
ruleBuilder.MeetsSpecification(new TestSpecification());
var customer = new Customer {
Age = 15
};
var context = new RuleEngineContext <Customer> (customer);
var whenResult = rule.WhenClause(context);
Assert.IsFalse(whenResult);
}
public void Example3Test()
{
var subject = new Example3Subject {
IsTrue = true
};
var ruleEngine = RuleEngine <Example3Subject> .CreateTypedRuleEngine();
var ruleEngineContext = new RuleEngineContext <Example3Subject>(subject);
var example3ContextObject = new Example3ContextObject();
ruleEngineContext.WorkingMemory.AddContextObject(example3ContextObject);
ruleEngine.ExecuteRules(ruleEngineContext);
Assert.AreEqual("hello world", example3ContextObject.Greeting);
}
public void AddConstraint_WithNotNullContraint_ARuleViolationIsAdded()
{
var rule = PropertyRule.CreatePropertyRule<Customer, string> ( c => c.FirstName, "Rule 1" );
rule.AddConstraint ( new NotNullConstraint () );
rule.AutoValidate = true;
var customer = new Customer ();
var context = new RuleEngineContext<Customer> ( customer );
rule.WhenClause ( context );
foreach ( var elseThenClause in rule.ElseThenClauses )
{
elseThenClause ( context );
}
Assert.IsTrue ( context.RuleViolationReporter.Count () == 1, "No Rule Violation was created." );
}
public void Process_WhenRuleIsSkipAndViolationError_RuleIsSkiped()
{
var customer = new Customer();
var ruleEngineContext = new RuleEngineContext <Customer> (customer);
var mockRuleCollection = new MockRuleCollection {
WhenClauseReturns = false
};
ruleEngineContext.RuleViolationReporter.Report(new RuleViolation(mockRuleCollection.MyMockRule, null, null));
(mockRuleCollection.MyMockRule as Rule).AddShouldRunClause(ctx => ctx.RuleViolationReporter.Count() == 0);
var ruleProcessor = new RuleProcessor();
ruleProcessor.Process(ruleEngineContext, mockRuleCollection.MyMockRule);
Assert.IsFalse(mockRuleCollection.WhenClauseCalled);
}
public void Rule_WithThenClauses_ThenClausesAreCallable()
{
var customer = new Customer ();
var ruleEngineContext = new RuleEngineContext<Customer> ( customer );
var rule = new Rule ( "Name" );
Action<IRuleEngineContext> thenClause1 = e => ( ( Customer )e.Subject ).Age = 20;
rule.AddThenClause ( thenClause1 );
Action<IRuleEngineContext> thenClause2 = e => ( ( Customer )e.Subject ).Age++;
rule.AddThenClause ( thenClause2 );
foreach ( var clause in rule.ThenClauses )
{
clause ( ruleEngineContext );
}
Assert.AreEqual ( 21, customer.Age );
}
public void ThenClause_WithRuleCollection_CollectionRulesAreRun()
{
var rule = CollectionPropertyRule.CreateCollectionPropertyRule<Patient, IEnumerable<Address>> (
p => p.Addresses, "Rule 1" );
var addressRuleCollection = new AddressRuleCollection ();
var ruleCalled = false;
addressRuleCollection.NewRule ( () => addressRuleCollection.MyEmptyRule ).When ( c => ruleCalled = true );
rule.WithRuleCollection ( addressRuleCollection );
var patient = new Patient ();
patient.Addresses.Add ( new Address ( null, null, null, null, null ) );
var ruleEngineContext = new RuleEngineContext<Patient> ( patient );
foreach ( var thenClause in rule.ThenClauses )
{
thenClause ( ruleEngineContext );
}
Assert.IsTrue ( ruleCalled );
}
public void ExecuteRules_Duplicate_HasRuleViolations()
{
var payorCoverageTypeMock = new Mock<PayorCoverageCacheType>();
payorCoverageTypeMock.SetupGet(pct => pct.WellKnownName).Returns("Test");
var payorCoverageCache = new PayorCoverageCache(
new Mock<Patient>().Object,
new Mock<PayorCache>().Object,
new DateRange(DateTime.Now, null),
"12345",
new PayorSubscriberCache(
new Address(
"Test",
null,
"City",
new Mock<CountyArea>().Object,
new Mock<StateProvince>().Object,
new Mock<Country>().Object,
new PostalCode("12345")),
null,
new Mock<AdministrativeGender>().Object,
new PersonName(string.Empty, "Fred", null, "Savage", null),
new Mock<PayorSubscriberRelationshipCacheType>().Object),
payorCoverageTypeMock.Object);
var repositoryMock = new Mock<IPayorCoverageCacheRepository>();
repositoryMock.Setup(
rep => rep.AnyPayorCoverageTypeInEffectiveDateRange(It.IsAny<long>(), It.IsAny<long>(), It.IsAny<PayorCoverageCacheType>(), It.IsAny<DateRange>())).Returns(
true);
var ruleCollection = new PayorCoverageCacheRuleCollection(repositoryMock.Object);
var ruleEngine = new RuleEngine<PayorCoverageCache>(ruleCollection);
var ruleContext = new RuleEngineContext<PayorCoverageCache>(payorCoverageCache);
ruleContext.WorkingMemory.AddContextObject(payorCoverageCache.PayorCoverageCacheType);
ruleContext.WorkingMemory.AddContextObject(payorCoverageCache.EffectiveDateRange);
var results = ruleEngine.ExecuteRules(ruleContext);
Assert.IsTrue(results.HasRuleViolation);
}
public void ExecuteRules_GivenPatientRuleCollection_AllRulesRun()
{
var patient = new Patient { Name = new Name () };
var patientRuleCollection = new PatientRuleCollection ();
var runRuleCount = 0;
foreach ( var patientRule in patientRuleCollection )
{
var ruleBuilder = new RuleBuilder<RuleEngineContext<Patient>, Patient> ( patientRule as Rule );
ruleBuilder.Then ( p => runRuleCount++ ).ElseThen ( p => runRuleCount++ );
}
var ruleEngine = new RuleEngine<Patient> ( patientRuleCollection );
var ruleEngineContext = new RuleEngineContext<Patient> ( patient );
ruleEngineContext.WorkingMemory.AddContextObject ( new Name () );
ruleEngine.ExecuteRules ( ruleEngineContext );
Assert.AreEqual ( patientRuleCollection.Count (), runRuleCount );
}
public void ExecuteRules_WithDisabledRule_DisabledRuleIsNotRun()
{
var patient = new Patient { Name = new Name () };
var patientRuleCollection = new PatientRuleCollection ();
patientRuleCollection.FirstNameCannotBeNull.Disable ();
var ruleRun = false;
var ruleBuilder = new RuleBuilder<RuleEngineContext<Patient>, Patient> ( patientRuleCollection.FirstNameCannotBeNull as Rule );
ruleBuilder.Then ( p => ruleRun = true ).ElseThen ( p => ruleRun = true );
var ruleEngine = new RuleEngine<Patient> ( patientRuleCollection );
var ruleEngineContext = new RuleEngineContext<Patient> ( patient );
ruleEngineContext.WorkingMemory.AddContextObject ( new Name () );
ruleEngine.ExecuteRules ( ruleEngineContext );
Assert.IsFalse ( ruleRun );
}
public void When_WithAWhenFunction_AssignsWhenFunctionToRule()
{
var rule = new Rule ( "Rule1" );
var ruleBuilder = new RuleBuilder<RuleEngineContext<Customer>, Customer> ( rule );
ruleBuilder.When ( ( cust, ctxt ) => cust.Age < 20 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var lessThan20 = rule.WhenClause ( context );
Assert.IsTrue ( lessThan20 );
}
public void When_GivenAWhenPredicate_AssignsWhenPredicateToRule()
{
var rule = new Rule ( "Rule1" );
var ruleBuilder = new RuleBuilder<RuleEngineContext<Customer>, Customer> ( rule );
ruleBuilder.When ( c => c.Age < 20 );
var customer = new Customer { Age = 10 };
var context = new RuleEngineContext<Customer> ( customer );
var lessThan20 = rule.WhenClause ( context );
Assert.IsTrue ( lessThan20 );
}
