public void DeriveStatusAndStatusSort_WhenCaseFlowDtoPropertiesIndicate_ViewAccountOnly_SetsStatusAndStatusName_On_ServiceDto(
double?testOutstandingBalance)
{
// Note: using double because 'decimal' can't be used in DataRow
CaseFlowAccountCommonTest caseFlowDto = new CaseFlowAccountCommonTest()
{
OutstandingBalance = (decimal?)testOutstandingBalance,
CanSetupIndividualPlan = false,
CanMakePayment = false
};
MyAccountsSummaryResultDto resultDtoToBeUpdated = new MyAccountsSummaryResultDto();
_process.DeriveStatusAndStatusSort(caseFlowDto, resultDtoToBeUpdated);
Assert.AreEqual("View Account Details Only", resultDtoToBeUpdated.AccountStatus);
Assert.AreEqual(StatusSort_ViewAccountDetailsOnly, resultDtoToBeUpdated.AccountStatusSort);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsClosed);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsWithSolicitors);
Assert.AreEqual(true, resultDtoToBeUpdated.AccountStatusIsViewOnly);
Assert.AreEqual(false, resultDtoToBeUpdated.CanManageAccount);
}
public void DeriveStatusAndStatusSort_WhenCaseFlowDtoPropertiesIndicate_NoPaymentArrangement_SetsStatusAndStatusName_On_ServiceDto(
double?testOutstandingBalance, bool testIsPlanInPlace)
{
// Note: using double because 'decimal' can't be used in DataRow
CaseFlowAccountCommonTest caseFlowDto = new CaseFlowAccountCommonTest()
{
OutstandingBalance = (decimal?)testOutstandingBalance,
HasArrangement = testIsPlanInPlace,
CanMakePayment = true // must set this or 'can set up plan' to avoid falling into View Only
};
MyAccountsSummaryResultDto resultDtoToBeUpdated = new MyAccountsSummaryResultDto();
_process.DeriveStatusAndStatusSort(caseFlowDto, resultDtoToBeUpdated);
Assert.AreEqual("There are no payments set up on this account.", resultDtoToBeUpdated.AccountStatus);
Assert.AreEqual(StatusSort_NoPaymentArrangement, resultDtoToBeUpdated.AccountStatusSort);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsClosed);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsWithSolicitors);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsViewOnly);
Assert.AreEqual(true, resultDtoToBeUpdated.CanManageAccount);
}
//
// Private
//
void PopulateCommonFields(ICaseFlowAccountCommon accountDto, MyAccountsSummaryResultDto resultDto, DateTime currentDateTime)
{
resultDto.OriginalCompany = accountDto.ClientName;
resultDto.AccountReference = accountDto.LowellReference;
resultDto.OutstandingBalance = accountDto.OutstandingBalance ?? 0.0M;
resultDto.HasArrangement = accountDto.HasArrangement;
resultDto.DiscountedBalance = DeriveDiscountedBalance(accountDto);
if (accountDto.HasArrangement && accountDto.OutstandingBalance > 0.0M)
{
resultDto.PaymentPlanMethod = accountDto.PlanType;
resultDto.PaymentPlanFrequency = accountDto.PlanFrequency;
resultDto.PaymentPlanAmount = accountDto.RegularAccountPaymentAmount;
}
// Note: expiry check only uses date part of current date, because the expiry is only a date
if (accountDto.DiscountAmount != null &&
accountDto.DiscountExpiry != null && currentDateTime.Date <= accountDto.DiscountExpiry &&
!IsDiscountAccepted(accountDto) &&
!_statusDeriverProcess.IsWithSolicitors(accountDto) &&
!(accountDto.HasArrangement && accountDto.PlanType == "Direct Debit"))
{
resultDto.DiscountOfferAmount = accountDto.DiscountAmount;
resultDto.DiscountOfferExpiry = accountDto.DiscountExpiry;
}
if (accountDto.Arrears > 0 && accountDto.HasArrangement)
{
resultDto.PaymentPlanArrearsAmount = accountDto.Arrears;
}
if (accountDto.HasArrangement &&
(accountDto.PlanType == "Direct Debit" ||
accountDto.PlanType == "Debit Card" ||
accountDto.PlanType == "Credit Card"))
{
resultDto.PaymentPlanIsAutomated = true;
}
_statusDeriverProcess.DeriveStatusAndStatusSort(accountDto, resultDto);
// Override 'Can Make Payment' to false, if with solicitors (worked out by status deriver)
if (resultDto.AccountStatusIsWithSolicitors)
{
resultDto.CanMakePayment = false;
}
else
{
resultDto.CanMakePayment = accountDto.CanMakePayment;
}
resultDto.CanAmendPlan = accountDto.CanAmendPlan;
resultDto.DirectDebitInFlight = accountDto.DirectDebitInFlight;
resultDto.NextPlanPaymentDate = accountDto.NextPlanPaymentDate;
resultDto.AddedSinceLastLogin = accountDto.AddedSinceLastLogin;
resultDto.NeverAllowPlanTransfer = accountDto.NeverAllowPlanTransfer;
resultDto.PlanPendingTransfer = accountDto.PlanPendingTransfer;
resultDto.PlanTransferredFrom = accountDto.PlanTransferredFrom;
}
// Updates the result Dto (passed up to portal), using CaseFlow information
public void DeriveStatusAndStatusSort(ICaseFlowAccountCommon caseFlowDto, MyAccountsSummaryResultDto resultDtoToBeUpdated)
{
// Closed
if ((caseFlowDto.OutstandingBalance ?? 0M) <= 0M &&
caseFlowDto.CanMakePayment == false &&
caseFlowDto.CanSetupIndividualPlan == false)
{
resultDtoToBeUpdated.AccountStatus = "Closed";
resultDtoToBeUpdated.AccountStatusSort = 5;
resultDtoToBeUpdated.AccountStatusIsClosed = true;
return;
}
// With Lowell Solicitors
if (caseFlowDto.Company == SolicitorsCompanyCode)
{
resultDtoToBeUpdated.AccountStatus = "With Lowell Solicitors";
resultDtoToBeUpdated.AccountStatusSort = 3;
resultDtoToBeUpdated.AccountStatusIsWithSolicitors = true;
return;
}
// View Account Details Only
if ((caseFlowDto.OutstandingBalance ?? 0M) > 0M &&
caseFlowDto.CanMakePayment == false &&
caseFlowDto.CanSetupIndividualPlan == false)
{
resultDtoToBeUpdated.AccountStatus = "View Account Details Only";
resultDtoToBeUpdated.AccountStatusSort = 4;
resultDtoToBeUpdated.AccountStatusIsViewOnly = true;
return;
}
// No Payment Arrangement
if ((caseFlowDto.OutstandingBalance ?? 0M) > 0M &&
caseFlowDto.HasArrangement == true)
{
resultDtoToBeUpdated.AccountStatus = "Plan in Place";
resultDtoToBeUpdated.AccountStatusSort = 1;
resultDtoToBeUpdated.CanManageAccount = true;
return;
}
// Otherwise... Must Plan in Place
resultDtoToBeUpdated.AccountStatus = "There are no payments set up on this account.";
resultDtoToBeUpdated.AccountStatusSort = 2;
resultDtoToBeUpdated.CanManageAccount = true;
}
internal async Task <MyAccountsResultDto> GetMyAccountsSummary(string accountId, DateTime currentDateTime)
{
CaseFlowMyAccountsDto caseFlowDto = await _getProcess.GetMyAccountsSummary(accountId);
MyAccountsResultDto resultDto = new MyAccountsResultDto();
resultDto.Accounts = new List <MyAccountsSummaryResultDto>();
foreach (ICaseFlowAccountCommon caseFlowSummaryDto in caseFlowDto.Summaries)
{
MyAccountsSummaryResultDto accountDto = new MyAccountsSummaryResultDto();
PopulateCommonFields(caseFlowSummaryDto, accountDto, currentDateTime);
resultDto.Accounts.Add(accountDto);
}
resultDto.Accounts.Sort(new AccountComparer());
return(resultDto);
}
public void DeriveStatusAndStatusSort_WhenCaseFlowDtoPropertiesIndicate_NOT_NoPaymentArrangement_SetsAnotherStatusAndStatusName_On_ServiceDto(
double?testOutstandingBalance, bool testIsPlanInPlace)
{
// Note: using double because 'decimal' can't be used in DataRow
CaseFlowAccountCommonTest caseFlowDto = new CaseFlowAccountCommonTest()
{
OutstandingBalance = (decimal?)testOutstandingBalance,
HasArrangement = testIsPlanInPlace,
CanMakePayment = true // must set this or 'can set up plan' to avoid falling into View Only
};
MyAccountsSummaryResultDto resultDtoToBeUpdated = new MyAccountsSummaryResultDto();
_process.DeriveStatusAndStatusSort(caseFlowDto, resultDtoToBeUpdated);
// Checks NOT at status
Assert.AreNotEqual("No Payment Arrangement", resultDtoToBeUpdated.AccountStatus);
Assert.AreNotEqual(StatusSort_NoPaymentArrangement, resultDtoToBeUpdated.AccountStatusSort);
}
public void DeriveStatusAndStatusSort_WhenCaseFlowDtoPropertiesIndicate_NOT_WithSolicitors_SetsAnotherStatusAndStatusName_On_ServiceDto(
long?testCompany)
{
CaseFlowAccountCommonTest caseFlowDto = new CaseFlowAccountCommonTest()
{
Company = testCompany, // *** IMPORTANT: if change method to company number, must also change CLOSED test
// Is superceded by 'Closed' therefore requires balance
// (not exhaustively testing this because 'Closed' tests check with company code 2)
OutstandingBalance = 0.1M
};
MyAccountsSummaryResultDto resultDtoToBeUpdated = new MyAccountsSummaryResultDto();
_process.DeriveStatusAndStatusSort(caseFlowDto, resultDtoToBeUpdated);
// Checks NOT at status
Assert.AreNotEqual("With Lowell Solicitors", resultDtoToBeUpdated.AccountStatus);
Assert.AreNotEqual(StatusSort_WithLowellSolicitors, resultDtoToBeUpdated.AccountStatusSort);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsWithSolicitors);
}
public void DeriveStatusAndStatusSort_WhenCaseFlowDtoPropertiesIndicate_NOT_Closed_SetsAnotherStatusAndStatusName_On_ServiceDto(
double?testOutstandingBalance, bool testCanSetupIndividualPlan, bool testCanMakePayment)
{
// Note: using double because 'decimal' can't be used in DataRow
CaseFlowAccountCommonTest caseFlowDto = new CaseFlowAccountCommonTest()
{
OutstandingBalance = (decimal?)testOutstandingBalance,
CanSetupIndividualPlan = testCanSetupIndividualPlan,
CanMakePayment = testCanMakePayment
};
MyAccountsSummaryResultDto resultDtoToBeUpdated = new MyAccountsSummaryResultDto();
_process.DeriveStatusAndStatusSort(caseFlowDto, resultDtoToBeUpdated);
// Checks NOT at status
Assert.AreNotEqual("Closed", resultDtoToBeUpdated.AccountStatus);
Assert.AreNotEqual(StatusSort_Closed, resultDtoToBeUpdated.AccountStatusSort);
Assert.AreEqual(false, resultDtoToBeUpdated.AccountStatusIsClosed);
}
public void GetMyAccounts_WhenProvidedUserId_RetrievesAccounts_And_OutputsTransformedModels()
{
// Arrange
const string userId = "Anything456";
CaseFlowMyAccountsDto caseFlowDto = new CaseFlowMyAccountsDto()
{
Summaries = new List <CaseFlowMyAccountsDto.AccountSummaryDto>()
{
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
LowellReference = "1234",
ClientName = "BarclayBob",
OutstandingBalance = 1234.56M,
CanMakePayment = false,
HasArrangement = true,
PlanType = "Direct Debit",
PlanFrequency = "Monthly",
RegularAccountPaymentAmount = 123.45M
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
LowellReference = "abc345",
ClientName = "Wah",
OutstandingBalance = 101.22M,
CanMakePayment = true,
// Ensure works with nulls
HasArrangement = false,
PlanType = null,
PlanFrequency = null,
RegularAccountPaymentAmount = null
},
}
};
_mockGetProcess.Setup(x => x.GetMyAccounts(userId)).Returns(Task.FromResult(caseFlowDto));
// Act
MyAccountsResultDto resultDto = _service.GetMyAccounts(userId).Result;
// Assert
Assert.AreEqual(2, resultDto.Accounts.Count);
{
MyAccountsSummaryResultDto account = resultDto.Accounts[0];
Assert.AreEqual("1234", account.AccountReference);
Assert.AreEqual("BarclayBob", account.OriginalCompany);
Assert.AreEqual(1234.56M, account.OutstandingBalance);
Assert.AreEqual(false, account.CanMakePayment);
Assert.AreEqual("Direct Debit", account.PaymentPlanMethod);
Assert.AreEqual("Monthly", account.PaymentPlanFrequency);
Assert.AreEqual(123.45M, account.PaymentPlanAmount);
}
{
MyAccountsSummaryResultDto account = resultDto.Accounts[1];
Assert.AreEqual("abc345", account.AccountReference);
Assert.AreEqual("Wah", account.OriginalCompany);
Assert.AreEqual(101.22M, account.OutstandingBalance);
Assert.AreEqual(true, account.CanMakePayment);
Assert.AreEqual(null, account.PaymentPlanMethod);
Assert.AreEqual(null, account.PaymentPlanFrequency);
Assert.AreEqual(null, account.PaymentPlanAmount);
}
}
public void GetMyAccountsSummary_WhenProvidedAccountId_RetrievesAccounts_CallsStatusDeriver_And_OrdersCorrectlyByStatusSortThenAccountName()
{
// Note: using mock Status Deriver, so as to avoid exhaustively testing statuses here, as responsibility
// for deriving statuses is with concrete Status Deriver class
// Mock will apply some status sort (and status) values, allowing testing of sort / sub-sort behaviour
// in service class under test
_mockStatusDeriverProcess.Setup(x => x.DeriveStatusAndStatusSort(
It.IsAny <ICaseFlowAccountCommon>(),
It.IsAny <MyAccountsSummaryResultDto>()))
.Callback <ICaseFlowAccountCommon, MyAccountsSummaryResultDto>(
(caseFlowAccountDto, resultDto) =>
{
// Status deriver places 'Company' (long integer) field into sort field to facilitate testing
Debug.Assert(caseFlowAccountDto.Company != null);
resultDto.AccountStatusSort = (int)caseFlowAccountDto.Company.Value;
});
// Get returns some CaseFlow dto's with mixed up sort ordering
// Ordering is by AccountStatusSort then ClientName
CaseFlowMyAccountsDto caseFlowDto = new CaseFlowMyAccountsDto()
{
Summaries = new List <CaseFlowMyAccountsDto.AccountSummaryDto>()
{
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 4, ClientName = "Def"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 100, ClientName = "jjj"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 3, ClientName = "1a"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 1, ClientName = "zzz"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 4, ClientName = "Ghi"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 3, ClientName = "1b"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 4, ClientName = "Abc"
},
new CaseFlowMyAccountsDto.AccountSummaryDto()
{
Company = 2, ClientName = "wibble"
},
}
};
_mockGetProcess.Setup(x => x.GetMyAccountsSummary("anything")).Returns(Task.FromResult(caseFlowDto));
//
// Check output is correctly ordered
//
MyAccountsResultDto outputDto = _service.GetMyAccountsSummary("anything").Result;
Assert.AreEqual(8, outputDto.Accounts.Count);
// Sort Value 1
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[0];
Assert.AreEqual("zzz", accountDto.OriginalCompany);
Assert.AreEqual(1, accountDto.AccountStatusSort);
}
// Sort Value 2
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[1];
Assert.AreEqual("wibble", accountDto.OriginalCompany);
Assert.AreEqual(2, accountDto.AccountStatusSort);
}
// Sort Value 3
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[2];
Assert.AreEqual("1a", accountDto.OriginalCompany);
Assert.AreEqual(3, accountDto.AccountStatusSort);
}
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[3];
Assert.AreEqual("1b", accountDto.OriginalCompany);
Assert.AreEqual(3, accountDto.AccountStatusSort);
}
// Sort Value 4
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[4];
Assert.AreEqual("Abc", accountDto.OriginalCompany);
Assert.AreEqual(4, accountDto.AccountStatusSort);
}
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[5];
Assert.AreEqual("Def", accountDto.OriginalCompany);
Assert.AreEqual(4, accountDto.AccountStatusSort);
}
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[6];
Assert.AreEqual("Ghi", accountDto.OriginalCompany);
Assert.AreEqual(4, accountDto.AccountStatusSort);
}
// Sort Value 100
{
MyAccountsSummaryResultDto accountDto = outputDto.Accounts[7];
Assert.AreEqual("jjj", accountDto.OriginalCompany);
Assert.AreEqual(100, accountDto.AccountStatusSort);
}
}
