public void When_validating_null_value_should_not_validate()
{
// Act
ValidationResult actual = _validator.Validate(null);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Result = IbanValidationResult.InvalidLength
});
}
public void When_validating_iban_with_unknown_country_code_should_not_validate(string ibanWithUnknownCountryCode)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithUnknownCountryCode);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = ibanWithUnknownCountryCode,
Result = IbanValidationResult.UnknownCountryCode
});
}
public void When_validating_multiple_times_it_should_succeed()
{
const string iban = "NL91ABNA0417164300";
// Act
ValidationResult result1 = _sut.Validate(iban);
ValidationResult result2 = _sut.Validate(iban);
// Assert
result1.IsValid.Should().BeTrue();
result1.Should().BeEquivalentTo(result2);
}
public void When_validating_iban_with_illegal_country_code_should_not_validate(string ibanWithIllegalCountryCode)
{
// Act
ValidationResult actual = Validator.Validate(ibanWithIllegalCountryCode);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithIllegalCountryCode,
Error = new IllegalCountryCodeCharactersResult()
});
}
public void When_validating_iban_with_invalid_checksum_should_not_validate(string ibanWithInvalidChecksum)
{
// Act
ValidationResult actual = Validator.Validate(ibanWithInvalidChecksum);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithInvalidChecksum,
Error = new IllegalCharactersResult()
});
}
public void When_validating_null_or_empty_value_should_not_validate(string iban)
{
// Act
ValidationResult actual = Validator.Validate(iban);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = iban,
Error = new InvalidLengthResult()
});
}
public void When_validating_iban_with_illegal_country_code_should_not_validate(string ibanWithIllegalCountryCode)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithIllegalCountryCode);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = ibanWithIllegalCountryCode,
Result = IbanValidationResult.IllegalCharacters
});
}
public void When_iban_contains_whitespace_should_validate(string ibanWithWhitespace)
{
// Act
ValidationResult actual = Validator.Validate(ibanWithWhitespace);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithWhitespace.StripWhitespaceOrNull(),
Country = Validator.SupportedCountries["NL"]
});
}
public void When_validating_iban_with_unknown_country_code_should_not_validate(string ibanWithUnknownCountryCode)
{
// Act
ValidationResult actual = Validator.Validate(ibanWithUnknownCountryCode);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithUnknownCountryCode,
Error = new UnknownCountryCodeResult()
});
}
public void When_validating_tampered_iban_should_not_validate(string tamperedIban)
{
// Act
ValidationResult actual = _validator.Validate(tamperedIban);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = tamperedIban,
Result = IbanValidationResult.InvalidCheckDigits,
Country = _countryValidationSupport.SupportedCountries[tamperedIban.Substring(0, 2)]
});
}
public void When_validating_tampered_iban_should_not_validate(string tamperedIban)
{
// Act
ValidationResult actual = Validator.Validate(tamperedIban);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = tamperedIban,
Error = new InvalidCheckDigitsResult(),
Country = Validator.SupportedCountries[tamperedIban.Substring(0, 2)]
});
}
public void When_validating_iban_with_incorrect_length_should_not_validate(string ibanWithIncorrectLength)
{
// Act
ValidationResult actual = Validator.Validate(ibanWithIncorrectLength);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithIncorrectLength,
Error = new InvalidLengthResult(),
Country = Validator.SupportedCountries[ibanWithIncorrectLength.Substring(0, 2)]
});
}
public void When_iban_contains_whitespace_should_validate(string ibanWithWhitespace)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithWhitespace);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = Iban.Normalize(ibanWithWhitespace),
Result = IbanValidationResult.Valid,
Country = _countryValidationSupport.SupportedCountries["NL"]
});
}
public void When_validating_iban_with_invalid_structure_should_not_validate(string ibanWithInvalidStructure)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithInvalidStructure);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = ibanWithInvalidStructure,
Result = IbanValidationResult.InvalidStructure,
Country = _countryValidationSupport.SupportedCountries[ibanWithInvalidStructure.Substring(0, 2)]
});
}
public void When_validating_iban_with_incorrect_length_should_not_validate(string ibanWithIncorrectLength)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithIncorrectLength);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = ibanWithIncorrectLength,
Result = IbanValidationResult.InvalidLength,
Country = _countryValidationSupport.SupportedCountries[ibanWithIncorrectLength.Substring(0, 2)]
});
}
public void When_validating_iban_with_invalid_checksum_should_not_validate(string ibanWithInvalidChecksum)
{
// Act
ValidationResult actual = _validator.Validate(ibanWithInvalidChecksum);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
Value = ibanWithInvalidChecksum,
Result = IbanValidationResult.IllegalCharacters,
Country = _countryValidationSupport.SupportedCountries[ibanWithInvalidChecksum.Substring(0, 2)]
});
}
public void When_validating_iban_that_allows_lowercase_it_should_validate()
{
const string ibanWithLowercase = "MT84MALT011000012345mtlcast001S";
// Act
ValidationResult actual = Validator.Validate(ibanWithLowercase);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithLowercase.ToUpperInvariant(),
Country = Validator.SupportedCountries[ibanWithLowercase.Substring(0, 2)]
});
}
public void When_validating_iban_with_invalid_structure_should_not_validate()
{
const string ibanWithInvalidStructure = "NL91ABNA041716430A"; // Last character should be digit.
// Act
ValidationResult actual = Validator.Validate(ibanWithInvalidStructure);
// Assert
actual.Should().BeEquivalentTo(new ValidationResult
{
AttemptedValue = ibanWithInvalidStructure,
Error = new InvalidStructureResult(),
Country = Validator.SupportedCountries[ibanWithInvalidStructure.Substring(0, 2)]
});
}
public void When_validating_good_iban_should_validate(string countryCode, string iban)
{
var expectedResult = new ValidationResult
{
Value = iban,
Result = IbanValidationResult.Valid,
Country = _countryValidationSupport.SupportedCountries[iban.Substring(0, 2)]
};
// Act
ValidationResult actual = _validator.Validate(iban);
// Assert
actual.Should().BeEquivalentTo(expectedResult);
}
#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
#pragma warning disable IDE0060 // Remove unused parameter
public void When_validating_good_iban_should_validate(string countryCode, string iban)
#pragma warning restore IDE0060 // Remove unused parameter
#pragma warning restore xUnit1026 // Theory methods should use all of their parameters
{
var expectedResult = new ValidationResult
{
AttemptedValue = iban,
Country = Validator.SupportedCountries[iban.Substring(0, 2)]
};
// Act
ValidationResult actual = Validator.Validate(iban);
// Assert
actual.Should().BeEquivalentTo(expectedResult);
}
[InlineData("AD12000120359100100")] // Invalid
public void Given_iban_when_parsing_should_give_same_result_as_validator(string attemptedIbanValue)
{
// Act
ValidationResult validatorResult = _ibanValidator.Validate(attemptedIbanValue);
bool tryParseResult = _sut.TryParse(attemptedIbanValue, out Iban iban, out ValidationResult tryParseValidationResult, out Exception _);
// Assert
validatorResult.IsValid.Should().Be(tryParseResult);
validatorResult.Should().BeEquivalentTo(tryParseValidationResult);
if (tryParseResult)
{
iban.Should().NotBeNull();
}
else
{
iban.Should().BeNull();
}
}
public void Given_custom_rule_fails_when_validating_should_not_validate()
{
const string iban = "NL91ABNA0417164300";
const string errorMessage = "My custom error";
_customValidationRuleMock
.Setup(m => m.Validate(It.IsAny <ValidationRuleContext>()))
.Returns(new ErrorResult(errorMessage));
// Act
ValidationResult actual = _sut.Validate(iban);
// Assert
actual.Should()
.BeEquivalentTo(new ValidationResult
{
AttemptedValue = iban,
Error = new ErrorResult(errorMessage),
Country = _sut.SupportedCountries["NL"]
});
}
