/// <summary>
/// If applicable, validators for non-empty, maximum length and input format are created.
/// </summary>
/// <param name="isReadOnly">
/// This flag is initialized with the value of <see cref="BusinessObjectBoundEditableWebControl.IsReadOnly"/>.
/// Implemantations should consider whether they require a validator also when the control is rendered as read-only.
/// </param>
/// <returns>An enumeration of all applicable validators.</returns>
/// <remarks>
/// <list type="bullet">
/// <item>
/// If the control requires input, a <see cref="RequiredFieldValidator"/> is generated.
/// </item>
/// <item>
/// If a maximum length is specified, a <see cref="LengthValidator"/> is generated.
/// </item>
/// <item>
/// If the <see cref="ActualValueType"/> is set to <see cref="BocTextValueType.DateTime"/>,
/// a <see cref="DateTimeValidator"/> is generated.
/// </item>
/// <item>
/// If the <see cref="ActualValueType"/> is set to <see cref="BocTextValueType.Date"/>
/// a <see cref="CompareValidator"/> is generated.
/// </item>
/// <item>
/// If the <see cref="ActualValueType"/> is set to one of the numeric types (such as <see cref="BocTextValueType.Int32"/> or
/// <see cref="BocTextValueType.Double"/>) a <see cref="NumericValidator"/> is generated.
/// </item>
/// </list>
/// </remarks>
/// <seealso cref="BusinessObjectBoundEditableWebControl.CreateValidators()">BusinessObjectBoundEditableWebControl.CreateValidators()</seealso>
protected override IEnumerable <BaseValidator> CreateValidators(bool isReadOnly)
{
IResourceManager resourceManager = GetResourceManager();
_requiredFieldValidator = null;
_lengthValidator = null;
_typeValidator = null;
if (isReadOnly)
{
yield break;
}
if (IsRequired)
{
_requiredFieldValidator = CreateRequiredFieldValidator(resourceManager);
yield return(_requiredFieldValidator);
}
if (TextBoxStyle.MaxLength.HasValue)
{
_lengthValidator = CreateLengthValidator(resourceManager);
yield return(_lengthValidator);
}
_typeValidator = CreateTypeValidator(resourceManager);
if (_typeValidator != null)
{
yield return(_typeValidator);
}
}
public void IsValidMinLengthMustReturnTrueWhenTheSpecifiedValueLenghtIsBigger()
{
LengthValidator lengthValidator = new LengthValidator(1);
Assert.IsTrue(lengthValidator.IsValid("1"));
Assert.IsTrue(lengthValidator.IsValid("123"));
}
private string GetErrorMessage(LengthValidator lengthVal, ClientModelValidationContext context)
{
var cfg = context.ActionContext.HttpContext.RequestServices.GetValidatorConfiguration();
var formatter = cfg.MessageFormatterFactory()
.AppendPropertyName(Rule.GetDisplayName(null))
.AppendArgument("MinLength", lengthVal.Min)
.AppendArgument("MaxLength", lengthVal.Max);
string message;
try {
message = lengthVal.Options.GetErrorMessageTemplate(null);
}
catch (FluentValidationMessageFormatException) {
message = cfg.LanguageManager.GetString("MinimumLength_Simple");
}
catch (NullReferenceException) {
message = cfg.LanguageManager.GetString("MinimumLength_Simple");
}
if (message.Contains("{TotalLength}"))
{
message = cfg.LanguageManager.GetString("MinimumLength_Simple");
}
message = formatter.BuildMessage(message);
return(message);
}
public void Min_and_max_properties_should_be_set()
{
var validator = new LengthValidator(1, 5);
validator.Min.ShouldEqual(1);
validator.Max.ShouldEqual(5);
}
public void Should_be_valid_when_length_is_between_values_using_instance_property()
{
var validator = new LengthValidator<Person>(p => p.Name.Length, p => p.Age);
var person = new Person {Name = "Bob", Age = 8};
Assert.That(validator.Validate(person, "ABCDE"), Is.True);
}
public void When_the_text_is_exactly_the_size_of_the_upper_bound_then_the_validator_should_pass()
{
string text = "Test";
var validator = new LengthValidator(1, 4);
var result = validator.Validate(new PropertyValidatorContext(null, new object(), x => text));
result.IsValid().ShouldBeTrue();
}
public void ShouldReturnTrueForObject()
{
LengthValidatableObjectTrue testValidatableObject = new LengthValidatableObjectTrue();
Validator lengthValidator = new LengthValidator(testValidatableObject, 25);
Assert.IsTrue(lengthValidator.Validate());
}
public void ShouldReturnFalseForObject()
{
object testObject = new object();
Validator lengthValidator = new LengthValidator(testObject, 5);
Assert.IsFalse(lengthValidator.Validate());
}
public void ShouldReturnFalseForDecimalValue()
{
testValueDecimal = 1.0M;
Validator lengthValidator = new LengthValidator(testValueDecimal, controlLength);
Assert.IsFalse(lengthValidator.Validate());
}
public void ShouldReturnFalseForStringValue()
{
testValueString = "Length less than 20!!!!";
Validator lengthValidator = new LengthValidator(testValueString, controlLengthString);
Assert.IsFalse(lengthValidator.Validate());
}
public void ShouldReturnFalseForIntValue()
{
testValueInt = 11;
Validator lengthValidator = new LengthValidator(testValueInt, controlLength);
Assert.IsFalse(lengthValidator.Validate());
}
public void ShouldReturnFalseForDoubleValue()
{
testValueDouble = 10.1F;
Validator lengthValidator = new LengthValidator(testValueDouble, controlLength);
Assert.IsFalse(lengthValidator.Validate());
}
public void ShouldReturnFalseForValidatableObject()
{
LengthValidatableObjectFalse testValidatableObject = new LengthValidatableObjectFalse();
Validator lengthValidator = new LengthValidator(testValidatableObject, 5);
Assert.IsFalse(lengthValidator.Validate());
}
public void When_the_text_is_between_the_range_specified_then_the_validator_should_pass()
{
string text = "Test";
var validator = new LengthValidator(1, 10);
var result = validator.Validate(new PropertyValidatorContext(null, new object(), x => text));
result.IsValid().ShouldBeTrue();
}
private string GetErrorMessage(LengthValidator lengthVal, ClientModelValidationContext context)
{
var formatter = new MessageFormatter()
.AppendPropertyName(Rule.GetDisplayName())
.AppendArgument("MinLength", lengthVal.Min)
.AppendArgument("MaxLength", lengthVal.Max);
bool messageNeedsSplitting = lengthVal.ErrorMessageSource.ResourceType == typeof(LanguageManager);
string message;
try {
message = lengthVal.ErrorMessageSource.GetString(null);
} catch (FluentValidationMessageFormatException) {
message = ValidatorOptions.LanguageManager.GetStringForValidator <MaximumLengthValidator>();
messageNeedsSplitting = true;
}
if (messageNeedsSplitting)
{
// If we're using the default resources then the mesage for length errors will have two parts, eg:
// '{PropertyName}' must be between {MinLength} and {MaxLength} characters. You entered {TotalLength} characters.
// We can't include the "TotalLength" part of the message because this information isn't available at the time the message is constructed.
// Instead, we'll just strip this off by finding the index of the period that separates the two parts of the message.
message = message.Substring(0, message.IndexOf(".") + 1);
}
message = formatter.BuildMessage(message);
return(message);
}
private string GetErrorMessage(LengthValidator lengthVal, ClientModelValidationContext context)
{
var formatter = ValidatorOptions.MessageFormatterFactory()
.AppendPropertyName(Rule.GetDisplayName())
.AppendArgument("MinLength", lengthVal.Min)
.AppendArgument("MaxLength", lengthVal.Max);
bool needsSimifiedMessage = lengthVal.Options.ErrorMessageSource is LanguageStringSource;
string message;
try {
message = lengthVal.Options.ErrorMessageSource.GetString(null);
} catch (FluentValidationMessageFormatException) {
message = ValidatorOptions.LanguageManager.GetString("MinimumLength_Simple");
needsSimifiedMessage = false;
}
if (needsSimifiedMessage && message.Contains("{TotalLength}"))
{
message = ValidatorOptions.LanguageManager.GetString("MinimumLength_Simple");
}
message = formatter.BuildMessage(message);
return(message);
}
public Length(int minLength, int maxLength)
{
validator = new LengthValidator()
{
Max = maxLength, Min = minLength
};
}
public Length(int exactLength)
{
validator = new LengthValidator()
{
Max = exactLength, Min = exactLength
};
}
public void IsValidMaxLengthMustReturnFalseWhenTheSpecifiedValueLenghtIsBigger()
{
LengthValidator lengthValidator = LengthValidator.CreateMaxLengthValidator(1);
Assert.IsFalse(lengthValidator.IsValid("12"));
Assert.IsFalse(lengthValidator.IsValid("1234"));
}
public void Should_be_invalid_when_length_is_lower_than_min_value_using_instance_property()
{
var validator = new LengthValidator<Person>(p => p.Name.Length, p => p.Age);
var person = new Person { Name = "Bob", Age = 8 };
Assert.That(validator.Validate(person, "AB"), Is.False);
}
public void DefaultErrorMessage_MaxLengthValidator()
{
var validator = new LengthValidator(1, 3);
Assert.That(validator.ErrorMessageSource, Is.TypeOf(typeof(LocalizedStringSource)));
Assert.That(validator.ErrorMessageSource.GetString(), Is.EqualTo(Messages.length_error));
}
public void TestDefaultErrorMessage()
{
var validator = new LengthValidator(2, 10);
Assert.AreEqual("length is invalid", validator.DefaultErrorMessage);
validator = new LengthValidator(5);
Assert.AreEqual("length is invalid", validator.DefaultErrorMessage);
}
public void Has_default_negated_message()
{
var validator = new LengthValidator<Person>(5, 10);
var message = validator.DefaultNegatedErrorMessage;
Console.WriteLine(message);
Assert.That(message, Is.Not.Null & Is.Not.Empty);
}
public void IsValidBetweenLengthMustReturnFalseWhenTheSpecifiedValueLenghtIsOutsideTheBoundaries()
{
LengthValidator lengthValidator = new LengthValidator(2, 4);
Assert.IsFalse(lengthValidator.IsValid(string.Empty));
Assert.IsFalse(lengthValidator.IsValid("1"));
Assert.IsFalse(lengthValidator.IsValid("12345"));
}
public void IsValidBetweenLengthMustReturnTrueWhenTheSpecifiedValueLenghtIsOutsideTheBoundaries()
{
LengthValidator lengthValidator = new LengthValidator(1, 5);
Assert.IsTrue(lengthValidator.IsValid("1"));
Assert.IsTrue(lengthValidator.IsValid("123"));
Assert.IsTrue(lengthValidator.IsValid("12345"));
}
public void IsValidMinLengthMustReturnFalseWhenTheSpecifiedValueLenghtIsSmaller()
{
LengthValidator lengthValidator = new LengthValidator(5);
Assert.IsFalse(lengthValidator.IsValid(string.Empty));
Assert.IsFalse(lengthValidator.IsValid("1"));
Assert.IsFalse(lengthValidator.IsValid("1234"));
}
public void IsValidMaxLengthMustReturnTrueWhenTheSpecifiedValueLenghtIsSmaller()
{
LengthValidator lengthValidator = LengthValidator.CreateMaxLengthValidator(3);
Assert.IsTrue(lengthValidator.IsValid("1"));
Assert.IsTrue(lengthValidator.IsValid("123"));
Assert.IsTrue(lengthValidator.IsValid(string.Empty));
}
/// <summary>
/// Adds a max length validator to the rule builder.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <param name="ruleBuilder">The rule builder.</param>
/// <param name="max">The maximum.</param>
/// <returns>Rule builder.</returns>
public static IEntityValidationRuleBuilder <TEntity, string> MaxLength <TEntity>(this IEntityValidationRuleBuilderInitial <TEntity, string> ruleBuilder, int max)
{
if (ruleBuilder == null)
{
throw new ArgumentNullException("ruleBuilder");
}
return(ruleBuilder.AddValidator(new EntityPropertyValidator(LengthValidator.CreateMaxLengthValidator(max))));
}
public void GivenNoLength_Validate_ReturnsFalse()
{
var message = new TestFixMessageBuilder(TestFixMessageBuilder.DefaultBody).AddLength("3").Build();
var uut = new LengthValidator(IntegerToFixConverter.Instance);
var msgContext = new FixMessageContext().Setup(message);
var result = uut.IsValid(message.AsSpan(), msgContext);
Assert.False(result);
}
public void GivenCorrectLength_Validate_ReturnsTrue(string input)
{
byte[] message = new TestFixMessageBuilder(input).Build();
var uut = new LengthValidator(IntegerToFixConverter.Instance);
var msgContext = new FixMessageContext().Setup(message);
var result = uut.IsValid(message.AsSpan(), msgContext);
Assert.True(result);
}
public void Has_default_negated_message()
{
var validator = new LengthValidator <Person>(5, 10);
var message = validator.DefaultNegatedErrorMessage;
Console.WriteLine(message);
Assert.That(message, Is.Not.Null & Is.Not.Empty);
}
public void Given_AnyValidator_When_Verifying_Then_ValidationMustPass()
{
// Arrange
var lengthValidator = new LengthValidator(1, 10);
var verifier = new PlaceholderVerifier();
// Act & Assert
AssertExtension.NotThrows(() => verifier.Verify(lengthValidator));
}
public void TestValidate_NullDomainObjectArg()
{
var presenceValidator = new PresenceValidator();
var lengthValidator = new LengthValidator(2, 10);
var nameProperty = typeof(Customer).GetProperty("Name");
string error;
Assert.Throws<ArgumentNullException>(() => presenceValidator.Validate<Customer>(null, nameProperty, out error));
Assert.Throws<ArgumentNullException>(() => lengthValidator.Validate<Customer>(null, nameProperty, out error));
}
public void Should_be_valid_when_length_is_equal_to_min_value_using_instance_property()
{
var validator = new LengthValidator <Person>(p => p.Name.Length, p => p.Age);
var person = new Person {
Name = "Bob", Age = 8
};
Assert.That(validator.Validate(person, "ABC"), Is.True);
}
public void Should_be_invalid_when_length_is_higher_than_max_value_using_instance_property()
{
var validator = new LengthValidator <Person>(p => p.Name.Length, p => p.Age);
var person = new Person {
Name = "Bob", Age = 8
};
Assert.That(validator.Validate(person, "ABCDEFGHIJ"), Is.False);
}
public void TestValidate_NotExistingProperty()
{
var presenceValidator = new PresenceValidator();
var lengthValidator = new LengthValidator(2, 10);
var account = new Account();
var ageProperty = typeof(Customer).GetProperty("Age");
string error;
Assert.Throws<MissingMemberException>(() => presenceValidator.Validate(account, ageProperty, out error));
Assert.Throws<MissingMemberException>(() => lengthValidator.Validate(account, ageProperty, out error));
}
public void Validate_WithSingleLengthValidator_Correctly()
{
//Arrange
IValueValidator <string> validator = new LengthValidator(5);
//Act
bool valid = validator.IsValid("hello");
//Assert
Assert.True(valid);
}
public void Should_create_lengthadapter_for_lengthvalidator()
{
// Given
var validator = new LengthValidator(1, 10);
// When
var result = factory.Create(this.rule, validator);
// Then
result.ShouldBeOfType <LengthAdapter>();
}
public void TestValidate_Indexer()
{
var presenceValidator = new PresenceValidator();
var lengthValidator = new LengthValidator(2, 10);
var account = new Account();
string error;
var indexerProperty = typeof(Account).GetProperty("Item");
Assert.Throws<NotSupportedException>(() => presenceValidator.Validate(account, indexerProperty, out error));
Assert.Throws<NotSupportedException>(() => lengthValidator.Validate(account, indexerProperty, out error));
}
public void Init()
{
Thread.CurrentThread.CurrentCulture =
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
validator1 = new LengthValidator(5);
validator1.Initialize(new CachedValidationRegistry(), typeof(TestTarget).GetProperty("TargetField"));
validator2 = new LengthValidator(4, 6);
validator2.Initialize(new CachedValidationRegistry(), typeof(TestTarget).GetProperty("TargetField"));
target = new TestTarget();
}
public void IsValid()
{
LengthValidator v = new LengthValidator();
v.Initialize(new LengthAttribute(5));
Assert.IsTrue(v.IsValid("12", null));
Assert.IsTrue(v.IsValid(null, null));
Assert.IsTrue(v.IsValid("12345", null));
Assert.IsFalse(v.IsValid("123456", null));
Assert.IsFalse(v.IsValid(11, null));
v.Initialize(new LengthAttribute(3, 6));
Assert.IsTrue(v.IsValid("123", null));
Assert.IsTrue(v.IsValid("123456", null));
Assert.IsFalse(v.IsValid("12", null));
Assert.IsFalse(v.IsValid("1234567", null));
}
public void TestValidate_String()
{
string error;
var accountNumberProperty = typeof(Account).GetProperty("Number");
var validator = new LengthValidator(6, 20);
var account = new Account { Number = UnitTestHelper.ACCOUNT_NUMBER };
Assert.IsTrue(validator.Validate(account, accountNumberProperty, out error));
Assert.IsNull(error);
account.Number = "A12345";
Assert.IsTrue(validator.Validate(account, accountNumberProperty, out error));
Assert.IsNull(error);
account.Number = "A0000000000";
Assert.IsTrue(validator.Validate(account, accountNumberProperty, out error));
Assert.IsNull(error);
account.Number = "12345678901234567890";
Assert.IsTrue(validator.Validate(account, accountNumberProperty, out error));
Assert.IsNull(error);
var customerNameProperty = typeof(Customer).GetProperty("Name");
validator = new LengthValidator(4);
var customer = new Customer { Name = "John" };
Assert.IsTrue(validator.Validate(customer, customerNameProperty, out error));
Assert.IsNull(error);
customer.Name = " ";
Assert.IsTrue(validator.Validate(customer, customerNameProperty, out error));
Assert.IsNull(error);
var addressStateCodeProperty = typeof(Address).GetProperty("StateCode");
var stateCodeValidator = new LengthValidator(2);
var address = new Address { StateCode = "NJ" };
Assert.IsTrue(stateCodeValidator.Validate(address, addressStateCodeProperty, out error));
Assert.IsNull(error);
address.StateCode = " ";
Assert.IsTrue(stateCodeValidator.Validate(address, addressStateCodeProperty, out error));
Assert.IsNull(error);
}
public void TestValidate_NotPublicProperty()
{
string error;
var validator = new LengthValidator(4, 6);
var customer = new Customer();
var internalProperty = typeof(Customer).GetProperty("Gender", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.IsFalse(validator.Validate(customer, internalProperty, out error));
Assert.AreEqual("Gender is too short (minimum is 4).", error);
customer.Gender = "Male";
Assert.IsTrue(validator.Validate(customer, internalProperty, out error));
Assert.IsNull(error);
}
public void TestValidate_NonStringType()
{
string error;
// Value type property.
var validator = new LengthValidator(4, 10);
var valueTypeProperty = typeof(Customer).GetProperty("ActivationMode");
var customer = new Customer { ActivationMode = ActivationMode.Client };
Assert.Throws<NotSupportedException>(() => validator.Validate(customer, valueTypeProperty, out error));
// Nullable value type property.
validator = new LengthValidator(2);
var countryProperty = typeof(Address).GetProperty("Country");
var address = new Address { Country = Country.RussianFederation };
Assert.Throws<NotSupportedException>(() => validator.Validate(address, countryProperty, out error));
// Domain object ref property.
var addressProperty = typeof(Customer).GetProperty("MailingAddress");
Assert.Throws<NotSupportedException>(() => validator.Validate(customer, addressProperty, out error));
// Collection property.
var collectionProperty = typeof(Account).GetProperty("Owners");
var account = new Account { Number = UnitTestHelper.ACCOUNT_NUMBER };
Assert.Throws<NotSupportedException>(() => validator.Validate(account, collectionProperty, out error));
}
public void TestValidate_NullPropertyArg()
{
var presenceValidator = new PresenceValidator();
var lengthValidator = new LengthValidator(2, 10);
var customer = new Customer();
string error;
Assert.Throws<ArgumentNullException>(() => presenceValidator.Validate(customer, null, out error));
Assert.Throws<ArgumentNullException>(() => lengthValidator.Validate(customer, null, out error));
}
/// <summary>
/// Checks length validation options.
/// </summary>
/// <param name="validator">The validator instance to check options.</param>
/// <param name="min">Desired minimum length value.</param>
/// <param name="max">Desired maximum length value.</param>
/// <param name="requiredLength">Desired required length value.</param>
private static void CheckValidationOptions(LengthValidator validator, int? min, int? max, int? requiredLength)
{
Assert.AreEqual(min, validator.Min);
Assert.AreEqual(max, validator.Max);
Assert.AreEqual(requiredLength, validator.RequiredLength);
}
public void TestWrongLengthMessage_BlankArg()
{
var validator = new LengthValidator(10);
Assert.Throws<ArgumentNullException>(() => validator.WrongLengthMessage = UnitTestHelper.NULL_STRING);
Assert.Throws<ArgumentNullException>(() => validator.WrongLengthMessage = null);
Assert.Throws<ArgumentException>(() => validator.WrongLengthMessage = String.Empty);
Assert.Throws<ArgumentException>(() => validator.WrongLengthMessage = UnitTestHelper.BLANK_STRING);
}
public void TestValidate_String_WrongLength()
{
const string WRONG_STATE_CODE_LENGTH = "StateCode should be 2 characters.";
string error;
var stateCodeProperty = typeof(Address).GetProperty("StateCode");
var address = new Address { StateCode = "NY1" };
var stateValidator = new LengthValidator(2);
Assert.IsFalse(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.AreEqual(WRONG_STATE_CODE_LENGTH, error);
address.StateCode = null;
Assert.IsFalse(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.AreEqual(WRONG_STATE_CODE_LENGTH, error);
address.StateCode = String.Empty;
Assert.IsFalse(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.AreEqual(WRONG_STATE_CODE_LENGTH, error);
address.StateCode = " ";
Assert.IsFalse(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.AreEqual(WRONG_STATE_CODE_LENGTH, error);
address.StateCode = "NY";
Assert.IsTrue(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.IsNull(error);
stateValidator.WrongLengthMessage = "Only {{count}} symbols length allowed";
address.StateCode = "N";
Assert.IsFalse(stateValidator.Validate(address, stateCodeProperty, out error));
Assert.AreEqual("Only 2 symbols length allowed", error);
}
public void Should_be_valid_when_length_is_equal_to_max_value()
{
var validator = new LengthValidator<Person>(2, 5);
Assert.That(validator.Validate(null, "ABCDE"), Is.True);
}
public void TestValidate_StaticProperty()
{
var presenceValidator = new PresenceValidator();
var lengthValidator = new LengthValidator(2, 10);
var customer = new Customer();
var ordersProperty = typeof(Customer).GetProperty("TotalOrders", BindingFlags.Static | BindingFlags.Public);
Customer.Group = "GroupName";
var groupProperty = typeof(Customer).GetProperty("Group", BindingFlags.Static | BindingFlags.Public);
string error;
Assert.Throws<NotSupportedException>(() => presenceValidator.Validate(customer, ordersProperty, out error));
Assert.Throws<NotSupportedException>(() => lengthValidator.Validate(customer, groupProperty, out error));
}
public void When_the_text_is_smaller_than_the_range_then_the_validator_should_fail()
{
string text = "Test";
var validator = new LengthValidator(5, 10);
var result = validator.Validate(new PropertyValidatorContext(null, new object(), x => text));
result.IsValid().ShouldBeFalse();
}
public void TestValidate_String_OutOfInterval()
{
const string TOO_SHORT = "Number is too short (minimum is 6).";
const string TOO_LONG = "Number is too long (maximum is 10).";
string error;
var accountNumberProperty = typeof(Account).GetProperty("Number");
var validator = new LengthValidator(6, 10);
var account = new Account();
Assert.IsNull(account.Number);
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = String.Empty;
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = "\n\r\t ";
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = " abc ";
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = null;
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = "A60000";
Assert.IsTrue(validator.Validate(account, accountNumberProperty, out error));
Assert.IsNull(error);
account.Number = "A6000";
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_SHORT, error);
account.Number = "12345678901";
Assert.IsFalse(validator.Validate(account, accountNumberProperty, out error));
Assert.AreEqual(TOO_LONG, error);
var customerNameProperty = typeof(Customer).GetProperty("Name");
validator = new LengthValidator(4, 6);
var customer = new Customer { Name = "Joe" };
Assert.IsFalse(validator.Validate(customer, customerNameProperty, out error));
Assert.AreEqual("Name is too short (minimum is 4).", error);
customer.Name = "Jillian";
validator.TooLongMessage = "It is too long name to remember, '{{count}}' is maximum";
Assert.IsFalse(validator.Validate(customer, customerNameProperty, out error));
Assert.AreEqual("It is too long name to remember, '6' is maximum", error);
customer.Name = "Bob";
validator.TooShortMessage = "Must be {{count}} symbols.";
Assert.IsFalse(validator.Validate(customer, customerNameProperty, out error));
Assert.AreEqual("Must be 4 symbols.", error);
}
public void Should_be_valid_when_length_is_between_values()
{
var validator = new LengthValidator<Person>(2, 5);
Assert.That(validator.Validate(null, "ABC"), Is.True);
}
public void TestTooLongMessage()
{
var validator = new LengthValidator(2, 10);
Assert.AreEqual("is too long (maximum is 10)", validator.TooLongMessage);
validator = new LengthValidator(0, 3);
Assert.AreEqual("is too long (maximum is 3)", validator.TooLongMessage);
validator = new LengthValidator(10);
Assert.AreEqual("is too long (maximum is {{count}})", validator.TooLongMessage);
const string TOO_LONG_LENGTH = "Tooo long length...";
validator.TooLongMessage = TOO_LONG_LENGTH;
Assert.AreEqual(TOO_LONG_LENGTH, validator.TooLongMessage);
const string TOO_LONG_LENGTH_WITH_COUNT = "{{count}} characters is the maximum allowed";
validator = new LengthValidator(1, 20) { TooLongMessage = TOO_LONG_LENGTH_WITH_COUNT };
Assert.AreEqual("20 characters is the maximum allowed", validator.TooLongMessage);
validator = new LengthValidator(20) { TooLongMessage = TOO_LONG_LENGTH_WITH_COUNT };
Assert.AreEqual(TOO_LONG_LENGTH_WITH_COUNT, validator.TooLongMessage);
}
public void TestWrongLengthMessage()
{
var validator = new LengthValidator(10);
Assert.AreEqual("should be 10 characters", validator.WrongLengthMessage);
validator = new LengthValidator(2, 10);
Assert.AreEqual("should be {{count}} characters", validator.WrongLengthMessage);
const string WRONG_COUNT = "should be {{count}} characters length";
validator = new LengthValidator(8) { WrongLengthMessage = WRONG_COUNT };
Assert.AreEqual("should be 8 characters length", validator.WrongLengthMessage);
validator = new LengthValidator(2, 10) { WrongLengthMessage = WRONG_COUNT };
Assert.AreEqual(WRONG_COUNT, validator.WrongLengthMessage);
}
public void TestTooShortMessage()
{
var validator = new LengthValidator(10, 20);
Assert.AreEqual("is too short (minimum is 10)", validator.TooShortMessage);
validator = new LengthValidator(1, 3);
Assert.AreEqual("is too short (minimum is 1)", validator.TooShortMessage);
validator = new LengthValidator(10);
Assert.AreEqual("is too short (minimum is {{count}})", validator.TooShortMessage);
const string TOO_SHORT_LENGTH = "Tooo short length...";
validator.TooShortMessage = TOO_SHORT_LENGTH;
Assert.AreEqual(TOO_SHORT_LENGTH, validator.TooShortMessage);
const string TOO_SHORT_LENGTH_WITH_COUNT = "{{count}} characters is the minimum allowed";
validator = new LengthValidator(3, 20) { TooShortMessage = TOO_SHORT_LENGTH_WITH_COUNT };
Assert.AreEqual("3 characters is the minimum allowed", validator.TooShortMessage);
validator = new LengthValidator(20) { TooShortMessage = TOO_SHORT_LENGTH_WITH_COUNT };
Assert.AreEqual(TOO_SHORT_LENGTH_WITH_COUNT, validator.TooShortMessage);
}
public void TestWrongLengthMessage_InvalidPlaceholder()
{
const string VALID_PLACEHOLDER = "should be {{{count}}} characters length";
const string INVALID_PLACEHOLDER_1 = "should be {count} characters length";
const string INVALID_PLACEHOLDER_2 = "should be {{count} characters length";
const string INVALID_PLACEHOLDER_3 = "should be {{coun}} characters length";
const string INVALID_PLACEHOLDER_4 = "should be {{Count}} characters length";
var validator = new LengthValidator(10) { WrongLengthMessage = VALID_PLACEHOLDER };
Assert.AreEqual("should be {10} characters length", validator.WrongLengthMessage);
validator.WrongLengthMessage = INVALID_PLACEHOLDER_1;
Assert.AreEqual(INVALID_PLACEHOLDER_1, validator.WrongLengthMessage);
validator.WrongLengthMessage = INVALID_PLACEHOLDER_2;
Assert.AreEqual(INVALID_PLACEHOLDER_2, validator.WrongLengthMessage);
validator.WrongLengthMessage = INVALID_PLACEHOLDER_3;
Assert.AreEqual(INVALID_PLACEHOLDER_3, validator.WrongLengthMessage);
validator.WrongLengthMessage = INVALID_PLACEHOLDER_4;
Assert.AreEqual(INVALID_PLACEHOLDER_4, validator.WrongLengthMessage);
}
public void TestTooShortMessage_InvalidPlaceholder()
{
const string VALID_PLACEHOLDER = "{{{count}}} characters is the minimum allowed";
const string INVALID_PLACEHOLDER_1 = "{count} characters is the minimum allowed";
const string INVALID_PLACEHOLDER_2 = "{{count} characters is the minimum allowed";
const string INVALID_PLACEHOLDER_3 = "{{coun}} characters is the minimum allowed";
const string INVALID_PLACEHOLDER_4 = "{{Count}} characters is the minimum allowed";
var validator = new LengthValidator(3, 20) { TooShortMessage = VALID_PLACEHOLDER };
Assert.AreEqual("{3} characters is the minimum allowed", validator.TooShortMessage);
validator.TooShortMessage = INVALID_PLACEHOLDER_1;
Assert.AreEqual(INVALID_PLACEHOLDER_1, validator.TooShortMessage);
validator.TooShortMessage = INVALID_PLACEHOLDER_2;
Assert.AreEqual(INVALID_PLACEHOLDER_2, validator.TooShortMessage);
validator.TooShortMessage = INVALID_PLACEHOLDER_3;
Assert.AreEqual(INVALID_PLACEHOLDER_3, validator.TooShortMessage);
validator.TooShortMessage = INVALID_PLACEHOLDER_4;
Assert.AreEqual(INVALID_PLACEHOLDER_4, validator.TooShortMessage);
}
public void Min_and_max_properties_should_be_set() {
var validator = new LengthValidator(1, 5);
validator.Min.ShouldEqual(1);
validator.Max.ShouldEqual(5);
}
public void When_the_validator_fails_the_error_message_should_be_set()
{
var validator = new LengthValidator(1, 2);
var result =
validator.Validate(new PropertyValidatorContext("Forename", null, x => "Gire and gimble in the wabe"));
result.Single().ErrorMessage.ShouldEqual("'Forename' must be between 1 and 2 characters. You entered 27 characters.");
}
