public void TestLevyAndCoInvestedCall()
{
// arrange
var levyPayment = new LevyPayment {
AmountDue = 45
};
var coInvestedPayment = new EmployerCoInvestedPayment {
AmountDue = 55
};
var requiredPayment = new RequiredPayment {
AmountDue = 100
};
levyPaymentProcessorMock.Setup(p => p.Process(requiredPayment)).Returns(new[] { levyPayment }).Verifiable();
coInvestedPaymentProcessorMock.Setup(p => p.Process(It.Is <RequiredPayment>(rp => rp.AmountDue == 55))).Returns(new[] { coInvestedPayment }).Verifiable();
// act
var actualPayments = processor.Process(requiredPayment);
// assert
actualPayments.Should().NotBeNull();
actualPayments.Should().HaveCount(2);
actualPayments[0].Should().BeSameAs(levyPayment);
actualPayments[1].Should().BeSameAs(coInvestedPayment);
}
public List <FundingSourcePaymentEvent> BuildFundingSourcePaymentsForRequiredPayment(CalculatedRequiredLevyAmount requiredPaymentEvent,
long employerAccountId, long jobId)
{
var fundingSourceEvents = new List <FundingSourcePaymentEvent>();
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = requiredPaymentEvent.SfaContributionPercentage,
AmountDue = requiredPaymentEvent.AmountDue,
IsTransfer = employerAccountId != requiredPaymentEvent.AccountId &&
requiredPaymentEvent.TransferSenderAccountId.HasValue &&
requiredPaymentEvent.TransferSenderAccountId == employerAccountId
};
var fundingSourcePayments = processor.Process(requiredPayment);
foreach (var fundingSourcePayment in fundingSourcePayments)
{
var fundingSourceEvent = mapper.Map <FundingSourcePaymentEvent>(fundingSourcePayment);
mapper.Map(requiredPaymentEvent, fundingSourceEvent);
fundingSourceEvent.JobId = jobId;
fundingSourceEvents.Add(fundingSourceEvent);
}
return(fundingSourceEvents);
}
public void TestSfaOnlyProcessorsCalled()
{
var requiredPayment = new RequiredPayment();
var employerCoInvestedPaymentProcessorMock = new Mock <IEmployerCoInvestedPaymentProcessor>(MockBehavior.Strict);
var sfaCoInvestedPaymentProcessorMock = new Mock <ISfaCoInvestedPaymentProcessor>(MockBehavior.Strict);
var payment1 = new EmployerCoInvestedPayment {
AmountDue = 0
};
var payment2 = new SfaCoInvestedPayment {
AmountDue = 100
};
employerCoInvestedPaymentProcessorMock.Setup(p => p.Process(requiredPayment)).Returns(payment1).Verifiable();
sfaCoInvestedPaymentProcessorMock.Setup(p => p.Process(requiredPayment)).Returns(payment2).Verifiable();
ICoInvestedPaymentProcessor processor = new CoInvestedPaymentProcessor(employerCoInvestedPaymentProcessorMock.Object, sfaCoInvestedPaymentProcessorMock.Object);
var actualPayments = processor.Process(requiredPayment);
actualPayments.Should().HaveCount(1);
actualPayments[0].Should().BeSameAs(payment2);
employerCoInvestedPaymentProcessorMock.Verify();
sfaCoInvestedPaymentProcessorMock.Verify();
}
public FundingSourcePayment Process(RequiredPayment message)
{
Validate(message);
var fundingSourcePayment = CreatePayment(message);
return(fundingSourcePayment);
}
private CalculatedRequiredIncentiveAmount BuildIncentiveRequiredPaymentEvent(RequiredPayment requiredPayment)
{
var paymentEvent = new CalculatedRequiredIncentiveAmount();
MapCommon(requiredPayment, paymentEvent);
paymentEvent.Type = (IncentivePaymentType)requiredPayment.Type;
paymentEvent.ContractType = (ContractType)ContractType;
return(paymentEvent);
}
private void Validate(RequiredPayment message)
{
var validationResults = validator.Validate(message);
if (validationResults.Any())
{
throw new FundingSourceRequiredPaymentValidationException(JsonConvert.SerializeObject(validationResults));
}
}
private static void AddRefundCommitmentDetails(RequiredPayment requiredPayment, PeriodisedRequiredPaymentEvent requiredPaymentEvent)
{
if (requiredPayment.Amount < 0)
{
requiredPaymentEvent.ApprenticeshipId = requiredPayment.ApprenticeshipId;
requiredPaymentEvent.ApprenticeshipPriceEpisodeId = requiredPayment.ApprenticeshipPriceEpisodeId;
requiredPaymentEvent.ApprenticeshipEmployerType = requiredPayment.ApprenticeshipEmployerType;
}
}
public IReadOnlyList <FundingSourcePayment> Process(RequiredPayment requiredPayment)
{
var transferAmount = levyBalanceService.TryFundTransfer(requiredPayment.AmountDue).AsRounded();
return(transferAmount == 0
? new FundingSourcePayment[0]
: new[] { new TransferPayment {
Type = FundingSourceType.Transfer, AmountDue = transferAmount
}, });
}
protected override FundingSourcePayment CreatePayment(RequiredPayment requiredPayment)
{
var amountToPay = requiredPayment.SfaContributionPercentage * requiredPayment.AmountDue;
return(new SfaCoInvestedPayment
{
AmountDue = amountToPay.AsRounded(),
Type = FundingSourceType.CoInvestedSfa,
});
}
public IReadOnlyList <FundingSourcePayment> Process(RequiredPayment requiredPayment)
{
var results = new List <FundingSourcePayment>
{
employerCoInvestedPaymentProcessor.Process(requiredPayment),
sfaCoInvestedPaymentProcessor.Process(requiredPayment),
}
.Where(x => x.AmountDue != 0);
return(results.ToArray());
}
public void AccountIdIsCorrect(Type requiredPaymentEventType)
{
var requiredPaymentEvent = Activator.CreateInstance(requiredPaymentEventType) as PeriodisedRequiredPaymentEvent;
var requiredPayment = new RequiredPayment
{
AccountId = 1,
TransferSenderAccountId = 2
};
mapper.Map(requiredPayment, requiredPaymentEvent);
requiredPaymentEvent.AccountId.Should().Be(requiredPayment.AccountId);
}
private void MapCommon(RequiredPayment requiredPayment, PeriodisedRequiredPaymentEvent paymentEvent)
{
paymentEvent.Learner = TestSession.Learner.ToLearner();
paymentEvent.Ukprn = TestSession.Ukprn;
paymentEvent.AmountDue = requiredPayment.Amount;
paymentEvent.JobId = TestSession.JobId;
paymentEvent.EventTime = DateTimeOffset.UtcNow;
paymentEvent.CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(AcademicYear, CollectionPeriod);
paymentEvent.DeliveryPeriod = requiredPayment.DeliveryPeriod;
paymentEvent.IlrSubmissionDateTime = TestSession.IlrSubmissionTime;
paymentEvent.LearningAim = TestSession.Learner.Course.ToLearningAim();
paymentEvent.PriceEpisodeIdentifier = requiredPayment.PriceEpisodeIdentifier;
}
public void PriceEpisodeIdentifierIsCorrect(Type requiredPaymentEventType)
{
var requiredPaymentEvent = Activator.CreateInstance(requiredPaymentEventType) as PeriodisedRequiredPaymentEvent;
var expectedPriceEpisodeIdentifier = "peid";
var requiredPayment = new RequiredPayment
{
PriceEpisodeIdentifier = expectedPriceEpisodeIdentifier,
};
var actual = mapper.Map(requiredPayment, requiredPaymentEvent);
actual.PriceEpisodeIdentifier.Should().Be(expectedPriceEpisodeIdentifier);
}
public void AmountIsCorrect(Type requiredPaymentEventType)
{
var requiredPaymentEvent = Activator.CreateInstance(requiredPaymentEventType) as PeriodisedRequiredPaymentEvent;
var expectedAmount = 100;
var requiredPayment = new RequiredPayment
{
Amount = expectedAmount,
};
var actual = mapper.Map(requiredPayment, requiredPaymentEvent);
actual.AmountDue.Should().Be(expectedAmount);
}
public void SfaPercentageIsCorrect(Type requiredPaymentEventType)
{
var requiredPaymentEvent = Activator.CreateInstance(requiredPaymentEventType) as CalculatedRequiredOnProgrammeAmount;
var expectedSfaPercentage = 100;
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = expectedSfaPercentage,
};
var actual = mapper.Map(requiredPayment, requiredPaymentEvent);
actual.SfaContributionPercentage.Should().Be(expectedSfaPercentage);
}
public IEnumerable <RequiredCoInvestedPaymentValidationResult> Validate(RequiredPayment requiredPayment)
{
var results = new List <RequiredCoInvestedPaymentValidationResult>();
if (requiredPayment.SfaContributionPercentage <= 0)
{
results.Add(new RequiredCoInvestedPaymentValidationResult
{
Rule = RequiredPaymentEventValidationRules.ZeroSfaContributionPercentage
});
}
return(results);
}
public void Should_Return_Unable_To_Pay_Transfer_If_No_Transfer_Allowance()
{
var requiredPayment = new RequiredPayment {
AmountDue = 50, IsTransfer = true, SfaContributionPercentage = .95M
};
mocker.GetMock <ITransferPaymentProcessor>()
.Setup(x => x.Process(requiredPayment))
.Returns(new FundingSourcePayment[0]);
var paymentProcessor = mocker.Resolve <PaymentProcessor>();
var payments = paymentProcessor.Process(requiredPayment);
payments.Count.Should().Be(1);
payments.All(p => p.Type == FundingSourceType.Transfer && p is UnableToFundTransferPayment && p.AmountDue == 50).Should().BeTrue();
}
public void TestProcessPaymentWithOneSfaContribution() // Small employer earnings have SFA contribution of 1
{
// arrange
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = 1m,
AmountDue = 100
};
// act
var payments = processor.Process(requiredPayment);
// assert
payments.Should().HaveCount(0);
}
public void Should_Return_Refund_Transfer_Payment()
{
var requiredPayment = new RequiredPayment {
AmountDue = -50, IsTransfer = true, SfaContributionPercentage = .95M
};
mocker.GetMock <ITransferPaymentProcessor>()
.Setup(x => x.Process(requiredPayment))
.Returns(new[] { new TransferPayment {
AmountDue = -50, Type = FundingSourceType.Transfer
} });
var paymentProcessor = mocker.Resolve <PaymentProcessor>();
var payments = paymentProcessor.Process(requiredPayment);
payments.Count.Should().Be(1);
payments.Count(p => p.Type == FundingSourceType.Transfer && p is TransferPayment && p.AmountDue == -50).Should().Be(1);
}
public void Should_Return_Transfer_And_Unable_To_Pay_Transfer_If_Not_Enough_Allowance_To_Cover_Whole_Transfer_Amount()
{
var requiredPayment = new RequiredPayment {
AmountDue = 50, IsTransfer = true, SfaContributionPercentage = .95M
};
mocker.GetMock <ITransferPaymentProcessor>()
.Setup(x => x.Process(requiredPayment))
.Returns(new[] { new TransferPayment {
AmountDue = 40, Type = FundingSourceType.Transfer
} });
var paymentProcessor = mocker.Resolve <PaymentProcessor>();
var payments = paymentProcessor.Process(requiredPayment);
payments.Count(p => p.Type == FundingSourceType.Transfer && p is TransferPayment && p.AmountDue == 40).Should().Be(1);
payments.Count(p => p.Type == FundingSourceType.Transfer && p is UnableToFundTransferPayment && p.AmountDue == 10).Should().Be(1);
}
public void TestProcessPaymentWithZeroLevyBalance()
{
// arrange
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = .9m,
AmountDue = 100
};
levyBalanceServiceMock.Setup(s => s.TryFund(100)).Returns(0).Verifiable();
// act
var payments = processor.Process(requiredPayment);
// assert
payments.Should().BeEmpty();
}
private PeriodisedRequiredPaymentEvent CreateRequiredPaymentEvent(RequiredPayment requiredPayment)
{
PeriodisedRequiredPaymentEvent paymentEvent;
switch (requiredPayment.Type)
{
case TransactionType.Learning:
case TransactionType.Completion:
case TransactionType.Balancing:
paymentEvent = BuildApprenticeshipContractTypeRequiredPaymentEvent(requiredPayment);
break;
default:
paymentEvent = BuildIncentiveRequiredPaymentEvent(requiredPayment);
break;
}
return(paymentEvent);
}
public void TestProcessRefundPayment()
{
// arrange
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = .9m,
AmountDue = -600
};
levyBalanceServiceMock.Setup(s => s.TryFund(-600)).Returns(-600).Verifiable();
// act
var payments = processor.Process(requiredPayment);
// assert
payments.Should().NotBeEmpty();
payments[0].AmountDue.Should().Be(-600);
}
public void TestProcessPaymentNoSfaContribution()
{
// arrange
var requiredPayment = new RequiredPayment
{
SfaContributionPercentage = 0m,
AmountDue = 100
};
levyBalanceServiceMock.Setup(s => s.TryFund(100)).Returns(100).Verifiable();
// act
var payments = processor.Process(requiredPayment);
// assert
payments.Should().HaveCount(1);
payments[0].AmountDue.Should().Be(100);
payments[0].Type.Should().Be(FundingSourceType.Levy);
}
public void Should_Use_TransferProcessor_For_Transfer_Payments()
{
var requiredPayment = new RequiredPayment {
AmountDue = 50, IsTransfer = true, SfaContributionPercentage = .95M
};
mocker.GetMock <ITransferPaymentProcessor>()
.Setup(x => x.Process(requiredPayment))
.Returns(new[] { new TransferPayment {
AmountDue = 50, Type = FundingSourceType.Transfer
} });
var paymentProcessor = mocker.Resolve <PaymentProcessor>();
var payments = paymentProcessor.Process(requiredPayment);
payments.Count.Should().Be(1);
payments.All(p => p.Type == FundingSourceType.Transfer && p is TransferPayment).Should().BeTrue();
mocker.GetMock <ILevyPaymentProcessor>()
.Verify(x => x.Process(It.IsAny <RequiredPayment>()), Times.Never);
}
public void TestLevyOnlyCall()
{
// arrange
var levyPayment = new LevyPayment {
AmountDue = 100
};
var requiredPayment = new RequiredPayment {
AmountDue = 100
};
levyPaymentProcessorMock.Setup(p => p.Process(It.IsAny <RequiredPayment>())).Returns(new[] { levyPayment }).Verifiable();
// act
var actualPayments = processor.Process(requiredPayment);
// assert
actualPayments.Should().NotBeNull();
actualPayments.Should().HaveCount(1);
actualPayments[0].Should().BeSameAs(levyPayment);
}
public IReadOnlyList <FundingSourcePayment> Process(RequiredPayment requiredPayment)
{
if (requiredPayment.SfaContributionPercentage == 1)
{
return(new FundingSourcePayment[0]);
}
var amountDue = levyBalanceService.TryFund(requiredPayment.AmountDue).AsRounded();
if (amountDue == 0)
{
return(new FundingSourcePayment[0]);
}
return(new[]
{
new LevyPayment
{
AmountDue = amountDue,
Type = FundingSourceType.Levy
}
});
}
public IReadOnlyList <FundingSourcePayment> Process(RequiredPayment requiredPayment)
{
var fundingSourcePayments = new List <FundingSourcePayment>();
if (requiredPayment.IsTransfer)
{
fundingSourcePayments.AddRange(transferPaymentProcessor.Process(requiredPayment));
var remainingTransferAmount = requiredPayment.AmountDue - fundingSourcePayments.Sum(transfer => transfer.AmountDue);
if (remainingTransferAmount > 0)
{
fundingSourcePayments.Add(new UnableToFundTransferPayment
{
AmountDue = remainingTransferAmount,
Type = FundingSourceType.Transfer
});
}
return(fundingSourcePayments);
}
fundingSourcePayments.AddRange(levyPaymentProcessor.Process(requiredPayment));
var amountDue = requiredPayment.AmountDue - fundingSourcePayments.Select(p => p.AmountDue).Sum();
if (amountDue != 0m)
{
var partFundedRequiredPayment = new RequiredPayment
{
AmountDue = amountDue,
SfaContributionPercentage = requiredPayment.SfaContributionPercentage
};
fundingSourcePayments.AddRange(coInvestedPaymentProcessor.Process(partFundedRequiredPayment));
}
return(fundingSourcePayments);
}
protected abstract FundingSourcePayment CreatePayment(RequiredPayment message);
private CalculatedRequiredOnProgrammeAmount BuildApprenticeshipContractTypeRequiredPaymentEvent(RequiredPayment requiredPayment)
{
var paymentEvent = ContractType == ContractType.Act1
? (CalculatedRequiredOnProgrammeAmount) new CalculatedRequiredLevyAmount()
: new CalculatedRequiredCoInvestedAmount();
MapCommon(requiredPayment, paymentEvent);
paymentEvent.OnProgrammeEarningType = (OnProgrammeEarningType)requiredPayment.Type;
paymentEvent.ContractType = (ContractType)ContractType;
paymentEvent.SfaContributionPercentage = SfaContributionPercentage;
return(paymentEvent);
}
