public async Task WhenCallingGetYearToDatePayments_WithMultipleProviders_TheYtdPaymentsAreCorrect()
        {
            var mocker = AutoMock.GetLoose();

            var payments = new List <PaymentModel>
            {
                new PaymentModel
                {
                    Ukprn            = 1,
                    CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(2021, 1),
                    ContractType     = ContractType.Act1,
                    Amount           = 1000,
                },
                new PaymentModel
                {
                    Ukprn            = 1,
                    CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(2021, 1),
                    ContractType     = ContractType.Act2,
                    Amount           = 2000,
                },

                new PaymentModel
                {
                    Ukprn            = 2,
                    CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(2021, 1),
                    ContractType     = ContractType.Act1,
                    Amount           = 10000,
                },
                new PaymentModel
                {
                    Ukprn            = 2,
                    CollectionPeriod = CollectionPeriodFactory.CreateFromAcademicYearAndPeriod(2021, 1),
                    ContractType     = ContractType.Act2,
                    Amount           = 20000,
                },
            };



            using (var context = new InMemoryMetricsQueryDataContext())
            {
                var factory = mocker.Mock <IMetricsQueryDataContextFactory>();
                factory.Setup(x => x.Create())
                .Returns(context);
                var sut = mocker.Create <PeriodEndMetricsRepository>();

                foreach (var payment in payments)
                {
                    await context.AddAsync(payment);
                }

                await context.SaveChangesAsync();

                var actual = await sut.GetYearToDatePayments(2021, 2, CancellationToken.None);

                actual.Where(x => x.Ukprn == 1).Should().HaveCount(1);
                actual.Where(x => x.Ukprn == 2).Should().HaveCount(1);
                actual.Where(x => x.Ukprn == 3).Should().BeEmpty();

                actual.Single(x => x.Ukprn == 1).Total.Should().Be(3000);
                actual.Single(x => x.Ukprn == 2).Total.Should().Be(30000);
            }
        }
        public void SetUp()
        {
            inMemoryMetricsQueryDataContext = new InMemoryMetricsQueryDataContext();

            moqer       = AutoMock.GetLoose();
            dcEarnings  = TestsHelper.DefaultDcEarnings;
            dasEarnings = TestsHelper.DefaultDasEarnings;
            dataLocks   = TestsHelper.DefaultDataLockedEarnings;

            var dcMetricsDataContext = moqer.Mock <IDcMetricsDataContext>();

            dcMetricsDataContext.Setup(ctx => ctx.GetEarnings(It.IsAny <long>(), It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(dcEarnings);

            moqer.Mock <IDcMetricsDataContextFactory>()
            .Setup(factory => factory.CreateContext(It.IsAny <short>()))
            .Returns(dcMetricsDataContext.Object);

            latestSuccessfulJob                  = moqer.Mock <LatestSuccessfulJobModel>().Object;
            latestSuccessfulJob.Ukprn            = 1234;
            latestSuccessfulJob.CollectionPeriod = 1;
            latestSuccessfulJob.AcademicYear     = 1920;
            latestSuccessfulJob.DcJobId          = 123;

            moqer.Mock <ISubmissionSummaryFactory>()
            .Setup(factory =>
                   factory.Create(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <short>(), It.IsAny <byte>()))
            .Returns((long ukprn, long jobId, short academicYear, byte collectionPeriod) => new SubmissionSummary(ukprn, jobId, collectionPeriod, academicYear));

            var jobsRepository = moqer.Mock <ISubmissionJobsRepository>();

            jobsRepository.Setup(x =>
                                 x.GetLatestSuccessfulJobForProvider(It.IsAny <long>(), It.IsAny <short>(), It.IsAny <byte>()))
            .ReturnsAsync(latestSuccessfulJob);

            moqer.Mock <ISubmissionJobsDataContext>();

            submissionMetricsRepository = moqer.Mock <ISubmissionMetricsRepository>();

            submissionMetricsRepository.Setup(repo => repo.GetDasEarnings(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(dasEarnings);
            submissionMetricsRepository.Setup(repo => repo.GetDasEarnings(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(dasEarnings);
            submissionMetricsRepository.Setup(repo => repo.GetDataLockedEarnings(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(dataLocks);
            submissionMetricsRepository.Setup(repo => repo.GetDataLockedEarningsTotal(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(TestsHelper.DefaultDataLockedTotal);
            submissionMetricsRepository.Setup(repo => repo.GetAlreadyPaidDataLockedEarnings(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(TestsHelper.AlreadyPaidDataLockedEarnings);
            submissionMetricsRepository.Setup(repo => repo.GetHeldBackCompletionPaymentsTotal(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(TestsHelper.DefaultHeldBackCompletionPayments);
            submissionMetricsRepository.Setup(repo => repo.GetYearToDatePaymentsTotal(It.IsAny <long>(), It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(TestsHelper.DefaultYearToDateAmounts);


            var queryDataContext = moqer.Mock <IMetricsQueryDataContextFactory>();

            queryDataContext.Setup(f => f.Create())
            .Returns(inMemoryMetricsQueryDataContext);

            var realSubmissionMetricsRepository = moqer.Create <SubmissionMetricsRepository>(
                new NamedParameter("metricsQueryDataContextFactory", queryDataContext.Object),
                new AutowiringParameter());

            submissionMetricsRepository
            .Setup(repo => repo.GetRequiredPayments(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .Returns(async(long ukprn, long jobId, CancellationToken cancellationToken) => await realSubmissionMetricsRepository.GetRequiredPayments(ukprn, jobId, cancellationToken));
        }