public void Should_localize_value()
 {
     using (new CultureScope("fr-fr")) {
         var orderValidator = new InlineValidator<Order>();
         orderValidator.RuleFor(x => x.Amount).GreaterThanOrEqualTo(1.2M).WithMessage("{ComparisonValue}");
         var result = orderValidator.Validate(new Order());
         var msg = result.Errors[0].ErrorMessage;
         msg.ShouldEqual("1,2");
     }
 }
		public ClientsideMessageTester() {
			System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
            System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");

            validator = new InlineValidator<TestModel>();
			controllerContext = CreateControllerContext();
		}
		public void Infers_display_name_from_DisplayNameAttribute() {
			var validator = new InlineValidator<DisplayNameTestModel> {
				v => v.RuleFor(x => x.Name2).NotNull()
			};

			var result = validator.Validate(new DisplayNameTestModel());
			result.Errors.Single().ErrorMessage.ShouldEqual("'Bar' must not be empty.");
		}
		public void MemberNameValidatorSelector_returns_true_when_property_name_matches() {
			var validator = new InlineValidator<TestObject> {
				v => v.RuleFor(x => x.SomeProperty).NotNull()
			};

			var result = validator.Validate(new TestObject(), "SomeProperty");
			result.Errors.Count.ShouldEqual(1);
		}
		public void Does_not_validate_other_property_using_expression() {
			var validator = new InlineValidator<TestObject> {
				v => v.RuleFor(x => x.SomeOtherProperty).NotNull()
			};

			var result = validator.Validate(new TestObject(), x => x.SomeProperty);
			result.Errors.Count.ShouldEqual(0);
		}
		public void Nested_collection_for_null_property_should_not_throw_null_reference() {
			var validator = new InlineValidator<request>();
			validator.When(r => r.person != null, () => {
				validator.RuleForEach(x => x.person.NickNames).NotNull();
			});

			var result = validator.Validate(new request());
			result.Errors.Count.ShouldEqual(0);
		}
예제 #7
0
        public void Fails_for_ienumerable_that_doesnt_implement_ICollection()
        {
            var validator = new InlineValidator<TestModel> {
                v => v.RuleFor(x => x.Strings).NotEmpty()
            };

            var result = validator.Validate(new TestModel());
            result.IsValid.ShouldBeFalse();
        }
		public void Validates_nullable_property_with_overriden_name_when_selected() {

			var validator = new InlineValidator<TestObject> {
				v => v.RuleFor(x => x.SomeNullableProperty.Value)
				.GreaterThan(0)
				.When(x => x.SomeNullableProperty.HasValue)
				.OverridePropertyName("SomeNullableProperty")
			};

			var result = validator.Validate(new TestObject { SomeNullableProperty = 0 }, x => x.SomeNullableProperty);
			result.Errors.Count.ShouldEqual(1);
		}
		public void Uses_localized_name_from_display_attribute() {
			using (new CultureScope("en-us")) {
				var validator = new InlineValidator<Person2> {
					v => v.RuleFor(x => x.Name).NotNull().WithMessage("{PropertyName}")
				};

				var result = validator.Validate(new Person2());
				result.Errors[0].ErrorMessage.ShouldEqual("foo");

				using (new CultureScope("fr-FR")) {
					result = validator.Validate(new Person2());
					result.Errors[0].ErrorMessage.ShouldEqual("bar");
				}
			}
		}
        public void Expected_error_code_check()
        {
            bool exceptionCaught = false;

            try {
                var validator = new InlineValidator <Person> {
                    v => v.RuleFor(x => x.Surname).NotNull().WithErrorCode("bar")
                };
                validator.ShouldHaveValidationErrorFor(x => x.Surname, null as string).WithErrorCode("foo");
            }
            catch (ValidationTestException e) {
                exceptionCaught = true;

                e.Message.ShouldEqual("Expected an error code of 'foo'. Actual error code was 'bar'");
            }

            exceptionCaught.ShouldBeTrue();
        }
        public void Expected_severity_check()
        {
            bool exceptionCaught = false;

            try {
                var validator = new InlineValidator <Person> {
                    v => v.RuleFor(x => x.Surname).NotNull().WithSeverity(Severity.Warning)
                };
                validator.ShouldHaveValidationErrorFor(x => x.Surname, null as string).WithSeverity(Severity.Error);
            }
            catch (ValidationTestException e) {
                exceptionCaught = true;

                e.Message.ShouldEqual($"Expected a severity of '{nameof(Severity.Error)}'. Actual severity was '{nameof(Severity.Warning)}'");
            }

            exceptionCaught.ShouldBeTrue();
        }
예제 #12
0
        // ---

        protected override FluentValidation.Results.ValidationResult ValidateFields()
        {
            var v = new InlineValidator <ChangePasswordModel>()
            {
                CascadeMode = CascadeMode.StopOnFirstFailure
            };

            v.RuleFor(_ => _.New)
            .Must(Common.ValidationRules.BeValidPasswordLength).WithMessage("Invalid length")
            ;

            v.RuleFor(_ => _.TfaCode)
            .Must(Common.ValidationRules.BeValidTfaCode).WithMessage("Invalid format")
            .When(_ => !string.IsNullOrWhiteSpace(_.TfaCode))
            ;

            return(v.Validate(this));
        }
예제 #13
0
        // ---

        protected override FluentValidation.Results.ValidationResult ValidateFields()
        {
            var v = new InlineValidator <ConfirmModel>()
            {
                CascadeMode = CascadeMode.StopOnFirstFailure
            };

            v.RuleFor(_ => _.Email)
            .EmailAddress().WithMessage("Invalid format")
            .Must(Common.ValidationRules.BeValidEmailLength)
            ;

            v.RuleFor(_ => _.Captcha)
            .Must(Common.ValidationRules.BeValidCaptchaLength).WithMessage("Invalid length")
            ;

            return(v.Validate(this));
        }
예제 #14
0
        public void Executes_in_rule_in_ruleset_and_default()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleSet("First, Default", () => {
                validator.RuleFor(x => x.Forename).NotNull();
            });

            var result = validator.Validate(new Person(), ruleSet: "First");

            result.Errors.Count.ShouldEqual(1);

            result = validator.Validate(new Person(), ruleSet: "Second");
            result.Errors.Count.ShouldEqual(0);

            result = validator.Validate(new Person());
            result.Errors.Count.ShouldEqual(1);
        }
예제 #15
0
        public void GreaterThan_to_error_string_is_correct()
        {
            // Arrange
            const int expectedNumber = 100;
            var       validator      = new InlineValidator <TestDto>();

            validator.RuleFor(x => x.IntProp).GreaterThan(expectedNumber);

            // Act
            var result = validator.Validate(new TestDto
            {
                IntProp = expectedNumber - 1,
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""greaterThan"",""comparisonValue"":""{expectedNumber}""}}");
        }
예제 #16
0
        public void Vai_retornar_caminhao_nao_cadastrado()
        {
            var caminhao = new Caminhao()
            {
                Id = 1
            };
            var validator = new InlineValidator <Caminhao>();

            caminhaoRepository.Setup(c => c.IdExistente(It.IsAny <long>()))
            .ReturnsAsync(false);

            validarCaminhaoCadastrado.AdicionarValidacao(validator);

            var resultado = validator.Validate(caminhao);

            Assert.IsFalse(resultado.IsValid);
            ContemErro(resultado, CodigoDoErroValidarCaminhaoCadastrado01);
        }
예제 #17
0
        public void Validates_collection_several_levels_deep()
        {
            var validator = new TestValidator {
                v => v.RuleFor(x => x.Surname).NotNull(),
                v => v.RuleForEach(x => x.Orders).SetValidator(y => new OrderValidator(y))
            };

            var rootValidator = new InlineValidator <Tuple <Person, object> >();

            rootValidator.RuleFor(x => x.Item1).SetValidator(validator);

            var results = rootValidator.Validate(Tuple.Create(person, new object()));

            results.Errors.Count.ShouldEqual(3);

            results.Errors[1].PropertyName.ShouldEqual("Item1.Orders[0].ProductName");
            results.Errors[2].PropertyName.ShouldEqual("Item1.Orders[2].ProductName");
        }
예제 #18
0
        public void Test_custom_state_with_concatenated_string()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleFor(x => x.Surname).NotNull().WithState(x => "Test" + 123);
            var result = validator.TestValidate(new Person());

            // String concatenated with integer means a different string reference is created:

            /*
             *      object s1 = "Test" + 123.ToString();
             *      object s2 = "Test123";
             *      bool check1 = s1 == s2; // False
             */
            // Test to ensure that this scenario is handled properly.
            result.ShouldHaveValidationErrorFor(x => x.Surname)
            .WithCustomState("Test123");
        }
예제 #19
0
        public void Includes_all_rulesets()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleFor(x => x.Forename).NotNull();
            validator.RuleSet("Test1", () => {
                validator.RuleFor(x => x.Surname).NotNull();
            });
            validator.RuleSet("Test2", () => {
                validator.RuleFor(x => x.Age).GreaterThan(0);
            });

            var result = validator.Validate(new Person(), options => {
                options.IncludeAllRuleSets();
            });

            result.Errors.Count.ShouldEqual(3);
        }
예제 #20
0
        public async Task Includes_all_rulesets_async()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleFor(x => x.Forename).MustAsync((x, t) => Task.FromResult(x != null));
            validator.RuleSet("Test1", () => {
                validator.RuleFor(x => x.Surname).MustAsync((x, t) => Task.FromResult(x != null));
            });
            validator.RuleSet("Test2", () => {
                validator.RuleFor(x => x.Age).MustAsync((x, t) => Task.FromResult(x > 0));
            });

            var result = await validator.ValidateAsync(new Person(), options => {
                options.IncludeAllRuleSets();
            });

            result.Errors.Count.ShouldEqual(3);
        }
예제 #21
0
        public void MinLength_error_string_is_correct()
        {
            // Arrange
            const int minLength = 5;
            const int entered   = minLength - 1;
            var       validator = new InlineValidator <TestDto>();

            validator.RuleFor(x => x.StringProp).MinimumLength(minLength);

            // Act
            var result = validator.Validate(new TestDto
            {
                StringProp = new string('a', entered),
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""minLength"",""minLength"":""{minLength}"",""entered"":""{entered}""}}");
        }
예제 #22
0
        public void LessThan_error_string_is_correct()
        {
            // Arrange
            const int limit     = 3;
            const int entered   = limit;
            var       validator = new InlineValidator <TestDto>();

            validator.RuleFor(x => x.IntProp).LessThan(limit);

            // Act
            var result = validator.Validate(new TestDto
            {
                IntProp = entered
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""lessThan"",""comparisonValue"":""{limit}""}}");
        }
예제 #23
0
        public void Equal_error_string_is_correct()
        {
            // Arrange
            const int target    = 3;
            const int entered   = target + 1;
            var       validator = new InlineValidator <TestDto>();

            validator.RuleFor(x => x.IntProp).Equal(target);

            // Act
            var result = validator.Validate(new TestDto
            {
                IntProp = entered
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""equal"",""comparisonValue"":""{target}""}}");
        }
예제 #24
0
        public void ExactLength_error_string_is_correct()
        {
            // Arrange
            const int limit     = 3;
            const int entered   = limit + 1;
            var       validator = new InlineValidator <TestDto>();

            validator.RuleFor(x => x.StringProp).Length(limit);

            // Act
            var result = validator.Validate(new TestDto
            {
                StringProp = new string('a', entered),
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""exactLength"",""length"":""{limit}"",""entered"":""{entered}""}}");
        }
예제 #25
0
        public void ScalePrecision_error_string_is_correct()
        {
            // Arrange
            const int expectedPrecision = 4;
            const int expectedScale     = 2;
            var       validator         = new InlineValidator <ScalePrecisionDto>();

            validator.RuleFor(x => x.DecimalProp).ScalePrecision(expectedScale, expectedPrecision);

            // Act
            var result = validator.Validate(new ScalePrecisionDto
            {
                DecimalProp = 123.45678m
            });

            // Assert
            result.Errors[0].ErrorMessage.ShouldBe(
                $@"{{""key"":""scalePrecision"",""expectedPrecision"":""{expectedPrecision}"",""expectedScale"":""{expectedScale}"",""digits"":""3"",""actualScale"":""5""}}");
        }
예제 #26
0
        public async Task Collection_async_RunsTasksSynchronously()
        {
            var result         = new List <bool>();
            var validator      = new InlineValidator <Person>();
            var orderValidator = new InlineValidator <Order>();

            orderValidator.RuleFor(x => x.ProductName).MustAsync((x, token) => {
                return(ExclusiveDelay(1)
                       .ContinueWith(t => result.Add(t.Result))
                       .ContinueWith(t => true));
            });

            validator.RuleFor(x => x.Orders).SetCollectionValidator(orderValidator);

            await validator.ValidateAsync(person);

            Assert.NotEmpty(result);
            Assert.All(result, Assert.True);
        }
예제 #27
0
                public static IValidator <PaymentMehtodsSection> GetValidator()
                {
                    var v = new InlineValidator <PaymentMehtodsSection>()
                    {
                        CascadeMode = CascadeMode.Continue
                    };

                    v.RuleFor(_ => _.EthDepositMinEther).GreaterThan(0);
                    v.RuleFor(_ => _.EthDepositMaxEther).GreaterThan(0);
                    v.RuleFor(_ => _.EthWithdrawMinEther).GreaterThan(0);
                    v.RuleFor(_ => _.EthWithdrawMaxEther).GreaterThan(0);

                    v.RuleFor(_ => _.CreditCardDepositMinUsd).GreaterThan(0);
                    v.RuleFor(_ => _.CreditCardDepositMaxUsd).GreaterThan(0);
                    v.RuleFor(_ => _.CreditCardWithdrawMinUsd).GreaterThan(0);
                    v.RuleFor(_ => _.CreditCardWithdrawMinUsd).GreaterThan(0);

                    return(v);
                }
예제 #28
0
        public void Uses_explicit_ruleset()
        {
            var addressValidator = new InlineValidator <Address>();

            addressValidator.RuleSet("ruleset1", () => {
                addressValidator.RuleFor(x => x.Line1).NotNull();
            });
            addressValidator.RuleFor(x => x.Line2).NotNull();
            var validator = new InlineValidator <Person>();

            validator.RuleFor(x => x.Address).SetValidator(addressValidator, ruleSets: "ruleset1");

            var result = validator.Validate(new Person {
                Address = new Address()
            });

            result.Errors.Count.ShouldEqual(1);
            result.Errors[0].PropertyName.ShouldEqual("Address.Line1");
        }
        public void Customm_within_ruleset()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleSet("foo", () => {
                validator.Custom(x => {
                    return(new ValidationFailure("x", "y"));
                });
            });
            validator.RuleSet("bar", () => {
                validator.Custom(x => {
                    return(new ValidationFailure("x", "y"));
                });
            });

            var result = validator.Validate(new Person(), ruleSet: "foo");

            result.Errors.Count.ShouldEqual(1);
        }
예제 #30
0
        public void Unexpected_state_check()
        {
            bool exceptionCaught = false;

            try {
                var validator = new InlineValidator <Person> {
                    v => v.RuleFor(x => x.Surname).NotNull().WithState(x => "bar"),
                    v => v.RuleFor(x => x.Surname).NotNull().WithState(x => "foo"),
                };
                validator.ShouldHaveValidationErrorFor(x => x.Surname, null as string).WithoutCustomState("bar");
            }
            catch (ValidationTestException e) {
                exceptionCaught = true;

                e.Message.ShouldEqual("Found an unexpected custom state of 'bar'");
            }

            exceptionCaught.ShouldBeTrue();
        }
예제 #31
0
        public async Task Combines_rulesets_and_explicit_properties_async()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleFor(x => x.Forename).NotNull();
            validator.RuleFor(x => x.Surname).NotNull();
            validator.RuleSet("Test", () => {
                validator.RuleFor(x => x.Age).GreaterThan(0);
            });

            var result = await validator.ValidateAsync(new Person(), options => {
                options.IncludeRuleSets("Test");
                options.IncludeProperties(x => x.Forename);
            });

            result.Errors.Count.ShouldEqual(2);
            result.Errors[0].PropertyName.ShouldEqual("Forename");
            result.Errors[1].PropertyName.ShouldEqual("Age");
        }
예제 #32
0
        public void Matches_any_failure()
        {
            var validator = new InlineValidator <Person> {
                v => v.RuleFor(x => x.Surname).NotEqual("foo"),
            };

            var resultWithFailure = validator.TestValidate(new Person {
                Surname = "foo"
            });
            var resultWithoutFailure = validator.TestValidate(new Person {
                Surname = ""
            });

            Assert.Throws <ValidationTestException>(() => resultWithoutFailure.ShouldHaveAnyValidationError());
            Assert.Throws <ValidationTestException>(() => resultWithFailure.ShouldNotHaveAnyValidationErrors());

            // Neither should throw.
            resultWithFailure.ShouldHaveAnyValidationError();
            resultWithoutFailure.ShouldNotHaveAnyValidationErrors();
        }
예제 #33
0
        public void Uses_useful_error_message_when_used_on_non_property()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleForEach(x => x.NickNames.AsEnumerable()).NotNull();

            bool thrown = false;

            try {
                validator.Validate(new Person {
                    NickNames = new string[] { null, null }
                });
            }
            catch (System.InvalidOperationException ex) {
                thrown = true;
                ex.Message.ShouldEqual("Could not infer property name for expression: x => x.NickNames.AsEnumerable(). Please explicitly specify a property name by calling OverridePropertyName as part of the rule chain. Eg: RuleForEach(x => x).NotNull().OverridePropertyName(\"MyProperty\")");
            }

            thrown.ShouldBeTrue();
        }
        public void New_CustomAsync_within_ruleset()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleSet("foo", () => {
                validator.RuleFor(x => x).CustomAsync(async(x, ctx, cancel) => {
                    ctx.AddFailure("x", "y");
                });
            });

            validator.RuleSet("bar", () => {
                validator.RuleFor(x => x).CustomAsync(async(x, ctx, cancel) => {
                    ctx.AddFailure("x", "y");
                });
            });

            var result = validator.ValidateAsync(new Person(), ruleSet: "foo").Result;

            result.Errors.Count.ShouldEqual(1);
        }
예제 #35
0
        public void For_IsNull_When_PropertyValueIsNull_Then_ValidationErrorIsNotReturned()
        {
            // Arrange:
            var validator = new InlineValidator <Person>();

            validator.Setup(x => x.Name)
            .IsNull();

            var toValidate = new Person
            {
                Name = null,
                Age  = default
            };

            // Act:
            var validationErrors = validator.Validate(toValidate);

            // Assert:
            validationErrors.Count.Should().Be(0);
        }
예제 #36
0
        public void When_runs_outside_RuleForEach_loop()
        {
            // Shouldn't throw an exception if the condition is run outside the loop.
            var validator = new InlineValidator <Tuple <Person> >();

            validator.RuleForEach(x => x.Item1.Orders).Must(x => false)
            .When(x => x.Item1 != null);

            var result = validator.Validate(Tuple.Create((Person)null));

            result.IsValid.ShouldBeTrue();

            result = validator.Validate(Tuple.Create(new Person()
            {
                Orders = new List <Order> {
                    new Order()
                }
            }));
            result.IsValid.ShouldBeFalse();
        }
예제 #37
0
        public async Task Transforms_collection_element_with_propagated_original_object_async()
        {
            var validator = new InlineValidator <Person>();

            validator.TransformForEach(x => x.Children, (parent, children) => new { ParentName = parent.Surname, Children = children })
            .Must(context => context.ParentName == context.Children.Surname);

            var child = new Person {
                Surname = "Pupa"
            };
            var result = await validator.ValidateAsync(new Person()
            {
                Surname = "Lupa", Children = new List <Person> {
                    child
                }
            });

            result.IsValid.ShouldBeFalse();
            result.Errors.Count.ShouldEqual(1);
        }
        public void New_Custom_within_ruleset()
        {
            var validator = new InlineValidator <Person>();

            validator.RuleSet("foo", () => {
                validator.RuleFor(x => x).Custom((x, ctx) => {
                    ctx.AddFailure("x", "y");
                });
            });

            validator.RuleSet("bar", () => {
                validator.RuleFor(x => x).Custom((x, ctx) => {
                    ctx.AddFailure("x", "y");
                });
            });

            var result = validator.Validate(new Person(), v => v.IncludeRuleSets("foo"));

            result.Errors.Count.ShouldEqual(1);
        }
        public void Expected_state_check()
        {
            bool exceptionCaught = false;

            try {
                var validator = new InlineValidator <Person> {
                    v => v.RuleFor(x => x.Surname).NotNull().WithState(x => "bar")
                };
                validator.TestValidate(new Person())
                .ShouldHaveValidationErrorFor(x => x.Surname)
                .WithCustomState("foo");
            }
            catch (ValidationTestException e) {
                exceptionCaught = true;

                e.Message.ShouldEqual("Expected custom state of 'foo'. Actual state was 'bar'");
            }

            exceptionCaught.ShouldBeTrue();
        }
 public void Setup()
 {
     System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
     validator = new InlineValidator<TestModel>();
     controllerContext = CreateControllerContext();
 }
        public void Flags_enum_invalid_when_using_outofrange_positive_value()
        {
            var inlineValidator = new InlineValidator<FlagsEnumPoco>();
            inlineValidator.RuleFor(x => x.SByteValue).IsInEnum();
            inlineValidator.RuleFor(x => x.ByteValue).IsInEnum();
            inlineValidator.RuleFor(x => x.Int16Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt16Value).IsInEnum();
            inlineValidator.RuleFor(x => x.Int32Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt32Value).IsInEnum();
            inlineValidator.RuleFor(x => x.Int64Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt64Value).IsInEnum();

            var poco = new FlagsEnumPoco();
            poco.PopulateWithInvalidPositiveValues();

            var result = inlineValidator.Validate(poco);
            result.IsValid.ShouldBeFalse();
            result.Errors.SingleOrDefault(x => x.PropertyName == "ByteValue").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "SByteValue").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "Int16Value").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "UInt16Value").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "Int32Value").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "UInt32Value").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "Int64Value").ShouldNotBeNull();
            result.Errors.SingleOrDefault(x => x.PropertyName == "UInt64Value").ShouldNotBeNull();
        }
        public void Flags_enum_valid_when_using_bitwise_value()
        {
            var inlineValidator = new InlineValidator<FlagsEnumPoco>();
            inlineValidator.RuleFor(x => x.SByteValue).IsInEnum();
            inlineValidator.RuleFor(x => x.ByteValue).IsInEnum();
            inlineValidator.RuleFor(x => x.Int16Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt16Value).IsInEnum();
            inlineValidator.RuleFor(x => x.Int32Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt32Value).IsInEnum();
            inlineValidator.RuleFor(x => x.Int64Value).IsInEnum();
            inlineValidator.RuleFor(x => x.UInt64Value).IsInEnum();

            var poco = new FlagsEnumPoco();
            poco.PopulateWithValidValues();

            var result = inlineValidator.Validate(poco);
            result.IsValid.ShouldBeTrue();
        }
 public void Nullable_enum_valid_when_property_value_is_null()
 {
     var validator = new InlineValidator<Foo>();
     validator.RuleFor(x => x.Gender).IsInEnum();
     var result = validator.Validate(new Foo());
     result.IsValid.ShouldBeTrue();
 }
 public void Nullable_enum_valid_when_value_specified()
 {
     var validator = new InlineValidator<Foo>();
     validator.RuleFor(x => x.Gender).IsInEnum();
     var result = validator.Validate(new Foo() { Gender = EnumGender.Male });
     result.IsValid.ShouldBeTrue();
 }