Add missing ErrorCodeSource on all Validator Constructors

mythz · mythz · commit 353cd6739a94 · 2017-04-14T04:10:14.000-04:00
diff --git a/src/ServiceStack/FluentValidation/ValidationErrors.cs b/src/ServiceStack/FluentValidation/ValidationErrors.cs
@@ -9,6 +9,8 @@ public static class ValidationErrors
     {
         public const string CreditCard = "CreditCard";
         public const string Email = "Email";
+        public const string Enum = "Enum";
+        public const string Empty = "Empty";
         public const string Equal = "Equal";
         public const string ExclusiveBetween = "ExclusiveBetween";
         public const string GreaterThanOrEqual = "GreaterThanOrEqual";
@@ -20,7 +22,9 @@ public static class ValidationErrors
         public const string NotEmpty = "NotEmpty";
         public const string NotEqual = "NotEqual";
         public const string NotNull = "NotNull";
+        public const string Null = "Null";
         public const string Predicate = "Predicate";
         public const string RegularExpression = "RegularExpression";
+        public const string ScalePrecision = "ScalePrecision";
     }
 }
diff --git a/src/ServiceStack/FluentValidation/Validators/EmptyValidator.cs b/src/ServiceStack/FluentValidation/Validators/EmptyValidator.cs
@@ -25,6 +25,7 @@ public class EmptyValidator : PropertyValidator, IEmptyValidator {
 		readonly object defaultValueForType;
 
 		public EmptyValidator(object defaultValueForType) : base(nameof(Messages.empty_error), typeof(Messages)) {
+            ErrorCodeSource = new StaticStringSource(ValidationErrors.Empty);
             this.defaultValueForType = defaultValueForType;
 		}
 
diff --git a/src/ServiceStack/FluentValidation/Validators/EnumValidator.cs b/src/ServiceStack/FluentValidation/Validators/EnumValidator.cs
@@ -27,6 +27,7 @@ public class EnumValidator : PropertyValidator
 		private readonly Type enumType;
 
 		public EnumValidator(Type enumType) : base(nameof(Messages.enum_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.Enum);
 			this.enumType = enumType;
 		}
 
diff --git a/src/ServiceStack/FluentValidation/Validators/GreaterThanOrEqualValidator.cs b/src/ServiceStack/FluentValidation/Validators/GreaterThanOrEqualValidator.cs
@@ -30,9 +30,10 @@ public GreaterThanOrEqualValidator(IComparable value) : base(value, nameof(Messa
 
 		public GreaterThanOrEqualValidator(Func<object, object> valueToCompareFunc, MemberInfo member)
 			: base(valueToCompareFunc, member, nameof(Messages.greaterthanorequal_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.GreaterThanOrEqual);
 		}
 
-		public override bool IsValid(IComparable value, IComparable valueToCompare) {
+        public override bool IsValid(IComparable value, IComparable valueToCompare) {
 			if (valueToCompare == null)
 				return false;
 
diff --git a/src/ServiceStack/FluentValidation/Validators/GreaterThanValidator.cs b/src/ServiceStack/FluentValidation/Validators/GreaterThanValidator.cs
@@ -31,9 +31,10 @@ public GreaterThanValidator(IComparable value) : base(value, nameof(Messages.gre
 
 		public GreaterThanValidator(Func<object, object> valueToCompareFunc, MemberInfo member)
 			: base(valueToCompareFunc, member, nameof(Messages.greaterthan_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.GreaterThan);
 		}
 
-		public override bool IsValid(IComparable value, IComparable valueToCompare) {
+        public override bool IsValid(IComparable value, IComparable valueToCompare) {
 			if (valueToCompare == null)
 				return false;
 
diff --git a/src/ServiceStack/FluentValidation/Validators/LengthValidator.cs b/src/ServiceStack/FluentValidation/Validators/LengthValidator.cs
@@ -30,10 +30,10 @@ public class LengthValidator : PropertyValidator, ILengthValidator {
 		public Func<object, int> MaxFunc { get; set; }
 
 		public LengthValidator(int min, int max) : this(min, max, nameof(Messages.length_error), typeof(Messages)) {
-            ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);
         }
 
 		public LengthValidator(int min, int max, string resourceName, Type resourceType) : base(resourceName, resourceType) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);
 			Max = max;
 			Min = min;
 
@@ -47,6 +47,7 @@ public LengthValidator(Func<object, int> min, Func<object, int> max)
 		}
 
 		public LengthValidator(Func<object, int> min, Func<object, int> max, string resourceName, Type resourceType) : base(resourceName, resourceType) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);
 			MaxFunc = max;
 			MinFunc = min;
 		}
diff --git a/src/ServiceStack/FluentValidation/Validators/LessThanOrEqualValidator.cs b/src/ServiceStack/FluentValidation/Validators/LessThanOrEqualValidator.cs
@@ -36,9 +36,10 @@ public LessThanOrEqualValidator(IComparable value)
 		public LessThanOrEqualValidator(Func<object, object> valueToCompareFunc, MemberInfo member)
 			: base(valueToCompareFunc, member, nameof(Messages.lessthanorequal_error), typeof(Messages))
         {
+            ErrorCodeSource = new StaticStringSource(ValidationErrors.LessThanOrEqual);
 		}
 
-		public override bool IsValid(IComparable value, IComparable valueToCompare)
+        public override bool IsValid(IComparable value, IComparable valueToCompare)
         {
 			if (valueToCompare == null)
 				return false;
diff --git a/src/ServiceStack/FluentValidation/Validators/LessThanValidator.cs b/src/ServiceStack/FluentValidation/Validators/LessThanValidator.cs
@@ -32,9 +32,10 @@ public LessThanValidator(IComparable value) : base(value, nameof(Messages.lessth
 
 		public LessThanValidator(Func<object, object> valueToCompareFunc, MemberInfo member)
 			: base(valueToCompareFunc, member, nameof(Messages.lessthan_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.LessThan);
 		}
 
-		public override bool IsValid(IComparable value, IComparable valueToCompare) {
+        public override bool IsValid(IComparable value, IComparable valueToCompare) {
 			if (valueToCompare == null)
 				return false;
 
diff --git a/src/ServiceStack/FluentValidation/Validators/NullValidator.cs b/src/ServiceStack/FluentValidation/Validators/NullValidator.cs
@@ -22,9 +22,10 @@ namespace ServiceStack.FluentValidation.Validators
 
 	public class NullValidator : PropertyValidator, INullValidator {
 		public NullValidator() : base(nameof(Messages.null_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.Null);
         }
 
-		protected override bool IsValid(PropertyValidatorContext context) {
+        protected override bool IsValid(PropertyValidatorContext context) {
 			if (context.PropertyValue != null) {
 				return false;
 			}
diff --git a/src/ServiceStack/FluentValidation/Validators/RegularExpressionValidator.cs b/src/ServiceStack/FluentValidation/Validators/RegularExpressionValidator.cs
@@ -38,29 +38,34 @@ public RegularExpressionValidator(string expression) : base(nameof(Messages.rege
 		}
 
 		public RegularExpressionValidator(Regex regex) : base(nameof(Messages.regex_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);
 			this.expression = regex.ToString();
 			this.regexFunc = x => regex;
 		}
 
 		public RegularExpressionValidator(string expression, RegexOptions options) : base(nameof(Messages.regex_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);
 			this.expression = expression;
 			var regex = new Regex(expression, options);
 			this.regexFunc = x => regex;
 		}
 
 		public RegularExpressionValidator(Func<object, string> expressionFunc)
 			: base(nameof(Messages.regex_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);
 			this.regexFunc = x => new Regex(expressionFunc(x));
 		}
 
 		public RegularExpressionValidator(Func<object, Regex> regexFunc)
 			: base(nameof(Messages.regex_error), typeof(Messages)) {
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);
 			this.regexFunc = regexFunc;
 		}
 
 		public RegularExpressionValidator(Func<object, string> expression, RegexOptions options)
 			: base(nameof(Messages.regex_error), typeof(Messages)) {
 
+		    ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);
 			this.regexFunc = x => new Regex(expression(x), options);
 		}
 
diff --git a/src/ServiceStack/FluentValidation/Validators/ScalePrecisionValidator.cs b/src/ServiceStack/FluentValidation/Validators/ScalePrecisionValidator.cs
@@ -85,6 +85,7 @@ protected override bool IsValid(PropertyValidatorContext context)
 
         private void Init(int scale, int precision)
         {
+            ErrorCodeSource = new StaticStringSource(ValidationErrors.ScalePrecision);
             Scale = scale;
             Precision = precision;
 
diff --git a/tests/ServiceStack.WebHost.Endpoints.Tests/ValidationExceptionTests.cs b/tests/ServiceStack.WebHost.Endpoints.Tests/ValidationExceptionTests.cs
@@ -0,0 +1,176 @@
+﻿using System;
+using System.Linq;
+using Funq;
+using NUnit.Framework;
+using ServiceStack.FluentValidation;
+using ServiceStack.FluentValidation.Validators;
+using ServiceStack.Text;
+using ServiceStack.Validation;
+
+namespace ServiceStack.WebHost.Endpoints.Tests
+{
+    public class TriggerValidators : IReturn<TriggerValidators>
+    {
+        public string CreditCard { get; set; }
+        public string Email { get; set; }
+        public string Empty { get; set; }
+        public string Equal { get; set; }
+        public int ExclusiveBetween { get; set; }
+        public int GreaterThanOrEqual { get; set; }
+        public int GreaterThan { get; set; }
+        public int InclusiveBetween { get; set; }
+        public string Length { get; set; }
+        public int LessThanOrEqual { get; set; }
+        public int LessThan { get; set; }
+        public string NotEmpty { get; set; }
+        public string NotEqual { get; set; }
+        public string Null { get; set; }
+        public string RegularExpression { get; set; }
+        public decimal ScalePrecision { get; set; }
+    }
+
+    public class TriggerValidatorsValidtor : AbstractValidator<TriggerValidators>
+    {
+        public TriggerValidatorsValidtor()
+        {
+            RuleFor(x => x.CreditCard).CreditCard();
+            RuleFor(x => x.Email).EmailAddress();
+            RuleFor(x => x.Empty).Empty();
+            RuleFor(x => x.Equal).Equal("Equal");
+            RuleFor(x => x.ExclusiveBetween).ExclusiveBetween(10, 20);
+            RuleFor(x => x.GreaterThanOrEqual).GreaterThanOrEqualTo(10);
+            RuleFor(x => x.GreaterThan).GreaterThan(10);
+            RuleFor(x => x.InclusiveBetween).InclusiveBetween(10, 20);
+            RuleFor(x => x.Length).Length(10);
+            RuleFor(x => x.LessThanOrEqual).LessThanOrEqualTo(10);
+            RuleFor(x => x.LessThan).LessThan(10);
+            RuleFor(x => x.NotEmpty).NotEmpty();
+            RuleFor(x => x.NotEqual).NotEqual("NotEqual");
+            RuleFor(x => x.Null).Null();
+            RuleFor(x => x.RegularExpression).Matches(@"^[a-z]*$");
+            RuleFor(x => x.ScalePrecision).SetValidator(new ScalePrecisionValidator(1, 1));
+        }
+    }
+
+    public class ValidatorIssues : IReturn<ValidatorIssues>
+    {
+        public DateTime ValidTo { get; set; }
+    }
+
+    public class ValidatorIssuesValidator : AbstractValidator<ValidatorIssues>
+    {
+        public ValidatorIssuesValidator()
+        {
+            RuleFor(x => x.ValidTo).GreaterThanOrEqualTo(x => DateTime.UtcNow);
+        }
+    }
+
+    public class ValidationService : Service
+    {
+        public object Any(TriggerValidators request) => request;
+        public object Any(ValidatorIssues request) => request;
+    }
+
+    public class ValidationExceptionTests
+    {
+        class AppHost : AppSelfHostBase
+        {
+            public AppHost() : base(nameof(ValidationExceptionTests), typeof(ValidationExceptionTests).GetAssembly()) { }
+
+            public override void Configure(Container container)
+            {
+                Plugins.Add(new ValidationFeature());
+
+                container.RegisterValidator(typeof(TriggerValidatorsValidtor));
+                container.RegisterValidator(typeof(ValidatorIssuesValidator));
+            }
+        }
+
+        private readonly ServiceStackHost appHost;
+        public ValidationExceptionTests()
+        {
+            appHost = new AppHost()
+                .Init()
+                .Start(Config.ListeningOn);
+        }
+
+        [OneTimeTearDown] public void OneTimeTearDown() => appHost.Dispose();
+
+        protected virtual JsonServiceClient GetClient() => new JsonServiceClient(Config.ListeningOn);
+
+        [Test]
+        public void Triggering_all_validtors_returns_right_ErrorCode()
+        {
+            var client = GetClient();
+            var request = new TriggerValidators
+            {
+                CreditCard = "NotCreditCard",
+                Email = "NotEmail",
+                Empty = "NotEmpty",
+                Equal = "NotEqual",
+                ExclusiveBetween = 1,
+                GreaterThan = 1,
+                GreaterThanOrEqual = 1,
+                InclusiveBetween = 1,
+                Length = "Length",
+                LessThan = 20,
+                LessThanOrEqual = 20,
+                NotEmpty = "",
+                NotEqual = "NotEqual",
+                Null = "NotNull",
+                RegularExpression = "FOO",
+                ScalePrecision = 123.456m
+            };
+
+            try
+            {
+                var response = client.Post(request);
+                Assert.Fail("Should throw");
+            }
+            catch (WebServiceException ex)
+            {
+                //ex.ResponseStatus.PrintDump();
+                var errors = ex.ResponseStatus.Errors;
+                Assert.That(errors.First(x => x.FieldName == "CreditCard").ErrorCode, Is.EqualTo("CreditCard"));
+                Assert.That(errors.First(x => x.FieldName == "Email").ErrorCode, Is.EqualTo("Email"));
+                Assert.That(errors.First(x => x.FieldName == "Email").ErrorCode, Is.EqualTo("Email"));
+                Assert.That(errors.First(x => x.FieldName == "Empty").ErrorCode, Is.EqualTo("Empty"));
+                Assert.That(errors.First(x => x.FieldName == "Equal").ErrorCode, Is.EqualTo("Equal"));
+                Assert.That(errors.First(x => x.FieldName == "ExclusiveBetween").ErrorCode, Is.EqualTo("ExclusiveBetween"));
+                Assert.That(errors.First(x => x.FieldName == "GreaterThan").ErrorCode, Is.EqualTo("GreaterThan"));
+                Assert.That(errors.First(x => x.FieldName == "GreaterThanOrEqual").ErrorCode, Is.EqualTo("GreaterThanOrEqual"));
+                Assert.That(errors.First(x => x.FieldName == "InclusiveBetween").ErrorCode, Is.EqualTo("InclusiveBetween"));
+                Assert.That(errors.First(x => x.FieldName == "Length").ErrorCode, Is.EqualTo("Length"));
+                Assert.That(errors.First(x => x.FieldName == "LessThan").ErrorCode, Is.EqualTo("LessThan"));
+                Assert.That(errors.First(x => x.FieldName == "LessThanOrEqual").ErrorCode, Is.EqualTo("LessThanOrEqual"));
+                Assert.That(errors.First(x => x.FieldName == "NotEmpty").ErrorCode, Is.EqualTo("NotEmpty"));
+                Assert.That(errors.First(x => x.FieldName == "NotEqual").ErrorCode, Is.EqualTo("NotEqual"));
+                Assert.That(errors.First(x => x.FieldName == "Null").ErrorCode, Is.EqualTo("Null"));
+                Assert.That(errors.First(x => x.FieldName == "RegularExpression").ErrorCode, Is.EqualTo("RegularExpression"));
+                Assert.That(errors.First(x => x.FieldName == "ScalePrecision").ErrorCode, Is.EqualTo("ScalePrecision"));
+            }
+        }
+
+        [Test]
+        public void Does_handle_reported_issues_correctly()
+        {
+            var client = GetClient();
+            var request = new ValidatorIssues
+            {
+                ValidTo = DateTime.UtcNow.AddDays(-1),
+            };
+
+            try
+            {
+                var response = client.Post(request);
+                Assert.Fail("Should throw");
+            }
+            catch (WebServiceException ex)
+            {
+                ex.ResponseStatus.PrintDump();
+                var errors = ex.ResponseStatus.Errors;
+                Assert.That(errors.First(x => x.FieldName == "ValidTo").ErrorCode, Is.EqualTo("GreaterThanOrEqual"));
+            }
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ public static class ValidationErrors`
`9`	`9`	`{`
`10`	`10`	`public const string CreditCard = "CreditCard";`
`11`	`11`	`public const string Email = "Email";`
	`12`	`+ public const string Enum = "Enum";`
	`13`	`+ public const string Empty = "Empty";`
`12`	`14`	`public const string Equal = "Equal";`
`13`	`15`	`public const string ExclusiveBetween = "ExclusiveBetween";`
`14`	`16`	`public const string GreaterThanOrEqual = "GreaterThanOrEqual";`
`@@ -20,7 +22,9 @@ public static class ValidationErrors`
`20`	`22`	`public const string NotEmpty = "NotEmpty";`
`21`	`23`	`public const string NotEqual = "NotEqual";`
`22`	`24`	`public const string NotNull = "NotNull";`
	`25`	`+ public const string Null = "Null";`
`23`	`26`	`public const string Predicate = "Predicate";`
`24`	`27`	`public const string RegularExpression = "RegularExpression";`
	`28`	`+ public const string ScalePrecision = "ScalePrecision";`
`25`	`29`	`}`
`26`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ public class EmptyValidator : PropertyValidator, IEmptyValidator {`
`25`	`25`	`readonly object defaultValueForType;`
`26`	`26`
`27`	`27`	`public EmptyValidator(object defaultValueForType) : base(nameof(Messages.empty_error), typeof(Messages)) {`
	`28`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.Empty);`
`28`	`29`	`this.defaultValueForType = defaultValueForType;`
`29`	`30`	`}`
`30`	`31`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ public class EnumValidator : PropertyValidator`
`27`	`27`	`private readonly Type enumType;`
`28`	`28`
`29`	`29`	`public EnumValidator(Type enumType) : base(nameof(Messages.enum_error), typeof(Messages)) {`
	`30`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.Enum);`
`30`	`31`	`this.enumType = enumType;`
`31`	`32`	`}`
`32`	`33`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,10 @@ public GreaterThanOrEqualValidator(IComparable value) : base(value, nameof(Messa`
`30`	`30`
`31`	`31`	`public GreaterThanOrEqualValidator(Func<object, object> valueToCompareFunc, MemberInfo member)`
`32`	`32`	`: base(valueToCompareFunc, member, nameof(Messages.greaterthanorequal_error), typeof(Messages)) {`
	`33`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.GreaterThanOrEqual);`
`33`	`34`	`}`
`34`	`35`
`35`		`- public override bool IsValid(IComparable value, IComparable valueToCompare) {`
	`36`	`+ public override bool IsValid(IComparable value, IComparable valueToCompare) {`
`36`	`37`	`if (valueToCompare == null)`
`37`	`38`	`return false;`
`38`	`39`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,10 @@ public GreaterThanValidator(IComparable value) : base(value, nameof(Messages.gre`
`31`	`31`
`32`	`32`	`public GreaterThanValidator(Func<object, object> valueToCompareFunc, MemberInfo member)`
`33`	`33`	`: base(valueToCompareFunc, member, nameof(Messages.greaterthan_error), typeof(Messages)) {`
	`34`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.GreaterThan);`
`34`	`35`	`}`
`35`	`36`
`36`		`- public override bool IsValid(IComparable value, IComparable valueToCompare) {`
	`37`	`+ public override bool IsValid(IComparable value, IComparable valueToCompare) {`
`37`	`38`	`if (valueToCompare == null)`
`38`	`39`	`return false;`
`39`	`40`
Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,10 @@ public class LengthValidator : PropertyValidator, ILengthValidator {`
`30`	`30`	`public Func<object, int> MaxFunc { get; set; }`
`31`	`31`
`32`	`32`	`public LengthValidator(int min, int max) : this(min, max, nameof(Messages.length_error), typeof(Messages)) {`
`33`		`- ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`public LengthValidator(int min, int max, string resourceName, Type resourceType) : base(resourceName, resourceType) {`
	`36`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);`
`37`	`37`	`Max = max;`
`38`	`38`	`Min = min;`
`39`	`39`
`@@ -47,6 +47,7 @@ public LengthValidator(Func<object, int> min, Func<object, int> max)`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public LengthValidator(Func<object, int> min, Func<object, int> max, string resourceName, Type resourceType) : base(resourceName, resourceType) {`
	`50`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.Length);`
`50`	`51`	`MaxFunc = max;`
`51`	`52`	`MinFunc = min;`
`52`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,10 @@ public LessThanOrEqualValidator(IComparable value)`
`36`	`36`	`public LessThanOrEqualValidator(Func<object, object> valueToCompareFunc, MemberInfo member)`
`37`	`37`	`: base(valueToCompareFunc, member, nameof(Messages.lessthanorequal_error), typeof(Messages))`
`38`	`38`	`{`
	`39`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.LessThanOrEqual);`
`39`	`40`	`}`
`40`	`41`
`41`		`- public override bool IsValid(IComparable value, IComparable valueToCompare)`
	`42`	`+ public override bool IsValid(IComparable value, IComparable valueToCompare)`
`42`	`43`	`{`
`43`	`44`	`if (valueToCompare == null)`
`44`	`45`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,10 @@ public LessThanValidator(IComparable value) : base(value, nameof(Messages.lessth`
`32`	`32`
`33`	`33`	`public LessThanValidator(Func<object, object> valueToCompareFunc, MemberInfo member)`
`34`	`34`	`: base(valueToCompareFunc, member, nameof(Messages.lessthan_error), typeof(Messages)) {`
	`35`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.LessThan);`
`35`	`36`	`}`
`36`	`37`
`37`		`- public override bool IsValid(IComparable value, IComparable valueToCompare) {`
	`38`	`+ public override bool IsValid(IComparable value, IComparable valueToCompare) {`
`38`	`39`	`if (valueToCompare == null)`
`39`	`40`	`return false;`
`40`	`41`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,10 @@ namespace ServiceStack.FluentValidation.Validators`
`22`	`22`
`23`	`23`	`public class NullValidator : PropertyValidator, INullValidator {`
`24`	`24`	`public NullValidator() : base(nameof(Messages.null_error), typeof(Messages)) {`
	`25`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.Null);`
`25`	`26`	`}`
`26`	`27`
`27`		`- protected override bool IsValid(PropertyValidatorContext context) {`
	`28`	`+ protected override bool IsValid(PropertyValidatorContext context) {`
`28`	`29`	`if (context.PropertyValue != null) {`
`29`	`30`	`return false;`
`30`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,29 +38,34 @@ public RegularExpressionValidator(string expression) : base(nameof(Messages.rege`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`public RegularExpressionValidator(Regex regex) : base(nameof(Messages.regex_error), typeof(Messages)) {`
	`41`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);`
`41`	`42`	`this.expression = regex.ToString();`
`42`	`43`	`this.regexFunc = x => regex;`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`public RegularExpressionValidator(string expression, RegexOptions options) : base(nameof(Messages.regex_error), typeof(Messages)) {`
	`47`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);`
`46`	`48`	`this.expression = expression;`
`47`	`49`	`var regex = new Regex(expression, options);`
`48`	`50`	`this.regexFunc = x => regex;`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`public RegularExpressionValidator(Func<object, string> expressionFunc)`
`52`	`54`	`: base(nameof(Messages.regex_error), typeof(Messages)) {`
	`55`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);`
`53`	`56`	`this.regexFunc = x => new Regex(expressionFunc(x));`
`54`	`57`	`}`
`55`	`58`
`56`	`59`	`public RegularExpressionValidator(Func<object, Regex> regexFunc)`
`57`	`60`	`: base(nameof(Messages.regex_error), typeof(Messages)) {`
	`61`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);`
`58`	`62`	`this.regexFunc = regexFunc;`
`59`	`63`	`}`
`60`	`64`
`61`	`65`	`public RegularExpressionValidator(Func<object, string> expression, RegexOptions options)`
`62`	`66`	`: base(nameof(Messages.regex_error), typeof(Messages)) {`
`63`	`67`
	`68`	`+ ErrorCodeSource = new StaticStringSource(ValidationErrors.RegularExpression);`
`64`	`69`	`this.regexFunc = x => new Regex(expression(x), options);`
`65`	`70`	`}`
`66`	`71`