public void CanProcessVocaLinkDoubleAlternateWithExceptionOne() { var accountDetails = new BankAccountDetails("118765", "64371389"); accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); var result = _firstStepDblAlCalculator.Process(accountDetails); Assert.True(result); }
public void CalculatesSumAsExpected() { var details = new BankAccountDetails("499273", "12345678"); var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 1"); var actual = _check.GetModulusSum(details, mapping); Assert.AreEqual(70,actual); }
public void ExceptionFiveValidationTestSumCheck() { var details = new BankAccountDetails("938611", "07806039"); var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5"); var actual = _check.GetModulusSum(details, mapping); Assert.AreEqual(51, actual); }
public void CalculatesExceptionSixTestCaseCorrectly() { var details = new BankAccountDetails("202959", "63748472"); var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 1"); var actual = _check.GetModulusSum(details, mapping); Assert.AreEqual(60,actual); }
public void ExceptionFiveSecondCheckDigitIncorrect() { var accountDetails = new BankAccountDetails("938063", "15764273"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _firstStepDblAlCalculator.Process(accountDetails); Assert.IsFalse(result); }
public void CanProcessVocalinkStandardEleven() { var accountDetails = new BankAccountDetails("107999", "88837491"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = new FirstStandardModulusElevenCalculator().Process(accountDetails); Assert.True(result); }
public void ExceptionFiveWhereFirstCheckPasses() { var accountDetails = new BankAccountDetails("938611", "07806039"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _firstStepDblAlCalculator.Process(accountDetails); Assert.IsFalse(result); }
public void ExceptionSixButNotAForeignAccount() { var accountDetails = new BankAccountDetails("202959", "63748472"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _secondStepDblAlCalculator.Process(accountDetails); Assert.IsTrue(result); }
public void ExceptionThreeWhereCisNeitherSixNorNine() { var accountDetails = new BankAccountDetails("827101", "28748352"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _secondStepDblAlCalculator.Process(accountDetails); Assert.IsTrue(result); }
public void CanProcessStandardElevenCheck() { var accountDetails = new BankAccountDetails("000000", "58177632"); accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); var result = new FirstStandardModulusElevenCalculator().Process(accountDetails); Assert.True(result); }
public void CanPassBasicModulus11Test() { var accountDetails = new BankAccountDetails("202959", "63748472"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _calculator.Process(accountDetails); Assert.IsTrue(result); }
public void KnownSortCodeIsTested(string sc, string an) { var accountDetails = new BankAccountDetails(sc, an); accountDetails.WeightMappings = _mockModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); _ruleStep.Process(accountDetails); _firstModulusCalculatorStep.Verify(nr => nr.Process(accountDetails)); }
public void CanProcessDoubleAlternateCheck() { var accountDetails = new BankAccountDetails("499273", "12345678"); accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); var result = _firstStepDblAlCalculator.Process(accountDetails); Assert.True(result); }
public void ExceptionFiveFirstCheckCorrectSecondIncorrect() { var details = new BankAccountDetails("938063", "15764273"); var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5"); var actual = _check.GetModulusSum(details, mapping); Assert.AreEqual(58, actual); }
protected bool ProcessWeightingRule(BankAccountDetails bankAccountDetails, IModulusWeightMapping modulusWeightMapping) { var weightingSum = new StandardModulusCheck().GetModulusSum(bankAccountDetails,modulusWeightMapping); var remainder = weightingSum%Modulus; return modulusWeightMapping.Exception == 4 ? bankAccountDetails.AccountNumber.GetExceptionFourCheckValue == remainder : remainder == 0; }
//938000 938696 Mod11 7 6 5 4 3 2 7 6 5 4 3 2 0 0 5 //938000 938696 DblAl 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5 public void ExceptionFiveDoubleAlternateWhenBothPass() { var details = new BankAccountDetails("938063", "55065200"); var mapping = new ModulusWeightMapping("938000 938696 DblAl 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5"); var actual = _check.GetModulusSum(details, mapping); Assert.AreEqual(40,actual); Assert.AreEqual(0,actual%10); }
public void CanGetSecondAlternativeExceptionTwoValue() { var target = new BankAccountDetails("123456", "10000090") { WeightMappings = BuildMappingList("123456", 1, 1) }; Assert.AreEqual(BankAccountDetails.AisNotZeroAndGisNineWeights, target.GetExceptionTwoAlternativeWeights(new int[1])); }
public void CorrectlySkipsUncheckableForeignAccount() { var accountDetails = new BankAccountDetails("200915", "41011166"); accountDetails.WeightMappings = _mockModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); _ruleStep.Process(accountDetails); Assert.IsTrue(accountDetails.FirstResult); _firstModulusCalculatorStep.Verify(nr => nr.Process(accountDetails), Times.Never()); }
public void CanCalculateForExceptionFiveWhereBothChecksPass() { var accountDetails = new BankAccountDetails("938063", "55065200"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var standardResult = _standardExceptionFiveCalculator.Process(accountDetails); var doubleResult = _secondDoubleAlternateExceptionFiveCalculator.Process(accountDetails); Assert.IsTrue(standardResult); Assert.IsTrue(doubleResult); }
public override bool Process(BankAccountDetails bankAccountDetails) { if (!bankAccountDetails.AccountNumber.IsValidCouttsNumber) { return false; } bankAccountDetails.AccountNumber.SetElementAt(7, '0'); return base.Process(bankAccountDetails); }
public void CanCalculateForExceptionFiveWhereFirstCheckDigitIsIncorrectWithARemainderOfOne() { var accountDetails = new BankAccountDetails("938063", "15763217"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var result = _standardExceptionFiveCalculator.Process(accountDetails); var doubleResult = _secondDoubleAlternateExceptionFiveCalculator.Process(accountDetails); Assert.IsFalse(result); Assert.IsTrue(doubleResult); }
private void ValidateStandardModulusWeightSumCalculation(string sc, string an, string mappingString, int expected) { var details = new BankAccountDetails(sc, an) { WeightMappings = new [] { ModulusWeightMapping.From(mappingString) } }; var actual = _checker.GetModulusSum(details, details.WeightMappings.First()); Assert.AreEqual(expected, actual); }
public void ExceptionOneChangesSum() { var details = new BankAccountDetails("123456", "12345678"); var mapping = new ModulusWeightMapping("012345 012346 dblal 1 2 3 4 5 6 7 8 9 10 11 12 13 14"); var withNoException = _check.GetModulusSum(details, mapping); mapping = new ModulusWeightMapping("012345 012346 dblal 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1"); var withException = _check.GetModulusSum(details, mapping); Assert.IsTrue(withNoException + 27 == withException); }
public void CanCalculateForExceptionFiveWhereCheckPassesWithSubstitution() { var accountDetails = new BankAccountDetails("938600", "42368003"); accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode); var standardResult = _standardExceptionFiveCalculator.Process(accountDetails); var doubleResult = _secondDoubleAlternateExceptionFiveCalculator.Process(accountDetails); Assert.IsTrue(standardResult); Assert.IsTrue(doubleResult); }
public bool GetModulusCalculation(BankAccountDetails bankAccountDetails) { Func<BankAccountDetails, bool> modulusChoice; if (_firstStepModulusChoices.TryGetValue(bankAccountDetails.WeightMappings.First().Algorithm, out modulusChoice)) { return modulusChoice(bankAccountDetails); } throw new InvalidOperationException("The routing dictionary had no match for the modulus algorithm provided"); }
public override bool Process(BankAccountDetails bankAccountDetails) { if (bankAccountDetails.WeightMappings.Count() != 2) { throw new ArgumentException( "Second Step Check must be passed bank details with two weight mapping rules"); } return ProcessWeightingRule(bankAccountDetails, bankAccountDetails.WeightMappings.Second()); }
public void UnknownSortCodeIsValid() { const string sortCode = "123456"; var accountDetails = new BankAccountDetails(sortCode, "12345678"); accountDetails.WeightMappings = _mockModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode); var result = _ruleStep.Process(accountDetails); Assert.IsTrue(result); Assert.IsTrue(accountDetails.FirstResult); _firstModulusCalculatorStep.Verify(fmc => fmc.Process(It.IsAny<BankAccountDetails>()), Times.Never()); }
/// <summary> /// If there are no SortCode Modulus Weight Mappings available then the BankAccountDetails validate as true. /// Otherwise move onto the first modulus calculation step /// </summary> public bool Process(BankAccountDetails bankAccountDetails) { var isValidForModulusCheck = bankAccountDetails.IsValidForModulusCheck(); var isUncheckableForeignAccount = bankAccountDetails.IsUncheckableForeignAccount(); if (!isValidForModulusCheck || isUncheckableForeignAccount) return true; var result = _firstModulusCalculatorStep.Process(bankAccountDetails); return result; }
/// <summary> /// /Perform the second double alternate check, and for the double alternate check with exception 5 the /// checkdigit is h from the original account number, except: /// • After dividing the result by 10; /// - if the remainder=0 and h=0 the account number is valid /// - for all other remainders, take the remainder away from 10. If the number you get is the same as h /// then the account number is valid. /// </summary> /// <param name="bankAccountDetails"></param> /// <returns></returns> public override bool Process(BankAccountDetails bankAccountDetails) { var remainder = GetWeightSumForStep(bankAccountDetails) % Modulus; switch (remainder) { case 0: return bankAccountDetails.AccountNumber.IntegerAt(7) == 0; default: return (Modulus - remainder) == bankAccountDetails.AccountNumber.IntegerAt(7); } }
private bool InitialSecondCheck(BankAccountDetails bankAccountDetails, IModulusWeightMapping mapping) { var alternativeWeightMapping = new ModulusWeightMapping(mapping) { WeightValues = bankAccountDetails .GetExceptionTwoAlternativeWeights( mapping.WeightValues) }; return ProcessWeightingRule(bankAccountDetails, alternativeWeightMapping); }