public void Should_be_valid_when_values_are_equal_using_instance_property()
{
var validator = new EqualValidator<Person, int>(p => p.Age);
var person = new Person {Age = 15};
Assert.That(validator.Validate(person, 15), Is.True);
}
public void DefaultErrorMessage_EqualValidator()
{
var validator = new EqualValidator(null);
Assert.That(validator.ErrorMessageSource, Is.TypeOf(typeof(LocalizedStringSource)));
Assert.That(validator.ErrorMessageSource.GetString(), Is.EqualTo(Messages.equal_error));
}
public void Has_default_negated_message()
{
var validator = new EqualValidator<Person, int>(10);
var message = validator.DefaultNegatedErrorMessage;
Console.WriteLine(message);
Assert.That(message, Is.Not.Null & Is.Not.Empty);
}
public void Given_CorrectBuildInValidatorWithDifferentValueToCompare_When_Verifying_Then_ValidationFail()
{
// Arrange
var comparisonValidator = new EqualValidator(10);
var verifier = new ComparisonValidatorVerifier <EqualValidator>(15);
// Act & Assert
AssertExtension.Throws <XunitException>(() => verifier.Verify(comparisonValidator), "(ValueToCompare property)");
}
public void Given_CorrectValidatorWithSameValueAndBuildInValidator_When_Verifying_Then_ValidationPass()
{
// Arrange
var comparisonValidator = new EqualValidator(15);
var verifier = new ComparisonValidatorVerifier <EqualValidator>(15);
// Act & Assert
AssertExtension.NotThrows(() => verifier.Verify(comparisonValidator));
}
public void Has_default_negated_message()
{
var validator = new EqualValidator <Person, int>(10);
var message = validator.DefaultNegatedErrorMessage;
Console.WriteLine(message);
Assert.That(message, Is.Not.Null & Is.Not.Empty);
}
public void Should_validate_property_value_without_instance_different_types() {
var validator = new EqualValidator(100M); // decimal
var parentContext = new ValidationContext(null);
var rule = new PropertyRule(null, x => 100D /* double */, null, null, typeof(string), null) {
PropertyName = "Surname"
};
var context = new PropertyValidatorContext(parentContext, rule, null);
var result = validator.Validate(context); // would fail saying that decimal is not double
result.Count().ShouldEqual(0);
}
public void Should_be_invalid_when_values_are_not_equal_using_instance_property()
{
var validator = new EqualValidator <Person, int>(p => p.Age);
var person = new Person {
Age = 15
};
Assert.That(validator.Validate(person, 51), Is.False);
}
public void Should_create_equaladapter_for_equalvalidator()
{
// Given
var validator = new EqualValidator(10);
// When
var result = factory.Create(this.rule, validator);
// Then
result.ShouldBeOfType<EqualAdapter>();
}
public void Should_create_equaladapter_for_equalvalidator()
{
// Given
var validator = new EqualValidator(10);
// When
var result = factory.Create(this.rule, validator);
// Then
result.ShouldBeOfType <EqualAdapter>();
}
private ValidationMessage Equal <TProp>(
TProp value,
TProp valueToCompare,
IEqualityComparer comparer = null,
ValidationMessageType validationMessageType = ValidationMessageType.Error)
{
var equalValidator = new EqualValidator <TestValidatableObject, TProp>(_ => valueToCompare, comparer, validationMessageType);
var context = new ValidationContext <TestValidatableObject, TProp>(null, nameof(TestValidatableObject.Number), null, value);
var validationMessage = equalValidator.ValidateProperty(context).FirstOrDefault();
return(validationMessage);
}
public void Should_validate_property_value_without_instance_different_types()
{
var validator = new EqualValidator(100M); // decimal
var parentContext = new ValidationContext(null);
var rule = new PropertyRule(null, x => 100D /* double */, null, null, typeof(string), null)
{
PropertyName = "Surname"
};
var context = new PropertyValidatorContext(parentContext, rule, null);
var result = validator.Validate(context); // would fail saying that decimal is not double
result.Count().ShouldEqual(0);
}
public void Format_IComparisonValidators()
{
var validator1 = new EqualValidator(5);
var validator2 = new NotEqualValidator(10);
var validator3 = new GreaterThanValidator(8);
var validator4 = new GreaterThanOrEqualValidator(7);
var validator5 = new LessThanValidator(2);
var validator6 = new LessThanOrEqualValidator(1);
var validator7 = new EqualValidator(o => o, typeof(Customer).GetProperty("UserName"));
Assert.That(_formatter.Format(validator1, _typeNameFormatter), Is.EqualTo("EqualValidator { ValueToCompare = '5' }"));
Assert.That(_formatter.Format(validator2, _typeNameFormatter), Is.EqualTo("NotEqualValidator { ValueToCompare = '10' }"));
Assert.That(_formatter.Format(validator3, _typeNameFormatter), Is.EqualTo("GreaterThanValidator { ValueToCompare = '8' }"));
Assert.That(_formatter.Format(validator4, _typeNameFormatter), Is.EqualTo("GreaterThanOrEqualValidator { ValueToCompare = '7' }"));
Assert.That(_formatter.Format(validator5, _typeNameFormatter), Is.EqualTo("LessThanValidator { ValueToCompare = '2' }"));
Assert.That(_formatter.Format(validator6, _typeNameFormatter), Is.EqualTo("LessThanOrEqualValidator { ValueToCompare = '1' }"));
Assert.That(_formatter.Format(validator7, _typeNameFormatter), Is.EqualTo("EqualValidator { MemberToCompare = 'Customer.UserName\r\n' }"));
}
public void AddValidation_adds_confirmed_rule()
{
// Arrange
var property = PropertyRule.Create <TestObject, string>(x => x.Property);
var otherProperty = PropertyRule.Create <TestObject, string>(x => x.OtherProperty);
var validator = new EqualValidator(otherProperty.PropertyFunc, otherProperty.Member);
var adapter = new EqualClientValidator(property, validator);
var context = new ClientModelValidationContextBuilder()
.WithModelType <string>()
.Build();
// Act
adapter.AddValidation(context);
// Assert
context.Attributes.Keys.ShouldContain("v-validate");
context.Attributes["v-validate"].ShouldBe("{confirmed:'OtherProperty'}");
}
private string GetErrorMessage(EqualValidator equalValidator, ClientModelValidationContext context)
{
var formatter = FluentValidation.ValidatorOptions.MessageFormatterFactory()
.AppendPropertyName(Rule.GetDisplayName())
.AppendArgument("ComparisonValue", equalValidator.ValueToCompare);
string messageTemplate;
try
{
messageTemplate = equalValidator.Options.ErrorMessageSource.GetString(null);
}
catch (FluentValidationMessageFormatException)
{
messageTemplate = FluentValidation.ValidatorOptions.LanguageManager.GetStringForValidator <EqualValidator>();
}
string message = formatter.BuildMessage(messageTemplate);
return(message);
}
public void Should_be_invalid_when_values_are_not_equal()
{
var validator = new EqualValidator<Person, int>(15);
Assert.That(validator.Validate(null, 51), Is.False);
}
public void Should_be_valid_when_values_are_equal()
{
var validator = new EqualValidator<Person, int>(15);
Assert.That(validator.Validate(null, 15), Is.True);
}
public void Should_be_invalid_when_values_are_not_equal()
{
var validator = new EqualValidator <Person, int>(15);
Assert.That(validator.Validate(null, 51), Is.False);
}
public void Should_be_valid_when_values_are_equal()
{
var validator = new EqualValidator <Person, int>(15);
Assert.That(validator.Validate(null, 15), Is.True);
}
