public void can_create_a_validation_pass_and_read_it_back()
{
var result = ValidationOutcome <string> .Pass(); // note, we can't infer the type of a pass
Assert.IsFalse(result.HasError);
Assert.IsTrue(result.IsValid);
}
public void can_implicitly_cast_a_success_result_to_its_contained_type()
{
var result = ValidationOutcome.Fail("value");
string value = result;
Assert.AreEqual("value", value);
}
/// <summary>
/// Finalizes the validation, clears task score data
/// </summary>
public void FinalizeValidation()
{
TableExtractionTaskReporting reporting = new TableExtractionTaskReporting();
foreach (var pair in Results)
{
if (pair.Value.Outcome == ValidationOutcome.undefined)
{
ValidationOutcome result = pair.Value.Compute();
pair.Value.ReportTable_Training = reporting.GetTaskExecutionScoreReport(pair.Key);
}
//pair.Key.PropertyDictionary.CollectProperties(pair.Value.PropertyValidation.GetResults()[ValidationOutcome.Validated]);
// pair.Key.score = new TableExtractionTaskScore();
}
ResultsByOutcome = new aceEnumListSet <ValidationOutcome, TaskValidationResult>();
foreach (var pair in Results)
{
ResultsByOutcome[pair.Value.Outcome].Add(pair.Value);
//pair.Key.PropertyDictionary.CollectProperties(pair.Value.PropertyValidation.GetResults()[ValidationOutcome.Validated]);
// pair.Key.score = new TableExtractionTaskScore();
}
}
private static ValidationOutcome CreateOutcome(
IEnumerable <ValidationResult> results)
{
var outcome = new ValidationOutcome();
foreach (var result in results)
{
var compositeResult = result as CompositeResult;
if (compositeResult == null)
{
var error = result.ErrorMessage;
foreach (var memberName in result.MemberNames)
{
outcome.AddError(memberName, error);
}
}
else
{
foreach (var memberName in result.MemberNames)
{
outcome.AddError(memberName, compositeResult.Outcome);
}
}
}
return(outcome);
}
public void WebHookUri_Validates(Uri uri, ValidationOutcome expected)
{
// Arrange
WebHook webHook = new WebHook { WebHookUri = uri };
var validationResults = new List<ValidationResult>();
var context = new ValidationContext(webHook) { MemberName = "WebHookUri" };
// Act
bool actual = Validator.TryValidateProperty(webHook.WebHookUri, context, validationResults);
// Assert
switch (expected)
{
case ValidationOutcome.Valid:
Assert.True(actual);
break;
case ValidationOutcome.Required:
Assert.False(actual);
Assert.Equal("The WebHookUri field is required.", validationResults.Single().ErrorMessage);
Assert.Equal("WebHookUri", validationResults.Single().MemberNames.Single());
break;
default:
Assert.True(false);
break;
}
}
public void WebHookUri_Validates(Uri uri, ValidationOutcome expected)
{
// Arrange
WebHook webHook = new WebHook {
WebHookUri = uri
};
var validationResults = new List <ValidationResult>();
var context = new ValidationContext(webHook)
{
MemberName = "WebHookUri"
};
// Act
bool actual = Validator.TryValidateProperty(webHook.WebHookUri, context, validationResults);
// Assert
switch (expected)
{
case ValidationOutcome.Valid:
Assert.True(actual);
break;
case ValidationOutcome.Required:
Assert.False(actual);
Assert.Equal("The WebHookUri field is required.", validationResults.Single().ErrorMessage);
Assert.Equal("WebHookUri", validationResults.Single().MemberNames.Single());
break;
default:
Assert.True(false);
break;
}
}
public void CreateTeamIntegritey(CreateTeam request, ValidationOutcome outcome)
{
if (request.Team == null)
{
outcome.AddError("Team", "Something really bad");
}
}
public void Secret_Validates(string secret, ValidationOutcome expected)
{
// Arrange
WebHook webHook = new WebHook {
Secret = secret
};
var validationResults = new List <ValidationResult>();
var context = new ValidationContext(webHook)
{
MemberName = "Secret"
};
// Act
bool actual = Validator.TryValidateProperty(webHook.Secret, context, validationResults);
// Assert
switch (expected)
{
case ValidationOutcome.Valid:
Assert.True(actual);
break;
case ValidationOutcome.Required:
Assert.False(actual);
Assert.Equal("The Secret field is required.", validationResults.Single().ErrorMessage);
Assert.Equal("Secret", validationResults.Single().MemberNames.Single());
break;
case ValidationOutcome.Invalid:
Assert.Equal("The WebHook secret key parameter must be between 32 and 64 characters long.", validationResults.Single().ErrorMessage);
Assert.Equal("Secret", validationResults.Single().MemberNames.Single());
break;
}
}
public async Task ShouldHaveName(Team player, ValidationOutcome outcome)
{
await Task.Delay(10);
if (string.IsNullOrEmpty(player.Name))
{
outcome.AddError("Name", "Name is required");
}
}
public void can_treat_a_result_as_boolean_to_read_success_status()
{
var good = ValidationOutcome <int> .Pass();
var bad = ValidationOutcome.Fail("reason");
Assert.IsTrue(good);
Assert.IsFalse(bad);
}
private static void AddErrors(ValidationResult result, ValidationOutcome outcome)
{
foreach (var error in result.Errors)
{
var child = error as OutcomeFailure;
var failure = child?.FailedOutcome ?? (object)error.ErrorMessage;
outcome.AddError(error.PropertyName, failure);
}
}
public static void ThrowOnInvalid <TValue>(Func <TValue, ValidationOutcome> validator, TValue value)
{
ValidationOutcome vo = validator(value);
if (vo != null)
{
throw new ValidationException(vo.Message);
}
}
public void Should_Notify_Nested_Error_Changes()
{
string propertyName = null;
var outcome = new ValidationOutcome();
outcome.ErrorsChanged += (s, e) => propertyName = e.PropertyName;
outcome.AddError("Company.Name", "Name can't be empty");
Assert.AreEqual("Company.Name", propertyName);
}
public ValidationResultViewModel BuildResult(ValidationOutcome outcome, string reportingYear = "", string reportName = "", string datasetName = "")
{
var result = new ValidationResultViewModel();
result.Quality = OutcomeQuality(outcome);
result.HelpTopic = outcome.GetDescription();
if (string.IsNullOrEmpty(result.HelpTopic))
{
result.HelpTopic = "DEPENDENCY CHECK";
result.HelpText = "Click here for more information";
}
else if (result.HelpTopic.ContainsIgnoreCase("Warning") || result.HelpTopic.ContainsIgnoreCase("Error"))
{
result.HelpTopic = result.HelpTopic.Replace("Warning ", null).Replace("Error ", null);
result.HelpText = "Click here for more information";
}
if (result.Quality == ValidationLevel.Success)
{
return(result);
}
var temp = OutcomeMesssage(outcome);
switch (outcome)
{
case ValidationOutcome.StaleBaseData:
temp = string.Format(temp, SourceViewModel.Website.ReportedYear, reportingYear, reportName);
break;
case ValidationOutcome.CostToChargeUndefined:
case ValidationOutcome.RealtimePhysicianDataCannotHaveSubReports:
temp = string.Format(temp, reportName);
break;
case ValidationOutcome.CmsProviderIdUnmapped:
case ValidationOutcome.HospitalProfileMissingLocalHospIdOrProviderId:
case ValidationOutcome.CostQualityAllFamilySelected:
temp = string.Format(temp, reportName);
break;
//case ValidationOutcome.HospitalProfileMissingMedicareDataset:
//case ValidationOutcome.HospitalProfileMissingIPDataset:
case ValidationOutcome.NoMeasuresForTheDataSet:
case ValidationOutcome.QIUnMappedHospitalLocalId:
case ValidationOutcome.UnMappedHospitalLocalId:
case ValidationOutcome.UnMappedHospitalProfileLocalId:
temp = string.Format(temp, datasetName);
break;
}
result.Message = temp;
result.CompositionArea = OutcomeArea(outcome);
return(result);
}
public void can_create_a_validation_failure_and_read_it_back()
{
var error_msg = "Hello, world";
var result = ValidationOutcome.Fail(error_msg); // can use the `ValidationOutcome` rather than `ValidationOutcome<T>` class to infer type of failures
Assert.IsTrue(result.HasError);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(error_msg, result.ValidationErrors);
}
public void Should_Add_Simple_Error()
{
var outcome = new ValidationOutcome();
outcome.AddError("Name", "Name can't be empty");
Assert.AreEqual("Name can't be empty", outcome["Name"]);
Assert.AreEqual("Name can't be empty", outcome.Error);
CollectionAssert.AreEqual(new[] { "Name" }, outcome.Culprits);
CollectionAssert.Contains(
outcome.GetErrors("Name").Cast <object>().ToArray(),
"Name can't be empty"
);
}
public Promise ShouldHaveLicensesCoach(Team team, ValidationOutcome outcome)
{
return(Promise.Delay(TimeSpan.FromMilliseconds(10)).Then((d, s) =>
{
var coach = team.Coach;
if (coach == null)
{
outcome.AddError("Coach", "Coach is required");
}
else if (string.IsNullOrEmpty(coach.License))
{
outcome.AddError("Coach.License", "Licensed Coach is required");
}
}));
}
private static ValidationResult CreateResult(
ValidationOutcome outcome, ValidationContext context)
{
var validationAware = context.InstanceToValidate as IValidationAware;
if (validationAware != null)
{
validationAware.ValidationOutcome = outcome;
}
return(outcome.IsValid ? new ValidationResult()
: new ValidationResult(new[]
{
new OutcomeFailure(context.PropertyChain.ToString(), outcome)
}));
}
private void OnValidationCoroutineComplete(ValidationOutcome outcome)
{
switch (outcome.code)
{
case ValidationOutcome.Code.Success:
ValidStart?.Invoke();
break;
default:
InvalidStart?.Invoke(outcome);
break;
}
onChainValidation.StopCoroutine(validationCR);
validationCR = null;
}
public void trying_to_implicitly_cast_a_passed_result_throws_an_exception()
{
var result = ValidationOutcome <int> .Pass();
try
{
int value = result;
Console.WriteLine(value);
}
catch (InvalidOperationException actual)
{
Assert.AreEqual("Tried to read errors of a successful validation", actual.Message);
return;
}
Assert.Fail("Did not throw exception");
}
public void ShouldHaveFullName(Player player, ValidationOutcome outcome)
{
if (string.IsNullOrEmpty(player.FirstName))
{
outcome.AddError("FirstName", "First name is required");
}
if (string.IsNullOrEmpty(player.LastName))
{
outcome.AddError("LastName", "Last name is required");
}
if (!player.DOB.HasValue)
{
outcome.AddError("DOB", "DOB is required");
}
}
private static TestOutcome ToTestOutcome(ValidationOutcome outcome)
{
if ((outcome & ValidationOutcome.Error) > 0)
{
return(TestOutcome.Failed);
}
if ((outcome & ValidationOutcome.Skipped) > 0)
{
return(TestOutcome.Skipped);
}
if ((outcome & ValidationOutcome.Passed) > 0)
{
return(TestOutcome.Passed);
}
return(TestOutcome.Inconclusive);
}
public void Should_Add_Nested_Error()
{
var outcome = new ValidationOutcome();
outcome.AddError("Company.Name", "Name can't be empty");
Assert.AreEqual($"[{Environment.NewLine}Name can't be empty{Environment.NewLine}]",
outcome["Company"]);
CollectionAssert.AreEqual(new[] { "Company" }, outcome.Culprits);
var company = outcome.GetOutcome("Company");
Assert.IsFalse(company.IsValid);
Assert.AreEqual("Name can't be empty", company["Name"]);
CollectionAssert.AreEqual(new[] { "Name" }, company.Culprits);
CollectionAssert.Contains(
outcome.GetErrors("Company").Cast <object>().ToArray(),
company);
}
private static void CollectErrors(ValidationOutcome outcome, ICollection <string> errors)
{
foreach (var culprit in outcome.Culprits)
{
foreach (var error in outcome.GetErrors(culprit))
{
if (error is ValidationOutcome child)
{
CollectErrors(child, errors);
}
else
{
errors.Add(error.ToString());
}
}
}
}
//expected maximum entry --name "name" --count "12" --help
public static ValidationOutcome Go(string[] args)
{
string[] pristineArgs = args.ToArray();
ValidationOutcome resultantValidationOutcome = ValidationOutcome.OK;
List <ValidationOutcome> outcomes = new List <ValidationOutcome>();
if (args != null && args.Any())
{
string currentArg;
// list of argument indices which have been used by known parameters
List <int> argumentUsedIndices = new List <int>();
for (int argIndex = 0; argIndex < args.Length; argIndex++)
{
if (!argumentUsedIndices.Contains(argIndex)) // this argument has already been used by a parameter
{
currentArg = args[argIndex];
if (MatchesKnownParameter(currentArg))
{
IConsoleParameter matchingParameter = GetMatchingParameter(currentArg);
if (matchingParameter.SyntaxOfParameterValid(args))
{
// Run parameter's validation
outcomes.Add(matchingParameter.Validate(args));
argumentUsedIndices.AddRange(matchingParameter.IndicesOfUsedArgs(args));
//Remove parameter from known set
KnownConsoleParameters.All.Remove(matchingParameter);
}
else // syntax of parameter doesn't match, therefore invalid
{
outcomes.Add(ValidationOutcome.Invalid);
}
}
else // parameter not recognized, declare it invalid
{
outcomes.Add(ValidationOutcome.Invalid);
}
}
resultantValidationOutcome = DetermineValidationOutcome(outcomes);
}
}
return(resultantValidationOutcome);
}
public static ConsoleColor ConsoleColor(this ValidationOutcome outcome)
{
if ((outcome & ValidationOutcome.Error) > 0)
{
return(FancyConsole.ConsoleErrorColor);
}
if ((outcome & ValidationOutcome.Warning) > 0)
{
return(FancyConsole.ConsoleWarningColor);
}
if ((outcome & ValidationOutcome.Passed) > 0)
{
return(FancyConsole.ConsoleSuccessColor);
}
if ((outcome & ValidationOutcome.Skipped) > 0)
{
return(FancyConsole.ConsoleWarningColor);
}
return(FancyConsole.ConsoleDefaultColor);
}
private HttpResponseMessage CreateInvalidRequestResponse()
{
var outcome = new ValidationOutcome();
foreach (var property in ModelState)
{
foreach (var error in property.Value.Errors)
{
var key = property.Key;
if (key.StartsWith("message."))
{
key = key.Substring(8);
}
outcome.AddError(key,
error.Exception?.Message ?? error.ErrorMessage);
}
}
return(CreateErrorResponse(
new ValidationException(outcome),
HttpStatusCode.BadRequest));
}
private IActionResult CreateInvalidResult(JsonSerializerSettings settings)
{
var outcome = new ValidationOutcome();
foreach (var property in ModelState)
{
foreach (var error in property.Value.Errors)
{
var key = property.Key;
if (key.StartsWith("message."))
{
key = key.Substring(8);
}
var message = error.Exception?.Message ?? error.ErrorMessage;
outcome.AddError(key, message);
}
}
return(CreateErrorResult(
new ValidationException(outcome), settings,
StatusCodes.Status400BadRequest));
}
public void AddResults(ValidationError[] errors, ValidationOutcome? outcome = null)
{
if (errors.Length == 0)
return;
this.Errors.AddRange(errors);
if (outcome.HasValue)
this.Outcome = outcome.Value;
}
public void SetOutcome(string actionName, ValidationOutcome outcome)
{
ActionFromName(actionName).Outcome = outcome;
}
public void AddResults(string actionName, ValidationError[] errors, ValidationOutcome? outcome = null)
{
this[actionName].AddResults(errors, outcome);
}
public void AddResult(string actionName, ValidationError error, ValidationOutcome? outcome = null )
{
this[actionName].AddResults(new ValidationError[] { error }, outcome);
}
private static TestOutcome ToTestOutcome(ValidationOutcome outcome)
{
if ((outcome & ValidationOutcome.Error) > 0)
return TestOutcome.Failed;
if ((outcome & ValidationOutcome.Skipped) > 0)
return TestOutcome.Skipped;
if ((outcome & ValidationOutcome.Passed) > 0)
return TestOutcome.Passed;
return TestOutcome.Inconclusive;
}
public void SetOutcome(string actionName, ValidationOutcome outcome)
{
ActionFromName(actionName).Outcome = outcome;
}
public void TryToPayUserValidator(IList <UserContentValidation> userValidations, ValidationOutcome outcome, long contentId, long subDirectoryId,
long adminId, double amountToSend)
{
//Pay the people
foreach (var validator in userValidations)
{
if (validator.ShouldBePersisted && outcome == ValidationOutcome.Keep ||
!validator.ShouldBePersisted && outcome == ValidationOutcome.Remove)
{
_transactionService.AddMoCreditsTransaction(validator.UserId, adminId,
amountToSend, TransferType.LinkedContentValidation, contentId);
_notificationService.NotifyAllUserValidators($"You got paid {amountToSend}mo for your participation in a validation. Well done, you were part of the concensus",
new List <long>()
{
validator.UserId
}, contentId, subDirectoryId);
}
else
{
_notificationService.NotifyAllUserValidators($"Unfortunatly you were not part of the concensus for a user validation you participated in. Better luck next time",
new List <long>()
{
validator.UserId
}, contentId, subDirectoryId);
}
}
}
public virtual ValidationOutcome SetOutcome(ValidationOutcome outcome, String message)
{
Message = message;
Outcome = outcome;
return(outcome);
}
