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