dualfroz
e9c920f846
RangeValidator's constructor guarded against an inverted range with
comparer.Compare(to, from) == -1. The IComparer<T>/IComparable<T> contract
only guarantees the sign of the result, not the magnitude, so the guard
silently failed for comparers returning other negatives, e.g. char.CompareTo
('a'.CompareTo('c') == -2) or custom comparers that return x - y. This let
InclusiveBetween('c', 'a') build a validator that can never pass instead of
throwing, unlike the int case which happens to return -1.
Compare against < 0 to honor the comparer contract. Add char-bound throw
tests to the inclusive and exclusive between suites.
201 lines
8.3 KiB
C#
201 lines
8.3 KiB
C#
#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_to_is_smaller_than_the_from_then_the_validator_should_throw_for_chars() {
|
|
// char.CompareTo returns the difference ('a' vs 'c' is -2), not just -1.
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => RangeValidatorFactory.CreateExclusiveBetween<Person, char>('c', 'a'));
|
|
}
|
|
|
|
[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();
|
|
}
|
|
}
|