private void WriteValidator(MinLengthValidator validator, int value)
{
if (value > 0)
{
WriteValidator(validator, value.ToString());
}
}
public void ShouldReturnFalseForObject()
{
object testObject = new object();
Validator minLengthValidator = new MinLengthValidator(testObject, 5);
Assert.IsFalse(minLengthValidator.Validate());
}
public void ShouldReturnFalseForValidatableObject()
{
MinLengthValidatableObjectFalse testValidatableObject = new MinLengthValidatableObjectFalse();
Validator minLengthValidator = new MinLengthValidator(testValidatableObject, 5);
Assert.IsFalse(minLengthValidator.Validate());
}
public void ShouldReturnFalseForStringValue()
{
testValueString = "Length less than 20!!!!";
Validator minLengthValidator = new MinLengthValidator(testValueString, controlLengthString);
Assert.IsFalse(minLengthValidator.Validate());
}
public void ShouldReturnTrueForObject()
{
MinLengthValidatableObjectTrue testValidatableObject = new MinLengthValidatableObjectTrue();
Validator minLengthValidator = new MinLengthValidator(testValidatableObject, 25);
Assert.IsTrue(minLengthValidator.Validate());
}
public void ShouldReturnFalseForDecimalValue()
{
testValueDecimal = 1M;
Validator minLengthValidator = new MinLengthValidator(testValueDecimal, controlLength);
Assert.IsFalse(minLengthValidator.Validate());
}
public void ShouldReturnFalseForDoubleValue()
{
testValueDouble = 1F;
Validator minLengthValidator = new MinLengthValidator(testValueDouble, controlLength);
Assert.IsFalse(minLengthValidator.Validate());
}
public void ShouldReturnFalseForIntValue()
{
testValueInt = 1;
Validator minLengthValidator = new MinLengthValidator(testValueInt, controlLength);
Assert.IsFalse(minLengthValidator.Validate());
}
public void Validator_IsInitialized()
{
const int minLength = 10;
var validator = new MinLengthValidator(minLength);
Assert.That(validator.MinLenght, Is.EqualTo(minLength));
}
private ValidationMessage MinLength(
string value,
int minLength,
ValidationMessageType validationMessageType = ValidationMessageType.Error)
{
var betweenLengthValidator = new MinLengthValidator <TestValidatableObject>(_ => minLength, validationMessageType);
var context = new ValidationContext <TestValidatableObject, string>(null, nameof(TestValidatableObject.Number), null, value);
var validationMessage = betweenLengthValidator.ValidateProperty(context).FirstOrDefault();
return(validationMessage);
}
public async Task Comment_Content_Length_Shorter_Than_MinLength()
{
// Setup
var validator = new MinLengthValidator(5);
var content = "Hi";
var context = new CommentContext(content);
// Act
var result = await validator.ValidateAsync(context);
// Assert
Assert.IsFalse(result.Successed);
}
public async Task Publication_Content_Length_Longer_Than_MinLength()
{
// Setup
var validator = new MinLengthValidator(5);
var content = "Hello_Hello";
var context = new PublicationContext(content);
// Act
var result = await validator.ValidateAsync(context);
// Assert
Assert.IsTrue(result.Successed);
}
public async Task Comment_Content_Length_Equal_MinLength()
{
// Setup
var validator = new MinLengthValidator(5);
var content = "Hello";
var context = new CommentContext(content);
// Act
var result = await validator.ValidateAsync(context);
// Assert
Assert.IsTrue(result.Successed);
}
public async Task Comment_Content_Length_Longer_Than_MinLength()
{
// Setup
var validator = new MinLengthValidator(5);
var content = "Hello_Hello";
var comment = new Comment(string.Empty, content, DateTimeOffset.Now, string.Empty, replyCommentId: null, null);
// Act
var result = await validator.ValidateAsync(comment);
// Assert
Assert.IsTrue(result.Successed);
}
/// <summary>
/// MinLength
/// </summary>
/// <typeparam name="T">DataType</typeparam>
/// <param name="length">length</param>
/// <param name="fields">field</param>
public static void MinLength <T>(int length, params ValidationField <T>[] fields)
{
string validatorKey = string.Format("{0}/{1}", typeof(MinLengthValidator).FullName, length);
DataValidator validator = null;
if (_validatorList.ContainsKey(validatorKey))
{
validator = _validatorList[validatorKey];
}
else
{
validator = new MinLengthValidator(length);
_validatorList.Add(validatorKey, validator);
}
SetValidation <T>(validator, fields);
}
public virtual void testMinLengthValidator()
{
MinLengthValidator validator = new MinLengthValidator();
assertTrue(validator.validate(null, null));
assertTrue(validator.validate("test", new TestValidatorContext("4")));
assertFalse(validator.validate("test", new TestValidatorContext("5")));
try
{
validator.validate("test", new TestValidatorContext("4.4"));
fail("exception expected");
}
catch (FormException e)
{
assertTrue(e.Message.contains("Cannot validate \"minlength\": configuration 4.4 cannot be interpreted as Integer"));
}
}
public async Task Publication_Content_Length_Equal_MinLength()
{
// Setup
var validator = new MinLengthValidator(5);
var content = "Hello";
var publication = new Publication(
string.Empty,
content,
Enumerable.Empty <string>(),
null,
DateTimeOffset.Now,
DateTimeOffset.Now);
// Act
var result = await validator.ValidateAsync(publication);
// Assert
Assert.IsTrue(result.Successed);
}
public void Then_correct_errors_are_returned(string input, string minLength, bool isValid)
{
var validator = new MinLengthValidator
{
ValidationDefinition = new ValidationDefinition()
{
ErrorMessage = "Length not achieved",
Name = "MinLength",
Value = minLength
}
};
var question = new Question {
QuestionId = "Q1"
};
var errors = validator.Validate(question, new Answer {
Value = input, QuestionId = question.QuestionId
});
(errors.Count is 0).Should().Be(isValid);
}
/// <summary>
/// The method validates whether a supplied object has a length greater than supplied minimum length.
/// </summary>
/// <param name="objectToValidate">An object to be valdiated.</param>
/// <param name="minLength">A minimum valid length value.</param>
/// <returns>True - if object is valid, false - if object is invalid.</returns>
public static bool IsGreaterThanMinLength(object objectToValidate, int minLength)
{
Validator validator = new MinLengthValidator(objectToValidate, minLength);
return(validator.Validate());
}
public void ShouldReturnTrueForDecimalValue()
{
Validator minLengthValidator = new MinLengthValidator(testValueDecimal, controlLength);
Assert.IsTrue(minLengthValidator.Validate());
}
public void ShouldReturnTrueForStringValue()
{
Validator minLengthValidator = new MinLengthValidator(testValueString, controlLengthString);
Assert.IsTrue(minLengthValidator.Validate());
}
