public void Boolean_Validator_Test()
{
var sut = new BooleanValidator();
var col1 = new ColumnTypeInfo()
{
AllowNull = true
};
var col2 = new ColumnTypeInfo()
{
AllowNull = false
};
Assert_Valid(sut.Validate(col1, "true"));
Assert_Valid(sut.Validate(col1, "TRUE"));
Assert_Valid(sut.Validate(col1, "True"));
Assert_Valid(sut.Validate(col1, "false"));
Assert_Valid(sut.Validate(col1, "FALSE"));
Assert_Valid(sut.Validate(col1, "False"));
Assert_Invalid(sut.Validate(col1, "Foo"));
Assert_Invalid_Replaced(sut.Validate(col2, "Foo"), false);
Assert_Invalid_Replaced(sut.Validate(col2, DBNull.Value), false);
}
public void BooleanValidator_IsValid_NullPropertyName()
{
BooleanValidator validator = new BooleanValidator(false);
string errorMessage;
Assert.Throws <ArgumentException>(() => validator.IsValid(true, null, this, out errorMessage));
Assert.Throws <ArgumentException>(() => validator.IsValid(true, String.Empty, this, out errorMessage));
}
public void BooleanValidator_Ctor()
{
BooleanValidator validator = new BooleanValidator(false);
Assert.False(validator.RequiredValue);
validator = new BooleanValidator(true);
Assert.True(validator.RequiredValue);
}
public void BooleanValidator_IsValid()
{
BooleanValidator validator = new BooleanValidator(false);
bool result = validator.IsValid(true, "test", this, out string errorMessage);
Assert.False(result);
Assert.NotNull(errorMessage);
result = validator.IsValid("false", "test", this, out errorMessage);
Assert.False(result);
Assert.NotNull(errorMessage);
result = validator.IsValid(false, "test", this, out errorMessage);
Assert.True(result);
Assert.Null(errorMessage);
}
public void TestTwoEqualInstancesHaveSameHashPasses(BooleanValidator validatorBase, ValidatorLinkage <BooleanValidator> firstLinkage, ValidatorLinkage <BooleanValidator> secondLinkage, bool areEqual)
{
"Given a new ValidatorBase instance"
.x(() => validatorBase = Validate.That("test1", true));
"And given a first ValidatorBase linkage instance"
.x(() => firstLinkage = new ValidatorLinkage <BooleanValidator>(validatorBase));
"And given a secondLinkage ValidatorBase linkage instance"
.x(() => secondLinkage = new ValidatorLinkage <BooleanValidator>(validatorBase));
"Testing that both linkage's hashes are equal"
.x(() => { areEqual = firstLinkage.GetHashCode() == secondLinkage.GetHashCode(); });
"Should evaluate true"
.x(() => areEqual.Should().BeTrue());
}
public static BooleanValidator That(string nameOfParameter, bool parameterValue)
{
return(BooleanValidator.GetInstance(nameOfParameter, parameterValue));
}
public void Valid_values_for_custom_validator(string value)
{
var validator = new BooleanValidator(new[] { "1", "Yes", "T" }, new[] { "0", "No", "F" });
Should.NotThrow(() => validator.Validate(value));
}
public void Invalid_values_for_default_case_sensitive_validator(string value)
{
var validator = new BooleanValidator(caseSensitive: true);
Should.Throw <ValidationException>(() => validator.Validate(value));
}
public void TestParameterIsFalseFails(string parameterName, bool parameterValue, BooleanValidator validatorBase, Action act)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter is false"
.x(() => act = () => validatorBase.IsFalse().OtherwiseThrowException());
"Should throw an exception"
.x(() => act.ShouldThrow <ArgumentException>()
.WithMessage(string.Format(Resources.MustBeFalse + "\r\nParameter name: {0}", parameterName)));
}
public void Invalid_values_for_default_validator(string value)
{
var validator = new BooleanValidator();
Should.Throw <ValidationException>(() => validator.Validate(value));
}
public void Valid_values_for_default_validator(string value)
{
var validator = new BooleanValidator();
Should.NotThrow(() => validator.Validate(value));
}
public void TestParameterEqualToWithCustomExceptionPasses(string parameterName, bool parameterValue, bool valueToCompare, BooleanValidator validatorBase, Action act)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter value is equal to the value to compare against and throwing a custom exception if not"
.x(() => validatorBase.IsEqualTo(valueToCompare).OtherwiseThrow(new ArgumentException("Some nonsense message", parameterName)));
"Should not result in an exception"
.x(() => validatorBase.CurrentException.Should().BeNull());
}
public void TestParameterEqualToWithCustomExceptionFails(string parameterName, bool parameterValue, bool valueToCompare, BooleanValidator validatorBase, Action act)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter value is equal to the value to compare against and throwing a custom exception if not"
.x(() => act = () => validatorBase.IsEqualTo(valueToCompare).OtherwiseThrow(new ArgumentException("Some nonsense message", parameterName)));
"Should result in that custom exception being thrown"
.x(() => act.ShouldThrow <ArgumentException>()
.WithMessage(string.Format("Some nonsense message\r\nParameter name: {0}", parameterName)));
}
public void TestParameterEqualToFails(string parameterName, bool parameterValue, bool valueToCompare, BooleanValidator validatorBase, Action act)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter value is equal to the value to compare against"
.x(() => act = () => validatorBase.IsEqualTo(valueToCompare).OtherwiseThrowException());
"Should throw an exception"
.x(() => act.ShouldThrow <ArgumentEqualityException>()
.WithMessage(string.Format(Resources.MustBeEqualToX + "\r\nParameter name: {1}", valueToCompare, parameterName)));
}
public void TestParameterIsFalsePasses(string parameterName, bool parameterValue, BooleanValidator validatorBase)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter is false"
.x(() => validatorBase.IsFalse().OtherwiseThrowException());
"Should not result in an exception"
.x(() => validatorBase.CurrentException.Should().BeNull());
}
public void Valid_values_for_default_case_sensitive_validator(string value)
{
var validator = new BooleanValidator(caseSensitive: true);
Should.NotThrow(() => validator.Validate(value));
}
public void TestParameterNotEqualToPasses(string parameterName, bool parameterValue, bool valueToCompare, BooleanValidator validatorBase)
{
"Given a new ValidatorBase"
.x(() => validatorBase = Validate.That(parameterName, parameterValue));
"Testing that the parameter value is equal to the value to compare against"
.x(() => validatorBase.IsNotEqualTo(valueToCompare).OtherwiseThrowException());
"Should not result in an exception"
.x(() => validatorBase.CurrentException.Should().BeNull());
}
