/// <inheritdoc />
protected override System.ComponentModel.DataAnnotations.ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value == null)
{
return(System.ComponentModel.DataAnnotations.ValidationResult.Success);
}
if (!(value is string strValue))
{
return(base.IsValid(value, validationContext));
}
IIbanValidator ibanValidator = GetValidator(validationContext);
ValidationResult result = ibanValidator.Validate(strValue);
if (result.Result == IbanValidationResult.Valid)
{
return(System.ComponentModel.DataAnnotations.ValidationResult.Success);
}
IEnumerable <string> memberNames = null;
if (validationContext.MemberName != null)
{
memberNames = new[] { validationContext.MemberName };
}
return(new System.ComponentModel.DataAnnotations.ValidationResult(FormatErrorMessage(validationContext.DisplayName), memberNames));
}
/// <inheritdoc />
protected override System.ComponentModel.DataAnnotations.ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value is null)
{
return(System.ComponentModel.DataAnnotations.ValidationResult.Success);
}
if (!(value is string strValue))
{
return(base.IsValid(value, validationContext));
}
IIbanValidator ibanValidator = GetValidator(validationContext);
ValidationResult result = ibanValidator.Validate(strValue);
if (result.IsValid)
{
return(System.ComponentModel.DataAnnotations.ValidationResult.Success);
}
validationContext.Items.Add("Error", result.Error);
IEnumerable <string>?memberNames = null;
if (validationContext.MemberName is { })
[InlineData(false, ValidationMethod.Loose)] // Loose mode.
public void Given_validation_method_when_adding_it_should_use_correct_method(bool?strict, ValidationMethod expectedValidationMethod)
{
// Act
Fixture.Configure(builder =>
{
switch (strict)
{
case null:
break;
case true:
builder.UseStrictValidation();
break;
case false:
builder.UseLooseValidation();
break;
}
});
DependencyResolverAdapter adapter = Fixture.Build();
// Assert
IIbanValidator validator = adapter.GetRequiredService <IIbanValidator>();
validator.Should()
.BeOfType <IbanValidator>()
.Which.Options.Method.Should()
.Be(expectedValidationMethod);
}
public InputModelValidator(IIbanValidator ibanValidator)
{
RuleFor(x => x.BankAccountNumber)
.NotNull()
.NotEmpty()
.Iban(ibanValidator);
}
public ValidatorTestThrowException()
{
_bankCodeValidator = new BankCodeValidator();
_branchCodeValidator = new BranchCodeValidator();
_accountNumberValidator = new AccountNumberValidator();
_ibanValidator = new IbanValidator();
_bbanValidator = new BbanValidator();
}
public void When_resolving_default_validator_multiple_times_it_should_return_same_instance()
{
// Act
IIbanValidator validator1 = Subject.GetRequiredService <IIbanValidator>();
IIbanValidator validator2 = Subject.GetRequiredService <IIbanValidator>();
// Assert
validator1.Should().BeSameAs(validator2);
}
public IbanNetOptionsBuilderTests()
{
IServiceProvider services = new ServiceCollection()
// Register rule
.AddIbanNet(builder => builder.ValidateNationalCheckDigits())
.BuildServiceProvider();
_validator = services.GetRequiredService <IIbanValidator>();
}
public void When_resolving_it_should_not_set_static_validator()
{
// Assert
IIbanValidator validator = Subject.GetService <IIbanValidator>();
// Act
Iban.Validator.Should()
.BeSameAs(_initialValidator)
.And.NotBeSameAs(validator);
}
public void Given_rule_is_registered_when_resolving_options_it_should_have_rule()
{
// Assert
IIbanValidator validator = Subject.GetService <IIbanValidator>();
validator.Should()
.BeOfType <IbanValidator>()
.Which.Options.Should()
.HaveRule <TestValidationRule>()
.And.HaveCount(1);
}
/// <summary>
/// Gets the validator from DI, and falls back to the default validator.
/// </summary>
/// <param name="serviceProvider"></param>
/// <returns></returns>
private static IIbanValidator GetValidator(IServiceProvider serviceProvider)
{
IIbanValidator ibanValidator = (IIbanValidator)serviceProvider?.GetService(typeof(IIbanValidator)) ?? Iban.Validator;
if (ibanValidator == null)
{
throw new InvalidOperationException(string.Format(Resources.IbanAttribute_ValidatorMissing, nameof(IIbanValidator)));
}
return(ibanValidator);
}
public void GlobalSetup()
{
// IbanNet setup
_strictValidator = new IbanValidator();
_looseValidator = new IbanValidator(new IbanValidatorOptions
{
Method = ValidationMethod.Loose
});
_testData = TestSamples.GetIbanSamples(1);
}
/// <summary>
/// Defines an IBAN validator on the current rule builder, but only for string properties.
/// Validation will fail if the value returned by the lambda is not a valid international bank account number.
/// </summary>
/// <typeparam name="T">Type of object being validated</typeparam>
/// <param name="ruleBuilder">The rule builder on which the validator should be defined</param>
/// <param name="ibanValidator">The <see cref="IIbanValidator" /> instance to use for validation.</param>
/// <returns></returns>
public static IRuleBuilderOptions <T, string> Iban <T>
(
this IRuleBuilder <T, string> ruleBuilder,
IIbanValidator ibanValidator)
{
if (ruleBuilder is null)
{
throw new ArgumentNullException(nameof(ruleBuilder));
}
return(ruleBuilder.SetValidator(new FluentIbanValidator(ibanValidator)));
}
public void When_registering_validator_it_should_add_validator_to_rule()
{
var ruleBuilderMock = new Mock <IRuleBuilder <object, string> >();
IIbanValidator ibanValidator = Mock.Of <IIbanValidator>();
// Act
// ReSharper disable once AssignNullToNotNullAttribute
ruleBuilderMock.Object.Iban(ibanValidator);
// Assert
ruleBuilderMock.Verify(m => m.SetValidator(It.IsAny <FluentIbanValidator>()), Times.Once);
}
public void GlobalSetup()
{
// IbanNet setup
_strictValidator = new IbanValidator();
_looseValidator = new IbanValidator(new IbanValidatorOptions {
Method = ValidationMethod.Loose
});
#if VALIDATOR_COMPARISONS
_nugetIbanValidator = new IbanValidation.IbanValidator();
#endif
_testData = TestSamples.GetIbanSamples(Count);
}
public void It_should_throw()
{
IIbanValidator ibanValidator = null;
// Act
// ReSharper disable once ObjectCreationAsStatement
// ReSharper disable once AssignNullToNotNullAttribute
Action act = () => new FluentIbanValidator(ibanValidator);
// Assert
act.Should()
.Throw <ArgumentNullException>()
.Which.ParamName.Should()
.Be(nameof(ibanValidator));
}
public void Given_null_validator_when_registering_validator_it_should_throw()
{
IRuleBuilder <object, string> ruleBuilder = Mock.Of <IRuleBuilder <object, string> >();
IIbanValidator ibanValidator = null;
// Act
// ReSharper disable once AssignNullToNotNullAttribute
Action act = () => ruleBuilder.Iban(ibanValidator);
// Assert
act.Should()
.ThrowExactly <ArgumentNullException>()
.Which.ParamName.Should()
.Be(nameof(ibanValidator));
}
public void Given_two_rules_are_registered_when_resolving_options_it_should_have_rules_in_order()
{
// Assert
IIbanValidator validator = Subject.GetService <IIbanValidator>();
var rules = validator.Should()
.BeOfType <IbanValidator>()
.Which.Options.Should()
.HaveRule <IIbanValidationRule>()
.And.HaveCount(3)
.And.Subject.ToList();
rules[0].Should().BeOfType <TestValidationRule>();
rules[1].Should().BeOfType <AnotherTestValidationRule>();
rules[2].Should().BeOfType(_fakeRuleType);
}
public VendorValidator(IIbanValidator ibanValidator)
{
//Todo finish validator
RuleFor(x => x.Blocked).NotEmpty();
RuleFor(x => x.Iban).NotEmpty().ForEach(x => x.Iban(ibanValidator));
RuleFor(x => x.Name).NotNull().NotEmpty();
RuleFor(x => x.CountryCode).Must(x => Region.Codes.Contains(x.ToUpper()));
RuleFor(x => x.CurrencyCode).Must(x => Region.Currencies.Contains(x.ToUpper()));
RuleFor(x => x.VatNumber);
RuleFor(x => x.VendorCustomerCode);
RuleFor(x => x.DefaultLedgerCode);
RuleFor(x => x.DefaultVatCode);
RuleFor(x => x.DefaultPaymentTermCode);
RuleFor(x => x.DefaultVatScenarioCode);
RuleFor(x => x.DefaultVatScenarioCode);
}
protected IbanTestFixture()
{
IbanValidatorMock = new Mock <IIbanValidator>();
IbanValidatorMock
.Setup(m => m.Validate(It.IsAny <string>()))
.Returns <string>(iban => new ValidationResult
{
AttemptedValue = iban
});
IbanValidatorMock
.Setup(m => m.Validate(null))
.Returns <string>(iban => new ValidationResult
{
AttemptedValue = null,
Error = new InvalidLengthResult()
});
IbanValidatorMock
.Setup(m => m.Validate(TestValues.InvalidIban))
.Returns <string>(iban => new ValidationResult
{
AttemptedValue = iban,
Error = new IllegalCharactersResult()
});
IbanValidatorMock
.Setup(m => m.Validate(TestValues.IbanForCustomRuleFailure))
.Returns <string>(iban => new ValidationResult
{
AttemptedValue = iban,
Error = new ErrorResult("Custom message")
});
IbanValidatorMock
.Setup(m => m.Validate(TestValues.IbanForCustomRuleException))
.Throws(new InvalidOperationException("Custom message"));
_originalValidator = Iban.Validator;
Iban.Validator = IbanValidatorMock.Object;
}
/// <summary>
/// Constructor that permits to set all the validator.
/// </summary>
/// <param name="bankCodeValidator">
/// Objects that contains the rules to validate a Bank Code.
/// </param>
/// <param name="branchCodeValidator">
/// Objects that contains the rules to validate a Branch Code.
/// </param>
/// <param name="accountNumberValidator">
/// Objects that contains the rules to validate an Account Number.
/// </param>
/// <param name="countryCodeValidator">
/// Objects that contains the rules to validate a Country Code.
/// </param>
/// <param name="ibanValidator">
/// Objects that contains the rules to validate an IBAN.
/// </param>
/// <param name="bbanValidator">
/// Objects that contains the rules to validate a BBAN.
/// </param>
/// <exception cref="ValidatorException">
/// If any validator is not valid a <see cref="ValidatorException" /> will be thrown.
/// </exception>
public DefaultValidators(
IBankCodeValidator bankCodeValidator,
IBranchCodeValidator branchCodeValidator,
IAccountNumberValidator accountNumberValidator,
ICountryCodeValidator countryCodeValidator,
IIbanValidator ibanValidator,
IBbanValidator bbanValidator)
{
CheckNotNullArgument<IBankCodeValidator>(bankCodeValidator, "bankCodeValidator");
CheckNotNullArgument<IBranchCodeValidator>(branchCodeValidator, "branchCodeValidator");
CheckNotNullArgument<IAccountNumberValidator>(accountNumberValidator, "accountNumberValidator");
CheckNotNullArgument<ICountryCodeValidator>(countryCodeValidator, "countryCodeValidator");
CheckNotNullArgument<IIbanValidator>(ibanValidator, "ibanValidator");
CheckNotNullArgument<IBbanValidator>(bbanValidator, "bbanValidator");
_bankCodeValidator = bankCodeValidator;
_branchCodeValidator = branchCodeValidator;
_accountNumberValidator = accountNumberValidator;
_countryCodeValidator = countryCodeValidator;
_ibanValidator = ibanValidator;
_bbanValidator = bbanValidator;
}
public void When_validating_with_unregistered_country_it_should_fail()
{
IIbanValidator validator = Subject.GetRequiredService <IIbanValidator>();
validator.Validate("DE89370400440532013000").IsValid.Should().BeFalse();
}
public void When_validating_with_registered_country_it_should_pass(string validIban)
{
IIbanValidator validator = Subject.GetRequiredService <IIbanValidator>();
validator.Validate(validIban).IsValid.Should().BeTrue();
}
/// <summary>
/// Initializes a new instance of the <see cref="IbanParser" /> class using specified <paramref name="ibanValidator" />.
/// </summary>
/// <param name="ibanValidator"></param>
public IbanParser(IIbanValidator ibanValidator)
{
_ibanValidator = ibanValidator ?? throw new ArgumentNullException(nameof(ibanValidator));
}
/// <summary>
/// Initializes a new instance of the <see cref="FluentIbanValidator"/> class using specified validator.
/// </summary>
/// <param name="ibanValidator">The IBAN validator to use.</param>
public FluentIbanValidator(IIbanValidator ibanValidator)
: base("'{PropertyName}' is not a valid IBAN.")
{
_ibanValidator = ibanValidator ?? throw new ArgumentNullException(nameof(ibanValidator));
}
public TestModelValidator(IIbanValidator ibanValidator)
{
RuleFor(x => x.BankAccountNumber).Iban(ibanValidator);
}
public void When_resolving_it_should_not_preserve_static_validator()
{
IIbanValidator validator = Subject.GetRequiredService <IIbanValidator>();
validator.Should().NotBeSameAs(_initialValidator);
}
protected override void Given()
{
_initialValidator = Iban.Validator;
Fixture.Configure(builder => { });
}
/// <summary>
/// Defines an IBAN validator on the current rule builder, but only for string properties.
/// Validation will fail if the value returned by the lambda is not a valid international bank account number.
/// </summary>
/// <typeparam name="T">Type of object being validated</typeparam>
/// <param name="ruleBuilder">The rule builder on which the validator should be defined</param>
/// <param name="ibanValidator">The <see cref="IIbanValidator"/> instance to use for validation.</param>
/// <returns></returns>
public static IRuleBuilderOptions <T, string> Iban <T>(
this IRuleBuilder <T, string> ruleBuilder, IIbanValidator ibanValidator)
{
return(ruleBuilder.SetValidator(new FluentIbanValidator(ibanValidator)));
}
protected override void Given()
{
Iban.Validator = _initialValidator = Mock.Of <IIbanValidator>();
Fixture.Configure(builder => { });
}
public IbanValidatorTest()
{
_ibanValidator = new IbanValidator();
}
