public void Given_invalid_value_when_validating_it_should_return_error()
{
const string testValue = "XX";
var country = new IbanCountry("NL")
{
Iban =
{
Structure = "my-structure"
}
};
_structureValidatorMock
.Setup(m => m.Validate(testValue))
.Returns(false)
.Verifiable();
// Act
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext(testValue)
{
Country = country
});
// Assert
actual.Should().BeOfType <InvalidStructureResult>();
_structureValidatorMock.Verify();
_structureValidationFactoryMock.Verify(m => m.CreateValidator(country.TwoLetterISORegionName, country.Iban.Structure), Times.Once);
}
public void Given_no_country_when_validating_it_should_return_error()
{
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext(string.Empty));
// Assert
actual.Should().BeOfType <InvalidStructureResult>();
_structureValidationFactoryMock.Verify(m => m.CreateValidator(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public void Given_that_no_validator_matches_iban_country_when_validating_it_should_pass()
{
var context = new ValidationRuleContext("XX000000", new IbanCountry("XX"));
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().BeSameAs(ValidationRuleResult.Success);
_checkDigitsValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Never);
}
public void Given_country_info_is_null_when_validating_it_should_return_error()
{
var context = new ValidationRuleContext(string.Empty)
{
Country = null
};
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().BeOfType <InvalidLengthResult>();
}
public void Given_that_bban_structure_length_is_zero_when_validating_it_should_fail()
{
var context = new ValidationRuleContext("ZZ000000", new IbanCountry("ZZ")
{
Bban = new BbanStructure(new TestPattern(Enumerable.Empty <PatternToken>()))
});
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().BeOfType <InvalidNationalCheckDigitsResult>();
_checkDigitsValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Never);
}
public void Given_value_of_valid_length_when_validating_it_should_return_success()
{
string value = new string('0', 10);
var context = new ValidationRuleContext(value)
{
Country = new IbanCountry("XX")
{
Iban = { Length = 10 }
}
};
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().Be(ValidationRuleResult.Success);
}
public void Given_value_of_invalid_length_when_validating_it_should_return_error(int count)
{
string value = new string('0', count);
var context = new ValidationRuleContext(value)
{
Country = new IbanCountry("XX")
{
Iban = { Length = 10 }
}
};
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().BeOfType <InvalidLengthResult>();
}
public void Given_valid_value_when_validating_it_should_return_success()
{
const string value = "ABCD123456";
const int expectedCheckDigit = 1;
_calculatorMock
.Setup(m => m.Compute(It.Is <char[]>(buf => buf.SequenceEqual("123456ABCD"))))
.Returns(expectedCheckDigit)
.Verifiable();
// Act
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext(value));
// Assert
actual.Should().Be(ValidationRuleResult.Success);
_calculatorMock.Verify();
}
public void Given_that_bban_expected_length_is_greater_than_available_when_validating_it_should_fail(int position, int length)
{
var context = new ValidationRuleContext("ZZ000000",
new IbanCountry("ZZ")
{
Bban = new BbanStructure(
new TestPattern(new[] { new PatternToken(AsciiCategory.Digit, length) }),
position)
});
// Act
ValidationRuleResult actual = _sut.Validate(context);
// Assert
actual.Should().BeOfType <InvalidNationalCheckDigitsResult>();
_checkDigitsValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Never);
}
public void Given_unknown_country_code_when_validating_it_should_return_error()
{
var context = new ValidationRuleContext("XX");
var sut = new IsValidCountryCodeRule(new IbanRegistry
{
Providers =
{
new IbanRegistryListProvider(new IbanCountry[0])
}
});
// Act
ValidationRuleResult actual = sut.Validate(new ValidationRuleContext("XX"));
// Assert
actual.Should().BeOfType <UnknownCountryCodeResult>();
context.Country.Should().BeNull();
}
public void Given_known_country_code_when_validating_it_should_return_success()
{
var context = new ValidationRuleContext("XX");
var country = new IbanCountry("XX");
var sut = new IsValidCountryCodeRule(new IbanRegistry
{
Providers =
{
new IbanRegistryListProvider(new[] { country })
}
});
// Act
ValidationRuleResult actual = sut.Validate(context);
// Assert
actual.Should().Be(ValidationRuleResult.Success);
context.Country.Should().BeSameAs(country);
}
public void Given_multiple_check_digit_validators_when_validating_it_should_only_use_those_that_have_matching_country()
{
var matchingCheckDigitValidatorMock = new Mock <NationalCheckDigitsValidator>(Mock.Of <ICheckDigitsCalculator>(), new[] { "WW" });
var checkDigitValidatorStubs = new Dictionary <string, IEnumerable <NationalCheckDigitsValidator> >
{
{ "ZZ", new[] { _checkDigitsValidatorMock.Object } },
{ "WW", new[] { matchingCheckDigitValidatorMock.Object } }
};
_checkDigitsValidatorMock
.Setup(m => m.Validate(It.IsAny <string>()))
.Returns(true)
.Verifiable();
matchingCheckDigitValidatorMock
.Setup(m => m.Validate(It.IsAny <string>()))
.Returns(true)
.Verifiable();
var sut = new HasValidNationalCheckDigitsRule(checkDigitValidatorStubs);
var context = new ValidationRuleContext("WW0123456",
new IbanCountry("WW")
{
Bban = new BbanStructure(
new TestPattern(new[] { new PatternToken(AsciiCategory.Digit, 7) }),
2)
});
// Act
ValidationRuleResult actual = sut.Validate(context);
// Assert
actual.Should().BeSameAs(ValidationRuleResult.Success);
matchingCheckDigitValidatorMock.Verify();
_checkDigitsValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Never);
}
public void Given_valid_value_when_validating_it_should_return_success()
{
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext("XX45"));
actual.Should().Be(ValidationRuleResult.Success);
}
public void Given_invalid_checksum_when_validating_it_should_return_error(string value)
{
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext(value));
actual.Should().BeOfType <IllegalCharactersResult>();
}
public void Given_empty_value_when_validating_it_should_return_error()
{
ValidationRuleResult actual = _sut.Validate(new ValidationRuleContext(string.Empty));
actual.Should().BeOfType <InvalidLengthResult>();
}
