public async Task Build_ProcessesAllReturnsInProducerList()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
ProducerList = new SchemeReturnProducer[]
{
new SchemeReturnProducer
{
Returns = new[] { A.Dummy <TonnageReturnType>(), A.Dummy <TonnageReturnType>() }
},
new SchemeReturnProducer
{
Returns = new[] { A.Dummy <TonnageReturnType>() }
}
}
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddEeeOutputAmount(A <string> ._, A <string> ._, A <WeeeCategory> ._, A <ObligationType> ._, A <decimal> ._))
.MustHaveHappened(Repeated.Exactly.Times(3));
}
public async Task Build_ProcessesAllReturnsInProducerList()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
ProducerList = new SchemeReturnProducer[]
{
new SchemeReturnProducer
{
Returns = new[] { A.Dummy<TonnageReturnType>(), A.Dummy<TonnageReturnType>() }
},
new SchemeReturnProducer
{
Returns = new[] { A.Dummy<TonnageReturnType>() }
}
}
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddEeeOutputAmount(A<string>._, A<string>._, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustHaveHappened(Repeated.Exactly.Times(3));
}
public async Task Build_ProcessesAllReturnsInDeliveredToAaTF()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
DeliveredToAATF = new[]
{
new SchemeReturnDeliveredToFacility
{
Returns = new[] { A.Dummy <TonnageReturnType>(), A.Dummy <TonnageReturnType>() }
},
new SchemeReturnDeliveredToFacility
{
Returns = new[] { A.Dummy <TonnageReturnType>() }
},
}
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddAatfDeliveredAmount(A <string> ._, A <string> ._, A <WeeeCategory> ._, A <ObligationType> ._, A <decimal> ._))
.MustHaveHappened(Repeated.Exactly.Times(3));
}
public async Task HandleAsync_SavesDataUpload()
{
// Arrange
var builder = new ProcessDataReturnXmlFileHandlerBuilder();
var schemeReturn = new SchemeReturn()
{
ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter1JanuaryMarch
};
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult <SchemeReturn>(A.Dummy <string>(),
schemeReturn, new List <XmlValidationError>());
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns <SchemeReturn>(A <ProcessDataReturnXmlFile> ._))
.Returns(xmlGeneratorResult);
A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A <SchemeReturn> ._))
.Returns(new DataReturnVersionBuilderResult(A.Dummy <DataReturnVersion>(), A.Dummy <List <ErrorData> >()));
// Act
await builder.InvokeHandleAsync();
// Assert
A.CallTo(() => builder.DataAccess.AddAndSaveAsync(A <DataReturnUpload> ._))
.MustHaveHappened(Repeated.Exactly.Once);
}
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");
}
}
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 Build_NoDeliveredToAe_DoesNotProcessDeliveredToAe()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
DeliveredToAE = null
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddAeDeliveredAmount(A <string> ._, A <string> ._, A <WeeeCategory> ._, A <ObligationType> ._, A <decimal> ._))
.MustNotHaveHappened();
}
public async Task Build_ProcessesAllReturnsInCollectedFromDcf()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
CollectedFromDCF = new[] { A.Dummy <TonnageReturnType>(), A.Dummy <TonnageReturnType>() }
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, A <WeeeCategory> ._, A <ObligationType> ._, A <decimal> ._))
.MustHaveHappened(Repeated.Exactly.Times(2));
}
public async Task Build_NoB2CWEEEFromDistributors_DoesNotProcessB2CWEEEFromDistributors()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
B2CWEEEFromDistributors = null
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Distributor, A <WeeeCategory> ._, A <ObligationType> ._, A <decimal> ._))
.MustNotHaveHappened();
}
public async Task Build_NoCollectedFromDcf_DoesNotProcessCollectedFromDcf()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
CollectedFromDCF = null
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustNotHaveHappened();
}
public async Task Build_NoProducers_DoesNotProcessProducerList()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
ProducerList = null
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddEeeOutputAmount(A<string>._, A<string>._, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustNotHaveHappened();
}
public void GenerateDataReturns_ReturnsExpectedDeserialisedType()
{
var schemeReturn = new SchemeReturn();
var builder = new GenerateFromXmlBuilder();
A.CallTo(() => builder.SchemaValidator.Validate(A <byte[]> ._, string.Empty, A <XNamespace> ._, A <string> ._))
.Returns(new List <XmlValidationError>());
A.CallTo(() => builder.XmlConverter.Deserialize <SchemeReturn>(A <XDocument> ._))
.Returns(schemeReturn);
var result = builder.Build().GenerateDataReturns <SchemeReturn>(new ProcessDataReturnXmlFile(A.Dummy <Guid>(), A.Dummy <byte[]>(), A.Dummy <string>()));
Assert.IsType <SchemeReturn>(result.DeserialisedType);
Assert.Equal(schemeReturn, result.DeserialisedType);
}
public void GenerateDataReturns_ReturnsExpectedDeserialisedType()
{
var schemeReturn = new SchemeReturn();
var builder = new GenerateFromXmlBuilder();
A.CallTo(() => builder.SchemaValidator.Validate(A<byte[]>._, string.Empty, A<XNamespace>._, A<string>._))
.Returns(new List<XmlValidationError>());
A.CallTo(() => builder.XmlConverter.Deserialize<SchemeReturn>(A<XDocument>._))
.Returns(schemeReturn);
var result = builder.Build().GenerateDataReturns<SchemeReturn>(new ProcessDataReturnXmlFile(A.Dummy<Guid>(), A.Dummy<byte[]>(), A.Dummy<string>()));
Assert.IsType<SchemeReturn>(result.DeserialisedType);
Assert.Equal(schemeReturn, result.DeserialisedType);
}
public async Task HandleAsync_SchemaErrors_DoesNotPerformBusinessValidation()
{
// Arrange
var builder = new ProcessDataReturnXmlFileHandlerBuilder();
var schemeReturn = new SchemeReturn() { ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter1JanuaryMarch };
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(A.Dummy<string>(),
schemeReturn, new List<XmlValidationError> { new XmlValidationError(Core.Shared.ErrorLevel.Error, XmlErrorType.Schema, "Test") });
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
.Returns(xmlGeneratorResult);
// Act
await builder.InvokeHandleAsync();
// Assert
A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._)).MustNotHaveHappened();
}
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);
}
public async Task HandleAsync_SavesDataUpload()
{
// Arrange
var builder = new ProcessDataReturnXmlFileHandlerBuilder();
var schemeReturn = new SchemeReturn() { ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter1JanuaryMarch };
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(A.Dummy<string>(),
schemeReturn, new List<XmlValidationError>());
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
.Returns(xmlGeneratorResult);
A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._))
.Returns(new DataReturnVersionBuilderResult(A.Dummy<DataReturnVersion>(), A.Dummy<List<ErrorData>>()));
// Act
await builder.InvokeHandleAsync();
// Assert
A.CallTo(() => builder.DataAccess.AddAndSaveAsync(A<DataReturnUpload>._))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_SchemaErrors_DoesNotPerformBusinessValidation()
{
// Arrange
var builder = new ProcessDataReturnXmlFileHandlerBuilder();
var schemeReturn = new SchemeReturn()
{
ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter1JanuaryMarch
};
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult <SchemeReturn>(A.Dummy <string>(),
schemeReturn, new List <XmlValidationError> {
new XmlValidationError(Core.Shared.ErrorLevel.Error, XmlErrorType.Schema, "Test")
});
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns <SchemeReturn>(A <ProcessDataReturnXmlFile> ._))
.Returns(xmlGeneratorResult);
// Act
await builder.InvokeHandleAsync();
// Assert
A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A <SchemeReturn> ._)).MustNotHaveHappened();
}
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_ProcessesAllReturnsInDeliveredToAaTF()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
DeliveredToAATF = new[]
{
new SchemeReturnDeliveredToFacility
{
Returns = new[] { A.Dummy<TonnageReturnType>(), A.Dummy<TonnageReturnType>() }
},
new SchemeReturnDeliveredToFacility
{
Returns = new[] { A.Dummy<TonnageReturnType>() }
},
}
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddAatfDeliveredAmount(A<string>._, A<string>._, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustHaveHappened(Repeated.Exactly.Times(3));
}
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);
}
public async Task Build_ProcessesAllReturnsInCollectedFromDcf()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
CollectedFromDCF = new[] { A.Dummy<TonnageReturnType>(), A.Dummy<TonnageReturnType>() }
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddWeeeCollectedAmount(WeeeCollectedAmountSourceType.Dcf, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustHaveHappened(Repeated.Exactly.Times(2));
}
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_NoDeliveredToAaTF_DoesNotProcessDeliveredToAaTF()
{
var builder = new DataReturnVersionFromXmlBuilderHelper("WEE/AA1111AA/SCH");
var schemeReturn = new SchemeReturn()
{
ApprovalNo = "WEE/AA1111AA/SCH",
DeliveredToAATF = null
};
await builder.Create().Build(schemeReturn);
A.CallTo(() => builder.DataReturnVersionBuilder.AddAatfDeliveredAmount(A<string>._, A<string>._, A<WeeeCategory>._, A<ObligationType>._, A<decimal>._))
.MustNotHaveHappened();
}
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);
}
}
