public void Test_ValidatorBuilder_Build() { var builder = new ValidatorBuilder<ValidateContext>(_Validation); var rule = builder.RuleFor(i => i.RuleSelector); var v = builder.Build(); Assert.NotNull(v); }
public ValidatorBuilderTest() { _validators = ValidatorBuilder <Validable> .Create() .AddValidator(new DescriptionIsEmptyValidator()) .AddValidator(new DescriptionIsNullValidator()) .AddValidator(new CountIsNullValidator()) .AddValidator(new CountIsZeroValidator()) .Build(); }
public void Test_ValidatorBuilder_RuleFor() { var builder = new ValidatorBuilder<ValidateContext>(_Validation); var rule = builder.RuleFor(i => i.RuleSelector); Assert.NotNull(rule); Assert.NotNull((rule as IRuleBuilder<ValidateContext, IRuleSelector>).ValueGetter); var setter = rule as IRuleMessageBuilder<ValidateContext, IRuleSelector>; Assert.NotNull(setter); Assert.Equal("RuleSelector", (setter as IValidateRuleBuilder).ValueName); }
public void Test_ValidatorBuilder_RuleFor() { var builder = new ValidatorBuilder <ValidateContext>(_Validation); var rule = builder.RuleFor(i => i.RuleSelector); Assert.NotNull(rule); Assert.NotNull((rule as IRuleBuilder <ValidateContext, IRuleSelector>).ValueGetter); var setter = rule as IRuleMessageBuilder <ValidateContext, IRuleSelector>; Assert.NotNull(setter); Assert.Equal("RuleSelector", (setter as IValidateRuleBuilder).ValueName); }
public static void ScaffoldEntities(string srcDirectory, string testDirectory, string projectBaseName, List <Entity> entities, string dbContextName, bool addSwaggerComments, List <Policy> policies, IFileSystem fileSystem, Verbosity verbosity) { foreach (var entity in entities) { EntityBuilder.CreateEntity(srcDirectory, entity, projectBaseName, fileSystem); DtoBuilder.CreateDtos(srcDirectory, entity, projectBaseName); ValidatorBuilder.CreateValidators(srcDirectory, projectBaseName, entity); ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName); QueryGetRecordBuilder.CreateQuery(srcDirectory, entity, dbContextName, projectBaseName); QueryGetListBuilder.CreateQuery(srcDirectory, entity, dbContextName, projectBaseName); CommandAddRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName); CommandDeleteRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName); CommandUpdateRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName); CommandPatchRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName); ControllerBuilder.CreateController(srcDirectory, entity, addSwaggerComments, policies, projectBaseName); // Shared Tests FakesBuilder.CreateFakes(testDirectory, projectBaseName, entity); // Integration Tests AddCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName); DeleteCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName); PatchCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName); GetRecordQueryTestBuilder.CreateTests(testDirectory, entity, projectBaseName); GetListQueryTestBuilder.CreateTests(testDirectory, entity, projectBaseName); PutCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName); // Functional Tests CreateEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); DeleteEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); GetEntityRecordTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); GetEntityListTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); PatchEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); PutEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName); if (verbosity == Verbosity.More) { WriteHelpText($"{projectBaseName} '{entity.Name}' entity was scaffolded successfully."); } } }
public static Task ValidateAsync(this IField field, object?value, IList <string> errors, Schema?schema = null, ValidationMode mode = ValidationMode.Default, ValidationUpdater?updater = null, IValidatorsFactory?factory = null, ValidationAction action = ValidationAction.Upsert) { var context = CreateContext(schema, mode, updater, action); var validator = new ValidatorBuilder(factory, context).ValueValidator(field); return(validator.ValidateAsync(value, context, CreateFormatter(errors))); }
private static void RunTemplateBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem) { // dbcontext DbContextBuilder.CreateDbContext(solutionDirectory, template); //entities foreach (var entity in template.Entities) { EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem); DtoBuilder.CreateDtos(solutionDirectory, entity); RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext); ValidatorBuilder.CreateValidators(solutionDirectory, entity); ProfileBuilder.CreateProfile(solutionDirectory, entity); ControllerBuilder.CreateController(solutionDirectory, entity); FakesBuilder.CreateFakes(solutionDirectory, template, entity); ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template, entity); GetTestBuilder.CreateEntityGetTests(solutionDirectory, template, entity); PostTestBuilder.CreateEntityWriteTests(solutionDirectory, template, entity); UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, template, entity); DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, template, entity); WebAppFactoryBuilder.CreateWebAppFactory(solutionDirectory, template, entity); } // environments AddStartupEnvironmentsWithServices(solutionDirectory, template); //seeders SeederBuilder.AddSeeders(solutionDirectory, template); //services SwaggerBuilder.AddSwagger(solutionDirectory, template); if (template.AuthSetup.AuthMethod == "JWT") { IdentityServicesModifier.SetIdentityOptions(solutionDirectory, template.AuthSetup); IdentitySeederBuilder.AddSeeders(solutionDirectory, template); IdentityRoleBuilder.CreateRoles(solutionDirectory, template.AuthSetup.Roles); RoleSeedBuilder.SeedRoles(solutionDirectory, template); } //final ReadmeBuilder.CreateReadme(solutionDirectory, template, fileSystem); if (template.AddGit) { GitSetup(solutionDirectory); } }
static void Main(string[] args) { var triangleValidator = new ValidatorBuilder <Triangle>() .AddRule(t => t.Name == "Triangle", t => $"Name {t.Name} is not correct") .AddRule(t => t.GetArea() > 20, t => $"Area value {t.GetArea()} is not correct. Should be more than 30") .Build(); var validationResult = triangleValidator.Validate(new Triangle(3, 6)); if (!validationResult.IsValid) { Console.WriteLine(string.Join(Environment.NewLine, validationResult.ErrorMessages)); } }
/// <summary> /// Creates File Cabinet. /// </summary> private static void CreateFileCabinet() { IRecordValidator validator = new ValidatorBuilder().CreateDefault(); if (SettingsApp.FileCabinetType.Equals(typeof(FileCabinetMemoryService))) { fileCabinetService = new FileCabinetMemoryService(validator, SettingsApp.StartId); } else if (SettingsApp.FileCabinetType.Equals(typeof(FileCabinetFilesystemService))) { FileStream fileStream = new FileStream(Settings.FileNameStorage, FileMode.Create, FileAccess.ReadWrite); fileCabinetService = new FileCabinetFilesystemService(validator, fileStream, SettingsApp.StartId); } }
public void Configure(ValidatorBuilder <T> builder) { var elementBuilder = new TypeValidatorBuilder <TElement>(); _configurator.Configure(elementBuilder); Validator <TElement> elementValidator = elementBuilder.Build(""); var nestedValidator = new NestedValidator <TElement>(elementValidator); var validator = new EnumerableValidator <T, TElement>(nestedValidator); builder.AddValidator(validator); }
/// <summary> /// Adds an explicit view model-level validation error (with the given /// <paramref name="errorMessage"/> to the current VM if any of its /// properties are invalid (see remarks). /// </summary> /// <remarks> /// This rule is useful if a VM is displayed in a grid where not all /// properties are visible in the grid. If any of the properites of a /// VM (visible or not) become invalid, a view model-level (row level) /// validation error is added to the VM (which is for example visualized /// by a red cross to the left of the grid row). This indicates to the /// user that something currently not visible may be invalid and that he /// or she should open the details of the current record to correct the /// validation error. /// </remarks> public static void ValidateProperties <TOwnerVM, TTargetVM, TDescriptor>( this ValidatorBuilder <TOwnerVM, TTargetVM, TDescriptor> builder, string errorMessage ) where TOwnerVM : IViewModel where TTargetVM : IViewModel where TDescriptor : class, IVMDescriptor { builder.CheckViewModel((args) => { if (!args.Owner.Kernel.GetValidationResult(ValidationResultScope.PropertiesOnly).IsValid) { args.AddError(errorMessage); } }); }
public void Validate_NoFields_Strings_Pattern_Invalid() { // Arrange var form = new QueryCollection(new Dictionary <string, StringValues>()); var validator = ValidatorBuilder .New() .RequiresStringWithPattern("email", new Regex("\\w+@\\w+\\.\\w+")) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public void File_QueryCollection_Invalid() { // Arrange var form = new QueryCollection(new Dictionary <string, StringValues>()); var validator = ValidatorBuilder .New() .RequiresFile("file", f => true) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
/// <summary> /// Adds an expli1cit view model-level validation error (with the given /// <paramref name="errorMessage"/>) to the current VM if any of its /// descendants are invalid (see remarks). /// </summary> /// <remarks> /// <para>Beware that the validation state is always propagated to to the /// parent (meaning that <see cref="ViewModel{TDescriptor}.IsValid"/> returns false /// if any descendant is invalid) but <see cref="ViewModel{TDescriptor}.GetValidationResult(ValidationResultScope)"/> /// with <see cref="ValidationResultScope.Self"/> does not return an error /// by default unless you add this validation rule.</para> /// <para>This validation rule is most useful in hierarchical data structures /// (e.g. an employee has projects which have tasks which have records) to /// guide the user to the (probably not visible) record that is actually /// invalid.</para> /// </remarks> public static void PropagateChildErrors <TOwnerVM, TTargetVM, TDescriptor>( this ValidatorBuilder <TOwnerVM, TTargetVM, TDescriptor> builder, string errorMessage ) where TOwnerVM : IViewModel where TTargetVM : IViewModel where TDescriptor : class, IVMDescriptor { builder.CheckViewModel((args) => { // TODO: Write test to verify that target is used instead of owner. if (!args.Target.Kernel.GetValidationResult(ValidationResultScope.Descendants).IsValid) { args.AddError(errorMessage); } }); }
public void Validate_TwoFields_Strings_MultipleValues_Bounded_NoFields_Valid() { // Arrange var form = new QueryCollection(new Dictionary <string, StringValues>()); var validator = ValidatorBuilder .New() .CanHaveStrings("vowels", 2, 5, vowel => vowel.Length == 1) .CanHaveStrings("consonants", 4, 5, consonant => consonant.Length == 1) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsTrue(valid); }
public void Configure(ValidatorBuilder <T> builder) { var propertyValidatorBuilder = new TypeValidatorBuilder <TProperty>(); foreach (var configurator in _configurators) { configurator.Configure(propertyValidatorBuilder); } Validator <TProperty> propertyValueValidator = propertyValidatorBuilder.Build("." + GetPropertyName(_propertyExpression)); var validator = new PropertyValidator <T, TProperty>(_propertyExpression, propertyValueValidator); builder.AddValidator(validator); }
public void Validate_NullForm_Invalid() { // Arrange IFormCollection form = null; var validator = ValidatorBuilder .New() .RequiresStringWithPattern("email", new Regex("[^@]+@[^.]+(\\.[^.]+)+", RegexOptions.Compiled)) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public void Validate_NullForm_Invalid() { // Arrange IQueryCollection form = null; var validator = ValidatorBuilder .New() .RequiresRational("flops") .WithCultureInfo(CultureInfo.InvariantCulture) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public void Test_ValidatorBuilder_RuleSet() { var builder = new ValidatorBuilder<ValidateContext>(_Validation); builder.RuleSet("a", b => { builder.RuleFor(i => i.Option); builder.RuleFor(i => i.RuleSelector); builder.RuleFor(i => i.RuleSelector); builder.Builders.RemoveAt(2); }); Assert.NotNull(builder.Builders); Assert.Equal(2, builder.Builders.Count); Assert.NotNull(builder.Builders[0]); Assert.NotNull(builder.Builders[1]); Assert.Equal("A", builder.Builders[0].RuleSet); Assert.Equal("A", builder.Builders[1].RuleSet); }
/// <summary> /// Creates custom validator. /// </summary> /// <param name="validatorBuilder">The instance of ValidatorBuilder class.</param> /// <returns>The instance of IRecordValidator class.</returns> public static IRecordValidator CreateСustom(this ValidatorBuilder validatorBuilder) { var rulesets = GetRulesets(); ValidationRuleset ruleset = rulesets.Custom; return(new CompositeValidator(new List <IRecordValidator> { new FirstNameValidator(ruleset.FirstName.MinLength, ruleset.FirstName.MaxLength), new LastNameValidator(ruleset.LastName.MinLength, ruleset.LastName.MaxLength), new DateOfBirthValidator(ruleset.DateOfBirth.From, ruleset.DateOfBirth.To), new FavouriteNumberValidator(ruleset.FavNumber.MinValue, ruleset.FavNumber.MaxValue), new FavouriteCharacterValidator(ruleset.FavCharacter.SymbolCase), new FavouriteGameValidator(ruleset.FavGame.MinLength, ruleset.FavGame.MaxLength), new DonationsValidator(ruleset.Donations.MinValue), })); }
public void Validate_Rational_Bounded_NoFields_Invalid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues>()); var validator = ValidatorBuilder .New() .RequiresRational("height", height => height > 10 && height < 300) .RequiresRational("weight", weigth => weigth > 10 && weigth < 300) .WithCultureInfo(CultureInfo.InvariantCulture) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
static void Main() { Validator <Student> validator = ValidatorBuilder .Build <Student>() // .AddValidation("Age", new Above18()) .AddValidation("Name", new NotNull()) .AddValidation <String>("Name", val => val.Length < 10); Student s1 = new Student(76135, "Anacleto", 20); validator.Validate(s1); s1.Print(); Student s2 = new Student(654354, "Maria Jose Catita", 25); validator.Validate(s2); s2.Print(); }
public void Validate_OneField_MultipleIntegers_Predicate_DataTest(int min, int max, bool expected, params string[] values) { // Arrange var form = new QueryCollection(new Dictionary <string, StringValues> { { "blah", new StringValues(values) } }); var validator = ValidatorBuilder .New() .RequiresIntegers("blah", min, max, i => i > 0 && i < 10) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.AreEqual(valid, expected); }
public void Validate_OneField_MultipleString_Pattern_DataTest(int min, int max, bool expected, params string[] values) { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { { "blah", new StringValues(values) } }); var validator = ValidatorBuilder .New() .RequiresStringsWithPattern("blah", min, max, new Regex("[1-5]")) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.AreEqual(valid, expected); }
public void Test_ValidatorBuilder_RuleSet() { var builder = new ValidatorBuilder <ValidateContext>(_Validation); builder.RuleSet("a", b => { builder.RuleFor(i => i.Option); builder.RuleFor(i => i.RuleSelector); builder.RuleFor(i => i.RuleSelector); builder.Builders.RemoveAt(2); }); Assert.NotNull(builder.Builders); Assert.Equal(2, builder.Builders.Count); Assert.NotNull(builder.Builders[0]); Assert.NotNull(builder.Builders[1]); Assert.Equal("A", builder.Builders[0].RuleSet); Assert.Equal("A", builder.Builders[1].RuleSet); }
public void File_OneFile_Invalid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues>(), new FormFileCollection { new FormFile(Stream.Null, 0, 0, "file", "adwdaw") }); var validator = ValidatorBuilder .New() .CanHaveFile("file", f => false) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public static async Task ValidateAsync(this ContentData data, PartitionResolver partitionResolver, IList <ValidationError> errors, Schema?schema = null, ValidationMode mode = ValidationMode.Default, ValidationUpdater?updater = null, IValidatorsFactory?factory = null, ValidationAction action = ValidationAction.Upsert) { var context = CreateContext(schema, mode, updater, action); var validator = new ValidatorBuilder(factory, context).ContentValidator(partitionResolver); await validator.ValidateInputAsync(data); foreach (var error in validator.Errors) { errors.Add(error); } }
public void Validate_OneField_String_Predicate_FieldsExists_Invalid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { { "type", "rum" } }); var validator = ValidatorBuilder .New() .RequiresString("type", s => s == "petrol" || s == "diesel") .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public void Validate_OneField_Integer_Unbounded_FieldExists_Valid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { { "number", "32423" }, }); var validator = ValidatorBuilder .New() .RequiresInteger("number") .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsTrue(valid); }
public void Validate_TwoFields_Integer_Unbounded_NoFields_Invalid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { }); var validator = ValidatorBuilder .New() .RequiresInteger("zip") .RequiresInteger("age") .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsFalse(valid); }
public void Validate_OneField_Integer_AllBounded_FieldExists_Valid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { { "zip", "9000" }, }); var validator = ValidatorBuilder .New() .RequiresInteger("zip", zip => zip > 1000 && zip < 9999) .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsTrue(valid); }
public void Validate_Builder_Throws() { // Arrange var form = new QueryCollection(new Dictionary <string, StringValues> { { "flops", "" } }); // Act and Assert Assert.Throws <ArgumentException>(() => { var validator = ValidatorBuilder .New() .RequiresInteger("flops") .RequiresInteger("flops") .Build(); }); }
public void Validate_EmptyField_Optional_Valid() { // Arrange var form = new FormCollection(new Dictionary <string, StringValues> { { "flops", "" } }); var validator = ValidatorBuilder .New() .CanHaveInteger("flops") .Build(); // Act var valid = validator.Validate(form); // Assert Assert.IsTrue(valid); }
public override void Configure(ValidatorBuilder<DateTime> builder) { var validator = new WithinPastDateTimeValidator(_period); builder.AddValidator(validator); }