public async Task ValidateAsync(object value, ValidationContext context, AddError addError)
{
try
{
object typedValue = null;
if (value is JToken jToken)
{
typedValue = jToken.IsNull() ? null : JsonValueConverter.ConvertValue(field, jToken);
}
var tasks = new List <Task>();
foreach (var validator in ValidatorsFactory.CreateValidators(field))
{
tasks.Add(validator.ValidateAsync(typedValue, context, addError));
}
await Task.WhenAll(tasks);
}
catch
{
addError(context.Path, "Not a valid value.");
}
}
public void Should_InitSpecification_OnlyOnce()
{
var validatorsFactoryMock = new Mock <ISpecificationsRepository>();
Specification <User> userSpecification = m => m.SetSingleError("user");
var userSpecificationExecuted = 0;
validatorsFactoryMock
.Setup(r => r.Get <User>())
.Returns(() =>
{
userSpecificationExecuted++;
return(userSpecification);
});
var validatorsFactory = new ValidatorsFactory(validatorsFactoryMock.Object);
validatorsFactory.GetOrInit <User>();
validatorsFactory.GetOrInit <User>();
var validator = validatorsFactory.GetOrInit <User>();
Assert.NotNull(validator);
Assert.Equal(1, userSpecificationExecuted);
Assert.Equal(typeof(User).FullName, validatorsFactory.Keys.Single());
Assert.Equal("user", validator.SingleError.Message);
}
public void Should_InitializeEmpty()
{
var validatorsFactoryMock = new Mock <ISpecificationsRepository>();
var validatorsFactory = new ValidatorsFactory(validatorsFactoryMock.Object);
Assert.Empty(validatorsFactory.Keys);
}
public ValidationContext(IValidationContextOptions options = null)
{
Id = Guid.NewGuid();
Options = OptionsService.GetVerifiedValidationContextOptions(options ?? new ValidationContextOptions());
SpecificationsRepository = new SpecificationsRepository(Options.Specifications);
ValidatorsFactory = new ValidatorsFactory(SpecificationsRepository);
TranslatorsRepository = new TranslatorsRepository(Options.Translations.ToArray());
}
public void Should_ThrowException_If_GettingNonExistingSpecification_ByType()
{
var validatorsFactoryMock = new Mock <ISpecificationsRepository>();
validatorsFactoryMock
.Setup(r => r.Get <User>())
.Returns(n => n);
var validatorsFactory = new ValidatorsFactory(validatorsFactoryMock.Object);
Assert.Throws <KeyNotFoundException>(() => { validatorsFactory.Get <Address>(); });
}
public IValidationResult <T> Validate <T>(T model, Func <IValidationOptions, IValidationOptions> setOptions = null)
where T : class
{
if (!Types.Contains(typeof(T)))
{
throw new SpecificationNotFoundException(typeof(T));
}
var validationOptions = setOptions != null
? OptionsService.GetVerifiedValidationOptions(setOptions(Options.ValidationOptions))
: Options.ValidationOptions;
var defaultTranslator = validationOptions.TranslationName != null
? TranslatorsRepository.Get(validationOptions.TranslationName)
: TranslatorsRepository.GetOriginal();
var translationProxy = new TranslationProxy(defaultTranslator, TranslatorsRepository);
if (model == null)
{
switch (validationOptions.NullRootStrategy)
{
case NullRootStrategy.ArgumentNullException:
{
throw new ArgumentNullException(nameof(model));
}
case NullRootStrategy.NoErrors:
{
return(new ValidationResult <T>(Id, translationProxy, Options.ValidationOptions));
}
default:
{
var report = new ErrorsCollection();
report.AddError(Options.ValidationOptions.RequiredError);
return(new ValidationResult <T>(Id, translationProxy, Options.ValidationOptions, null, report));
}
}
}
var specification = ValidatorsFactory.GetOrInit <T>();
var executionContext = new ExecutionContext(validationOptions, ValidatorsFactory);
var errorsCollection = ValidatorExecutor.Execute(specification, model, executionContext, validationOptions.ValidationStrategy, 0);
return(new ValidationResult <T>(Id, translationProxy, Options.ValidationOptions, model, errorsCollection));
}
private void InitializeValidators()
{
validators = new List <IValidator>();
// Ideally this should be a dependency in the construtor, but since requirement is for parameterless constructor, create a new factory object here.
IValidatorsFactory validatorsFactory = new ValidatorsFactory();
// Ideally set of validators should be defined in some external configuration. For brevity, hard coding it here.
// Note: Order of validators is also carefully defined with consideration. In case of multiple violation, first validation error will only occur.
validators.Add(validatorsFactory.GetValidator(Constants.LengthValidatorName));
validators.Add(validatorsFactory.GetValidator(Constants.InvalidCharValidatorName));
validators.Add(validatorsFactory.GetValidator(Constants.ChecksumValidatorName));
}
public void Should_InitSpecification_WithValidator_And_WithKey()
{
var validatorsFactoryMock = new Mock <ISpecificationsRepository>();
Specification <User> userSpecification = m => m.SetSingleError("user");
var userSpecificationExecuted = false;
validatorsFactoryMock
.Setup(r => r.Get <User>())
.Returns(() =>
{
userSpecificationExecuted = true;
return(userSpecification);
});
Specification <Address> addressSpecification = m => m.SetSingleError("address");
var addressSpecificationExecuted = false;
validatorsFactoryMock
.Setup(r => r.Get <Address>())
.Returns(() =>
{
addressSpecificationExecuted = true;
return(addressSpecification);
});
var validatorsFactory = new ValidatorsFactory(validatorsFactoryMock.Object);
Specification <User> userDefinedSpecification = m => m.SetSingleError("user_defined");
var validator = validatorsFactory.GetOrInit(userDefinedSpecification, "key");
Assert.NotNull(validator);
Assert.False(userSpecificationExecuted);
Assert.False(addressSpecificationExecuted);
Assert.Equal("key", validatorsFactory.Keys.Single());
Assert.Equal("user_defined", validator.SingleError.Message);
}
public static Task ValidateOptionalAsync(this IField field, IJsonValue value, IList <string> errors, ValidationContext context = null)
{
return(new FieldValidator(ValidatorsFactory.CreateValidators(field).ToArray(), field).ValidateAsync(value,
CreateContext(context).Optional(true),
CreateFormatter(errors)));
}
