/// <summary>
/// Validates the specified IBAN for correctness.
/// </summary>
/// <param name="iban">The IBAN value.</param>
/// <returns>a validation result, indicating if the IBAN is valid or not</returns>
public ValidationResult Validate(string iban)
{
InitRegistry();
string normalizedIban = Iban.Normalize(iban);
var context = new ValidationContext
{
Value = normalizedIban,
Result = IbanValidationResult.Valid,
Country = GetMatchingCountry(normalizedIban)
};
foreach (IIbanValidationRule rule in _rules)
{
rule.Validate(context);
if (context.Result != IbanValidationResult.Valid)
{
break;
}
}
return(new ValidationResult
{
Value = normalizedIban?.ToUpperInvariant(),
Result = context.Result,
Country = context.Country
});
}
/// <summary>
/// Validates the specified IBAN for correctness.
/// </summary>
/// <param name="iban">The IBAN value.</param>
/// <returns>a validation result, indicating if the IBAN is valid or not</returns>
public ValidationResult Validate(string?iban)
{
string?normalizedIban = Iban.NormalizeOrNull(iban);
var context = new ValidationRuleContext(normalizedIban ?? string.Empty);
var validationResult = new ValidationResult
{
AttemptedValue = normalizedIban
};
foreach (IIbanValidationRule rule in _rules)
{
try
{
validationResult.Error = rule.Validate(context) as ErrorResult;
}
#pragma warning disable CA1031 // Do not catch general exception types - justification: custom rules can throw unexpected exceptions. We handle it with ExceptionResult.
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
validationResult.Error = new ExceptionResult(ex);
}
if (!validationResult.IsValid)
{
break;
}
}
validationResult.Country = context.Country;
return(validationResult);
}
public void It_should_normalize(string iban, string expected)
{
// Act
var actual = new Iban(iban);
// Assert
actual.ToString().Should().Be(expected);
}
public When_comparing_for_inequality()
{
var ibanParser = new IbanParser(IbanValidatorMock.Object);
_iban = ibanParser.Parse(TestValues.ValidIban);
_equalIban = ibanParser.Parse(TestValues.ValidIbanPartitioned);
_otherIban = ibanParser.Parse("AE070331234567890123456");
}
public void With_null_value_should_throw()
{
// Act
Action act = () => Iban.Parse(null);
// Assert
act.Should().Throw <ArgumentNullException>("the provided value was null").Which.ParamName.Should().Be("value");
}
public override void SetUp()
{
base.SetUp();
_iban = Iban.Parse(TestValues.ValidIban);
_equalIban = Iban.Parse(TestValues.ValidIbanPartitioned);
_otherIban = Iban.Parse("AE070331234567890123456");
}
public void With_null_value_should_return_false()
{
// Act
bool actual = Iban.TryParse(null, out Iban iban);
// Assert
actual.Should().BeFalse("the provided value was null which is not valid");
iban.Should().BeNull("parsing did not succeed");
}
public void With_invalid_value_should_throw()
{
// Act
Action act = () => Iban.Parse(TestValues.InvalidIban);
// Assert
act.ShouldThrow <IbanFormatException>("the provided value was invalid")
.Which.Result
.Should().Be(IbanValidationResult.IllegalCharacters);
}
public void By_reference_when_other_is_null_should_return_false()
{
Iban nullIban = null;
// Act
// ReSharper disable once AssignNullToNotNullAttribute
bool actual = _iban.Equals(nullIban);
// Assert
actual.Should().BeFalse();
}
public void With_invalid_value_should_return_false()
{
// Act
bool actual = Iban.TryParse(TestValues.InvalidIban, out Iban iban);
// Assert
actual.Should().BeFalse("the provided value was invalid");
iban.Should().BeNull("parsing did not succeed");
IbanValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Once);
}
public void It_should_be_same_as_underlying_string_value()
{
var iban = new Iban(TestValues.ValidIban);
int expectedHashCode = TestValues.ValidIban.GetHashCode();
// Act
int actual = iban.GetHashCode();
// Assert
actual.Should().Be(expectedHashCode);
}
public void With_value_that_causes_custom_rule_to_throw_should_rethrow()
{
// Act
Action act = () => Iban.Parse(TestValues.IbanForCustomRuleException);
// Assert
IbanFormatException ex = act.Should().Throw <IbanFormatException>("the provided value was invalid").Which;
ex.Result.Should().BeNull();
ex.InnerException.Should().NotBeNull();
ex.Message.Should().Contain("is not a valid IBAN.");
}
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 With_valid_value_should_pass()
{
// Act
var actual = Iban.TryParse(TestValues.ValidIban, out var iban);
// Assert
actual.Should().BeTrue("the provided value was valid");
iban.Should().NotBeNull().
And.BeOfType <Iban>()
.Which.ToString()
.Should().Be(TestValues.ValidIban);
_ibanValidatorMock.Verify(m => m.Validate(It.IsAny <string>()), Times.Once);
}
public void With_valid_value_should_return_iban()
{
Iban iban = null;
// Act
Action act = () => iban = Iban.Parse(TestValues.ValidIban);
// Assert
act.ShouldNotThrow <IbanFormatException>();
iban.Should().NotBeNull("the value should be parsed")
.And.BeOfType <Iban>()
.Which.ToString()
.Should().Be(TestValues.ValidIban, "the returned value should match the provided value");
}
public void With_value_that_fails_custom_rule_should_throw()
{
// Act
Action act = () => Iban.Parse(TestValues.IbanForCustomRuleFailure);
// Assert
IbanFormatException ex = act.Should().Throw <IbanFormatException>("the provided value was invalid").Which;
ex.Result.Should().BeEquivalentTo(new ValidationResult
{
Error = new ErrorResult("Custom message"),
AttemptedValue = TestValues.IbanForCustomRuleFailure
});
ex.InnerException.Should().BeNull();
ex.Message.Should().Be("Custom message");
}
public void With_invalid_value_should_throw()
{
// Act
Action act = () => Iban.Parse(TestValues.InvalidIban);
// Assert
IbanFormatException ex = act.Should().Throw <IbanFormatException>("the provided value was invalid").Which;
ex.Result.Should().BeEquivalentTo(new ValidationResult
{
Error = new IllegalCharactersResult(),
AttemptedValue = TestValues.InvalidIban
});
ex.InnerException.Should().BeNull();
ex.Message.Should().Be("The IBAN contains illegal characters.");
}
/// <summary>
/// Validates the specified IBAN for correctness.
/// </summary>
/// <param name="iban">The IBAN value.</param>
/// <returns>a validation result, indicating if the IBAN is valid or not</returns>
public IbanValidationResult Validate(string iban)
{
var normalizedIban = Iban.Normalize(iban);
var validationResult = IbanValidationResult.Valid;
foreach (var rule in Rules)
{
validationResult = rule.Validate(normalizedIban);
if (validationResult != IbanValidationResult.Valid)
{
break;
}
}
return(validationResult);
}
/// <inheritdoc />
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
switch (value)
{
case null:
return(null);
case string strValue:
if (Iban.TryParse(strValue, out var iban))
{
return(iban);
}
break;
}
return(base.ConvertFrom(context, culture, value));
}
/// <summary>
/// Attempts to parse the specified <paramref name="value"/> into an <see cref="Iban"/>.
/// </summary>
/// <param name="value">The IBAN value to parse.</param>
/// <param name="iban">The <see cref="Iban"/> if the <paramref name="value"/> is parsed successfully.</param>
/// <param name="validationResult">The validation result.</param>
/// <returns>true if the <paramref name="value"/> is parsed successfully, or false otherwise</returns>
private static bool TryParse(string value, out Iban iban, out IbanValidationResult validationResult)
{
iban = null;
validationResult = IbanValidationResult.IllegalCharacters;
if (value == null)
{
return(false);
}
var normalizedValue = Normalize(value);
if ((validationResult = Validator.Validate(normalizedValue)) == IbanValidationResult.Valid)
{
iban = new Iban(normalizedValue.ToUpperInvariant());
return(true);
}
return(false);
}
/// <summary>
/// Attempts to parse the specified <paramref name="value"/> into an <see cref="Iban"/>.
/// </summary>
/// <param name="value">The IBAN value to parse.</param>
/// <param name="iban">The <see cref="Iban"/> if the <paramref name="value"/> is parsed successfully.</param>
/// <param name="validationResult">The validation result.</param>
/// <returns>true if the <paramref name="value"/> is parsed successfully, or false otherwise</returns>
private static bool TryParse(string value, out Iban iban, out IbanValidationResult validationResult)
{
iban = null;
validationResult = IbanValidationResult.IllegalCharacters;
if (value == null)
{
return(false);
}
// Although our validator normalizes too, we can't rely on this fact if other implementations
// are provided (like mocks, or maybe faster validators). Thus, to ensure this class correctly
// represents the IBAN value, we normalize inline here and take the penalty.
string normalizedValue = Normalize(value);
ValidationResult result = Validator.Validate(normalizedValue);
if (result.Result == IbanValidationResult.Valid)
{
iban = new Iban(normalizedValue.ToUpperInvariant());
return(true);
}
return(false);
}
public override void SetUp()
{
base.SetUp();
_iban = Iban.Parse(TestValues.ValidIban);
}
private bool Equals(Iban other)
{
return(string.Equals(_iban, other._iban));
}
/// <summary>
/// Attempts to parse the specified <paramref name="value"/> into an <see cref="Iban"/>.
/// </summary>
/// <param name="value">The IBAN value to parse.</param>
/// <param name="iban">The <see cref="Iban"/> if the <paramref name="value"/> is parsed successfully.</param>
/// <returns>true if the <paramref name="value"/> is parsed successfully, or false otherwise</returns>
public static bool TryParse(string value, out Iban iban)
{
iban = null;
return(TryParse(value, out iban, out var _));
}
public When_formatting()
{
_iban = new Iban(TestValues.ValidIban);
}
/// <summary>
/// Attempts to parse the specified <paramref name="value"/> into an <see cref="Iban"/>.
/// </summary>
/// <param name="value">The IBAN value to parse.</param>
/// <param name="iban">The <see cref="Iban"/> if the <paramref name="value"/> is parsed successfully.</param>
/// <returns>true if the <paramref name="value"/> is parsed successfully, or false otherwise</returns>
public static bool TryParse(string value, out Iban iban)
{
iban = null;
return(TryParse(value, out iban, out IbanValidationResult _));
}
