/// <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 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."); }