/// <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 _)); }