public void SetInMemoryDataSource_GivenServiceProvider_RequestsInMemoryRulesStorageAndSetsOnSelector()
        {
            // Arrange
            InMemoryRulesStorage <ContentType, ConditionType> inMemoryRulesStorage = Mock.Of <InMemoryRulesStorage <ContentType, ConditionType> >();

            IServiceCollection serviceDescriptors = new ServiceCollection();

            serviceDescriptors.AddSingleton(inMemoryRulesStorage);
            IServiceProvider serviceProvider = serviceDescriptors.BuildServiceProvider();

            IRulesDataSourceSelector <ContentType, ConditionType> rulesDataSourceSelector = Mock.Of <IRulesDataSourceSelector <ContentType, ConditionType> >();

            IRulesDataSource <ContentType, ConditionType> actualRulesDataSource = null;

            Mock.Get(rulesDataSourceSelector)
            .Setup(x => x.SetDataSource(It.IsAny <IRulesDataSource <ContentType, ConditionType> >()))
            .Callback <IRulesDataSource <ContentType, ConditionType> >((rds) =>
            {
                actualRulesDataSource = rds;
            });

            // Act
            rulesDataSourceSelector.SetInMemoryDataSource(serviceProvider);

            // Assert
            actualRulesDataSource.Should().NotBeNull();
            actualRulesDataSource.Should().BeOfType <InMemoryProviderRulesDataSource <ContentType, ConditionType> >();
            Mock.Get(rulesDataSourceSelector)
            .Verify();
        }
        public async Task BodyMassIndex_NoConditions_ReturnsDefaultFormula()
        {
            // Arrange
            string             expectedFormulaDescription = "Body Mass Index default formula";
            string             expectedFormulaValue       = "weight / (height ^ 2)";
            const ContentTypes expectedContent            = ContentTypes.BodyMassIndexFormula;
            DateTime           expectedMatchDate          = new DateTime(2018, 06, 01);

            Condition <ConditionTypes>[] expectedConditions = new Condition <ConditionTypes> [0];

            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = await RulesFromJsonFile.Load
                                                                              .FromJsonFileAsync <ContentTypes, ConditionTypes>(DataSourceFilePath);

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetDataSource(rulesDataSource)
                                                                     .Build();

            // Act
            Rule <ContentTypes, ConditionTypes> actual = await rulesEngine.MatchOneAsync(expectedContent, expectedMatchDate, expectedConditions);

            // Assert
            actual.Should().NotBeNull();
            Formula actualFormula = actual.ContentContainer.GetContentAs <Formula>();

            actualFormula.Description.Should().Be(expectedFormulaDescription);
            actualFormula.Value.Should().Be(expectedFormulaValue);
        }
 internal RulesEngine(
     IConditionsEvalEngine <TConditionType> conditionsEvalEngine,
     IRulesDataSource <TContentType, TConditionType> rulesDataSource,
     RulesEngineOptions rulesEngineOptions)
 {
     this.conditionsEvalEngine = conditionsEvalEngine;
     this.rulesDataSource      = rulesDataSource;
     this.rulesEngineOptions   = rulesEngineOptions;
 }
        public async Task BuildingSecuritySystem_FireScenario_ReturnsActionsToTrigger()
        {
            // Assert
            const SecuritySystemActionables securitySystemActionable = SecuritySystemActionables.FireSystem;

            DateTime expectedMatchDate = new DateTime(2018, 06, 01);

            Condition <SecuritySystemConditions>[] expectedConditions = new Condition <SecuritySystemConditions>[]
            {
                new Condition <SecuritySystemConditions>
                {
                    Type  = SecuritySystemConditions.TemperatureCelsius,
                    Value = 100.0m
                },
                new Condition <SecuritySystemConditions>
                {
                    Type  = SecuritySystemConditions.SmokeRate,
                    Value = 55.0m
                },
                new Condition <SecuritySystemConditions>
                {
                    Type  = SecuritySystemConditions.PowerStatus,
                    Value = "Online"
                }
            };

            IRulesDataSource <SecuritySystemActionables, SecuritySystemConditions> rulesDataSource = await RulesFromJsonFile.Load
                                                                                                     .FromJsonFileAsync <SecuritySystemActionables, SecuritySystemConditions>(DataSourceFilePath);

            RulesEngine <SecuritySystemActionables, SecuritySystemConditions> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                                            .WithContentType <SecuritySystemActionables>()
                                                                                            .WithConditionType <SecuritySystemConditions>()
                                                                                            .SetDataSource(rulesDataSource)
                                                                                            .Build();

            // Act
            IEnumerable <Rule <SecuritySystemActionables, SecuritySystemConditions> > actual = await rulesEngine.MatchManyAsync(securitySystemActionable, expectedMatchDate, expectedConditions);

            // Assert
            actual.Should().NotBeNull();

            IEnumerable <SecuritySystemAction> securitySystemActions = actual.Select(r => r.ContentContainer.GetContentAs <SecuritySystemAction>()).ToList();

            securitySystemActions.Should().Contain(ssa => ssa.ActionName == "CallFireBrigade")
            .And.Contain(ssa => ssa.ActionName == "CallPolice")
            .And.Contain(ssa => ssa.ActionName == "ActivateSprinklers")
            .And.HaveCount(3);
        }
        public async Task AddRule_AddingNewRuleWithAgeConditionOnTop_NewRuleIsInsertedAndExistentRulePriorityUpdated()
        {
            // Arrange
            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = await RulesFromJsonFile.Load
                                                                              .FromJsonFileAsync <ContentTypes, ConditionTypes>(DataSourceFilePath);

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetDataSource(rulesDataSource)
                                                                     .Build();

            RuleBuilderResult <ContentTypes, ConditionTypes> newRuleResult = RuleBuilder.NewRule <ContentTypes, ConditionTypes>()
                                                                             .WithName("Body Mass Index up to 18 years formula")
                                                                             .WithDateBegin(DateTime.Parse("2018-01-01"))
                                                                             .WithContentContainer(new ContentContainer <ContentTypes>(ContentTypes.BodyMassIndexFormula, (t) => new Formula
            {
                Description = "Body Mass Index up to 18 years formula",
                Value       = "weight / ((height + 1) ^ 2)" // Not real, for the sake of the test.
            }))
                                                                             .WithCondition(cnb => cnb
                                                                                            .AsValued(ConditionTypes.Age)
                                                                                            .OfDataType <int>()
                                                                                            .WithComparisonOperator(Operators.LesserThanOrEqual)
                                                                                            .SetOperand(18)
                                                                                            .Build())
                                                                             .Build();

            Rule <ContentTypes, ConditionTypes> newRule = newRuleResult.Rule;
            RuleAddPriorityOption ruleAddPriorityOption = new RuleAddPriorityOption
            {
                PriorityOption = PriorityOptions.AtTop
            };

            // Act
            RuleOperationResult ruleOperationResult = await rulesEngine.AddRuleAsync(newRule, ruleAddPriorityOption).ConfigureAwait(false);

            // Assert
            ruleOperationResult.Should().NotBeNull();
            ruleOperationResult.IsSuccess.Should().BeTrue();

            IEnumerable <Rule <ContentTypes, ConditionTypes> > rules = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>()).ConfigureAwait(false);

            rules.Should().NotBeNull().And.HaveCount(2);
            rules.Should().ContainEquivalentOf(newRule);
            newRule.Priority.Should().Be(1, "rule should to priority 1 if inserted at top.");
        }
        public async Task GetCarInsuranceAdvice_SearchForRulesExcludingRulesWithoutSearchConditions_ReturnsNoRules()
        {
            // Arrange
            const ContentTypes expectedContent   = ContentTypes.CarInsuranceAdvice;
            DateTime           expectedMatchDate = new DateTime(2018, 06, 01);
            SearchArgs <ContentTypes, ConditionTypes> searchArgs = new SearchArgs <ContentTypes, ConditionTypes>
            {
                Conditions = new Condition <ConditionTypes>[]
                {
                    new Condition <ConditionTypes>
                    {
                        Type  = ConditionTypes.RepairCosts,
                        Value = 800.00000m
                    },
                    new Condition <ConditionTypes>
                    {
                        Type  = ConditionTypes.RepairCostsCommercialValueRate,
                        Value = 86.33m
                    }
                },
                ContentType = expectedContent,
                DateBegin   = expectedMatchDate,
                DateEnd     = expectedMatchDate,
                ExcludeRulesWithoutSearchConditions = true
            };

            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = await RulesFromJsonFile.Load
                                                                              .FromJsonFileAsync <ContentTypes, ConditionTypes>(DataSourceFilePath, serializedContent : false);

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetDataSource(rulesDataSource)
                                                                     .Configure(reo =>
            {
                reo.PriotityCriteria = PriorityCriterias.BottommostRuleWins;
            })
                                                                     .Build();

            // Act
            IEnumerable <Rule <ContentTypes, ConditionTypes> > actual = await rulesEngine.SearchAsync(searchArgs);

            // Assert
            actual.Should().NotBeNull();
            actual.Should().HaveCount(0);
        }
        public async Task GetCarInsuranceAdvice_RepairCostsNotWorthIt_ReturnsRefusePaymentPerFranchise()
        {
            // Arrange
            CarInsuranceAdvices expected          = CarInsuranceAdvices.RefusePaymentPerFranchise;
            const ContentTypes  expectedContent   = ContentTypes.CarInsuranceAdvice;
            DateTime            expectedMatchDate = new DateTime(2018, 06, 01);

            Condition <ConditionTypes>[] expectedConditions = new Condition <ConditionTypes>[]
            {
                new Condition <ConditionTypes>
                {
                    Type  = ConditionTypes.RepairCosts,
                    Value = 800.00000m
                },
                new Condition <ConditionTypes>
                {
                    Type  = ConditionTypes.RepairCostsCommercialValueRate,
                    Value = 23.45602m
                }
            };

            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = await RulesFromJsonFile.Load
                                                                              .FromJsonFileAsync <ContentTypes, ConditionTypes>(DataSourceFilePath, serializedContent : false);

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetDataSource(rulesDataSource)
                                                                     .Configure(reo =>
            {
                reo.PriotityCriteria = PriorityCriterias.BottommostRuleWins;
            })
                                                                     .Build();

            // Act
            Rule <ContentTypes, ConditionTypes> actual = await rulesEngine.MatchOneAsync(expectedContent, expectedMatchDate, expectedConditions);

            // Assert
            actual.Should().NotBeNull();
            CarInsuranceAdvices actualContent = actual.ContentContainer.GetContentAs <CarInsuranceAdvices>();

            actualContent.Should().Be(expected);
        }
        public void SetInMemoryDataSource_NoParametersGiven_CreatesTransientInMemoryRulesStorageAndSetsOnSelector()
        {
            // Arrange
            IRulesDataSourceSelector <ContentType, ConditionType> rulesDataSourceSelector = Mock.Of <IRulesDataSourceSelector <ContentType, ConditionType> >();

            IRulesDataSource <ContentType, ConditionType> actualRulesDataSource = null;

            Mock.Get(rulesDataSourceSelector)
            .Setup(x => x.SetDataSource(It.IsAny <IRulesDataSource <ContentType, ConditionType> >()))
            .Callback <IRulesDataSource <ContentType, ConditionType> >((rds) =>
            {
                actualRulesDataSource = rds;
            });

            // Act
            rulesDataSourceSelector.SetInMemoryDataSource();

            // Assert
            actualRulesDataSource.Should().NotBeNull();
            actualRulesDataSource.Should().BeOfType <InMemoryProviderRulesDataSource <ContentType, ConditionType> >();
            Mock.Get(rulesDataSourceSelector)
            .Verify();
        }
Esempio n. 9
0
 public AddRuleManagementOperation(IRulesDataSource <TContentType, TConditionType> rulesDataSource, Rule <TContentType, TConditionType> rule)
 {
     this.rulesDataSource = rulesDataSource;
     this.rule            = rule;
 }
Esempio n. 10
0
 public ManagementOperationsController <TContentType, TConditionType> UsingDataSource(IRulesDataSource <TContentType, TConditionType> rulesDataSource)
 => new ManagementOperationsController <TContentType, TConditionType>(rulesDataSource, this.rules);
Esempio n. 11
0
        public async Task GetCarInsuranceAdvice_UpdatesRuleAndAddsNewOneAndEvaluates_ReturnsPay()
        {
            // Arrange
            const ContentTypes expectedContent   = ContentTypes.CarInsuranceAdvice;
            DateTime           expectedMatchDate = new DateTime(2018, 06, 01);

            Condition <ConditionTypes>[] expectedConditions = new Condition <ConditionTypes>[]
            {
                new Condition <ConditionTypes>
                {
                    Type  = ConditionTypes.RepairCosts,
                    Value = 800.00000m
                },
                new Condition <ConditionTypes>
                {
                    Type  = ConditionTypes.RepairCostsCommercialValueRate,
                    Value = 23.45602m
                }
            };

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetMongoDbDataSource(this.mongoClient, this.mongoDbProviderSettings)
                                                                     .Configure(reo =>
            {
                reo.PriotityCriteria = PriorityCriterias.BottommostRuleWins;
            })
                                                                     .Build();

            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = CreateRulesDataSourceTest <ContentTypes, ConditionTypes>(this.mongoClient, this.mongoDbProviderSettings);

            RuleBuilderResult <ContentTypes, ConditionTypes> ruleBuilderResult = RuleBuilder.NewRule <ContentTypes, ConditionTypes>()
                                                                                 .WithName("Car Insurance Advise on self damage coverage")
                                                                                 .WithDateBegin(DateTime.Parse("2018-01-01"))
                                                                                 .WithContentContainer(new ContentContainer <ContentTypes>(ContentTypes.CarInsuranceAdvice, (t) => CarInsuranceAdvices.Pay))
                                                                                 .Build();
            IEnumerable <Rule <ContentTypes, ConditionTypes> > existentRules1 = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>
            {
                Name = "Car Insurance Advise on repair costs lower than franchise boundary"
            });

            Rule <ContentTypes, ConditionTypes> ruleToAdd     = ruleBuilderResult.Rule;
            Rule <ContentTypes, ConditionTypes> ruleToUpdate1 = existentRules1.FirstOrDefault();

            ruleToUpdate1.Priority = 2;

            // Act 1
            RuleOperationResult updateOperationResult1 = await rulesEngine.UpdateRuleAsync(ruleToUpdate1);

            Rule <ContentTypes, ConditionTypes> eval1 = await rulesEngine.MatchOneAsync(expectedContent, expectedMatchDate, expectedConditions);

            IEnumerable <Rule <ContentTypes, ConditionTypes> > rules1 = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>());

            // Assert 1
            updateOperationResult1.Should().NotBeNull();
            updateOperationResult1.IsSuccess.Should().BeTrue();

            eval1.Priority.Should().Be(2);
            CarInsuranceAdvices content1 = eval1.ContentContainer.GetContentAs <CarInsuranceAdvices>();

            content1.Should().Be(CarInsuranceAdvices.RefusePaymentPerFranchise);

            Rule <ContentTypes, ConditionTypes> rule11 = rules1.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lesser than 80% of commercial value");

            rule11.Should().NotBeNull();
            rule11.Priority.Should().Be(1);
            Rule <ContentTypes, ConditionTypes> rule12 = rules1.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lower than franchise boundary");

            rule12.Should().NotBeNull();
            rule12.Priority.Should().Be(2);
            Rule <ContentTypes, ConditionTypes> rule13 = rules1.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs greater than 80% of commercial value");

            rule13.Should().NotBeNull();
            rule13.Priority.Should().Be(3);

            // Act 2
            RuleOperationResult addOperationResult = await rulesEngine.AddRuleAsync(ruleToAdd, new RuleAddPriorityOption
            {
                PriorityOption        = PriorityOptions.AtRuleName,
                AtRuleNameOptionValue = "Car Insurance Advise on repair costs lower than franchise boundary"
            });

            Rule <ContentTypes, ConditionTypes> eval2 = await rulesEngine.MatchOneAsync(expectedContent, expectedMatchDate, expectedConditions);

            IEnumerable <Rule <ContentTypes, ConditionTypes> > rules2 = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>());

            // Assert 2
            addOperationResult.Should().NotBeNull();
            addOperationResult.IsSuccess.Should().BeTrue();

            eval2.Priority.Should().Be(3);
            CarInsuranceAdvices content2 = eval2.ContentContainer.GetContentAs <CarInsuranceAdvices>();

            content2.Should().Be(CarInsuranceAdvices.RefusePaymentPerFranchise);

            Rule <ContentTypes, ConditionTypes> rule21 = rules2.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lesser than 80% of commercial value");

            rule21.Should().NotBeNull();
            rule21.Priority.Should().Be(1);
            Rule <ContentTypes, ConditionTypes> rule22 = rules2.FirstOrDefault(r => r.Name == "Car Insurance Advise on self damage coverage");

            rule22.Should().NotBeNull();
            rule22.Priority.Should().Be(2);
            Rule <ContentTypes, ConditionTypes> rule23 = rules2.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lower than franchise boundary");

            rule23.Should().NotBeNull();
            rule23.Priority.Should().Be(3);
            Rule <ContentTypes, ConditionTypes> rule24 = rules2.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs greater than 80% of commercial value");

            rule24.Should().NotBeNull();
            rule24.Priority.Should().Be(4);

            // Act 3
            IEnumerable <Rule <ContentTypes, ConditionTypes> > existentRules2 = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>
            {
                Name = "Car Insurance Advise on repair costs lower than franchise boundary"
            });

            Rule <ContentTypes, ConditionTypes> ruleToUpdate2 = existentRules2.FirstOrDefault();

            ruleToUpdate2.Priority = 4;

            RuleOperationResult updateOperationResult2 = await rulesEngine.UpdateRuleAsync(ruleToUpdate2);

            Rule <ContentTypes, ConditionTypes> eval3 = await rulesEngine.MatchOneAsync(expectedContent, expectedMatchDate, expectedConditions);

            IEnumerable <Rule <ContentTypes, ConditionTypes> > rules3 = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>());

            // Assert 3
            updateOperationResult2.Should().NotBeNull();
            updateOperationResult2.IsSuccess.Should().BeTrue();

            eval3.Priority.Should().Be(4);
            CarInsuranceAdvices content3 = eval3.ContentContainer.GetContentAs <CarInsuranceAdvices>();

            content3.Should().Be(CarInsuranceAdvices.RefusePaymentPerFranchise);

            Rule <ContentTypes, ConditionTypes> rule31 = rules3.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lesser than 80% of commercial value");

            rule31.Should().NotBeNull();
            rule31.Priority.Should().Be(1);
            Rule <ContentTypes, ConditionTypes> rule32 = rules3.FirstOrDefault(r => r.Name == "Car Insurance Advise on self damage coverage");

            rule32.Should().NotBeNull();
            rule32.Priority.Should().Be(2);
            Rule <ContentTypes, ConditionTypes> rule33 = rules3.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs greater than 80% of commercial value");

            rule33.Should().NotBeNull();
            rule33.Priority.Should().Be(3);
            Rule <ContentTypes, ConditionTypes> rule34 = rules3.FirstOrDefault(r => r.Name == "Car Insurance Advise on repair costs lower than franchise boundary");

            rule34.Should().NotBeNull();
            rule34.Priority.Should().Be(4);
        }
 public UpdateRulesManagementOperation(IRulesDataSource <TContentType, TConditionType> rulesDataSource)
 {
     this.rulesDataSource = rulesDataSource;
 }
Esempio n. 13
0
 public ConfiguredRulesEngineBuilder(IRulesDataSource <TContentType, TConditionType> rulesDataSource)
 {
     this.rulesDataSource    = rulesDataSource;
     this.rulesEngineOptions = RulesEngineOptions.NewWithDefaults();
 }
        public async Task AddRule_AddingNewRuleWithAgeConditionAtPriority1AndNewRuleAtPriority3_NewRuleIsInsertedAndExistentRulePriorityUpdatedAndNewRuleInsertedAfter()
        {
            // Arrange
            IRulesDataSource <ContentTypes, ConditionTypes> rulesDataSource = await RulesFromJsonFile.Load
                                                                              .FromJsonFileAsync <ContentTypes, ConditionTypes>(DataSourceFilePath);

            RulesEngine <ContentTypes, ConditionTypes> rulesEngine = RulesEngineBuilder.CreateRulesEngine()
                                                                     .WithContentType <ContentTypes>()
                                                                     .WithConditionType <ConditionTypes>()
                                                                     .SetDataSource(rulesDataSource)
                                                                     .Build();

            RuleBuilderResult <ContentTypes, ConditionTypes> newRuleResult1 = RuleBuilder.NewRule <ContentTypes, ConditionTypes>()
                                                                              .WithName("Body Mass Index up to 18 years formula")
                                                                              .WithDateBegin(DateTime.Parse("2018-01-01"))
                                                                              .WithContentContainer(new ContentContainer <ContentTypes>(ContentTypes.BodyMassIndexFormula, (t) => new Formula
            {
                Description = "Body Mass Index up to 18 years formula",
                Value       = "weight / ((height + 1) ^ 2)" // Not real, for the sake of the test.
            }))
                                                                              .WithCondition(cnb => cnb
                                                                                             .AsValued(ConditionTypes.Age)
                                                                                             .OfDataType <int>()
                                                                                             .WithComparisonOperator(Operators.LesserThanOrEqual)
                                                                                             .SetOperand(18)
                                                                                             .Build())
                                                                              .Build();

            Rule <ContentTypes, ConditionTypes> newRule1 = newRuleResult1.Rule;
            RuleAddPriorityOption ruleAddPriorityOption1 = RuleAddPriorityOption.ByPriorityNumber(1);

            RuleBuilderResult <ContentTypes, ConditionTypes> ruleBuilderResult2 = RuleBuilder.NewRule <ContentTypes, ConditionTypes>()
                                                                                  .WithName("Sample rule")
                                                                                  .WithDateBegin(DateTime.Parse("2021-01-01"))
                                                                                  .WithContentContainer(new ContentContainer <ContentTypes>(ContentTypes.BodyMassIndexFormula, (t) => new Formula
            {
                Description = "Sample formula",
                Value       = "0"
            }))
                                                                                  .Build();

            Rule <ContentTypes, ConditionTypes> newRule2 = ruleBuilderResult2.Rule;
            RuleAddPriorityOption ruleAddPriorityOption2 = RuleAddPriorityOption.ByPriorityNumber(4);

            // Act
            RuleOperationResult ruleOperationResult1 = await rulesEngine.AddRuleAsync(newRule1, ruleAddPriorityOption1).ConfigureAwait(false);

            RuleOperationResult ruleOperationResult2 = await rulesEngine.AddRuleAsync(newRule2, ruleAddPriorityOption2).ConfigureAwait(false);

            // Assert
            ruleOperationResult1.Should().NotBeNull();
            ruleOperationResult1.IsSuccess.Should().BeTrue();

            ruleOperationResult2.Should().NotBeNull();
            ruleOperationResult2.IsSuccess.Should().BeTrue();

            IEnumerable <Rule <ContentTypes, ConditionTypes> > rules = await rulesDataSource.GetRulesByAsync(new RulesFilterArgs <ContentTypes>()).ConfigureAwait(false);

            rules.Should().NotBeNull().And.HaveCount(3);
            rules.Should().ContainEquivalentOf(newRule1);
            newRule1.Priority.Should().Be(1, "rule should to priority 1 if inserted at priority 1");
            newRule2.Priority.Should().Be(3, "rule should have priority 3 if inserted at priority 3, given that last rule after insert was at priority 2.");
        }
Esempio n. 15
0
            public IConfiguredRulesEngineBuilder <TContentType, TConditionType> SetDataSource(IRulesDataSource <TContentType, TConditionType> rulesDataSource)
            {
                if (rulesDataSource == null)
                {
                    throw new ArgumentNullException(nameof(rulesDataSource));
                }

                return(new ConfiguredRulesEngineBuilder <TContentType, TConditionType>(rulesDataSource));
            }
Esempio n. 16
0
 public ManagementOperationsController(IRulesDataSource <TContentType, TConditionType> rulesDataSource, IEnumerable <Rule <TContentType, TConditionType> > rules)
 {
     this.managementOperations = new List <IManagementOperation <TContentType, TConditionType> >();
     this.rulesDataSource      = rulesDataSource;
     this.rules = rules;
 }