public void Should_AddError_When_Invalid(ValidationStrategy validationStrategy, RuleType ruleType)
{
var args = new[] { Arg.Text("key", "value") };
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, false, "message", args);
AsNullableRule rule = new AsNullableRule <object, int>(memberSpecification);
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal("message", errorsCollection.Errors.Single().Message);
if (ruleType == RuleType.Validate)
{
Assert.Same(args, errorsCollection.Errors.Single().Arguments);
}
else
{
Assert.Null(errorsCollection.Errors.Single().Arguments);
}
}
public void Should_OverrideErrorMessage_When_Chain(ValidationStrategy validationStrategy)
{
var rule = new AsNullableRule <object, int>(be => be
.Valid(m => true, "message1", new[] { Arg.Text("key1", "value1") })
.AsRelative(m => true).WithMessage("message2")
.Valid(m => false, "message3", new[] { Arg.Text("key3", "value3") })
.AsRelative(m => false).WithMessage("message4")
.Valid(m => true, "message5", new[] { Arg.Text("key5", "value5") })
.AsRelative(m => false).WithMessage("message6")
.Valid(m => false, "message7", new[] { Arg.Text("key7", "value7") })
.AsRelative(m => true).WithMessage("message8")
.SetSingleError("message_overriden")
);
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal("message_overriden", errorsCollection.Errors.Single().Message);
Assert.Null(errorsCollection.Errors.Single().Arguments);
}
public void Should_PassStrategy(ValidationStrategy validationStrategy)
{
var model = new MemberClass
{
Inner = new InnerClass()
};
var executed = new int[3];
Predicate <InnerClass> isValid1 = c =>
{
Assert.Same(c, model.Inner);
executed[0]++;
return(false);
};
Predicate <InnerClass> isValid2 = c =>
{
Assert.Same(c, model.Inner);
executed[1]++;
return(false);
};
Predicate <InnerClass> isValid3 = c =>
{
Assert.Same(c, model.Inner);
executed[2]++;
return(false);
};
Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner;
var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member;
var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m
.Valid(isValid1)
.Valid(isValid2)
.Valid(isValid3)
);
memberScope.TryGetErrors(model, new ExecutionContextStub(), validationStrategy, 0, out _);
if (validationStrategy == ValidationStrategy.Complete)
{
Assert.True(executed.All(i => i == 1));
}
else if (validationStrategy == ValidationStrategy.FailFast)
{
Assert.Equal(1, executed.ElementAt(0));
Assert.Equal(0, executed.ElementAt(1));
Assert.Equal(0, executed.ElementAt(2));
}
else if (validationStrategy == ValidationStrategy.Force)
{
Assert.True(executed.All(i => i == 0));
}
}
public void Should_PassMemberToPredicate_When_Validate(ValidationStrategy validationStrategy)
{
var executed = false;
int?member = 1230;
MemberSpecification <object, int> memberSpecification = be => be.Valid(m =>
{
Assert.Equal(member.Value, m);
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
public void Should_PassModelToPredicate_When_AsRelative(ValidationStrategy validationStrategy)
{
var executed = false;
var model = new object();
MemberSpecification <object, int> memberSpecification = be => be.AsRelative(m =>
{
Assert.Same(model, m);
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
model,
1230,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
/// <summary>
/// Creates a new validation context using the specified options.
/// </summary>
/// <param name="instanceToValidate">The instance to validate</param>
/// <param name="options">Callback that allows extra options to be configured.</param>
public static ValidationContext <T> CreateWithOptions(T instanceToValidate, Action <ValidationStrategy <T> > options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var strategy = new ValidationStrategy <T>();
options(strategy);
return(strategy.BuildContext(instanceToValidate));
}
void CustomizeValidationStrategy(
ValidationStrategy <TArgument> strategy)
{
if (_ruleSets?.Any() == true)
{
strategy.IncludeRuleSets(_ruleSets);
}
else if (_properties?.Any() == true)
{
strategy.IncludeProperties(_properties);
}
}
public bool TryGetErrors(TModel model, IExecutionContext executionContext, ValidationStrategy validationStrategy, int depth, out IErrorsCollection scopeErrorsCollection)
{
var anyErrors = Rule.TryGetErrors(model, executionContext, validationStrategy, out var errorsCollection);
if (!errorsCollection.IsEmpty && (RuleSingleError != null))
{
scopeErrorsCollection = ErrorsCollection.WithSingleOrNull(RuleSingleError);
return(true);
}
scopeErrorsCollection = errorsCollection;
return(anyErrors);
}
public bool TryGetErrors(TModel model, IExecutionContext executionContext, ValidationStrategy validationStrategy, int depth, out IErrorsCollection scopeErrorsCollection)
{
var errorsCollection = _getErrors(this, model, executionContext ?? throw new ArgumentNullException(nameof(executionContext)), validationStrategy, depth);
if (!errorsCollection.IsEmpty && (RuleSingleError != null))
{
scopeErrorsCollection = ErrorsCollection.WithSingleOrNull(RuleSingleError);
return(true);
}
scopeErrorsCollection = errorsCollection;
return(!scopeErrorsCollection.IsEmpty);
}
public void Should_NotAddError_When_Valid(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => true;
var error = new Error("message");
var rule = new AsRelativeRule <object>(isValid, error);
rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.Same(ErrorsCollection.Empty, errorsCollection);
Assert.True(errorsCollection.IsEmpty);
}
public void Should_AddError_When_Invalid(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => false;
var error = new Error("message");
var rule = new ValidRule <object>(isValid, error);
var getErrorsResult = rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Same(error, errorsCollection.Errors.Single());
}
public void Should_NotAddError_When_NullMember(ValidationStrategy validationStrategy, RuleType ruleType)
{
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, true, "message");
AsNullableRule rule = new AsNullableRule <object, int>(memberSpecification);
var getErrorsResult = rule.TryGetErrors(
new object(),
null,
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.False(getErrorsResult);
Assert.True(errorsCollection.IsEmpty);
Assert.Empty(errorsCollection.Errors);
}
public void Should_AddError_When_Invalid_And_NullArgs(ValidationStrategy validationStrategy, RuleType ruleType)
{
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, false, "message");
AsNullableRule rule = new AsNullableRule <object, int>(memberSpecification);
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal("message", errorsCollection.Errors.Single().Message);
Assert.Null(errorsCollection.Errors.Single().Arguments);
}
public void Should_PassStrategy(ValidationStrategy validationStrategy)
{
var model = new MemberClass();
var executed = 0;
var modelScope = new ModelScope <MemberClass>(c =>
{
Assert.Same(c, model);
executed = 1;
return(true);
});
modelScope.TryGetErrors(model, new ExecutionContextStub(), validationStrategy, 0, out _);
Assert.Equal(validationStrategy == ValidationStrategy.Force ? 0 : 1, executed);
}
public void Should_OverrideErrorMessage_When_Valid_And_Force(ValidationStrategy validationStrategy, RuleType ruleType)
{
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, true, "message", new[] { Arg.Text("key", "value") });
var rule = new AsNullableRule <object, int>(c => memberSpecification(c).SetSingleError("message_overriden"));
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal("message_overriden", errorsCollection.Errors.Single().Message);
Assert.Null(errorsCollection.Errors.Single().Arguments);
}
public void Should_AddSingleError_When_Valid_And_Force(ValidationStrategy validationStrategy, RuleType ruleType)
{
var args = new[] { Arg.Text("key", "value") };
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, true, "message", args);
AsNullableRule rule = new AsNullableRule <object, int>(memberSpecification);
rule.RuleSingleError = new Error("ruleSingleError");
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal("ruleSingleError", errorsCollection.Errors.Single().Message);
}
public void Should_AddDefaultError_When_Invalid_And_NoError(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => false;
var error = new Error("default error {arg}", new[] { Arg.Text("key", "value") });
var rule = new ValidRule <object>(isValid);
var getErrorsResult = rule.TryGetErrors(new object(),
new ExecutionContextStub
{
DefaultError = error
},
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Same(error, errorsCollection.Errors.Single());
}
public void Should_ExecutePredicate(ValidationStrategy validationStrategy)
{
var executed = 0;
Predicate <object> isValid = m =>
{
executed++;
return(true);
};
var rule = new AsRelativeRule <object>(isValid);
rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.Equal(1, executed);
}
public void Should_NotExecutePredicate_When_NullMember(ValidationStrategy validationStrategy)
{
var executed = 0;
Predicate <object> isValid = m =>
{
executed++;
return(true);
};
var rule = new ValidRule <object>(isValid);
rule.TryGetErrors(null,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.Equal(0, executed);
}
public void Should_NotExecuteCollect_When_AsRelative_And_NullMember(ValidationStrategy validationStrategy)
{
var executed = false;
MemberSpecification <object, int> memberSpecification = be => be.AsRelative(m =>
{
executed = true;
return(true);
});
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
null,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.False(executed);
}
public void Should_PassEqualValueToPredicate(ValidationStrategy validationStrategy)
{
var executed = false;
var member = 123.123;
Predicate <object> isValid = m =>
{
executed = true;
Assert.Equal(member, m);
return(true);
};
var rule = new ValidRule <object>(isValid);
rule.TryGetErrors(member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
public void Should_ExecuteCollect_When_Validate(ValidationStrategy validationStrategy)
{
var executed = false;
MemberSpecification <object, int> memberSpecification = be => be.Valid(m =>
{
executed = true;
return(true);
}, "message");
var rule = new AsNullableRule <object, int>(memberSpecification);
rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
public void Should_PassReferenceToPredicate(ValidationStrategy validationStrategy)
{
var executed = false;
var member = new object();
Predicate <object> isValid = m =>
{
executed = true;
Assert.Same(member, m);
return(true);
};
var rule = new AsRelativeRule <object>(isValid);
rule.TryGetErrors(member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
//TODO we could make the list of tableNames to check for be an array, so that this method is a bit more "agnostic" to implementation
void Start()
{
if (!doneStart)
{ //put init stuff here
DebugConsole.Log("GameStateServer.Start()");
dbManip.TryEnableForeignKeys(); //VERY IMPORTANT to ensure foreign keys are enforced
if (dbManip.VerifyTableExistence(RAY_TABLE_NAMES))
{
//choose which Validation strategy you want to use
valStrat = new ValidationStrategyMemoized(dbManip);
}
else //probably don't have a propperly set up db.
//TODO give them an easy way to set one up.
{
DebugConsole.LogError("Did not find expected table(s) in db. Make sure it is set up!");
}
doneStart = true;
}
}
public ObjectValidator(Type targetType, ValidatorFactory validatorFactory, string targetRuleset, string keyFormat)
: base(targetType, targetRuleset)
{
var itypes = targetType.GetInterfaces();
m_validators = new Validator[itypes.Length];
if (m_validators.Length > 0)
{
EnumerableHelper.ForEach(itypes,
(i, type) => m_validators[i] = validatorFactory.CreateValidator(type, targetRuleset));
m_strategy = ValidateInterfacesStrategy;
}
else
{
m_strategy = base.DoValidate;
}
if (!String.IsNullOrEmpty(keyFormat))
{
KeyFormat = keyFormat;
m_strategy = FormatKeyStrategy;
}
}
public void Should_AddDefaultError_When_Invalid_And_NoError(ValidationStrategy validationStrategy, RuleType ruleType)
{
var args = new[] { Arg.Text("key", "value") };
var message = "default error {arg}";
var memberSpecification = GetSingleRuleMemberSpecification(ruleType, false);
var rule = new AsNullableRule <object, int>(memberSpecification);
var getErrorsResult = rule.TryGetErrors(
new object(),
default(int),
new ExecutionContextStub
{
DefaultError = new Error(message, args)
},
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Equal(message, errorsCollection.Errors.Single().Message);
Assert.Same(args, errorsCollection.Errors.Single().Arguments);
}
/// <summary>
/// Default constructor.
/// </summary>
public DicomAnonymizer()
{
_validationStrategy = new ValidationStrategy();
SpecificCharacterSet = @"ISO_IR 192";
}
/// <summary>
/// Default constructor.
/// </summary>
public DicomAnonymizer()
{
_validationStrategy = new ValidationStrategy();
}
public static void Default <TInput>(ValidationStrategy <TInput> validationStrategy)
{
}
public static IErrorsCollection ExecuteMember <TModel, TMember>(IMemberValidator memberValidator, TModel model, TMember memberValue, IExecutionContext executionContext, ValidationStrategy validationStrategy, int depth)
where TModel : class
{
ErrorsCollection result = null;
// ReSharper disable once CompareNonConstrainedGenericWithNull
var exists = IsValueType(typeof(TMember)) || (memberValue != null);
var strategy = validationStrategy;
var includeRequired = !memberValidator.IsOptional && (!exists || (strategy == ValidationStrategy.Force));
if (includeRequired)
{
result = new ErrorsCollection();
result.AddError(memberValidator.RequiredError ?? executionContext.RequiredError);
}
if ((strategy == ValidationStrategy.Complete) && (memberValidator.SingleError != null))
{
strategy = ValidationStrategy.FailFast;
}
if ((strategy == ValidationStrategy.FailFast) && (result != null) && !result.IsEmpty)
{
return(result);
}
if (exists || (strategy == ValidationStrategy.Force))
{
foreach (var rule in memberValidator.Rules)
{
bool anyErrors;
IErrorsCollection ruleErrorsCollection;
if (rule is ValidRule <TMember> validateRule)
{
anyErrors = validateRule.TryGetErrors(memberValue, executionContext, strategy, out ruleErrorsCollection);
}
else if (rule is AsRelativeRule <TModel> validateRelationRule)
{
anyErrors = validateRelationRule.TryGetErrors(model, executionContext, strategy, out ruleErrorsCollection);
}
else if (rule is AsModelRule validModelRule)
{
anyErrors = validModelRule.TryGetErrors(memberValue, executionContext, strategy, depth, out ruleErrorsCollection);
}
else if (rule is AsCollectionRule validCollectionRule)
{
anyErrors = validCollectionRule.TryGetErrors(model, memberValue, executionContext, strategy, depth, out ruleErrorsCollection);
}
else if (rule is AsNullableRule validNullableRule)
{
anyErrors = validNullableRule.TryGetErrors(model, memberValue, executionContext, strategy, out ruleErrorsCollection);
}
else
{
throw new InvalidRuleException("Unknown rule");
}
if (!anyErrors)
{
continue;
}
if (result == null)
{
result = new ErrorsCollection();
}
result.Include(ruleErrorsCollection);
if (strategy == ValidationStrategy.FailFast)
{
break;
}
}
}
if ((result == null) || result.IsEmpty)
{
return(ErrorsCollection.Empty);
}
if (memberValidator.SingleError == null)
{
return(result);
}
var summaryErrorResult = new ErrorsCollection();
if (includeRequired)
{
summaryErrorResult.AddError(executionContext.RequiredError ?? memberValidator.RequiredError);
}
summaryErrorResult.AddError(memberValidator.SingleError);
return(summaryErrorResult);
}
public static IErrorsCollection ExecuteCollectionMember <TModel, TItem>(IMemberValidator memberValidator, TModel model, IEnumerable <TItem> memberValue, IExecutionContext executionContext, ValidationStrategy validationStrategy, int depth)
where TModel : class
{
ErrorsCollection result = null;
if (validationStrategy == ValidationStrategy.Force)
{
var itemErrorsCollection = ExecuteMember(
memberValidator,
model,
default(TItem),
executionContext,
validationStrategy,
depth
);
result = new ErrorsCollection();
result.AddError(executionContext.CollectionForceKey, itemErrorsCollection);
}
else if (memberValue != null)
{
var items = memberValue.ToArray();
for (var i = 0; i < items.Length; i++)
{
var item = items.ElementAt(i);
var itemErrorsCollection = ExecuteMember(
memberValidator,
model,
item,
executionContext,
validationStrategy,
depth
);
if (itemErrorsCollection.IsEmpty)
{
continue;
}
if (result == null)
{
result = new ErrorsCollection();
}
result.AddError(i.ToString(), itemErrorsCollection);
if ((validationStrategy == ValidationStrategy.FailFast) && !result.IsEmpty)
{
break;
}
}
}
return(GetOrEmpty(result));
}
public static IErrorsCollection ExecuteNullableMember <TModel, TMember>(IMemberValidator memberValidator, TModel model, TMember?memberValue, IExecutionContext executionContext, ValidationStrategy validationStrategy)
where TModel : class
where TMember : struct
{
ErrorsCollection result = null;
var strategy = validationStrategy;
if ((strategy == ValidationStrategy.Complete) && (memberValidator.SingleError != null))
{
strategy = ValidationStrategy.FailFast;
}
foreach (var rule in memberValidator.Rules)
{
IError error = null;
if (rule is ValidRule <TMember> validateRule)
{
if ((strategy == ValidationStrategy.Force) ||
(memberValue.HasValue && !validateRule.IsValid(memberValue.Value)))
{
error = validateRule.RuleSingleError ?? validateRule.Error ?? executionContext.DefaultError;
}
}
else if (rule is AsRelativeRule <TModel> relationRule)
{
if ((strategy == ValidationStrategy.Force) ||
(memberValue.HasValue && !relationRule.IsValid(model)))
{
error = relationRule.RuleSingleError ?? relationRule.Error ?? executionContext.DefaultError;
}
}
else
{
throw new InvalidRuleException($"Unknown (or not allowed) rule in {nameof(AsNullableRule)}");
}
if (error == null)
{
continue;
}
if (result == null)
{
result = new ErrorsCollection();
}
if (memberValidator.SingleError != null)
{
result.AddError(memberValidator.SingleError);
break;
}
result.AddError(error);
if (strategy == ValidationStrategy.FailFast)
{
break;
}
}
return(GetOrEmpty(result));
}
