Example #1
0
        public async Task HandleAsync_XmlContainsBusinessErrorAndWarning_StoresBusinessErrorAndWarning()
        {
            using (DatabaseWrapper database = new DatabaseWrapper())
            {
                // Arrange
                ModelHelper  helper       = new ModelHelper(database.Model);
                DomainHelper domainHelper = new DomainHelper(database.WeeeContext);

                var organisation      = helper.CreateOrganisation();
                var scheme            = helper.CreateScheme(organisation);
                var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false);

                database.Model.SaveChanges();

                var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);

                var schemeReturn = new SchemeReturn()
                {
                    ComplianceYear = "2016",
                    ReturnPeriod   = SchemeReturnReturnPeriod.Quarter3JulySeptember
                };

                var xmlGeneratorResult = new GenerateFromDataReturnXmlResult <SchemeReturn>(
                    "Test XML string",
                    schemeReturn,
                    new List <XmlValidationError>());

                A.CallTo(() => builder.XmlGenerator.GenerateDataReturns <SchemeReturn>(A <ProcessDataReturnXmlFile> ._))
                .Returns(xmlGeneratorResult);

                var dbDataReturnVersion     = domainHelper.GetDataReturnVersion(dataReturnVersion.Id);
                var businessErrorAndWarning = new List <ErrorData>
                {
                    new ErrorData("Error text", ErrorLevel.Error),
                    new ErrorData("Warning text", ErrorLevel.Warning)
                };

                var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, businessErrorAndWarning);

                A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A <SchemeReturn> ._))
                .Returns(dataReturnVersionBuilderResult);

                // Act
                var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id);

                // Assert
                var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId);

                Assert.Equal(2, dataReturnUpload.Errors.Count);
                Assert.All(dataReturnUpload.Errors, e => Assert.Equal(Domain.Error.UploadErrorType.Business, e.ErrorType));
                Assert.Contains(dataReturnUpload.Errors, p => p.ErrorLevel == Domain.Error.ErrorLevel.Error && p.Description == "Error text");
                Assert.Contains(dataReturnUpload.Errors, p => p.ErrorLevel == Domain.Error.ErrorLevel.Warning && p.Description == "Warning text");
            }
        }
Example #2
0
        public async Task HandleAsync_XmlDoesNotContainSchemaError_StoresAvailableDataReturnData()
        {
            using (DatabaseWrapper database = new DatabaseWrapper())
            {
                // Arrange
                ModelHelper  helper       = new ModelHelper(database.Model);
                DomainHelper domainHelper = new DomainHelper(database.WeeeContext);

                var organisation      = helper.CreateOrganisation();
                var scheme            = helper.CreateScheme(organisation);
                var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false);

                database.Model.SaveChanges();

                var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);

                var schemeReturn = new SchemeReturn()
                {
                    ComplianceYear = "2016",
                    ReturnPeriod   = SchemeReturnReturnPeriod.Quarter3JulySeptember
                };

                var xmlGeneratorResult = new GenerateFromDataReturnXmlResult <SchemeReturn>(
                    "Test XML string",
                    schemeReturn,
                    new List <XmlValidationError>());

                A.CallTo(() => builder.XmlGenerator.GenerateDataReturns <SchemeReturn>(A <ProcessDataReturnXmlFile> ._))
                .Returns(xmlGeneratorResult);

                var dbDataReturnVersion            = domainHelper.GetDataReturnVersion(dataReturnVersion.Id);
                var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, A.Dummy <List <ErrorData> >());

                A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A <SchemeReturn> ._))
                .Returns(dataReturnVersionBuilderResult);

                // Act
                var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id, fileName : "XML file name");

                // Assert
                var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId);

                Assert.Equal(scheme.Id, dataReturnUpload.Scheme.Id);
                Assert.Equal("Test XML string", dataReturnUpload.RawData.Data);
                Assert.Equal("XML file name", dataReturnUpload.FileName);
                Assert.Equal(2016, dataReturnUpload.ComplianceYear);
                Assert.Equal(Convert.ToInt32(QuarterType.Q3), dataReturnUpload.Quarter);
                Assert.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime);
            }
        }
Example #3
0
        public async Task Build_ReturnsResult()
        {
            var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");

            var expectedResult = new DataReturnVersionBuilderResult(A.Dummy <DataReturnVersion>(), A.Dummy <List <ErrorData> >());

            A.CallTo(() => builder.DataReturnVersionBuilder.Build())
            .Returns(expectedResult);

            SchemeReturn schemeReturn = new SchemeReturn()
            {
                ApprovalNo = "WEE/AA1111AA/SCH"
            };

            var actualResult = await builder.Create().Build(schemeReturn);

            Assert.Equal(expectedResult, actualResult);
        }
Example #4
0
        public async Task <DataReturnVersionBuilderResult> Build(SchemeReturn schemeReturn)
        {
            // PreValidate (any validation before business validation)
            var preValidationErrors = await dataReturnVersionBuilder.PreValidate();

            // And process XML-specific validation
            var schemeApprovalNumberMismatchResult = schemeApprovalNumberMismatch.Validate(schemeReturn.ApprovalNo,
                                                                                           dataReturnVersionBuilder.Scheme);

            var preBusinessValidationResult = new DataReturnVersionBuilderResult();

            preBusinessValidationResult.ErrorData.AddRange(preValidationErrors);
            preBusinessValidationResult.ErrorData.AddRange(schemeApprovalNumberMismatchResult);

            // If there are any pre-business validation errors return them
            if (preBusinessValidationResult.ErrorData.Any())
            {
                return(preBusinessValidationResult);
            }

            // Then build the Data Return Version
            if (schemeReturn.ProducerList != null)
            {
                foreach (var producer in schemeReturn.ProducerList)
                {
                    foreach (var tonnageReturn in producer.Returns)
                    {
                        await dataReturnVersionBuilder.AddEeeOutputAmount(producer.RegistrationNo,
                                                                          producer.ProducerCompanyName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                                                                          tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            if (schemeReturn.CollectedFromDCF != null)
            {
                foreach (var collectedFromDcf in schemeReturn.CollectedFromDCF)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf,
                                                                          collectedFromDcf.CategoryName.ToDomainWeeeCategory(), collectedFromDcf.ObligationType.ToDomainObligationType(), collectedFromDcf.TonnesReturnValue);
                }
            }

            if (schemeReturn.B2CWEEEFromDistributors != null)
            {
                foreach (var weeeFromDistributor in schemeReturn.B2CWEEEFromDistributors)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor,
                                                                          weeeFromDistributor.CategoryName.ToDomainWeeeCategory(), weeeFromDistributor.ObligationType.ToDomainObligationType(), weeeFromDistributor.TonnesReturnValue);
                }
            }

            if (schemeReturn.B2CWEEEFromFinalHolders != null)
            {
                foreach (var weeeFromFinalHolders in schemeReturn.B2CWEEEFromFinalHolders)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder,
                                                                          weeeFromFinalHolders.CategoryName.ToDomainWeeeCategory(), weeeFromFinalHolders.ObligationType.ToDomainObligationType(), weeeFromFinalHolders.TonnesReturnValue);
                }
            }

            if (schemeReturn.DeliveredToAATF != null)
            {
                foreach (var deliveredToAatf in schemeReturn.DeliveredToAATF)
                {
                    foreach (var tonnageReturn in deliveredToAatf.Returns)
                    {
                        await dataReturnVersionBuilder.AddAatfDeliveredAmount(deliveredToAatf.AATFApprovalNo, deliveredToAatf.FacilityName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                                                                              tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            if (schemeReturn.DeliveredToAE != null)
            {
                foreach (var deliveredToAe in schemeReturn.DeliveredToAE)
                {
                    foreach (var tonnageReturn in deliveredToAe.Returns)
                    {
                        await dataReturnVersionBuilder.AddAeDeliveredAmount(deliveredToAe.AEApprovalNo, deliveredToAe.OperatorName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                                                                            tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            return(await dataReturnVersionBuilder.Build());
        }
        public async Task HandleAsync_XmlDoesNotContainSchemaError_StoresAvailableDataReturnData()
        {
            using (DatabaseWrapper database = new DatabaseWrapper())
            {
                // Arrange
                ModelHelper helper = new ModelHelper(database.Model);
                DomainHelper domainHelper = new DomainHelper(database.WeeeContext);

                var organisation = helper.CreateOrganisation();
                var scheme = helper.CreateScheme(organisation);
                var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false);

                database.Model.SaveChanges();

                var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);

                var schemeReturn = new SchemeReturn()
                {
                    ComplianceYear = "2016",
                    ReturnPeriod = SchemeReturnReturnPeriod.Quarter3JulySeptember
                };

                var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(
                    "Test XML string",
                    schemeReturn,
                    new List<XmlValidationError>());

                A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
                     .Returns(xmlGeneratorResult);

                var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id);
                var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, A.Dummy<List<ErrorData>>());

                A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._))
                    .Returns(dataReturnVersionBuilderResult);

                // Act
                var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id, fileName: "XML file name");

                // Assert
                var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId);

                Assert.Equal(scheme.Id, dataReturnUpload.Scheme.Id);
                Assert.Equal("Test XML string", dataReturnUpload.RawData.Data);
                Assert.Equal("XML file name", dataReturnUpload.FileName);
                Assert.Equal(2016, dataReturnUpload.ComplianceYear);
                Assert.Equal(Convert.ToInt32(QuarterType.Q3), dataReturnUpload.Quarter);
                Assert.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime);
            }
        }
        public async Task HandleAsync_XmlContainsError_DoesNotReturnVersionForDataUpload()
        {
            using (DatabaseWrapper database = new DatabaseWrapper())
            {
                // Arrange
                ModelHelper helper = new ModelHelper(database.Model);
                DomainHelper domainHelper = new DomainHelper(database.WeeeContext);

                var organisation = helper.CreateOrganisation();
                var scheme = helper.CreateScheme(organisation);
                var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false);

                database.Model.SaveChanges();

                var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);

                var schemeReturn = new SchemeReturn()
                {
                    ComplianceYear = "2016",
                    ReturnPeriod = SchemeReturnReturnPeriod.Quarter3JulySeptember
                };

                var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(
                    "Test XML string",
                    schemeReturn,
                    new List<XmlValidationError>());

                A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
                     .Returns(xmlGeneratorResult);

                var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id);
                var businessErrorAndWarning = new List<ErrorData>
                {
                    new ErrorData("Error text", ErrorLevel.Error)
                };

                var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, businessErrorAndWarning);

                A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._))
                    .Returns(dataReturnVersionBuilderResult);

                // Act
                var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id);

                // Assert
                var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId);

                Assert.Null(dataReturnUpload.DataReturnVersion);
            }
        }
        public async Task<DataReturnVersionBuilderResult> Build(SchemeReturn schemeReturn)
        {
            // PreValidate (any validation before business validation)
            var preValidationErrors = await dataReturnVersionBuilder.PreValidate();

            // And process XML-specific validation
            var schemeApprovalNumberMismatchResult = schemeApprovalNumberMismatch.Validate(schemeReturn.ApprovalNo,
                dataReturnVersionBuilder.Scheme);

            var preBusinessValidationResult = new DataReturnVersionBuilderResult();
            preBusinessValidationResult.ErrorData.AddRange(preValidationErrors);
            preBusinessValidationResult.ErrorData.AddRange(schemeApprovalNumberMismatchResult);

            // If there are any pre-business validation errors return them
            if (preBusinessValidationResult.ErrorData.Any())
            {
                return preBusinessValidationResult;
            }

            // Then build the Data Return Version
            if (schemeReturn.ProducerList != null)
            {
                foreach (var producer in schemeReturn.ProducerList)
                {
                    foreach (var tonnageReturn in producer.Returns)
                    {
                        await dataReturnVersionBuilder.AddEeeOutputAmount(producer.RegistrationNo,
                              producer.ProducerCompanyName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                              tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            if (schemeReturn.CollectedFromDCF != null)
            {
                foreach (var collectedFromDcf in schemeReturn.CollectedFromDCF)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf,
                         collectedFromDcf.CategoryName.ToDomainWeeeCategory(), collectedFromDcf.ObligationType.ToDomainObligationType(), collectedFromDcf.TonnesReturnValue);
                }
            }

            if (schemeReturn.B2CWEEEFromDistributors != null)
            {
                foreach (var weeeFromDistributor in schemeReturn.B2CWEEEFromDistributors)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor,
                            weeeFromDistributor.CategoryName.ToDomainWeeeCategory(), weeeFromDistributor.ObligationType.ToDomainObligationType(), weeeFromDistributor.TonnesReturnValue);
                }
            }

            if (schemeReturn.B2CWEEEFromFinalHolders != null)
            {
                foreach (var weeeFromFinalHolders in schemeReturn.B2CWEEEFromFinalHolders)
                {
                    await dataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.FinalHolder,
                           weeeFromFinalHolders.CategoryName.ToDomainWeeeCategory(), weeeFromFinalHolders.ObligationType.ToDomainObligationType(), weeeFromFinalHolders.TonnesReturnValue);
                }
            }

            if (schemeReturn.DeliveredToAATF != null)
            {
                foreach (var deliveredToAatf in schemeReturn.DeliveredToAATF)
                {
                    foreach (var tonnageReturn in deliveredToAatf.Returns)
                    {
                        await dataReturnVersionBuilder.AddAatfDeliveredAmount(deliveredToAatf.AATFApprovalNo, deliveredToAatf.FacilityName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                                     tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            if (schemeReturn.DeliveredToAE != null)
            {
                foreach (var deliveredToAe in schemeReturn.DeliveredToAE)
                {
                    foreach (var tonnageReturn in deliveredToAe.Returns)
                    {
                        await dataReturnVersionBuilder.AddAeDeliveredAmount(deliveredToAe.AEApprovalNo, deliveredToAe.OperatorName, tonnageReturn.CategoryName.ToDomainWeeeCategory(),
                                         tonnageReturn.ObligationType.ToDomainObligationType(), tonnageReturn.TonnesReturnValue);
                    }
                }
            }

            return await dataReturnVersionBuilder.Build();
        }
        public async Task Build_ReturnsResult()
        {
            var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");

            var expectedResult = new DataReturnVersionBuilderResult(A.Dummy<DataReturnVersion>(), A.Dummy<List<ErrorData>>());

            A.CallTo(() => builder.DataReturnVersionBuilder.Build())
                 .Returns(expectedResult);

            SchemeReturn schemeReturn = new SchemeReturn()
            {
                ApprovalNo = "WEE/AA1111AA/SCH"
            };

            var actualResult = await builder.Create().Build(schemeReturn);

            Assert.Equal(expectedResult, actualResult);
        }