public static void Main(string[] args)
{
var userInterface = new UserInterface();
if (!userInterface.AreInputsValid(args))
{
userInterface.DisplayUsageMessage();
}
var file = args[0];
var amount = int.Parse(args[1]);
var appSettings = new AppSettings();
var marketDataDataAccess = new MarketDataDataAccess(new FileSystem(), appSettings, file);
try
{
var marketData = marketDataDataAccess.ReadAllMarketData();
var loanCalculator = new LoanCalculator(marketData, appSettings, amount);
var quote = loanCalculator.Calculate();
userInterface.DisplayQuote(quote);
}
catch (Exception e)
{
userInterface.DisplayExceptionMessage(e);
}
}
public void DoTheMathTestAmountinputDownNegative()
{
// Arrange
var loanCalculator = new LoanCalculator();
var loanCalcInput = new LoanCalcInput()
{
Amount = 100000,
Interest = 0.055F,
DownPayment = -20000,
Term = 30
};
// Act
var exceptionMessage = null as string;
try
{
loanCalculator.DoTheMath(loanCalcInput);
}
catch (Exception e)
{
exceptionMessage = e.Message;
}
// Assert
var expectedExceptionMessage = $"{LoanCalculator.NegativeNumberNotAllowedMessage}\r\n" +
$"{LeadTextParameterName}{LoanCalculator.ParamLabelInputDownPayment}\r\n" +
$"{LeadTextActualValue}{loanCalcInput.DownPayment}.";
Assert.AreEqual(expectedExceptionMessage, exceptionMessage);
}
public void LoanCalculatorLoanOnlySmall()
{
LoanCalculator lc = new LoanCalculator(amntCar);
Assert.Equal(pmtcarAt45For5, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Car, lc.LoanType);
}
public void LoanCalculatorLoanOnlyLarge()
{
LoanCalculator lc = new LoanCalculator(amntHouse);
Assert.Equal(pmtHouseAt45For30, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Home, lc.LoanType);
}
public void Run_WithValidInput_WorksCorrectly()
{
// Data
var memberDetailsData =
JsonConvert.DeserializeObject <MemberDetails[]>(System.IO.File.ReadAllText(@"./Data/members.json"));
var memberContributions = JsonConvert.DeserializeObject <MemberContributions[]>(
System.IO.File.ReadAllText(@"./Data/contributions.json"));
// Arrange
var loansCalculator = new LoanCalculator();
var loansRepositoryMock = new Mock <ILoansRepository>();
loansRepositoryMock.Setup(x => x.GetMemberDetails(It.IsAny <int[]>()))
.Returns(() => memberDetailsData);
loansRepositoryMock.Setup(x => x.GetMemberContributions(It.IsAny <int>()))
.Returns(() => memberContributions[0]);
var memberIds = memberDetailsData.Select(x => x.Id).ToArray();
// Act
var sut = new LoanCalculatorService(loansRepositoryMock.Object, loansCalculator);
sut.Run(memberIds);
// Assert
// 1. Repository calls
loansRepositoryMock.Verify(x =>
x.GetMemberDetails(memberIds), Times.AtMostOnce);
loansRepositoryMock.Verify(x => x.GetMemberContributions(It.Is <int>(x => x == memberIds[0])));
loansRepositoryMock.Verify(x => x.SaveMemberLoan(
It.Is <int>(x => x == memberIds[0]),
It.Is <int>(x => x == 85000)));
}
public static List<AmortizationScheduleModel> CreateScheduleItems(LoanApplication loanApplication, AmortizationSchedule schedule)
{
var today = DateTime.Now;
LoanCalculatorOptions options = new LoanCalculatorOptions();
options.LoanReleaseDate = schedule.LoanReleaseDate;
options.PaymentStartDate = schedule.PaymentStartDate;
options.LoanAmount = loanApplication.LoanAmount;
options.LoanTerm = loanApplication.LoanTermLength;
options.LoanTermId = loanApplication.LoanTermUomId;
var paymentMode = UnitOfMeasure.GetByID(loanApplication.PaymentModeUomId);
options.PaymentMode = paymentMode.Name;
options.PaymentModeId = paymentMode.Id;
var aiInterestComputationMode = ApplicationItem.GetFirstActive(loanApplication.Application, ProductFeatureCategory.InterestComputationModeType);
int interestComputation = 0;
if (aiInterestComputationMode != null)
interestComputation = aiInterestComputationMode.ProductFeatureApplicability.ProductFeatureId;
var interestComputationMode = ProductFeature.GetById(interestComputation);
var interestRate = ProductFeature.GetByName(loanApplication.InterestRateDescription);
options.InterestComputationMode = interestComputationMode.Name;
options.InterestRateDescription = interestRate.Name;
options.InterestRate = loanApplication.InterestRate ?? 0;
options.InterestRateDescriptionId = interestRate.Id;
LoanCalculator calculator = new LoanCalculator();
var items = calculator.GenerateLoanAmortization(options);
return items;
}
public void CalculateTest()
{
var calculator = new LoanCalculator();
LoanCalculations actual = calculator.Calculate(new PersonalLoan(PersonalLoanName, 100000, 10, 6, Payback.EveryMonth));
Assert.Equal(new LoanCalculations(10600m, 106000m, 6000m), actual, new LoanCalculationsComparer());
}
public void Calculate_WhenAmountInvalid_ThrowsException(int amount)
{
var loanCalculator = new LoanCalculator(null, _appSettingsMock.Object, amount);
Action action = () => loanCalculator.Calculate();
action.ShouldThrow <ArgumentException>().WithMessage(
"The loan amount must be between 1000 " +
"and 15000 inclusive and must be a multiple of 100.");
}
public void display_an_eror_message_if_the_number_of_input_parameters_is_incorrect(params string[] input)
{
var loanCalculator = new LoanCalculator(inputValidator.Object, quotePrinterMock.Object, marketDataSource.Object,
marketLenders.Object, interestCalculationMock.Object);
loanCalculator.GetQuoteFor(MonthlyPayments, input);
quotePrinterMock.Verify(a => a.PrintError(It.IsAny <string>()), Times.Once);
}
public void LoanCalculatorLargeThenSetTypeToSmall()
{
LoanCalculator lc = new LoanCalculator(amntHouse);
lc.LoanType = LoanCalculator.LoanTypes.Small;
Assert.Equal(pmtHouseAt45For5, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Small, lc.LoanType);
}
public void LoanCalculatorSmallThenSetTypeToLarge()
{
LoanCalculator lc = new LoanCalculator(amntCar);
lc.LoanType = LoanCalculator.LoanTypes.Home;
Assert.Equal(pmtCarAt45For30, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Home, lc.LoanType);
}
public void SetAllLargeThenSetTypeToLarge()
{
LoanCalculator lc = new LoanCalculator(amntHouse);
lc.LoanType = LoanCalculator.LoanTypes.Home;
SetAllToZero(lc);
Assert.Equal(pmtHouseAt45For30, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Home, lc.LoanType);
}
public void HighInterestTest()
{
float principle = 10000;
float rate = 1.0f;
int payments = 24;
float ExpectedAmount = 976.32f;
float result = LoanCalculator.CalculateLoan(principle, rate, payments);
Assert.AreEqual(ExpectedAmount.ToString("0.00"), result.ToString("0.00"));
}
public void CalculateLoan()
{
int amountToBorrow = 1000;
var calculator = new LoanCalculator(_lenders);
LoanQuote quote = calculator.Calculate(amountToBorrow, 36);
var expectedQuote = new LoanQuote(1000, 0.07M, 30.88M, 1111.53M);
Assert.AreEqual(expectedQuote, quote);
}
public void ZeroPrincipleTest()
{
float principle = 0;
float rate = 0.15f;
int payments = 15;
float ExpectedAmount = 0;
float result = LoanCalculator.CalculateLoan(principle, rate, payments);
Assert.AreEqual(ExpectedAmount.ToString("0.00"), result.ToString("0.00"));
}
public void ZeroRateTest()
{
float principle = 99;
float rate = 0f;
int payments = 1;
string ExpectedAmount = "NaN";
float result = LoanCalculator.CalculateLoan(principle, rate, payments);
Assert.AreEqual(ExpectedAmount, result.ToString("0.00"));
}
public void SetAllSmallThenSetTypeToSmall()
{
LoanCalculator lc = new LoanCalculator(amntCar);
lc.LoanType = LoanCalculator.LoanTypes.Small;
SetAllToZero(lc);
Assert.Equal(pmtcarAt45For5, lc.CalculatePayment());
Assert.Equal(LoanCalculator.LoanTypes.Small, lc.LoanType);
}
public void NormalTest()
{
float principle = 2018;
float rate = 0.15f;
int payments = 12;
float ExpectedAmount = 182.14f;
float result = LoanCalculator.CalculateLoan(principle, rate, payments);
Assert.AreEqual(ExpectedAmount.ToString("0.00"), result.ToString("0.00"));
}
public void ZeroPayments()
{
float principle = 500;
float rate = 0.08f;
int payments = 0;
string ExpectedAmount = "∞";
float result = LoanCalculator.CalculateLoan(principle, rate, payments);
Assert.AreEqual(ExpectedAmount, result.ToString("0.00"));
}
public void Calculate_WhenOnlyOneLenderExistsAndHeCanSupplyAllTheMoney_PicksThatLender()
{
var lenders = new List <Lender> {
new Lender("Lender 1", 0.07m, 1000)
};
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
VerifyQuote(quote, 0.07m, 1000, 1005.65m, 1005.65m);
}
public void GetBoostLoanAmount_WithValidInput_ReturnsValidResult(double memberTerm, int expectedResult)
{
// Arrange
var sut = new LoanCalculator();
// Act
var result = sut.GetBoostLoanAmount(memberTerm);
// Assert
Assert.Equal(expectedResult, result);
}
public void GetLoanAmount_WithValidInput_ReturnsValidResult(int memberContribution, int expectedResult)
{
// Arrange
var sut = new LoanCalculator();
// Act
var result = sut.GetLoanAmount(memberContribution);
// Assert
Assert.Equal(expectedResult, result);
}
public void LoanCalculatorInSufficientAmountInTheMarket_Test()
{
try
{
loanCalculator = new LoanCalculator(@"market.csv", 15000);
}
catch(Exception ex)
{
Assert.IsTrue(ex.Message.Contains("It is impossible to provide quote at this time!"));
}
}
public void Calculate_WhenALenderHasMoreThanTheAmountRequired_BorrowsAmountRequiredFromLender()
{
var lenders = new List <Lender>
{
new Lender("Lender 1", 0.01m, 2000)
};
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
VerifyQuote(quote, 0.01m, 1000, 1000.83m, 1000.83m);
}
public void TestExampleCase()
{
var calculator = new LoanCalculator(new LoanOptions {
Interest = 5, AdministrationFeeRate = 1, AdministrationFeeMax = 10000
});
var result = calculator.Calculate(500000, 120);
result.AdminstrationFee.Should().Be(5000);
result.MonthlyPayment.Should().Be(5303.28f);
result.TotalInterest.Should().Be(136393.09f);
result.AnnualPercentageRate.Should().Be(5.22f);
}
public void CalculateInterestPaidPercentage_WithZeroLoanTerm_Exception()
{
// ARRANGE
decimal totalAmountRepaid = 3000;
int loanTerm = 0;
decimal totalDebt = 9000;
// ACT
// ASSERT
Assert.Throws <ArgumentException>(() =>
LoanCalculator.InterestPaidPercentage(totalAmountRepaid, loanTerm, totalDebt));
}
public void display_an_eror_message_if_exception_was_caught()
{
var loanCalculator = new LoanCalculator(inputValidator.Object, quotePrinterMock.Object, marketDataSource.Object,
marketLenders.Object, interestCalculationMock.Object);
var errorMessage = "an error message";
marketLenders.Setup(a => a.GetMinInterestRate(new LoanOffers(), It.IsAny <Money>(), It.IsAny <int>()))
.Throws(new ZopaLoansException(errorMessage));
loanCalculator.GetQuoteFor(MonthlyPayments, inputParameters);
quotePrinterMock.Verify(a => a.PrintError(errorMessage), Times.Once);
}
public void CalculateInterestPaidPercentage_WithOneMonthLoanTerm_ReturnsZero()
{
// ARRANGE
decimal totalAmountRepaid = 9000;
int loanTerm = 1;
decimal totalDebt = 9000;
// ACT
var interestPercent = LoanCalculator.InterestPaidPercentage(totalAmountRepaid, loanTerm, totalDebt);
// ASSERT
Assert.AreEqual(interestPercent, 0);
}
public void Calculate_WhenMultipleLendersExistAndTheyAllCanSupplyExactlyTheWholeAmount_PicksTheOneWithTheLowestRate()
{
var lenders = new List <Lender>
{
new Lender("Lender 1", 0.08m, 1000),
new Lender("Lender 2", 0.07m, 1000)
};
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
VerifyQuote(quote, 0.07m, 1000, 1005.65m, 1005.65m);
}
public void Calculate_WhenMultipleLendersCombinedHaveMoreThanTheAmountRequired_BorrowsAmountRequiredFromLenders()
{
var lenders = new List <Lender>
{
new Lender("Lender 1", 0.01m, 750),
new Lender("Lender 2", 0.02m, 750)
};
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
VerifyQuote(quote, 0.0125m, 1000, 1001.04m, 1001.04m);
}
public void Calculate_WhenNoQualifyingLendersExist_ReturnsUnQuotable(params int[] availableAmounts)
{
var lenders = new List <Lender>();
foreach (var amount in availableAmounts)
{
lenders.Add(new Lender("Lender " + amount, 1, amount));
}
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
quote.Should().BeOfType <UnQuotable>();
}
public void Calculate_WhenMultipleLendersCanTogetherProvideExactlyTheRightAmount_BorrowsFromAllTheLenders(params int[] availableAmounts)
{
var lenders = new List <Lender>();
for (var index = 0; index < availableAmounts.Length; index++)
{
var amount = availableAmounts[index];
lenders.Add(new Lender("Lender 1" + amount, (index + 1) * 0.01m, amount));
}
var loanCalculator = new LoanCalculator(lenders, _appSettingsMock.Object, 1000);
var quote = loanCalculator.Calculate();
VerifyQuote(quote, 0.021m, 1000, 1001.73m, 1001.73m);
}
protected void btnGenerate_Click(object sender, DirectEventArgs e)
{
LoanApplicationForm form = this.CreateOrRetrieve<LoanApplicationForm>();
form.AmortizationSchedules.Clear();
form.Cheques.Clear();
var today = DateTime.Now;
LoanCalculatorOptions options = new LoanCalculatorOptions();
options.LoanReleaseDate = datLoanReleaseDate.SelectedDate;
options.PaymentStartDate = datPaymentStartDate.SelectedDate;
options.LoanAmount = Convert.ToDecimal(this.nfLoanAmount.Value);
options.LoanTerm = (int)nfLoanTerm.Number;
options.LoanTermId = int.Parse(hiddenLoanTermTimeUnitId.Text);
options.PaymentMode = cmbPaymentMode.SelectedItem.Text;
options.PaymentModeId = int.Parse(cmbPaymentMode.SelectedItem.Value);
options.InterestComputationMode = cmbInterestComputationMode.SelectedItem.Text;
options.InterestRateDescription = cmbInterestRate.SelectedItem.Text;
options.InterestRate = (decimal)nfInterestRate.Number;
options.InterestRateDescriptionId = int.Parse(cmbInterestRate.SelectedItem.Value);
options.PaymentStartDate = datPaymentStartDate.SelectedDate;
options.LoanReleaseDate = datLoanReleaseDate.SelectedDate;
options.TermOption = txtTermOption.Text;
LoanCalculator calculator = new LoanCalculator();
var models = calculator.GenerateLoanAmortization(options);
storeAmortizationSchedule.DataSource = models;
storeAmortizationSchedule.DataBind();
List<AmortizationScheduleModel> sched = new List<AmortizationScheduleModel>();
foreach (var item in models)
{
form.AddSchedule(item);
sched.Add(item);
}
if (chckCheck.Checked)
{
List<ChequeModel> cheque = new List<ChequeModel>();
foreach (AmortizationScheduleModel model in models)
{
ChequeModel cheques = new ChequeModel();
cheques.Amount = model.TotalPayment;
cheques.ChequeDate = model.ScheduledPaymentDate;
form.AddCheque(cheques);
cheque.Add(cheques);
}
storeCheques.DataSource = cheque;
storeCheques.DataBind();
}
else if (chckCheck.Checked == false)
{
this.SelectionModelCheque.SelectAll();
grdpnlCheque.DeleteSelected();
form.Cheques.Clear();
}
hdnOnChangeDates.Value = "0";
}
/// <summary>
/// Setting up environemnt for some tests
/// </summary>
/// <param name="loanAmount"></param>
/// <param name="fileName"></param>
public void Setup(long loanAmount, string fileName = "market.csv")
{
customCulture.NumberFormat.PercentDecimalSeparator = ".";
customCulture.NumberFormat.CurrencyGroupSeparator = "";
loanCalculator = new LoanCalculator(fileName, loanAmount);
}
protected void btnGenerate_Click(object sender, DirectEventArgs e)
{
var today = DateTime.Now;
LoanCalculatorOptions options = new LoanCalculatorOptions();
options.LoanReleaseDate = datLoanReleaseDate.SelectedDate;
options.PaymentStartDate = datPaymentStartDate.SelectedDate;
options.LoanAmount = Convert.ToDecimal(this.nfLoanAmount.Value);
options.LoanTerm = (int)nfLoanTerm.Number;
options.LoanTermId = int.Parse(hiddenLoanTermTimeUnitId.Text);
options.PaymentMode = cmbPaymentMode.SelectedItem.Text;
options.PaymentModeId = int.Parse(cmbPaymentMode.SelectedItem.Value);
options.InterestComputationMode = cmbInterestComputationMode.SelectedItem.Text;
options.InterestRateDescription = cmbInterestRate.SelectedItem.Text;
options.InterestRate = (decimal)nfInterestRate.Number;
options.InterestRateDescriptionId = int.Parse(cmbInterestRate.SelectedItem.Value);
LoanCalculator calculator = new LoanCalculator();
var models = calculator.GenerateLoanAmortization(options);
storeAmortizationSchedule.DataSource = models;
storeAmortizationSchedule.DataBind();
}
public static void Approve(LoanApplication loanApplication, DateTime today, DateTime loanReleaseDate, DateTime paymentStartDate)
{
RoleType borrowerRoleType = RoleType.BorrowerApplicationType;
PartyRole borrowerPartyRole = PartyRole.GetPartyRoleFromLoanApplication(loanApplication, borrowerRoleType);
PartyRole customerPartyRole = PartyRole.GetByPartyIdAndRole(borrowerPartyRole.PartyId, RoleType.CustomerType);
LoanApplicationStatu loanStatus = LoanApplicationStatu.CreateOrUpdateCurrent(loanApplication, LoanApplicationStatusType.ApprovedType, today);
var agreement = Agreement.Create(loanApplication, AgreementType.LoanAgreementType, today);
//Create new Loan Agreement Record
LoanAgreement loanAgreement = new LoanAgreement();
loanAgreement.Agreement = agreement;
Context.LoanAgreements.AddObject(loanAgreement);
var agreementItem = Create(loanApplication, agreement);
Context.AgreementItems.AddObject(agreementItem);
var borrower = RoleType.BorrowerAgreementType;
var newBorrowerPartyRole = PartyRole.Create(borrower, customerPartyRole.Party, today);
Context.PartyRoles.AddObject(newBorrowerPartyRole);
var newBorrowerAgreementRole = CreateAgreementRole(agreement, newBorrowerPartyRole);
Context.AgreementRoles.AddObject(newBorrowerAgreementRole);
CreateAgreementForCoBorrowers(loanApplication, agreement, today);
CreateAgreementForGuarantor(loanApplication, agreement, today);
var pendingdvst = DisbursementVcrStatusEnum.PendingType;
var disbursement = LoanDisbursementVcr.Create(loanApplication, agreement, today);
DisbursementVcrStatu.CreateOrUpdateCurrent(disbursement, pendingdvst, today);
//TODO :: Generate Amortization Schedule....
AmortizationSchedule schedule = new AmortizationSchedule();
schedule.DateGenerated = today;
schedule.EffectiveDate = today;
schedule.LoanReleaseDate = today;
schedule.PaymentStartDate = paymentStartDate;
schedule.LoanAgreement = loanAgreement;
Context.AmortizationSchedules.AddObject(schedule);
LoanCalculatorOptions options = new LoanCalculatorOptions();
var aiInterestComputationMode = ApplicationItem.GetFirstActive(loanApplication.Application, ProductFeatureCategory.InterestComputationModeType);
options.InterestComputationMode = aiInterestComputationMode.ProductFeatureApplicability.ProductFeature.Name;
options.LoanAmount = loanApplication.LoanAmount;
options.LoanTerm = loanApplication.LoanTermLength;
options.LoanTermId = loanApplication.LoanTermUomId;
options.InterestRate = loanApplication.InterestRate ?? 0;
options.InterestRateDescription = loanApplication.InterestRateDescription;
options.InterestRateDescriptionId = Context.ProductFeatures.SingleOrDefault(entity => entity.Name == loanApplication.InterestRateDescription).Id;
options.PaymentModeId = loanApplication.PaymentModeUomId;
options.PaymentMode = UnitOfMeasure.GetByID(options.PaymentModeId).Name;
options.PaymentStartDate = paymentStartDate;
options.LoanReleaseDate = loanReleaseDate;
LoanCalculator loanCalculator = new LoanCalculator();
var models = loanCalculator.GenerateLoanAmortization(options);
foreach (var model in models)
{
AmortizationScheduleItem item = new AmortizationScheduleItem();
item.AmortizationSchedule = schedule;
item.ScheduledPaymentDate = model.ScheduledPaymentDate;
item.PrincipalPayment = model.PrincipalPayment;
item.InterestPayment = model.InterestPayment;
item.PrincipalBalance = model.PrincipalBalance;
item.TotalLoanBalance = model.TotalLoanBalance;
item.IsBilledIndicator = false;
Context.AmortizationScheduleItems.AddObject(item);
}
Context.SaveChanges();
}
