dualfroz/FluentValidation-FluentValidation
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upstream FluentValidation/FluentValidation state of the touched files before 00e7987e97

Browse Source
This commit is contained in:
upstream committed 2026-09-02 10:59:11 +02:00
commit cbfaed6ee6
3 files changed
+461
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/FluentValidation.Tests/ExclusiveBetweenValidatorTests.cs
+194
View File
@@ -0,0 +1,194 @@
#region License
// Copyright (c) .NET Foundation and contributors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// The latest version of this file can be found at https://github.com/FluentValidation/FluentValidation
#endregion
namespace FluentValidation.Tests;
using System;
using System.Linq;
using Xunit;
using Validators;
public class ExclusiveBetweenValidatorTests {
DateTime _fromDate;
DateTime _toDate;
public ExclusiveBetweenValidatorTests() {
CultureScope.SetDefaultCulture();
_fromDate = new DateTime(2009, 1, 1);
_toDate = new DateTime(2009, 12, 31);
}
[Fact]
public void When_the_value_is_between_the_range_specified_then_the_validator_should_pass() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 5 });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_then_the_validator_should_fail() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 0 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_text_is_larger_than_the_range_then_the_validator_should_fail() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 11 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_upper_bound_then_the_validator_should_fail() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 10 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_lower_bound_then_the_validator_should_fail() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 1 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_to_is_smaller_than_the_from_then_the_validator_should_throw() {
Assert.Throws<ArgumentOutOfRangeException>(() => new TestValidator{v => v.RuleFor(x => x.Id).ExclusiveBetween(10, 1)});
}
[Fact]
public void When_the_validator_fails_the_error_message_should_be_set() {
var validator = new TestValidator { v => v.RuleFor(x => x.Id).ExclusiveBetween(1, 10) };
var result = validator.Validate(new Person { Id = 0 });
result.Errors.Single().ErrorMessage.ShouldEqual("'Id' must be between 1 and 10 (exclusive). You entered 0.");
}
[Fact]
public void To_and_from_properties_should_be_set() {
var propertyValidator = RangeValidatorFactory.CreateExclusiveBetween<Person, int>(1, 10);
propertyValidator.From.ShouldEqual(1);
propertyValidator.To.ShouldEqual(10);
}
[Fact]
public void When_the_value_is_between_the_range_specified_then_the_validator_should_pass_for_strings() {
var validator = new TestValidator { v => v.RuleFor(x => x.Surname).ExclusiveBetween("aa", "zz") };
var result = validator.Validate(new Person { Surname = "bbb" });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator { v => v.RuleFor(x => x.Surname).ExclusiveBetween("bbb", "zz") };
var result = validator.Validate(new Person { Surname = "aaa" });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_text_is_larger_than_the_range_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).ExclusiveBetween("aaa", "bbb"));
var result = validator.Validate(new Person {Surname = "zzz"});
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_upper_bound_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).ExclusiveBetween("aa", "zz"));
var result = validator.Validate(new Person { Surname = "aa" });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_lower_bound_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).ExclusiveBetween("aa", "zz"));
var result = validator.Validate(new Person { Surname = "zz" });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_to_is_smaller_than_the_from_then_the_validator_should_throw_for_strings() {
Assert.Throws<ArgumentOutOfRangeException>(() => RangeValidatorFactory.CreateExclusiveBetween<Person, string>("ccc", "aaa"));
}
[Fact]
public void When_the_validator_fails_the_error_message_should_be_set_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).ExclusiveBetween("bbb", "zzz"));
var result = validator.Validate(new Person { Surname = "aaa" });
result.Errors.Single().ErrorMessage.ShouldEqual("'Surname' must be between bbb and zzz (exclusive). You entered aaa.");
}
[Fact]
public void To_and_from_properties_should_be_set_for_strings() {
var validator = RangeValidatorFactory.CreateExclusiveBetween<Person,string>("a", "c");
validator.From.ShouldEqual("a");
validator.To.ShouldEqual("c");
}
[Fact]
public void To_and_from_properties_should_be_set_for_dates() {
var validator = RangeValidatorFactory.CreateExclusiveBetween<Person, DateTime>(_fromDate, _toDate);
validator.From.ShouldEqual(_fromDate);
validator.To.ShouldEqual(_toDate);
}
[Fact]
public void Validates_with_nullable_when_property_is_null() {
var validator = new TestValidator(v => v.RuleFor(x => x.NullableInt).ExclusiveBetween(1, 5));
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
[Fact]
public void Validates_with_nullable_when_property_not_null() {
var validator = new TestValidator(v => v.RuleFor(x => x.NullableInt).ExclusiveBetween(1, 5));
var result = validator.Validate(new Person { NullableInt = 10 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_between_the_range_specified_by_icomparer_then_the_validator_should_pass() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).ExclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "5 Main St." } });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_by_icomparer_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).ExclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "1 Main St." } });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_larger_than_the_range_by_icomparer_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).ExclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "11 Main St." } });
result.IsValid.ShouldBeFalse();
}
}
src/FluentValidation.Tests/InclusiveBetweenValidatorTests.cs
+183
View File
@@ -0,0 +1,183 @@
#region License
// Copyright (c) .NET Foundation and contributors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// The latest version of this file can be found at https://github.com/FluentValidation/FluentValidation
#endregion
namespace FluentValidation.Tests;
using System;
using System.Linq;
using Xunit;
using Validators;
public class InclusiveBetweenValidatorTests {
public InclusiveBetweenValidatorTests() {
CultureScope.SetDefaultCulture();
}
[Fact]
public void When_the_value_is_between_the_range_specified_then_the_validator_should_pass() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person { Id = 5 });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person { Id = 0 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_text_is_larger_than_the_range_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person() { Id = 11 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_upper_bound_then_the_validator_should_pass() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person { Id = 10 });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_lower_bound_then_the_validator_should_pass() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person { Id = 1 });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_to_is_smaller_than_the_from_then_the_validator_should_throw() {
Assert.Throws<ArgumentOutOfRangeException>(() => new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(10, 1)));
}
[Fact]
public void When_the_validator_fails_the_error_message_should_be_set() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).InclusiveBetween(1, 10));
var result = validator.Validate(new Person { Id = 0 });
result.Errors.Single().ErrorMessage.ShouldEqual("'Id' must be between 1 and 10. You entered 0.");
}
[Fact]
public void To_and_from_properties_should_be_set() {
var validator = RangeValidatorFactory.CreateInclusiveBetween<Person ,int>(1, 10);
validator.From.ShouldEqual(1);
validator.To.ShouldEqual(10);
}
[Fact]
public void When_the_value_is_between_the_range_specified_then_the_validator_should_pass_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("aa", "zz"));
var result = validator.Validate(new Person { Surname = "bbb" });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("bbb", "zz"));
var result = validator.Validate(new Person { Surname = "aaa" });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_text_is_larger_than_the_range_then_the_validator_should_fail_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("aaa", "bbb"));
var result = validator.Validate(new Person { Surname = "zzz" });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_upper_bound_then_the_validator_should_pass_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("aa", "zz"));
var result = validator.Validate(new Person { Surname = "aa" });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_exactly_the_size_of_the_lower_bound_then_the_validator_should_pass_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("aa", "zz"));
var result = validator.Validate(new Person { Surname = "zz" });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_to_is_smaller_than_the_from_then_the_validator_should_throw_for_strings() {
Assert.Throws<ArgumentOutOfRangeException>(() => RangeValidatorFactory.CreateInclusiveBetween<Person, string>("ccc", "aaa"));
}
[Fact]
public void When_the_validator_fails_the_error_message_should_be_set_for_strings() {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).InclusiveBetween("bbb", "zzz"));
var result = validator.Validate(new Person { Surname = "aaa" });
result.Errors.Single().ErrorMessage.ShouldEqual("'Surname' must be between bbb and zzz. You entered aaa.");
}
[Fact]
public void To_and_from_properties_should_be_set_for_strings() {
var validator = RangeValidatorFactory.CreateInclusiveBetween<Person, string>("a", "c");
validator.From.ShouldEqual("a");
validator.To.ShouldEqual("c");
}
[Fact]
public void Validates_with_nullable_when_property_is_null() {
var validator = new TestValidator(v => v.RuleFor(x => x.NullableInt).InclusiveBetween(1, 5));
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
[Fact]
public void Validates_with_nullable_when_property_not_null() {
var validator = new TestValidator(v => v.RuleFor(x => x.NullableInt).InclusiveBetween(1, 5));
var result = validator.Validate(new Person { NullableInt = 10 });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_between_the_range_specified_by_icomparer_then_the_validator_should_pass() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).InclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer
()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "5 Main St." } });
result.IsValid.ShouldBeTrue();
}
[Fact]
public void When_the_value_is_smaller_than_the_range_by_icomparer_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).InclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "1 Main St." } });
result.IsValid.ShouldBeFalse();
}
[Fact]
public void When_the_value_is_larger_than_the_range_by_icomparer_then_the_validator_should_fail() {
var validator = new TestValidator(v => v.RuleFor(x => x.Address).InclusiveBetween(
new Address() { Line1 = "3 Main St." },
new Address() { Line1 = "10 Main St." },
new StreetNumberComparer()));
var result = validator.Validate(new Person { Address = new Address() { Line1 = "11 Main St." } });
result.IsValid.ShouldBeFalse();
}
}
src/FluentValidation/Validators/RangeValidator.cs
+84
View File
@@ -0,0 +1,84 @@
#region License
// Copyright (c) .NET Foundation and contributors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// The latest version of this file can be found at https://github.com/FluentValidation/FluentValidation
#endregion
namespace FluentValidation.Validators;
using System;
using System.Collections.Generic;
/// <summary>
/// Base class for range validation.
/// </summary>
public abstract class RangeValidator<T, TProperty> : PropertyValidator<T, TProperty>, IBetweenValidator {
readonly IComparer<TProperty> _explicitComparer;
public RangeValidator(TProperty from, TProperty to, IComparer<TProperty> comparer) {
To = to;
From = from;
_explicitComparer = comparer;
if (comparer.Compare(to, from) == -1) {
throw new ArgumentOutOfRangeException(nameof(to), "To should be larger than from.");
}
}
public TProperty From { get; }
public TProperty To { get; }
object IBetweenValidator.From => From;
object IBetweenValidator.To => To;
protected abstract bool HasError(TProperty value);
public override bool IsValid(ValidationContext<T> context, TProperty value) {
// If the value is null then we abort and assume success.
// This should not be a failure condition - only a NotNull/NotEmpty should cause a null to fail.
if (value == null) return true;
if (HasError(value)) {
context.MessageFormatter
.AppendArgument("From", From)
.AppendArgument("To", To);
return false;
}
return true;
}
protected int Compare(TProperty a, TProperty b) {
return _explicitComparer.Compare(a, b);
}
protected override string GetDefaultMessageTemplate(string errorCode) {
return Localized(errorCode, Name);
}
}
public static class RangeValidatorFactory {
public static ExclusiveBetweenValidator<T, TProperty> CreateExclusiveBetween<T,TProperty>(TProperty from, TProperty to)
where TProperty : IComparable<TProperty>, IComparable =>
new ExclusiveBetweenValidator<T, TProperty>(from, to, ComparableComparer<TProperty>.Instance);
public static InclusiveBetweenValidator<T, TProperty> CreateInclusiveBetween<T,TProperty>(TProperty from, TProperty to)
where TProperty : IComparable<TProperty>, IComparable {
return new InclusiveBetweenValidator<T, TProperty>(from, to, ComparableComparer<TProperty>.Instance);
}
}