Example #1
0
        public void fail_model_is_null_in_collection()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .ForEach(m => m.B.Cs)
            .Assert(_is.NotNull);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                B = new ModelB
                {
                    Cs = new[]
                    {
                        new ModelC(),
                        null
                    }
                }
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal("Cs.B[1]:not-null",
                         Assert.Single(result)
                         );
        }
Example #2
0
        public void with_when()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .When(_is.Equal("ZZZ"))
            .Assert(_is.Null);

            rule
            .For(m => m.Name)
            .When(_is.Equal("YYY"))
            .Assert(_is.Email);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = "ZZZ"
            });

            Assert.Equal(new[] { "Name:null" }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = "YYY"
            });
            Assert.Equal(new[] { "Name:email" }, result);
        }
Example #3
0
        public void validate_accross_graph_hierarchy()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .When(b =>
                  b.For(m => m.Name)
                  .Assert(_is.NotNullOrEmpty)
                  )
            .Assert(b =>
                    b.For(m => m.B)
                    .Assert(_is.NotNull)
                    );

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty
            });

            Assert.Equal(new string[] {}, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = "NOT EMPTY",
                B    = null
            });
            Assert.Equal(new[] { "B:not-null" }, result);
        }
Example #4
0
        public void with_or()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .Assert(_is.Equal("ZZZ"))
            .Or(_is.Equal("YYY"));

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = "YYY"
            });

            Assert.Equal(new string[] {}, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = "ZZZ"
            });
            Assert.Equal(new string[] {}, result);
        }
Example #5
0
        public void when_first_assert_fails_stop()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .Assert(_is.NotEmpty)
            .Assert(_is.Email);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = "NOT EMPTY"
            });

            Assert.Equal(new[] { "Name:email" }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = string.Empty
            });

            Assert.Equal(new[] { "Name:not-empty" }, result);
        }
Example #6
0
        public void if_not_empty_then_is_email()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .When(_is.NotEmpty)
            .Assert(_is.Email);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = "NOT EMPTY"
            });

            Assert.Equal(new[] { "Name:email" }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = string.Empty
            });

            Assert.Equal(new string[] {}, result);
        }
Example #7
0
        public void with_method_stops_on_first_assert_fail_but_runs_next_rule()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .Assert(with_method_build)
            .For(m => m.Name)
            .Assert(_is.NotEmpty);

            rule
            .For(m => m.B)
            .Assert(_is.NotNull);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty,
                Size = 0
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal(new[] { "Name:not-empty", "B:not-null" }, result);
        }
Example #8
0
        public void with_method()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m)
            .Assert(with_method_build);
            rule
            .For(m => m.Size)
            .Assert(with_method_build_size);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty,
                Size = 0
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.True(result.ElementAt(0)
                        .StartsWith("Name:not-empty"));
            Assert.True(result.ElementAt(1)
                        .StartsWith("Size:min"));
        }
Example #9
0
        public void fail_model_name_is_empty_and_size_is_0()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .Assert(_is.NotNull)
            .Assert(_is.NotEmpty);
            rule
            .For(m => m.Size)
            .Assert(_is.Min(1));

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty,
                Size = 0
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.True(result.ElementAt(0)
                        .StartsWith("Name:not-empty"));
            Assert.True(result.ElementAt(1)
                        .StartsWith("Size:min"));
        }
Example #10
0
        public void fail_model_is_null()
        {
            var builder = GetBuilder();

            GetRule(builder)
            .Assert(_is.NotNull);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(null);

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal(":not-null",
                         Assert.Single(result)
                         );
        }
Example #11
0
        public void with_more_ors()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .When(_is.NotNull)
            .Assert(_is.Empty)
            .Or(_is.Email)
            .Or(_is.Equal("Test", StringComparison.OrdinalIgnoreCase));

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = "ZZZ"
            });

            Assert.Equal(new[] { "Name:empty", "Name:email", "Name:equal" }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = ""
            });
            Assert.Equal(new string[] { }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = "*****@*****.**"
            });
            Assert.Equal(new string[] { }, result);

            result = new ValidationRuleValidator <ModelA>(builder)
                     .Validate(new ModelA
            {
                Name = "test"
            });
            Assert.Equal(new string[] { }, result);
        }
Example #12
0
        public void with_asserts_all_predicates()
        {
            var builder = GetBuilder();

            GetRule(builder)
            .For(m => m.Name)
            .Assert(_is.NotNull, _is.Email);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = null
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal(new[] { "Name:not-null", "Name:email" }, result);
        }
Example #13
0
        public void fail_model_name_is_null_in_collection_allowing_for_null_model()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .ForEach(m => m.B.Cs)
            .When(_is.NotNull)
            .For(m => m.Name)
            .Assert(_is.NotNull);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                B = new ModelB
                {
                    Cs = new[]
                    {
                        null,
                        new ModelC {
                            Name = "Name"
                        },
                        new ModelC()
                    }
                }
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal("Cs.B[2].Name:not-null",
                         Assert.Single(result)
                         );
        }
Example #14
0
        public void with_method_predicate()
        {
            var builder = GetBuilder();
            var rule    = GetRule(builder);

            rule
            .For(m => m.Name)
            .Assert("a-function", with_method_predicate_name);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty,
                Size = 0
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.True(result.ElementAt(0)
                        .StartsWith("Name:a-function"));
        }
Example #15
0
        public void fail_model_name_is_empty()
        {
            var builder = GetBuilder();

            GetRule(builder)
            .For(m => m.Name)
            .Assert(_is.NotNull)
            .Assert(_is.NotEmpty);

            var result = new ValidationRuleValidator <ModelA>(builder)
                         .Validate(new ModelA
            {
                Name = string.Empty
            });

            foreach (var error in result)
            {
                Console.WriteLine(error);
            }

            Assert.Equal("Name:not-empty",
                         Assert.Single(result)
                         );
        }