public void RulesWithMultipleParameters_ShouldReturnProperly()
{
const string source = "return abc.abc == def.abc;";
const string source2 = "return abc.abc != def.abc;";
var pm = new StubRuleProvider();
var group = new RuleGroup("group", new List <RuleParameter> {
new RuleParameter(typeof(Thing), "abc"), new RuleParameter(typeof(Thing), "def")
});
var rule0 = Rule.CreateRule().Named("rule10").WithGroup(group).WithSource(source).LoadNow().Build();
var rule1 = Rule.CreateRule().Named("rule11").WithGroup(group).WithSource(source2).LoadNow().Build();
pm.SetRules(rule0, rule1);
RuleRunner runner = new RuleRunner(pm);
var res = runner.RunRules("group", new Thing {
abc = 4
}, new Thing {
abc = 4
}); // try with dummy data class
var en = res.GetEnumerator();
en.MoveNext();
Assert.AreEqual("rule10", en.Current.RuleName);
Assert.AreEqual(true, en.Current.Result);
en.MoveNext();
Assert.AreEqual("rule11", en.Current.RuleName);
Assert.AreEqual(false, en.Current.Result);
}
public void RunRuleByID_FrameworkIssueLinkIsNotNull_PropagatesToResult()
{
const string frameworkIssueLink = "https://docs.microsoft.com/known-framework-link";
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(true).Verifiable();
var infoStub = new RuleInfo
{
ErrorCode = EvaluationCode.NeedsReview,
FrameworkIssueLink = frameworkIssueLink,
};
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.PassesTest(e)).Returns(true).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(frameworkIssueLink, result.RuleInfo.FrameworkIssueLink);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public void BeforeScenario()
{
_ruleRunner = new RuleRunner();
_objectContainer.RegisterInstanceAs(_ruleRunner);
_ruleRunner.Setup().Wait();
}
public void RunRuleByID_RuleNotApplicableForNonMatchingCondition()
{
// This test has the side effect of ensuring IRule.Evaluate is not called
// when the condition is not matched.
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(false).Verifiable();
var infoStub = new RuleInfo();
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.NotApplicable, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(infoStub, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public void RunRuleByID_ReturnsExecutionErrorWhenConditionMatchesThrowsException()
{
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Throws <Exception>().Verifiable();
var infoStub = new RuleInfo();
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.RuleExecutionError, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(infoStub, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
private static int ExecuteOperationByInputOptions(CommandLineOptions options)
{
int exitCode = 0;
switch (options.Operation)
{
case Operation.ShowHelp:
CommandLineParser.PrintUsage();
exitCode = 0;
break;
case Operation.ListRules:
var ruleRunner = new RuleRunner();
ruleRunner.RunListRules();
exitCode = 0;
break;
case Operation.Format:
var formatRunner = new FormatRunner();
exitCode = formatRunner.RunFormat(options);
break;
default:
throw new Exception("Invalid enum value: " + options.Operation);
}
return(exitCode);
}
public void RunRuleByID_ReturnsExpectedEvaluationCodeWhenSuccessful()
{
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(true).Verifiable();
var ruleMock = CreateRuleMock(conditionMock.Object, EvaluationCode.NeedsReview, e);
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.NeedsReview, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(ruleMock.Object.Info, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
private static RuleRunner SetupRunner()
{
var runner = new RuleRunner();
Compose(runner);
return(runner);
}
public void Validate(TemperatureType temperatureType, ICollection <CommandType> commands)
{
var ctx = new ValidationContext(new List <CommandType>(), temperatureType, commands);
var cancelValidation = false;
foreach (var command in commands)
{
if (cancelValidation)
{
break;
}
ctx.CurrentCommand = command;
var anyRulesFailed = false;
var ruleRunner = new RuleRunner <ValidationContext>(_rulePack);
ruleRunner.RuleRan += (object sender, RuleRanEventArgs <ValidationContext> e, ref bool cancel) =>
{
if (!e.Passed)
{
anyRulesFailed = true;
}
OnRuleRan(new RuleRanEventArgs(e.Rule.Method, e.Passed, command), ref cancel);
};
ruleRunner.Run(ctx);
OnCommandValidated(new DressCommandValidationEventArgs(command, anyRulesFailed), ref cancelValidation);
ctx.AlreadyExecuted.Add(command);
}
}
/// <summary>
/// Private helper function (formerly in SaveSnapshotZip) to make it easier to call with different inputs
/// </summary>
private static void SaveSnapshotFromElement(int?focusedElementId, A11yFileMode mode, Dictionary <SnapshotMetaPropertyName, object> otherProperties, Contexts.ElementContext ec, Package package, A11yElement root)
{
var json = JsonConvert.SerializeObject(root, Formatting.Indented);
using (MemoryStream mStrm = new MemoryStream(Encoding.UTF8.GetBytes(json)))
{
AddStream(package, mStrm, elementFileName);
}
if (ec.DataContext.Screenshot != null)
{
using (MemoryStream mStrm = new MemoryStream())
{
ec.DataContext.Screenshot.Save(mStrm, System.Drawing.Imaging.ImageFormat.Png);
mStrm.Seek(0, SeekOrigin.Begin);
AddStream(package, mStrm, screenshotFileName);
}
}
var meta = new SnapshotMetaInfo(mode, RuleRunner.GetRuleVersion(), focusedElementId, ec.DataContext.ScreenshotElementId, otherProperties);
var jsonMeta = JsonConvert.SerializeObject(meta, Formatting.Indented);
using (MemoryStream mStrm = new MemoryStream(Encoding.UTF8.GetBytes(jsonMeta)))
{
AddStream(package, mStrm, metatdataFileName);
}
}
public async Task <IActionResult> Post([FromBody] RuleRequest request)
{
var runner = new RuleRunner(new RuleDefinitionRepository(_context));
var result = await runner.ApplyAsync(request);
return(Ok(result));
}
public void RunRuleByID_ReturnsExpectedEvaluationCodeWhenPassesTestFalse()
{
var e = new MockA11yElement();
var conditionMock = new Mock <Condition>(MockBehavior.Strict);
conditionMock.Setup(m => m.Matches(e)).Returns(true).Verifiable();
var infoStub = new RuleInfo
{
ErrorCode = EvaluationCode.NeedsReview,
};
var ruleMock = new Mock <IRule>(MockBehavior.Strict);
ruleMock.Setup(m => m.Condition).Returns(conditionMock.Object).Verifiable();
ruleMock.Setup(m => m.PassesTest(e)).Returns(false).Verifiable();
ruleMock.Setup(m => m.Info).Returns(() => infoStub).Verifiable();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.NeedsReview, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(ruleMock.Object.Info, result.RuleInfo);
conditionMock.VerifyAll();
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
public void RuleWithGoodAndBadAndUnknownLink()
{
var linkVerifierService = new RuleRunner(new List <ILinkRule> {
bassicRule
});
var result = linkVerifierService.VerifyLinks(links);
AssertLinkIsBad(result, badLink);
AssertLinkIsGood(result, goodLink);
AssertLinkIsUnknown(result, unknownLink);
}
public void RuleIgnoresLink_LinkReturnedUnknown()
{
var linkVerifierService = new RuleRunner(new List <ILinkRule> {
bassicRule
});
var result = linkVerifierService.VerifyLinks(new List <LinkDto> {
unknownLink
});
AssertLinkIsUnknown(result, unknownLink);
}
public void RuleDisapprovesLink_LinkReturnedBad()
{
var linkVerifierService = new RuleRunner(new List <ILinkRule> {
bassicRule
});
var result = linkVerifierService.VerifyLinks(new List <LinkDto> {
badLink
});
AssertLinkIsBad(result, badLink);
}
public void AnylizeThousandsOfLinks_AllLinksInResult()
{
var rule1 = A.Fake <ILinkRule>();
var rule2 = A.Fake <ILinkRule>();
var allLinks = CreateAllLinks(rule1, rule2);
var linkVerifierService = new RuleRunner(new [] { rule1, rule2 });
var results = linkVerifierService.VerifyLinks(allLinks);
AssertLinkWereClassifiedCorrectly(results);
Assert.AreEqual(LinkLoop * 2, results.GoodLinks.Count(), "Didn't get enough good links");
Assert.AreEqual(LinkLoop, results.BadLinks.Count(), "Didn't get enough bad links");
Assert.AreEqual(LinkLoop * 3, results.UnknownLinks.Count(), "Didn't get enough unknown links");
}
public void RuleSetsLinkToUnknownTest_NextRulesIgnoreLinks()
{
var firstRule = A.Fake <ILinkRule>();
var secondRule = A.Fake <ILinkRule>();
firstRule.SetLinkTo(true, LinkStatus.Unknown, unknownLink);
secondRule.SetLinkTo(true, LinkStatus.Good, unknownLink);
var linkVerifierService = new RuleRunner(new List <ILinkRule> {
firstRule, secondRule
});
var result = linkVerifierService.VerifyLinks(links);
AssertLinkIsUnknown(result, unknownLink);
}
public void RunRule_ImproperParams_ShouldThrow()
{
const string source = "return true;";
var pm = new StubRuleProvider();
var group = new RuleGroup("group", null);
var rule = Rule.CreateRule().Named("rule").WithGroup(group).WithSource(source).Build();
pm.SetRules(rule);
RuleRunner runner = new RuleRunner(pm);
var results = runner.RunRules("group", 4).ToList(); // to list is required for the rules to actually run.
Assert.IsFalse(results.Single().HasResult);
Assert.AreEqual("rule", results.Single().RuleName);
var x = results.Single().Result;
}
/// <summary>
/// Refresh tree node data with all children at once.
/// <param name="mode">indicate the mode</param>
/// </summary>
public void RefreshTreeData(TreeViewMode mode)
{
this.WalkerMode = mode;
if (this.Elements.Count != 0)
{
this.Elements.Clear();
}
//Set parent of Root explicitly for testing.
var ancestry = new DesktopElementAncestry(this.WalkerMode, this.SelectedElement);
// Pre-count the ancestors in our bounded count, so that our count is accurate
_elementCounter.TryAdd(ancestry.Items.Count);
this.TopMostElement = ancestry.First;
// clear children
ListHelper.DisposeAllItemsAndClearList(this.SelectedElement.Children);
this.SelectedElement.UniqueId = 0;
PopulateChildrenTreeNode(this.SelectedElement, ancestry.Last, ancestry.NextId);
// do population of ancesters all togather with children
var list = new List <A11yElement>(this.Elements);
foreach (var item in ancestry.Items)
{
this.Elements.Add(item);
}
// populate Elements first
this.Elements.AsParallel().ForAll(e => e.PopulateAllPropertiesWithLiveData());
// check whether there is any elements which couldn't be updated in parallel, if so, update it in sequence.
var nuel = this.Elements.Where(e => e.Properties == null);
if (nuel.Any())
{
nuel.ToList().ForEach(e => e.PopulateAllPropertiesWithLiveData());
}
// run tests
list.AsParallel().ForAll(e =>
{
e.ScanResults?.Items.Clear();
RuleRunner.Run(e);
});
}
public void TwoRulesTest()
{
var firstRule = A.Fake <ILinkRule>();
var secondRule = A.Fake <ILinkRule>();
firstRule.SetLinkTo(true, LinkStatus.Bad, badLink);
secondRule.SetLinkTo(true, LinkStatus.Good, goodLink);
var linkVerifierService = new RuleRunner(new List <ILinkRule> {
firstRule, secondRule
});
var result = linkVerifierService.VerifyLinks(links);
AssertLinkIsBad(result, badLink);
AssertLinkIsGood(result, goodLink);
AssertLinkIsUnknown(result, unknownLink);
}
static void Main(string[] args)
{
var designation = new Designation()
{
Id = 1,
Name = "ManaGer",
};
var employee = new Employee
{
Id = 1,
Name = "Nejimon",
Designation = designation,
LstDesignation = new List <Designation>()
{
new Designation()
{
Id = 1, Name = "Fulano"
}
}
};
//employee.Teste.Find(r => r.Id == 1)
//new Func<TestConsoleApp.Employee, bool>((input) => { return input.Numeros.Contains(10) });
var thirdAssemblyClass = new ClassFromAnotherAssembly
{
Id = 1
};
var runner = new RuleRunner();
var statementResult = runner.IsStatementTrue("input.Id == 1", employee);
var blockResult = runner.IsBlockTrue("if(input.Designation != null && input.Designation.Name != null && input.Designation.Name.ToLower() == \"manager\") return true; else return false;", employee);
var blockResult1 = runner.IsBlockTrue("return input.LstDesignation.Find(r => r.Name == \"Fulano\") != null;", employee);
//demo of how types from another assembly can be used:
var runner2 = new RuleRunner(new List <Assembly>
{
typeof(ClassFromAnotherAssembly).Assembly //you need to add reference to the external assembly like this.
});
var statementResult2 = runner2.IsStatementTrue("input.Id == 1", thirdAssemblyClass);
}
public void RunRuleByID_ReturnsExecutionErrorForUnknownRuleID()
{
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => null).Verifiable();
var e = new MockA11yElement();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.RuleExecutionError, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.IsNull(result.RuleInfo);
providerMock.VerifyAll();
}
public void RunRuleByID_ReturnsExecutionErrorWhenEvaluateNotImplemented()
{
var e = new MockA11yElement();
var rule = new RuleWithEvaluateNotImplemented();
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => rule);
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.RuleExecutionError, result.EvaluationCode);
Assert.AreEqual(rule.Info, result.RuleInfo);
providerMock.VerifyAll();
}
static void Compose(RuleRunner runner)
{
var catalog = new AggregateCatalog();
foreach (var directory in AssemblyFolders)
{
catalog.Catalogs.Add(new DirectoryCatalog(directory));
}
foreach (var filename in AssemblyNames)
{
var assembly = Assembly.LoadFile(filename);
catalog.Catalogs.Add(new AssemblyCatalog(assembly));
}
var container = new CompositionContainer(catalog);
container.ComposeParts(runner);
}
public void Setup()
{
runner = new RuleRunner();
solutionResult = new RulesResultBase();
projectResult = new RulesResultBase();
project = new Project("", new Guid());
solution = new Solution("", new[] { project });
solutionRuleProcessor = MockRepository.GenerateMock <ISolutionRuleProcessor>();
solutionRuleProcessor.Expect(r => r.RunRules(solution)).Return(solutionResult);
projectRuleProcessor = MockRepository.GenerateMock <IProjectRuleProcessor>();
projectRuleProcessor.Expect(r => r.RunRules(project)).Return(projectResult);
runner.SolutionProcessors = new[] { solutionRuleProcessor };
runner.ProjectProcessors = new[] { projectRuleProcessor };
results = runner.RunRules(solution);
}
public void RunRuleByID_CallsPassesTestWhenConditionIsNull()
{
var e = new MockA11yElement();
var ruleMock = CreateRuleMock(null, EvaluationCode.Pass, e);
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.GetRule(It.IsAny <RuleId>())).Returns(() => ruleMock.Object).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var result = runner.RunRuleByID(default(RuleId), e);
Assert.AreEqual(EvaluationCode.Pass, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(ruleMock.Object.Info, result.RuleInfo);
ruleMock.VerifyAll();
providerMock.VerifyAll();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//get the project file
StartUpWindow win = new StartUpWindow();
win.ShowDialog();
//if a file selected
if (win.DialogResult == DialogResult.OK)
{
//build main objects
CalidusProjectManager projectManager = new CalidusProjectManager();
CalidusProjectModel project = new CalidusProjectModel(projectManager.ReadFrom(win.SelectedProjectFile));
CalidusRuleConfigurationFactory configFactory = new CalidusRuleConfigurationFactory(project, projectManager);
RuleRunner runner = new RuleRunner();
RuleViolationList violationList = new RuleViolationList();
//prepare main view
MainWindow mainView = new MainWindow();
//assign controllers
MainController c = new MainController(mainView, project, win.IsNewProject, projectManager, runner, violationList);
ViolationListController violationListController = new ViolationListController(mainView.ViolationListView, project, violationList);
CheckableRuleTreeController checkableRuleListController = new CheckableRuleTreeController(mainView.CheckableRuleTreeView, new CalidusRuleProvider(), configFactory);
FileTreeController fileListController = new FileTreeController(mainView.FileListView, project);
SourceLocationController sourceLocationController = new SourceLocationController(mainView.SourceLocationView, project);
RuleRunnerController ruleRunnerController = new RuleRunnerController(mainView.RuleRunnerView, runner, project, configFactory);
StatusController statusController = new StatusController(mainView.StatusView, violationList);
//run application
Application.Run(mainView);
}
}
public void RunAll_ReturnsExpectedResults()
{
var e = new MockA11yElement();
var ruleMocks = new List <Mock <IRule> >();
var codes = Enum.GetValues(typeof(EvaluationCode)) as IEnumerable <EvaluationCode>;
foreach (var code in codes)
{
ruleMocks.Add(CreateRuleMock(Condition.True, code, e));
}
var rules = from m in ruleMocks select(m.Object);
var providerMock = new Mock <IRuleProvider>(MockBehavior.Strict);
providerMock.Setup(m => m.All).Returns(() => rules).Verifiable();
var runner = new RuleRunner(providerMock.Object);
var results = runner.RunAll(e);
Assert.AreEqual(codes.Count(), results.Count());
for (var i = 0; i < results.Count(); ++i)
{
var result = results.ElementAt(i);
var expectedCode = codes.ElementAt(i);
var ruleMock = ruleMocks[i];
Assert.AreEqual(expectedCode, result.EvaluationCode);
Assert.AreEqual(e, result.element);
Assert.AreEqual(ruleMock.Object.Info, result.RuleInfo);
ruleMock.VerifyAll();
}
providerMock.VerifyAll();
}
/// <summary>
/// Python rule.
/// </summary>
public static void Rule3(int i, decimal d, string s)
{
Rule3Request request = new Rule3Request();
request.Integer = i;
request.Decimal = d;
request.String = s;
Console.WriteLine("--- Rule3Request ---");
Console.WriteLine(request.Integer);
Console.WriteLine(request.Decimal);
Console.WriteLine(request.String);
RuleRunner rr = new RuleRunner();
Rule3Response response = (Rule3Response)rr.Run("Hf.Rules.Rule3", request);
Console.WriteLine("--- Rule3Response ---");
Console.WriteLine(response.Boolean);
Console.WriteLine(response.DateTime);
Console.WriteLine(response.Decimal);
Console.WriteLine(response.Integer);
Console.WriteLine(response.String);
}
public void RunRulesWithListTest()
{
const string source = "return abc.abc == 4;";
const string source2 = "return abc.abc != 4;";
var pm = new StubRuleProvider();
var group = new RuleGroup("group", new List <RuleParameter> {
new RuleParameter(typeof(Thing), "abc")
});
var rule0 = Rule.CreateRule().Named("rule0").WithGroup(group).WithSource(source).LoadNow().Build();
var rule1 = Rule.CreateRule().Named("rule1").WithGroup(group).WithSource(source).LoadNow().Build();
var rule2 = Rule.CreateRule().Named("rule2").WithGroup(group).WithSource(source2).LoadNow().Build();
pm.SetRules(rule0, rule1, rule2);
RuleRunner runner = new RuleRunner(pm);
var res = runner.RunRulesWithList("group", new List <Tuple <string, object> > {
Tuple.Create("abc", (object)new Thing {
abc = 4
})
}); // try with dummy data class
var en = res.GetEnumerator();
en.MoveNext();
Assert.AreEqual("rule0", en.Current.RuleName);
Assert.AreEqual(true, en.Current.Result);
en.MoveNext();
Assert.AreEqual("rule1", en.Current.RuleName);
Assert.AreEqual(true, en.Current.Result);
en.MoveNext();
Assert.AreEqual("rule2", en.Current.RuleName);
Assert.AreEqual(false, en.Current.Result);
}
