public static IAsyncValidationRule AddChildValidatable([NotNull] this ValidationHelper validator,
[NotNull] Expression<Func<IValidatable>> childValidatableGetter)
{
Guard.NotNull(validator, nameof(validator));
Guard.NotNull(childValidatableGetter, nameof(childValidatableGetter));
Func<IValidatable> getter = childValidatableGetter.Compile();
return validator.AddAsyncRule(PropertyName.For(childValidatableGetter), () =>
{
IValidatable validatable = getter();
if (validatable != null)
{
return validatable.Validate().ContinueWith(r =>
{
ValidationResult result = r.Result;
var ruleResult = new RuleResult();
foreach (ValidationError error in result.ErrorList)
{
ruleResult.AddError(error.ErrorText);
}
return ruleResult;
});
}
return TaskEx.FromResult(RuleResult.Valid());
});
}
private static string GetRuleResultMessage(RuleResult d, int level)
{
var subMessage = string.Empty;
if (d.InnerResult != null)
subMessage = ReadDetails(d.InnerResult, level + 1);
return d.Message + " (" + d.FullName + ")" + subMessage;
}
protected override RuleResult DoService(string notification)
{
RuleResult res = new RuleResult(GetType().Name);
Count counter = new Count();
counter.Command = "sp_countevents";
res.AddEvidence(counter.Calculate().ToString());
return res;
}
private List<RuleResult> BuildCache(RuleSet rule)
{
var visitor = new CssItemCollector<RuleSet>();
rule.Parent.Accept(visitor);
List<RuleResult> list = new List<RuleResult>();
foreach (RuleSet rs in visitor.Items)
{
RuleResult result = new RuleResult(rs, rs.Start, GetSelectorText(rs));
list.Add(result);
}
return list;
}
private static void InvokeMethod(RuleResult ruleresult, Action action)
{
try
{
action.Invoke();
}
catch (RuleExecutionException ex)
{
ruleresult.RuleMessage = ex.RuleMessage;
ruleresult.Status = ex.Status;
}
}
public void Setup()
{
Bootstrapper.BootstrapTest();
_field = ObjectMother.ValidField("Raif").WithEntityId(1);
_task1 = ObjectMother.ValidTask("task1").WithEntityId(1);
_task1.ScheduledStartTime = DateTime.Parse("1/2/2020 8:00 AM");
_task2 = ObjectMother.ValidTask("task1").WithEntityId(2);
_task2.ScheduledStartTime = DateTime.Parse("1/3/2020 8:00 AM");
_task3 = ObjectMother.ValidTask("task1").WithEntityId(3);
_task3.ScheduledStartTime = DateTime.Parse("1/1/2010 8:00 AM");
_field.AddPendingTask(_task1);
_field.AddPendingTask(_task2);
_field.AddCompletedTask(_task3);
_SUT = new FieldHasNoOutstandingTasks();
_ruleResult = _SUT.Execute(_field);
}
public static IAsyncValidationRule AddChildValidatable([NotNull] this ValidationHelper validator,
[NotNull] Expression<Func<IValidatable>> childValidatableGetter)
{
Contract.Requires(validator != null);
Contract.Requires(childValidatableGetter != null);
Contract.Ensures(Contract.Result<IAsyncValidationRule>() != null);
Func<IValidatable> getter = childValidatableGetter.Compile();
return validator.AddAsyncRule(PropertyName.For(childValidatableGetter), () =>
{
IValidatable validatable = getter();
if (validatable != null)
{
#if SILVERLIGHT_4
validatable.Validate(result =>
{
#else
return validatable.Validate().ContinueWith(r =>
{
ValidationResult result = r.Result;
#endif
var ruleResult = new RuleResult();
foreach (ValidationError error in result.ErrorList)
{
ruleResult.AddError(error.ErrorText);
}
return ruleResult;
});
}
return Task.Factory.StartNew(() => RuleResult.Valid());
});
}
/// <summary>
/// Creates a validation rule that validates all the <see cref="IValidatable"/> items in the collection specified in <paramref name="validatableCollectionGetter"/>
/// and adds error to this object from all the validatable items in invalid.
/// </summary>
/// <param name="validator">An instance of <see cref="ValidationHelper"/> that is used for validation.</param>
/// <param name="validatableCollectionGetter">Expression for getting the collection of <see cref="IValidatable"/> objects to add as child items.</param>
/// <returns>An instance of <see cref="IValidationRule"/> that represents the newly created validation rule.</returns>
[NotNull, SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]
public void Setup()
{
Bootstrapper.BootstrapTest();
_systemClock = SystemClock.For(DateTime.Parse("1/1/2020 8:00 AM"));
_field = ObjectMother.ValidField("Raif").WithEntityId(1);
_event1 = ObjectMother.ValidEvent("event1").WithEntityId(1);
_event1.StartTime = DateTime.Parse("1/2/2020 8:00 AM");
_event2 = ObjectMother.ValidEvent("event1").WithEntityId(2);
_event2.StartTime = DateTime.Parse("1/3/2020 8:00 AM");
_event3 = ObjectMother.ValidEvent("event1").WithEntityId(3);
_event3.StartTime = DateTime.Parse("1/1/2010 8:00 AM");
_field.AddEvent(_event1);
_field.AddEvent(_event2);
_field.AddEvent(_event3);
_SUT = new FieldHasNoOutstandingEvents(_systemClock);
_ruleResult = _SUT.Execute(_field);
}
public RuleResult RunRule(Action action, string rule)
{
var ruleresult = new RuleResult {Description = rule, Status = RuleStatus.Passed};
try
{
InvokeMethod(ruleresult, action);
}
catch (Exception ex)
{
ruleresult.Status = RuleStatus.Error;
ruleresult.RuleMessage = "Unhandled exception occured Message was :" + ex.Message+
"\n Stacktrace is :" + ex.StackTrace;
}
return ruleresult;
}
public void Setup()
{
Bootstrapper.BootstrapTest();
_systemClock = SystemClock.For(DateTime.Parse("1/1/2020 8:00 AM"));
_employee = ObjectMother.ValidEmployee("Raif").WithEntityId(1);
_task1 = ObjectMother.ValidTask("task1").WithEntityId(1);
_task1.ScheduledStartTime = DateTime.Parse("1/2/2020 8:00 AM");
_task2 = ObjectMother.ValidTask("task1").WithEntityId(2);
_task2.ScheduledStartTime = DateTime.Parse("1/3/2020 8:00 AM");
_task3 = ObjectMother.ValidTask("task1").WithEntityId(3);
_task3.ScheduledStartTime = DateTime.Parse("1/1/2010 8:00 AM");
_employee.AddTask(_task1);
_employee.AddTask(_task2);
_employee.AddTask(_task3);
_SUT = new EmployeeHasNoOutstandingTasks(_systemClock);
_ruleResult = _SUT.Execute(_employee);
}
public RuleResult Evaluate(producerType element)
{
var result = RuleResult.Pass();
if (element.status == statusType.I &&
element.producerBusiness != null)
{
var company = element.producerBusiness.Item as companyType;
if (company != null)
{
var companyNumber = CompanyRegistrationNumberFormatter
.FormatCompanyRegistrationNumber(company.companyNumber);
if (!string.IsNullOrEmpty(companyNumber) &&
(producerQuerySet.GetLatestCompanyProducers().Any(p =>
{
var existingCompanyRegistrationNumber = CompanyRegistrationNumberFormatter
.FormatCompanyRegistrationNumber(p.ProducerBusiness.CompanyDetails.CompanyNumber);
return(!string.IsNullOrEmpty(existingCompanyRegistrationNumber) &&
existingCompanyRegistrationNumber == companyNumber);
})
||
migratedProducerQuerySet.GetAllMigratedProducers().Any(m =>
{
var migratedProducerCompanyNumber = CompanyRegistrationNumberFormatter
.FormatCompanyRegistrationNumber(m.CompanyNumber);
return(!string.IsNullOrEmpty(migratedProducerCompanyNumber) &&
migratedProducerCompanyNumber == companyNumber);
})))
{
result = RuleResult.Fail(
string.Format(@"We have previously issued a producer registration number (PRN) to {0} with company registration number (CRN) {1}. To register this producer, provide its existing PRN and use the status 'A' in the XML file.",
element.GetProducerName(), company.companyNumber),
Core.Shared.ErrorLevel.Error);
}
}
}
return(result);
}
public void AsyncValidation_MultipleRulesForSameTarget_DoesNotExecuteRulesIfPerviousFailed()
{
TestUtils.ExecuteWithDispatcher((uiThreadDispatcher, completedAction) =>
{
// ARRANGE
var validation = new ValidationHelper();
var dummy = new DummyViewModel();
bool firstRuleExecuted = false;
bool secondRuleExecuted = false;
validation.AddRule(nameof(dummy.Foo),
() =>
{
firstRuleExecuted = true;
return(RuleResult.Invalid("Error1"));
});
validation.AddAsyncRule(nameof(dummy.Foo),
() =>
{
return(Task.Run(() =>
{
secondRuleExecuted = true;
return RuleResult.Invalid("Error2");
}));
});
// ACT
validation.ValidateAllAsync().ContinueWith(result =>
{
// VERIFY
Assert.True(firstRuleExecuted, "First rule must have been executed");
Assert.False(secondRuleExecuted,
"Second rule should not have been executed because first rule failed.");
completedAction();
});
});
}
private int GetPolicyResult(RuleResult result)
{
if (_failOn == RuleResult.None)
{
return(0);
}
if (_failOn == RuleResult.Warning && result == RuleResult.Warning)
{
return(1);
}
if (_failOn == RuleResult.Fail && result != RuleResult.Fail)
{
return(0);
}
// everything else is Fail
return(2);
}
public RuleResult Execute <ENTITY>(ENTITY employee) where ENTITY : DomainEntity
{
var result = new RuleResult {
Success = true
};
var count = 0;
var _employee = employee as Employee;
_employee.GetTasks().Each(x => { if (x.ScheduledStartTime > _systemClock.Now)
{
count++;
}
});
if (count > 0)
{
result.Success = false;
result.Message = CoreLocalizationKeys.EMPLOYEE_HAS_TASKS_IN_FUTURE.ToFormat(count);
}
return(result);
}
public RuleResult SatisfiedBy(InputData <TIn> input)
{
RuleResult finalResult = RuleResult.NoMatch;
foreach (var rule in rules)
{
RuleResult result = rule.SatisfiedBy(input.NewContext());
if (result == RuleResult.NoMatch)
{
return(RuleResult.NoMatch);
}
if (finalResult != RuleResult.MatchNoEmit)
{
finalResult = result;
}
input.MatchedRules.Add(rule);
}
return(finalResult);
}
public void detects_similar_copypasta()
{
Mock <IClock> clockMock = new();
CopypastaRule rule = new(clockMock.Object, Duration.FromSeconds(10));
const string copypasta1 =
"What the *** did you just *** type about me, you little bitch? I’ll have you know I graduated top of my class at MIT, and I’ve been involved in numerous secret raids with Anonymous, and I have over 300 confirmed DDoSes.";
const string copypasta2 =
"What the f**k did you just f*****g say about me, you little bitch? I'll have you know I graduated top of my class in the Navy Seals, and I've been involved in numerous secret raids on Al-Quaeda, and I have over 300 confirmed kills.";
clockMock.Setup(c => c.GetCurrentInstant()).Returns(Instant.FromUnixTimeSeconds(0));
RuleResult resultFirstSeen = rule.Check(TextMessage(copypasta1));
Assert.IsInstanceOf <RuleResult.Nothing>(resultFirstSeen);
clockMock.Setup(c => c.GetCurrentInstant()).Returns(Instant.FromUnixTimeSeconds(5));
RuleResult resultSimilarCopypasted = rule.Check(TextMessage(copypasta2));
Assert.IsInstanceOf <RuleResult.GivePoints>(resultSimilarCopypasted);
}
public void FetchOrAddRule_NewRule_ReturnRule()
{
RuleResult ruleResult = GenerateRuleResult();
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddStandardsRuleResult = (_) =>
{
return(new string[] { Standard });
};
Rule addedRule = GenerateRuleFromRuleResult(ruleResult);
Rule returnedRule = ResultsFileSarifMapper.FetchOrAddRule(ruleResult);
AssertRulesEqual(addedRule, returnedRule);
Assert.IsTrue(ResultsFileSarifMapper.RuleList.ContainsKey(ruleResult.Rule.ToString()));
}
}
public void ignores_different_messages()
{
Mock <IClock> clockMock = new();
CopypastaRule rule = new(clockMock.Object, Duration.FromSeconds(10));
const string copypasta1 =
"What the f**k did you just f*****g say about me, you little bitch? I'll have you know I graduated top of my class in the Navy Seals, and I've been involved in numerous secret raids on Al-Quaeda, and I have over 300 confirmed kills.";
const string copypasta2 =
"Welch eynen verschissenen Unfug schicktest du dich zur Hölle nochmal an, über das heilige römische Reych in die Welt herauszuthragen, du Lustknabe? Seyd drumb in Kennthnisz gesetzet, dass min threue Sünderseele meynes Gewalthauvns besther Landsknecht gewesen und an Schwerthzügen gegen holländische Rebellen meynen Theil trug, derer nicht nur zahlreych, sondern auch occulter Natura waren.";
clockMock.Setup(c => c.GetCurrentInstant()).Returns(Instant.FromUnixTimeSeconds(0));
RuleResult resultFirstSeen = rule.Check(TextMessage(copypasta1));
Assert.IsInstanceOf <RuleResult.Nothing>(resultFirstSeen);
clockMock.Setup(c => c.GetCurrentInstant()).Returns(Instant.FromUnixTimeSeconds(5));
RuleResult resultSimilarCopypasted = rule.Check(TextMessage(copypasta2));
Assert.IsInstanceOf <RuleResult.Nothing>(resultSimilarCopypasted);
}
public RuleResult Evaluate(producerType producer)
{
if (producer.status == statusType.A && !string.IsNullOrEmpty(producer.registrationNo))
{
var validRegistrationNumbers = producerQuerySet.GetAllRegistrationNumbers()
.Union(migratedProducerQuerySet.GetAllRegistrationNumbers())
.Select(prn => prn.ToLowerInvariant());
if (!validRegistrationNumbers.Contains(producer.registrationNo.ToLowerInvariant()))
{
return
(RuleResult.Fail(
string.Format(
"We cannot recognise the producer registration number (PRN) you have entered for {0} {1}. Enter the correct PRN for this producer.",
producer.GetProducerName(), producer.registrationNo)));
}
}
return(RuleResult.Pass());
}
public async void MixedValidation_SyncRuleThrowsExceptionAfterSuccesfullAsyncRule_ExceptionIsPropogated()
{
// ARRANGE
var validator = new ValidationHelper();
validator.AddAsyncRule(async() =>
{
return(await Task.Run(() => RuleResult.Valid()));
});
validator.AddRule(() => { throw new InvalidOperationException("Test"); });
// ACT & VERIFY
var task = Assert.ThrowsAsync <ValidationException>(() => validator.ValidateAllAsync());
if (task != await Task.WhenAny(task, Task.Delay(TimeSpan.FromSeconds(5))))
{
Assert.True(false, "Looks like the validation is stuck (didn't complete in a timeout), which means it didn't handle the exception properly.");
}
}
public async Task <RuleResultDto> Update(Guid tenantId, Guid id, UpdateRuleDto updateRuleDto)
{
RuleKey ruleKey = RuleKey.New(tenantId, id);
Rule rule = await this.ruleRepository.GetById(ruleKey);
if (rule == null)
{
throw new NotFoundException(FormattableString.Invariant($"{nameof(Rule)} was not found. TenantId = {tenantId} | Id = {id}"));
}
UpdateRule updateRule = this.updateRuleConversionProfile.Convert(tenantId, id, updateRuleDto);
RuleResult ruleResult = await this.updateRuleService.UpdateRule(updateRule);
return(new RuleResultDto
{
AffectedRule = ruleResult.AffectedRule != null?this.ConvertToDto(ruleResult.AffectedRule) : null,
ErrorMessages = ruleResult.ErrorMessages.Select(m => new { m.Code, m.Message })
});
}
public void Reset_AllTargetsBecomeValidAgain()
{
// ARRANGE
var dummy = new DummyViewModel();
var validation = new ValidationHelper();
validation.AddRule(nameof(dummy.Foo), () => RuleResult.Invalid("error1"));
validation.AddRule(nameof(dummy.Bar), () => RuleResult.Invalid("error2"));
validation.ValidateAll();
// ACT
validation.Reset();
// VERIFY
Assert.True(validation.GetResult().IsValid);
Assert.True(validation.GetResult(nameof(dummy.Foo)).IsValid);
Assert.True(validation.GetResult(nameof(dummy.Bar)).IsValid);
}
private void ConfigureValidationRules()
{
Validator.AddRequiredRule(() => Name, "Please add the name.");
Validator.AddRequiredRule(() => Phone, "Please add phone number,");
Validator.AddRequiredRule(() => Age, "Please add the age.");
Validator.AddRule(() => Age,
() =>
{
if (Age == null && int.TryParse(Age, out r))
{
return(RuleResult.Invalid("Please set age by numbers."));
}
else
{
Age = Age;
}
return(RuleResult.Valid());
});
}
public override IRuleResult Apply()
{
var result = new RuleResult();
switch (Model.EmployeeRating)
{
case "Exceeds Expectation":
case "Outstanding":
result.Result = true;
break;
case "Underperformer":
case "Meets Expectation":
default:
result.Result = false;
break;
}
return(result);
}
public RuleResult Execute <ENTITY>(ENTITY field) where ENTITY : DomainEntity
{
var result = new RuleResult {
Success = true
};
var count = 0;
var _field = field as Field;
_field.GetEvents().Each(x => { if (x.StartTime > _systemClock.Now)
{
count++;
}
});
if (count > 0)
{
result.Success = false;
result.Message = CoreLocalizationKeys.FIELD_HAS_EVENTS_IN_FUTURE.ToFormat(count);
}
return(result);
}
public override RuleResult Execute()
{
RuleResult result = new RuleResult();
try
{
DateTime OrderDate = Convert.ToDateTime(Data.Fields.GetFieldByAlias("order_date").FieldValue);
if (OrderDate < System.DateTime.Today.AddDays(-1))
{
MessageBox.Show("Order Date Cannot Be More Than 1 day in the past");
Data.Fields.GetFieldByAlias("order_date").FieldValue = Convert.ToString(System.DateTime.Today);
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
result.Success = true;
return(result);
}
public static RuleResult computeRuleResult(Rule rule, SQLParameter parameter, String ruleOutput)
{
Boolean passed = ruleOutput == "";
RuleResult ruleResult = new RuleResult();
ruleResult.Passed = passed;
if (!passed)
{
ruleResult.RuleID = rule.getRuleID();
ruleResult.Rule = rule;
ruleResult.ObjectType = EA.ObjectType.otParameter;
ruleResult.ObjectID = parameter.OperationID;
ruleResult.EaObject = parameter;
ruleResult.ErrorOutput = ruleOutput;
ruleResult.ErrorLevel = rule.getErrorLevel(parameter, ruleOutput);
ruleResult.NameOfObject = parameter.Name;
ruleResult.TypeOfObject = "Parameter";
}
return(ruleResult);
}
private void ConfigureValidationRules()
{
//false for AddCategory, True for RemoveCategory
switch (IsChecked)
{
case false:
Validator.AddRule(nameof(AddCategoryText),
() => RuleResult.Assert(!string.IsNullOrEmpty(AddCategoryText), "Cannot be empty"));
Validator.AddRule(nameof(AddCategoryText),
() => RuleResult.Assert(CheckAddCategoryName() != true, "Category already exists"));
Validator.AddRule(nameof(AddCategoryText),
() => RuleResult.Assert(AddCategoryText != "All", "Invalid category title"));
break;
case true:
Validator.AddRule(nameof(RemoveCategoryText),
() => RuleResult.Assert(!string.IsNullOrEmpty(RemoveCategoryText), "No category selected"));
break;
}
}
public void RemoveRule_ThisRuleHadValidationError_ErrorGetsRemovedAlso()
{
// ARRANGE
var validation = new ValidationHelper();
validation.AddRule(RuleResult.Valid);
var invalidRule = validation.AddRule(() => RuleResult.Invalid("error"));
var validationResult = validation.ValidateAll();
Assert.False(validationResult.IsValid);
// ACT
validation.RemoveRule(invalidRule);
validationResult = validation.GetResult();
// VERIFY
Assert.True(validationResult.IsValid);
}
public RuleResult FeedToken(Token t)
{
if (_isFinished)
{
throw new Exception("Tried to feed a token to an already-finished ThenChainParser.");
}
var currentCallabck = _ruleSequence[_currentRuleIndex].onMatched;
// HACK: Create the first rule, if it hasn't been already.
if (_currentRule == null)
{
_currentRule = _ruleSequence[_currentRuleIndex].ruleFactory();
}
// Feed the token to the current rule
var result = _currentRule.FeedToken(t);
// If it failed, cascade that failure upwards
if (result.status == RuleStatus.Failed)
{
return(result);
}
// If it succeeded, invoke the callback and move to the next rule
if (result.status == RuleStatus.Complete)
{
currentCallabck(result.node);
_currentRuleIndex++;
// If the last rule just succeeded, the whole chain is complete.
if (_currentRuleIndex >= _ruleSequence.Count)
{
_isFinished = true;
return(RuleResult.Complete(_node));
}
_currentRule = _ruleSequence[_currentRuleIndex].ruleFactory();
}
return(RuleResult.GoodSoFar());
}
public CalculationPointPersistanceHolder Convert(RuleResult points, PMSReport.Domain.Model.CalculationData employeeData,
PMS.Domain.Model.Employees.Employee employee, PMS.Domain.Model.Periods.Period period,
PMS.Domain.Model.Calculations.Calculation calculation)
{
var res = new CalculationPointPersistanceHolder(jipRep, employeeData.CalculationPoints);
foreach (var item in points.CalculationPoints)
{
res.AddSummeryCalculationPoint(period, calculation, item.Name, item.Value, item.Final);
}
foreach (var item in points.Results)
{
res.AddSummeryEmployeePoint(period, calculation, employee, item.Name, item.Value, item.Final);
}
var jprs = from i in points.JobResults
join j in employeeData.JobPositions
on i.Key equals j.Key.DictionaryName
select new { j, i.Value };
foreach (var item in jprs)
{
foreach (var i in item.Value.Results)
{
res.AddSummeryJobPositionPoint(period, calculation, employee, item.j.Key, i.Name, i.Value, i.Final);
}
var jirs = from n in item.Value.IndexResults
join m in item.j.Value.Indices.Select(k => k.Key)
on n.Key equals m.DictionaryName
select new { m, n.Value };
foreach (var i in jirs)
{
foreach (var k in i.Value)
{
res.AddJobIndexPoint(period, calculation, employee, item.j.Key, i.m, k.Name, k.Value, k.Final);
}
}
}
return(res);
}
public void Validate_MultipleRulesForSameTarget_OptionToAllowValidationOnFailedTargetsIsSetForSpecificRule_ThatRuleIsExecuted()
{
// ARRANGE
var validation = new ValidationHelper();
var dummy = new DummyViewModel();
bool firstRuleExecuted = false;
bool secondRuleExecuted = false;
bool thirdRuleExecuted = false;
validation.AddRule(nameof(dummy.Foo),
() =>
{
firstRuleExecuted = true;
return(RuleResult.Invalid("Error1"));
});
validation.AddRule(nameof(dummy.Foo),
() =>
{
secondRuleExecuted = true;
return(RuleResult.Invalid("Error2"));
});
validation.AddRule(nameof(dummy.Foo),
() =>
{
thirdRuleExecuted = true;
return(RuleResult.Invalid("Error3"));
}).WithSettings(s => s.ExecuteOnAlreadyInvalidTarget = true);
// ACT
validation.ValidateAll();
// VERIFY
Assert.True(firstRuleExecuted, "First rule must have been executed");
Assert.False(secondRuleExecuted, "Second rule should not have been executed because first rule failed.");
Assert.True(thirdRuleExecuted, "Third rule should be executed because it is configured to be executed on already invalid target.");
}
public void Reset_ResultChangedFiresForInvalidTargets()
{
// ARRANGE
var dummy = new DummyViewModel();
var validation = new ValidationHelper();
validation.AddRule(RuleResult.Valid);
validation.AddRule(nameof(dummy.Foo), () => RuleResult.Invalid("error1"));
validation.AddRule(nameof(dummy.Bar), () => RuleResult.Invalid("error2"));
validation.ValidateAll();
bool eventFiredForFoo = false;
bool evernFiredForBar = false;
validation.ResultChanged += (sender, args) =>
{
if (Equals(args.Target, nameof(dummy.Foo)))
{
eventFiredForFoo = true;
}
else if (Equals(args.Target, nameof(dummy.Bar)))
{
evernFiredForBar = true;
}
else
{
Assert.False(true, "ResultChanged event fired for an unexpected target.");
}
Assert.True(args.NewResult.IsValid);
};
// ACT
validation.Reset();
// VERIFY
Assert.True(eventFiredForFoo);
Assert.True(evernFiredForBar);
}
public bool Validate()
{
ErrorSummary = string.Empty;
Validator.AddRule(
nameof(Mode),
() => RuleResult.Assert(
!Mode.IsNullOrEmpty(),
$"{nameof(Mode)} is required"
)
);
Validator.AddRule(
nameof(Outcome),
() => RuleResult.Assert(
!Outcome.IsNullOrEmpty(),
$"{nameof(Outcome)} is required"
)
);
Validator.AddRule(
nameof(Date),
() => RuleResult.Assert(
Date <= DateTime.Today,
$"{nameof(Date)} should be a valid date"
)
);
var result = Validator.ValidateAll();
Errors = result.AsObservableDictionary();
if (null != Errors && Errors.Count > 0)
{
ErrorSummary = Errors.First().Value;
}
return(result.IsValid);
}
/// <summary>
/// Populates all descendents with test results and sets them to
/// pass if the control is a button (any predicate would work)
/// and returns number that should pass
/// </summary>
/// <param name="ke"></param>
/// <returns></returns>
public static void PopulateChildrenTests(A11yElement ke)
{
if (ke == null)
{
throw new ArgumentNullException(nameof(ke));
}
foreach (var item in ke.ScanResults.Items)
{
item.Items = new List <RuleResult>();
RuleResult r = new RuleResult();
r.Status = ke.ControlTypeId == Axe.Windows.Core.Types.ControlType.UIA_ButtonControlTypeId ? ScanStatus.Pass : ScanStatus.Fail;
item.Items.Add(r);
}
;
foreach (var c in ke.Children)
{
PopulateChildrenTests(c);
}
;
}
public static LogLevel ToLogLevel(this RuleResult value)
{
var result = LogLevel.Information;
switch (value)
{
case RuleResult.Success:
result = LogLevel.Information;
break;
case RuleResult.Warning:
result = LogLevel.Warning;
break;
case RuleResult.Fail:
result = LogLevel.Error;
break;
}
return(result);
}
public void RemoveRule_ReExecuteValidation_RemovedRuleDoesNotExecute()
{
// ARRANGE
var validation = new ValidationHelper();
validation.AddRule(RuleResult.Valid);
var invalidRule = validation.AddRule(() => RuleResult.Invalid("error"));
var validationResult = validation.ValidateAll();
Assert.False(validationResult.IsValid);
// ACT
validation.RemoveRule(invalidRule);
validationResult = validation.ValidateAll();
// VERIFY
Assert.True(validationResult.IsValid);
}
public RuleResult RunRule(Action action, string rule, Type exceptiontype)
{
var ruleresult = new RuleResult { Description = rule, Status = RuleStatus.Passed };
try
{
InvokeMethod(ruleresult, action);
ruleresult.RuleMessage =String.Format("Expected exception was {0} but it never occured", exceptiontype);
ruleresult.Status = RuleStatus.Failed;
}
catch (Exception ex)
{
if (ex.GetType() == exceptiontype)
return ruleresult;
ruleresult.RuleMessage = String.Format("Expected exception was {0} but instead was {1}\nStacktrace: {2}", exceptiontype, ex.GetType()
, ex.StackTrace);
ruleresult.Status = RuleStatus.Failed;
}
return ruleresult;
}
public IReadOnlyCollection <RuleResult> EvaluateRules(string scriptText, TSqlScript script, SqlVersion sqlVersion, IEnumerable <IRule> rules)
{
var allRuleResults = new List <RuleResult>();
var activeRules = rules.Where(x => x.Configuration.IsRuleEnabled);
var activeRulesMatchingSqlVersion = activeRules.Where(aX => aX.Configuration.SupportedSqlVersions.IsAnalyzableSqlVersion(sqlVersion));
foreach (var rule in activeRulesMatchingSqlVersion)
{
try
{
var ruleResults = rule.Evaluate(scriptText, script);
allRuleResults.AddRange(ruleResults);
}
catch (Exception exception)
{
var exceptionResult = new RuleResult(rule, 0, 0, $"Exception in rule: {exception}", MessageSeverity.Error);
allRuleResults.Add(exceptionResult);
}
}
return(allRuleResults);
}
private void AddRules()
{
Validator.AddRequiredRule(() => FirstName, "Vorname ist ein Pflichtfeld");
Validator.AddRequiredRule(() => LastName, "Nachname ist ein Pflichtfeld");
Validator.AddRequiredRule(() => Street, "Strasse ist ein Pflichtfeld");
Validator.AddRequiredRule(() => Zip, "Postleitzahl ist ein Pflichtfeld");
Validator.AddRequiredRule(() => City, "Ort ist ein Pflichtfeld");
Validator.AddRule(nameof(Email),
() =>
{
if (!string.IsNullOrEmpty(Email))
{
return(RuleResult.Assert(Regex.IsMatch(Email,
@"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z",
RegexOptions.IgnoreCase),
"Email-Adresse ungültig"));
}
return(RuleResult.Valid());
});
}
public override RuleResult Execute()
{
var result = new RuleResult {
Success = true
};
foreach (DataField field in Data.Fields)
{
if (field.ClassName == "global")
{
continue;
}
if (Uri.TryCreate(field.FieldValue, UriKind.Absolute, out var uri))
{
if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps ||
uri.Scheme == Uri.UriSchemeFile)
{
continue;
}
result.Message =
$"Incorrect URL scheme ({uri.Scheme}) for field {field.TableName}.{field.FieldName}";
result.Success = false;
}
else if (IsAlternativeUrlValid(field.FieldValue))
{
result.Success = true;
}
else
{
// Let the user know that the call failed.
result.Message = $"Incorrect URL format for field {field.TableName}.{field.FieldName}";
result.Success = false;
}
}
return(result);
}
public static RuleResult Combine([NotNull] this RuleResult firstRuleResult, [NotNull] RuleResult secondRuleResult)
{
Contract.Requires(firstRuleResult != null);
Contract.Requires(secondRuleResult != null);
Contract.Ensures(Contract.Result<RuleResult>() != null);
var result = new RuleResult();
foreach (string error in firstRuleResult.Errors)
{
result.AddError(error);
}
foreach (string error in secondRuleResult.Errors)
{
if (!result.Errors.Contains(error))
{
result.AddError(error);
}
}
return result;
}
public static RuleResult Combine([NotNull] this RuleResult firstRuleResult,
[NotNull] RuleResult secondRuleResult)
{
Guard.NotNull(firstRuleResult, nameof(firstRuleResult));
Guard.NotNull(secondRuleResult, nameof(secondRuleResult));
var result = new RuleResult();
foreach (string error in firstRuleResult.Errors)
{
result.AddError(error);
}
foreach (string error in secondRuleResult.Errors)
{
if (!result.Errors.Contains(error))
{
result.AddError(error);
}
}
return result;
}
protected RuleOutcome CreateOutcome(RuleResult result, string format, params object[] args) {
return CreateOutcome(result, String.Format(format, args));
}
public static IAsyncValidationRule AddChildValidatableCollection([NotNull] this ValidationHelper validator,
[NotNull] Expression<Func<IEnumerable<IValidatable>>> validatableCollectionGetter)
{
Contract.Requires(validator != null);
Contract.Requires(validatableCollectionGetter != null);
Contract.Ensures(Contract.Result<IAsyncValidationRule>() != null);
Func<IEnumerable<IValidatable>> getter = validatableCollectionGetter.Compile();
return validator.AddAsyncRule(PropertyName.For(validatableCollectionGetter), () =>
{
IEnumerable<IValidatable> items = getter();
if (items == null)
{
return Task.Factory.StartNew(() => RuleResult.Valid());
}
return Task.Factory.StartNew(() =>
{
var result = new RuleResult();
// Execute validation on all items at the same time, wait for all
// to fininish and combine the results.
var results = new List<ValidationResult>();
var syncEvent = new ManualResetEvent(false);
var itemsArray = items as IValidatable[] ?? items.ToArray();
int[] numerOfThreadsNotYetCompleted = { itemsArray.Length };
foreach (var item in itemsArray)
{
#if SILVERLIGHT_4
item.Validate(r =>
{
Exception ex = null;
#else
item.Validate().ContinueWith(tr =>
{
ValidationResult r = tr.Result;
AggregateException ex = tr.Exception;
#endif
lock (results)
{
// ReSharper disable ConditionIsAlwaysTrueOrFalse
if (ex == null && r != null)
// ReSharper restore ConditionIsAlwaysTrueOrFalse
{
results.Add(r);
}
if (Interlocked.Decrement(ref numerOfThreadsNotYetCompleted[0]) == 0)
{
syncEvent.Set();
}
}
});
}
if (numerOfThreadsNotYetCompleted[0] > 0)
{
// Wait for all items to finish validation
syncEvent.WaitOne();
// Add errors from all validation results
foreach (ValidationResult itemResult in results)
{
foreach (ValidationError error in itemResult.ErrorList)
{
result.AddError(error.ErrorText);
}
}
}
return result;
});
});
}
// TODO: Is there a better way to find the line number?
private static int FindLineNumber(RuleResult ost)
{
string text = ost.Rule.StyleSheet.Text.Substring(0, ost.Start);
return text.Count(t => t == '\n') + 1;
}
public RuleOutcome(RuleResult result, string ruleName, string ruleNumber, string message) {
this.Result = result;
this.Message = message;
this.RuleName = ruleName;
this.RuleNumber = ruleNumber;
}
public OperRuleTemplate(RuleResult r, HttpOperationHandler p)
{
//ValidateHandler(p);
_p = p;
_r = r;
}
private static void AddErrorsFromRuleResult(ValidationResult resultToAddTo, ValidationRule validationRule,
RuleResult ruleResult)
{
if (!ruleResult.IsValid)
{
IEnumerable<object> errorTargets = validationRule.Target.UnwrapTargets();
foreach (object errorTarget in errorTargets)
{
foreach (string ruleError in ruleResult.Errors)
{
resultToAddTo.AddError(errorTarget, ruleError);
}
}
}
}
private void SaveRuleValidationResultAndNotifyIfNeeded(ValidationRule rule, RuleResult ruleResult, SynchronizationContext syncContext)
{
lock (syncRoot)
{
IEnumerable<object> ruleTargets = rule.Target.UnwrapTargets();
foreach (object ruleTarget in ruleTargets)
{
IDictionary<ValidationRule, RuleResult> targetRuleMap = GetRuleMapForTarget(ruleTarget);
RuleResult currentRuleResult = GetCurrentValidationResultForRule(targetRuleMap, rule);
if (!Equals(currentRuleResult, ruleResult))
{
lock (ruleValidationResultMap)
{
targetRuleMap[rule] = ruleResult;
}
// Notify that validation result for the target has changed
NotifyResultChanged(ruleTarget, GetResult(ruleTarget), syncContext);
}
}
}
}
public static IAsyncValidationRule AddChildValidatableCollection([NotNull] this ValidationHelper validator,
[NotNull] Expression<Func<IEnumerable<IValidatable>>> validatableCollectionGetter)
{
Guard.NotNull(validator, nameof(validator));
Guard.NotNull(validatableCollectionGetter, nameof(validatableCollectionGetter));
Func<IEnumerable<IValidatable>> getter = validatableCollectionGetter.Compile();
return validator.AddAsyncRule(PropertyName.For(validatableCollectionGetter), () =>
{
IEnumerable<IValidatable> items = getter();
if (items == null)
{
return TaskEx.FromResult(RuleResult.Valid());
}
items = items as IValidatable[] ?? items.ToArray();
if (!items.Any())
{
return TaskEx.FromResult(RuleResult.Valid());
}
var result = new RuleResult();
// Execute validation on all items at the same time, wait for all
// to finish and combine the results.
var results = new List<ValidationResult>();
var tasks = new List<Task<ValidationResult>>();
foreach (var item in items)
{
var task = item.Validate().ContinueWith(tr =>
{
ValidationResult r = tr.Result;
AggregateException ex = tr.Exception;
lock (results)
{
if (ex == null && r != null)
{
results.Add(r);
}
}
return tr.Result;
});
tasks.Add(task);
}
var resultTask = TaskEx.WhenAll(tasks).ContinueWith(tr =>
{
if (tr.Exception == null)
{
// Add errors from all validation results
foreach (ValidationResult itemResult in results)
{
foreach (ValidationError error in itemResult.ErrorList)
{
result.AddError(error.ErrorText);
}
}
return result;
}
throw new AggregateException(tr.Exception);
});
return resultTask;
});
}
public OperRuleBuilder(RuleResult r, OperPredAndRuleBuilder orb)
{
_orb = orb;
_r = r;
}
protected RuleOutcome CreateOutcome(RuleResult result, string message) {
return new RuleOutcome(result, this.Name, this.Number, message);
}
private RuleResult PostCheck(RuleResult beforeTearingDown)
{
CurrentRule.TearDown ();
//If current is not the default, and report the greater
if (beforeTearingDown == RuleResult.DoesNotApply)
return beforeTearingDown;
if (CurrentRuleResult > beforeTearingDown)
return CurrentRuleResult;
return beforeTearingDown;
}
