public async Task HandleAsync_CreatesUserWithStandardUserRole()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var user = helper.GetOrCreateUser("TestUser");
user.Email = "*****@*****.**";
database.Model.SaveChanges();
var handler = new AddCompetentAuthorityUserHandler(database.WeeeContext, A.Dummy<ITestUserEmailDomains>());
// Act
var competentAuthorityUserId = await handler.HandleAsync(new AddCompetentAuthorityUser(user.Id));
var competentAuthorityUser = domainHelper.GetCompetentAuthorityUser(competentAuthorityUserId);
// Assert
Assert.Equal(user.Id, competentAuthorityUser.UserId);
Assert.NotNull(competentAuthorityUser.Role);
Assert.Equal("InternalUser", competentAuthorityUser.Role.Name);
}
}
public async Task Fetch_ReturnsDataForSpecifiedComplianceYearOnly()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
var scheme = helper.CreateScheme();
var memberUpload1 = helper.CreateSubmittedMemberUpload(scheme);
memberUpload1.ComplianceYear = 2016;
var producer1 = helper.CreateProducerAsCompany(memberUpload1, "AAA");
var memberUpload2 = helper.CreateSubmittedMemberUpload(scheme);
memberUpload2.ComplianceYear = 2017;
var producer2 = helper.CreateProducerAsCompany(memberUpload2, "AAA");
database.Model.SaveChanges();
var dataAccess = new GetProducerDetailsDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.Fetch("AAA", 2016);
// Assert
Assert.Single(result);
Assert.Equal(2016, result.Single().RegisteredProducer.ComplianceYear);
}
}
public async Task GetComplianceYears_DoesNotReturnUnsubmittedUploads()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
var scheme = helper.CreateScheme();
var memberUpload = helper.CreateMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
memberUpload.IsSubmitted = false;
var producer1 = helper.CreateProducerAsCompany(memberUpload, "AAA");
database.Model.SaveChanges();
var dataAccess = new GetProducerComplianceYearDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.GetComplianceYears("AAA");
// Assert
Assert.Empty(result);
}
}
public async Task Execute_HappyPath_ReturnsProducerEeeDataHistory()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
//Arrange
ModelHelper helper = new ModelHelper(db.Model);
var scheme1 = helper.CreateScheme();
scheme1.ApprovalNumber = "WEE/TE0000ST/SCH";
var memberUpload1 = helper.CreateSubmittedMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2000;
var producer1 = helper.CreateProducerAsCompany(memberUpload1, "PRN123");
producer1.ObligationType = "B2B";
var dataReturnVersion1 = helper.CreateDataReturnVersion(scheme1, 2000, 1);
dataReturnVersion1.SubmittedDate = new DateTime(2015, 1, 6);
var dataReturnVersion2 = helper.CreateDataReturnVersion(scheme1, 2000, 2);
dataReturnVersion2.SubmittedDate = new DateTime(2015, 1, 8);
helper.CreateEeeOutputAmount(dataReturnVersion1, producer1.RegisteredProducer, "B2B", 1, 100);
helper.CreateEeeOutputAmount(dataReturnVersion2, producer1.RegisteredProducer, "B2B", 2, 200);
var scheme2 = helper.CreateScheme();
scheme2.ApprovalNumber = "WEE/TE0000S1/SCH";
var memberUpload2 = helper.CreateSubmittedMemberUpload(scheme2);
memberUpload2.ComplianceYear = 2000;
var producer2 = helper.CreateProducerAsCompany(memberUpload2, "PRN123");
producer2.ObligationType = "B2C";
var dataReturnVersion3 = helper.CreateDataReturnVersion(scheme2, 2000, 1);
dataReturnVersion1.SubmittedDate = new DateTime(2015, 1, 9);
var dataReturnVersion4 = helper.CreateDataReturnVersion(scheme2, 2000, 2);
dataReturnVersion4.SubmittedDate = new DateTime(2015, 1, 10);
helper.CreateEeeOutputAmount(dataReturnVersion3, producer2.RegisteredProducer, "B2C", 1, 40);
helper.CreateEeeOutputAmount(dataReturnVersion4, producer2.RegisteredProducer, "B2C", 2, 1000);
db.Model.SaveChanges();
// Act
var results = await db.StoredProcedures.SpgProducerEeeHistoryCsvData("PRN123");
//Assert
Assert.NotNull(results);
ProducerEeeHistoryCsvData.ProducerInReturnsResult b2cProducer = results.ProducerReturnsHistoryData.Find(x => (x.ApprovalNumber == "WEE/TE0000S1/SCH"));
Assert.NotNull(b2cProducer);
Assert.Equal(2000, b2cProducer.ComplianceYear);
Assert.Equal(1000, b2cProducer.Cat2B2C);
Assert.Equal("Yes", b2cProducer.LatestData);
ProducerEeeHistoryCsvData.ProducerInReturnsResult b2bProducer = results.ProducerReturnsHistoryData.Find(x => (x.ApprovalNumber == "WEE/TE0000ST/SCH"));
Assert.NotNull(b2bProducer);
Assert.Equal(2000, b2bProducer.ComplianceYear);
Assert.Equal(200, b2bProducer.Cat2B2B);
Assert.Null(b2bProducer.Cat2B2C);
Assert.Equal("Yes", b2bProducer.LatestData);
Assert.Equal(4, results.ProducerReturnsHistoryData.Count);
}
}
public async Task Fetch_ReturnsDataForSubmittedProducerOnly()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
var scheme = helper.CreateScheme();
var memberUpload = helper.CreateMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
memberUpload.IsSubmitted = false;
var producer = helper.CreateProducerAsCompany(memberUpload, "AAA");
database.Model.SaveChanges();
var dataAccess = new GetProducerDetailsDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.Fetch("AAA", 2016);
// Assert
Assert.Empty(result);
}
}
public async void GetOrganisationUsers_SameUserRejectedMultipleTimesForOneOrganisation_ButAlsoHasAnotherStatus_ReturnsTheOtherStatus(Core.Shared.UserStatus status)
{
using (var dbWrapper = new DatabaseWrapper())
{
// Add AspNet user user
var modelHelper = new ModelHelper(dbWrapper.Model);
var aspNetUser = modelHelper.CreateUser("My username", IdType.Guid);
dbWrapper.Model.SaveChanges();
// Add organisation
var uniqueOrgName = "Test Org " + Guid.NewGuid();
var country = dbWrapper.WeeeContext.Countries.First();
var organisation = Domain.Organisation.Organisation.CreateSoleTrader(uniqueOrgName);
organisation.AddOrUpdateMainContactPerson(new Domain.Organisation.Contact("First name", "Last name", "Developer"));
organisation.AddOrUpdateAddress(AddressType.OrganisationAddress, new Domain.Organisation.Address(
"Address line 1",
string.Empty,
"Town",
string.Empty,
string.Empty,
country,
"01234567890",
"[email protected]"));
organisation.CompleteRegistration();
dbWrapper.WeeeContext.Organisations.Add(organisation);
dbWrapper.WeeeContext.SaveChanges();
// Add same organisation user multiple times, rejected
var rejectedOrganisationUsers = new List<Domain.Organisation.OrganisationUser>
{
new Domain.Organisation.OrganisationUser(Guid.Parse(aspNetUser.Id),
organisation.Id,
UserStatus.Rejected),
new Domain.Organisation.OrganisationUser(Guid.Parse(aspNetUser.Id),
organisation.Id,
UserStatus.Rejected),
new Domain.Organisation.OrganisationUser(Guid.Parse(aspNetUser.Id),
organisation.Id,
UserStatus.Rejected)
};
var otherOrganisationUser = new Domain.Organisation.OrganisationUser(Guid.Parse(aspNetUser.Id),
organisation.Id,
status.ToDomainEnumeration<UserStatus>());
dbWrapper.WeeeContext.OrganisationUsers.AddRange(rejectedOrganisationUsers);
dbWrapper.WeeeContext.OrganisationUsers.Add(otherOrganisationUser);
dbWrapper.WeeeContext.SaveChanges();
var dataAccess = new FindMatchingUsersDataAccess(dbWrapper.WeeeContext);
var result = (await dataAccess.GetOrganisationUsers())
.Where(ou => ou.OrganisationName == uniqueOrgName);
Assert.Single(result);
var organisationUser = result.Single();
Assert.Equal(status, organisationUser.Status);
}
}
public async void GetComplianceYearsWithSubmittedMemberUploads_SchemeHasSubmittedMemberUpload_ReturnsCorrespondingComplianceYear()
{
const int complianceYear = 1923;
using (var databaseWrapper = new DatabaseWrapper())
{
// Arrange
var modelHelper = new ModelHelper(databaseWrapper.Model);
var scheme = modelHelper.CreateScheme();
var memberUpload = modelHelper.CreateMemberUpload(scheme);
memberUpload.IsSubmitted = true;
memberUpload.ComplianceYear = complianceYear;
await databaseWrapper.Model.SaveChangesAsync();
// Act
var dataAccess = new SchemeDataAccess(databaseWrapper.WeeeContext);
var result = await dataAccess.GetComplianceYearsWithSubmittedMemberUploads(scheme.Id);
// Assert
Assert.Single(result);
Assert.Equal(complianceYear, result.Single());
}
}
public async Task Execute_WithNonSubmittedMemberUpload_IgnoresProducer()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme1 = helper.CreateScheme();
MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2016;
memberUpload1.IsSubmitted = false;
helper.CreateProducerAsCompany(memberUpload1, "WEE/11AAAA11");
db.Model.SaveChanges();
// Act
List<MembersDetailsCsvData> results = await db.StoredProcedures.SpgCSVDataBySchemeComplianceYearAndAuthorisedAuthority(2016, false, false, scheme1.Id, null);
// Assert
Assert.NotNull(results);
Assert.Equal(0, results.Count);
}
}
public async Task Submit_SetsDataReturnVersionAsSubmitted()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var scheme = helper.CreateScheme();
var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 1, false);
database.Model.SaveChanges();
var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id);
var dataAccess = new SubmitReturnVersionDataAccess(database.WeeeContext);
// Act
await dataAccess.Submit(dbDataReturnVersion);
// Assert
Assert.Equal(dataReturnVersion.Id, dbDataReturnVersion.Id);
Assert.True(dbDataReturnVersion.IsSubmitted);
Assert.NotNull(dbDataReturnVersion.SubmittedDate);
Assert.Equal(database.WeeeContext.GetCurrentUser(), dbDataReturnVersion.SubmittingUserId);
Assert.Equal(dataReturnVersion.Id, dbDataReturnVersion.DataReturn.CurrentVersion.Id);
}
}
public async Task FetchDataReturnOrDefault_ReturnsDataReturnForSpecifiedYearOnly()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var scheme = helper.CreateScheme();
helper.CreateDataReturnVersion(scheme, 2016, 1, true);
var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2017, 1, true);
database.Model.SaveChanges();
var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2017, QuarterType.Q1), database.WeeeContext);
// Act
var result = await dataAccess.FetchDataReturnOrDefault();
// Assert
Assert.Equal(2017, result.Quarter.Year);
Assert.Equal(dataReturnVersion.DataReturn.Id, result.Id);
}
}
public async void SpgSubmissionChangesCsvData_ReturnsProducerAsNew_WhenExistingProducerUploadButNoSubmissionForSameYearAndScheme()
{
using (var database = new DatabaseWrapper())
{
// Arrange
ModelHelper modelHelper = new ModelHelper(database.Model);
var scheme = modelHelper.CreateScheme();
var memberUpload1 = modelHelper.CreateSubmittedMemberUpload(scheme);
memberUpload1.ComplianceYear = 2016;
memberUpload1.IsSubmitted = false;
modelHelper.CreateProducerAsCompany(memberUpload1, "1111");
var memberUpload2 = modelHelper.CreateSubmittedMemberUpload(scheme);
memberUpload2.ComplianceYear = 2016;
modelHelper.CreateProducerAsCompany(memberUpload2, "1111");
database.Model.SaveChanges();
StoredProcedures storedProcedures = new StoredProcedures(database.WeeeContext);
// Act
var result = await storedProcedures.SpgSubmissionChangesCsvData(memberUpload2.Id);
// Assert
Assert.Single(result);
Assert.Equal("New", result[0].ChangeType);
}
}
public async Task MemberUploadSubmissionHandler_SubmitMemberUpload_NewRegisteredProducer_ContainsCorrectValueFor_CurrentSubmission()
{
using (var database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var scheme = helper.CreateScheme();
string registrationNumber = "AAAA";
int complianceYear = 2016;
var registeredProducer = helper.GetOrCreateRegisteredProducer(scheme, complianceYear, registrationNumber);
var memberUpload = helper.CreateMemberUpload(scheme);
memberUpload.ComplianceYear = complianceYear;
memberUpload.IsSubmitted = false;
var producerSubmission = helper.CreateProducerAsCompany(memberUpload, registrationNumber);
// At least one user is required in the database.
helper.GetOrCreateUser("A user");
database.Model.SaveChanges();
User user = await database.WeeeContext.Users.FirstAsync();
IDomainUserContext domainUserContext = A.Fake<IDomainUserContext>();
A.CallTo(() => domainUserContext.GetCurrentUserAsync()).Returns(user);
var handler = new MemberUploadSubmissionHandler(A.Dummy<IWeeeAuthorization>(), database.WeeeContext, domainUserContext);
await handler.HandleAsync(new MemberUploadSubmission(scheme.OrganisationId, memberUpload.Id));
var registeredProducerDb = FindRegisteredProducer(database, registeredProducer.Id);
Assert.Equal(registeredProducerDb.CurrentSubmission.Id, producerSubmission.Id);
}
}
public async Task GetPreviousSubmission_ReturnsNullIfPreviousUploadButNoSubmission()
{
using (var database = new DatabaseWrapper())
{
// Arrange
DataReturnSubmissionsDataAccess dataAccess = new DataReturnSubmissionsDataAccess(database.WeeeContext);
ModelHelper modelHelper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var scheme = modelHelper.CreateScheme();
var dataReturnVersion = modelHelper.CreateDataReturnVersion(scheme, 2015, 1, false);
var dataReturnVersion2 = modelHelper.CreateDataReturnVersion(scheme, 2015, 1, true);
dataReturnVersion2.SubmittedDate = new DateTime(2015, 2, 1);
database.Model.SaveChanges();
var domainDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion2.Id);
// Act
var result = await dataAccess.GetPreviousSubmission(domainDataReturnVersion);
// Assert
Assert.Null(result);
}
}
public async Task GetPreviousSubmission_ReturnsPreviousSubmissionForSameSchemeOnly()
{
using (var database = new DatabaseWrapper())
{
// Arrange
DataReturnSubmissionsDataAccess dataAccess = new DataReturnSubmissionsDataAccess(database.WeeeContext);
ModelHelper modelHelper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var scheme1 = modelHelper.CreateScheme();
var dataReturnVersion = modelHelper.CreateDataReturnVersion(scheme1, 2015, 1, true);
dataReturnVersion.SubmittedDate = new DateTime(2015, 1, 1);
var dataReturnVersion2 = modelHelper.CreateDataReturnVersion(scheme1, 2015, 1, true);
dataReturnVersion2.SubmittedDate = new DateTime(2015, 3, 1);
var scheme2 = modelHelper.CreateScheme();
var dataReturnVersion3 = modelHelper.CreateDataReturnVersion(scheme2, 2015, 1, true);
dataReturnVersion3.SubmittedDate = new DateTime(2015, 2, 1);
database.Model.SaveChanges();
var domainDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion2.Id);
// Act
var result = await dataAccess.GetPreviousSubmission(domainDataReturnVersion);
// Assert
Assert.NotNull(result);
Assert.Equal(dataReturnVersion.Id, result.Id);
}
}
public async Task CreateRegisteredProducer_ProducerIsNotRemoved()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
await context.SaveChangesAsync();
producer = context.RegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.False(producer.Removed);
Assert.Null(producer.RemovedDate);
}
}
public async Task RemoveRegisteredProducer_ProducerIsMarkedAsRemovedAndRemovedDateIsSet()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var organisation = Organisation.CreateSoleTrader("My trading name");
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var scheme = new Scheme(organisation.Id);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
var producer = new RegisteredProducer("ABC12345", 2017, scheme);
context.AllRegisteredProducers.Add(producer);
SystemTime.Freeze(new DateTime(2016, 10, 1));
producer.Remove();
SystemTime.Unfreeze();
await context.SaveChangesAsync();
producer = context.AllRegisteredProducers
.SingleOrDefault(p => p.Id == producer.Id);
Assert.NotNull(producer);
Assert.True(producer.Removed);
Assert.NotNull(producer.RemovedDate);
Assert.Equal(new DateTime(2016, 10, 1), producer.RemovedDate);
}
}
public async Task GetComplianceYears_ReturnsComplianceYearForRegisteredProducer()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
var scheme = helper.CreateScheme();
var memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
var producer1 = helper.CreateProducerAsCompany(memberUpload, "AAA");
database.Model.SaveChanges();
var dataAccess = new GetProducerComplianceYearDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.GetComplianceYears("AAA");
// Assert
Assert.Single(result);
Assert.Contains(2016, result);
}
}
public async void FetchSchemeInfo_WithValidOrganisationId_ReturnsScheme()
{
using (var database = new DatabaseWrapper())
{
// Arrange
Guid organisationId = Guid.NewGuid();
ModelHelper modelHelper = new ModelHelper(database.Model);
var scheme = modelHelper.CreateScheme();
scheme.ApprovalNumber = "1234";
scheme.Organisation.Id = organisationId;
scheme.Organisation.TradingName = "TradingName";
database.Model.SaveChanges();
ProducerListFactoryDataAccess dataAccess = new ProducerListFactoryDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.FetchSchemeInfo(organisationId);
// Assert
Assert.Equal("1234", result.First().ApprovalNumber);
Assert.Equal("TradingName", result.First().TradingName);
}
}
public async void PerformanceTest(int expectedUnderMilliseconds, string producerRegistrationNumber)
{
using (var databaseWrapper = new DatabaseWrapper())
{
// Arrange
var producerEeeMap = new ProducerEeeMap();
A.CallTo(
() =>
mapper.Map<IEnumerable<ProducerEeeByQuarter>, ProducerEeeDetails>(
A<IEnumerable<ProducerEeeByQuarter>>._))
.ReturnsLazily((IEnumerable<ProducerEeeByQuarter> input) => producerEeeMap.Map(input));
var stopwatch = Stopwatch.StartNew();
await Handler(databaseWrapper.WeeeContext)
.HandleAsync(new GetProducerDetails
{
RegistrationNumber = producerRegistrationNumber
});
stopwatch.Stop();
// Assert
Assert.InRange(stopwatch.ElapsedMilliseconds, 0, expectedUnderMilliseconds);
}
}
public async Task Execute_HappyPath_ReturnsProducerWithSelectedSchemeandAA()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme1 = helper.CreateScheme();
scheme1.CompetentAuthorityId = new Guid("4EEE5942-01B2-4A4D-855A-34DEE1BBBF26");
MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2016;
memberUpload1.IsSubmitted = true;
memberUpload1.SubmittedDate = new DateTime(2015, 1, 1);
ProducerSubmission producer1 = helper.CreateProducerAsCompany(memberUpload1, "WEE/11AAAA11");
db.Model.SaveChanges();
// Act
List<MembersDetailsCsvData> results =
await db.StoredProcedures.SpgCSVDataBySchemeComplianceYearAndAuthorisedAuthority(2016, false,
false, scheme1.Id, scheme1.CompetentAuthorityId);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
MembersDetailsCsvData result = results[0];
Assert.Equal("WEE/11AAAA11", result.PRN);
}
}
public async void SpgSubmissionChangesCsvData_ReturnsProducerAsNew_ProducerRegisteredForDifferentSchemeWithinSameYear_ButFirstSubmissionForCurrentScheme()
{
using (var database = new DatabaseWrapper())
{
// Arrange
ModelHelper modelHelper = new ModelHelper(database.Model);
var scheme = modelHelper.CreateScheme();
var memberUpload = modelHelper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
modelHelper.CreateProducerAsCompany(memberUpload, "1111", "B2B");
var scheme2 = modelHelper.CreateScheme();
var memberUpload2 = modelHelper.CreateSubmittedMemberUpload(scheme2);
memberUpload2.ComplianceYear = 2016;
modelHelper.CreateProducerAsCompany(memberUpload2, "1111", "B2C");
database.Model.SaveChanges();
StoredProcedures storedProcedures = new StoredProcedures(database.WeeeContext);
// Act
var result = await storedProcedures.SpgSubmissionChangesCsvData(memberUpload2.Id);
// Assert
Assert.Single(result);
Assert.Equal("New", result[0].ChangeType);
}
}
public async Task Execute_ReturnsProducers_WithNonZeroChargesOnly()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
ModelHelper helper = new ModelHelper(db.Model);
var scheme = helper.CreateScheme();
var invoiceRun = helper.CreateInvoiceRun();
var memberUpload = helper.CreateSubmittedMemberUpload(scheme, invoiceRun);
memberUpload.ComplianceYear = 2016;
var producer1 = helper.CreateProducerAsCompany(memberUpload, "PRN123");
producer1.ChargeThisUpdate = 0;
producer1.Invoiced = true;
var producer2 = helper.CreateProducerAsCompany(memberUpload, "PRN567");
producer2.ChargeThisUpdate = 10;
producer2.Invoiced = true;
db.Model.SaveChanges();
var result = await db.StoredProcedures.SpgInvoiceRunChargeBreakdown(invoiceRun.Id);
Assert.Single(result);
Assert.Equal("PRN567", result.Single().PRN);
}
}
public async Task HandleAsync_XmlContainsSchemaError_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);
database.Model.SaveChanges();
var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(
"Test XML string",
A.Dummy<SchemeReturn>(),
new List<XmlValidationError> { new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text") });
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
.Returns(xmlGeneratorResult);
// 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.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime);
}
}
public async Task HandleAsync_XmlContainsSchemaError_CreatesDataReturnUpload_WithNullComplianceYearAndQuarter()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var organisation = helper.CreateOrganisation();
helper.CreateScheme(organisation);
database.Model.SaveChanges();
var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>(
"Test XML string",
A.Dummy<SchemeReturn>(),
new List<XmlValidationError> { new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text") });
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._))
.Returns(xmlGeneratorResult);
// Act
var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id);
// Assert
var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId);
Assert.Null(dataReturnUpload.ComplianceYear);
Assert.Null(dataReturnUpload.Quarter);
}
}
public async Task GetLatestProducerEeeData_ReturnsData_WhenDataAvailableForSpecifiedScheme()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
var helper = new ModelHelper(database.Model);
var organisation = helper.CreateOrganisation();
var scheme = helper.CreateScheme(organisation);
var memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
var producer = helper.CreateProducerAsCompany(memberUpload, "WEE/MM0001AA");
var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 1, isSubmitted: true);
var producerEee = helper.CreateEeeOutputAmount(dataReturnVersion, producer.RegisteredProducer, "B2C", 1, 1000);
database.Model.SaveChanges();
// Act
var querySet = new SchemeEeeDataQuerySet(organisation.Id, "2016", database.WeeeContext);
var result = await querySet.GetLatestProducerEeeData("WEE/MM0001AA");
// Assert
Assert.NotNull(result);
Assert.Single(result);
}
}
public async Task FetchInvoiceRunsAsync_Always_ReturnsResultsOrderedByIssuedDateDescending()
{
using (DatabaseWrapper wrapper = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(wrapper.Model);
AspNetUser user = helper.GetOrCreateUser("TestUser");
Weee.Tests.Core.Model.Country country = new Weee.Tests.Core.Model.Country();
country.Id = new Guid("FA20ED45-5488-491D-A117-DFC09C9C1BA2");
country.Name = "Test Country";
CompetentAuthority databaseAuthority = new CompetentAuthority();
databaseAuthority.Id = new Guid("DDE398F6-809E-416D-B70D-B36606F221FC");
databaseAuthority.Name = "Test Authority 1";
databaseAuthority.Abbreviation = "T1";
databaseAuthority.Country = country;
databaseAuthority.Email = "TestEmailAddress";
wrapper.Model.CompetentAuthorities.Add(databaseAuthority);
InvoiceRun invoiceRun1 = new InvoiceRun();
invoiceRun1.Id = new Guid("CE7A2617-AE16-403E-A7BF-BF01AD223872");
invoiceRun1.CompetentAuthority = databaseAuthority;
invoiceRun1.IssuedByUserId = user.Id;
invoiceRun1.IssuedDate = new DateTime(2015, 1, 2);
wrapper.Model.InvoiceRuns.Add(invoiceRun1);
InvoiceRun invoiceRun2 = new InvoiceRun();
invoiceRun2.Id = new Guid("728CDF55-1C3C-4BE0-80CB-0BC82CC9DFA3");
invoiceRun2.CompetentAuthority = databaseAuthority;
invoiceRun2.IssuedByUserId = user.Id;
invoiceRun2.IssuedDate = new DateTime(2015, 1, 1);
wrapper.Model.InvoiceRuns.Add(invoiceRun2);
InvoiceRun invoiceRun3 = new InvoiceRun();
invoiceRun3.Id = new Guid("B235CD4F-8188-4BC0-ADA2-55FD6B34BC01");
invoiceRun3.CompetentAuthority = databaseAuthority;
invoiceRun3.IssuedByUserId = user.Id;
invoiceRun3.IssuedDate = new DateTime(2015, 1, 3);
wrapper.Model.InvoiceRuns.Add(invoiceRun3);
wrapper.Model.SaveChanges();
UKCompetentAuthority domainAuthority = wrapper.WeeeContext.UKCompetentAuthorities.Find(databaseAuthority.Id);
FetchInvoiceRunsDataAccess dataAccess = new FetchInvoiceRunsDataAccess(wrapper.WeeeContext);
// Act
IReadOnlyList<Domain.Charges.InvoiceRun> results = await dataAccess.FetchInvoiceRunsAsync(domainAuthority);
// Assert
Assert.NotNull(results);
Assert.Equal(3, results.Count);
Assert.Collection(results,
r1 => Assert.Equal(new DateTime(2015, 1, 3), r1.IssuedDate),
r2 => Assert.Equal(new DateTime(2015, 1, 2), r2.IssuedDate),
r3 => Assert.Equal(new DateTime(2015, 1, 1), r3.IssuedDate));
}
}
public async Task SpgProducerEeeDataHistoryCsvTests_ForEachQuarter_ReturnsProducerEeeDataHistoryLatestDataSetToYes()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
//Arrange
ModelHelper helper = new ModelHelper(db.Model);
var scheme1 = helper.CreateScheme();
scheme1.ApprovalNumber = "WEE/TE1111ST/SCH";
var memberUpload1 = helper.CreateSubmittedMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2000;
var producer1 = helper.CreateProducerAsCompany(memberUpload1, "PRN345");
producer1.ObligationType = "B2B";
var dataReturnVersion1 = helper.CreateDataReturnVersion(scheme1, 2000, 4);
dataReturnVersion1.SubmittedDate = new DateTime(2015, 1, 8);
var dataReturnVersion2 = helper.CreateDataReturnVersion(scheme1, 2000, 2);
dataReturnVersion2.SubmittedDate = new DateTime(2015, 1, 6);
var dataReturnVersion3 = helper.CreateDataReturnVersion(scheme1, 2000, 3);
dataReturnVersion3.SubmittedDate = new DateTime(2015, 1, 3);
var dataReturnVersion4 = helper.CreateDataReturnVersion(scheme1, 2000, 1);
dataReturnVersion4.SubmittedDate = new DateTime(2015, 1, 1);
//Latest for quarter 4
var dataReturnVersion5 = helper.CreateDataReturnVersion(scheme1, 2000, 4);
dataReturnVersion5.SubmittedDate = new DateTime(2015, 1, 10);
helper.CreateEeeOutputAmount(dataReturnVersion1, producer1.RegisteredProducer, "B2B", 10, 100);
helper.CreateEeeOutputAmount(dataReturnVersion2, producer1.RegisteredProducer, "B2B", 11, 200);
helper.CreateEeeOutputAmount(dataReturnVersion3, producer1.RegisteredProducer, "B2B", 12, 300);
helper.CreateEeeOutputAmount(dataReturnVersion4, producer1.RegisteredProducer, "B2B", 13, 500);
helper.CreateEeeOutputAmount(dataReturnVersion5, producer1.RegisteredProducer, "B2B", 13, 600);
db.Model.SaveChanges();
// Act
var results = await db.StoredProcedures.SpgProducerEeeHistoryCsvData("PRN345");
//Assert
Assert.NotNull(results);
Assert.Equal("Yes", results.ProducerReturnsHistoryData[4].LatestData);
Assert.Equal(600, results.ProducerReturnsHistoryData[4].Cat13B2B);
Assert.Equal("No", results.ProducerReturnsHistoryData[3].LatestData);
Assert.Equal(100, results.ProducerReturnsHistoryData[3].Cat10B2B);
Assert.Equal("Yes", results.ProducerReturnsHistoryData[2].LatestData);
Assert.Equal(200, results.ProducerReturnsHistoryData[2].Cat11B2B);
Assert.Equal("Yes", results.ProducerReturnsHistoryData[1].LatestData);
Assert.Equal(300, results.ProducerReturnsHistoryData[1].Cat12B2B);
Assert.Equal("Yes", results.ProducerReturnsHistoryData[0].LatestData);
Assert.Equal(500, results.ProducerReturnsHistoryData[0].Cat13B2B);
Assert.Equal(5, results.ProducerReturnsHistoryData.Count);
}
}
public async Task FetchInvoiceRunsAsync_WithSpecifiedAuthority_OnlyReturnsInvoiceRunsForTheSpecifiedAuthority()
{
using (DatabaseWrapper wrapper = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(wrapper.Model);
AspNetUser user = helper.GetOrCreateUser("TestUser");
Weee.Tests.Core.Model.Country country = new Weee.Tests.Core.Model.Country();
country.Id = new Guid("FA20ED45-5488-491D-A117-DFC09C9C1BA2");
country.Name = "Test Country";
CompetentAuthority databaseAuthority1 = new CompetentAuthority();
databaseAuthority1.Id = new Guid("DDE398F6-809E-416D-B70D-B36606F221FC");
databaseAuthority1.Name = "Test Authority 1";
databaseAuthority1.Abbreviation = "T1";
databaseAuthority1.Country = country;
databaseAuthority1.Email = "TestEmailAddress";
wrapper.Model.CompetentAuthorities.Add(databaseAuthority1);
CompetentAuthority databaseAuthority2 = new CompetentAuthority();
databaseAuthority2.Id = new Guid("FBCEDC2F-0825-4066-B24E-86D3A2FD892B");
databaseAuthority2.Name = "Test Authority 2";
databaseAuthority2.Abbreviation = "T2";
databaseAuthority2.Country = country;
databaseAuthority2.Email = "TestEmailAddress2";
wrapper.Model.CompetentAuthorities.Add(databaseAuthority2);
InvoiceRun invoiceRunForAuthority1 = new InvoiceRun();
invoiceRunForAuthority1.Id = new Guid("CE7A2617-AE16-403E-A7BF-BF01AD223872");
invoiceRunForAuthority1.CompetentAuthority = databaseAuthority1;
invoiceRunForAuthority1.IssuedByUserId = user.Id;
invoiceRunForAuthority1.IssuedDate = new DateTime(2015, 1, 1);
wrapper.Model.InvoiceRuns.Add(invoiceRunForAuthority1);
InvoiceRun invoiceRunForAuthority2 = new InvoiceRun();
invoiceRunForAuthority2.Id = new Guid("728CDF55-1C3C-4BE0-80CB-0BC82CC9DFA3");
invoiceRunForAuthority2.CompetentAuthority = databaseAuthority2;
invoiceRunForAuthority2.IssuedByUserId = user.Id;
invoiceRunForAuthority2.IssuedDate = new DateTime(2015, 1, 1);
wrapper.Model.InvoiceRuns.Add(invoiceRunForAuthority2);
wrapper.Model.SaveChanges();
UKCompetentAuthority domainAuthority1 = wrapper.WeeeContext.UKCompetentAuthorities.Find(databaseAuthority1.Id);
FetchInvoiceRunsDataAccess dataAccess = new FetchInvoiceRunsDataAccess(wrapper.WeeeContext);
// Act
IReadOnlyList<Domain.Charges.InvoiceRun> results = await dataAccess.FetchInvoiceRunsAsync(domainAuthority1);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
Assert.Equal(new Guid("CE7A2617-AE16-403E-A7BF-BF01AD223872"), results[0].Id);
}
}
public async Task HappyPath_ManyUniquePrnsGeneratedAndSeedUpdatedToExpectedValue()
{
// arrange
var validXmlLocation = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase), @"ExampleXML\v3-valid-many-insertions.xml");
var validXmlString = File.ReadAllText(new Uri(validXmlLocation).LocalPath);
var validXmlBytes = File.ReadAllBytes(new Uri(validXmlLocation).LocalPath);
using (var database = new DatabaseWrapper())
{
var modelHelper = new ModelHelper(database.Model);
var org = modelHelper.CreateOrganisation();
var scheme = modelHelper.CreateScheme(org);
var memberUpload = modelHelper.CreateMemberUpload(scheme);
var message = new ProcessXmlFile(org.Id, validXmlBytes, "File name");
var initialSeed = database.WeeeContext.SystemData.Select(sd => sd.LatestPrnSeed).First();
var expectedSeed = ExpectedSeedAfterThisXml(validXmlString, initialSeed);
var whiteSpaceCollapser = A.Fake<IWhiteSpaceCollapser>();
var xmlConverter = new XmlConverter(whiteSpaceCollapser, new Deserializer());
var schemeType = xmlConverter.Deserialize<schemeType>(xmlConverter.Convert(message.Data));
var producerCharges = new Dictionary<string, ProducerCharge>();
var anyAmount = 30;
var anyChargeBandAmount = A.Dummy<ChargeBandAmount>();
foreach (var producerData in schemeType.producerList)
{
var producerName = producerData.GetProducerName();
if (!producerCharges.ContainsKey(producerName))
{
producerCharges.Add(producerName,
new ProducerCharge { Amount = anyAmount, ChargeBandAmount = anyChargeBandAmount });
}
}
database.Model.SaveChanges();
var contextMemberUpload = database.WeeeContext.MemberUploads
.Single(mu => mu.Id == memberUpload.Id);
// act
var producers = await new GenerateFromXml(
xmlConverter,
new GenerateFromXmlDataAccess(database.WeeeContext)).GenerateProducers(message, contextMemberUpload, producerCharges);
// assert
long newSeed = database.WeeeContext.SystemData.Select(sd => sd.LatestPrnSeed).First();
Assert.Equal(expectedSeed, newSeed);
var prns = producers.Select(p => p.RegisteredProducer.ProducerRegistrationNumber);
Assert.Equal(prns.Distinct(), prns); // all prns should be unique
}
}
public async Task FetchSchemeByOrganisationIdAsync_ThrowsInvalidOperationException_WhenNoMatchingOrganisationId()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
var dataAccess = new ProcessDataReturnXmlFileDataAccess(database.WeeeContext);
await Assert.ThrowsAsync<InvalidOperationException>(() => dataAccess.FetchSchemeByOrganisationIdAsync(Guid.NewGuid()));
}
}
public async void FetchSchemeByOrganisationId_WitValidOrganisationId_ReturnsScheme()
{
using (var database = new DatabaseWrapper())
{
var organisationId = new Guid("72BB14DF-DCD5-4DBB-BBA9-4CFC26AD80F9");
var dataAccess = new GetSchemePublicInfoDataAccess(database.WeeeContext);
// Arrange
var modelHelper = new ModelHelper(database.Model);
var scheme1 = modelHelper.CreateScheme();
scheme1.Organisation.Id = organisationId;
database.Model.SaveChanges();
// Act
var result = await dataAccess.FetchSchemeByOrganisationId(organisationId);
// Assert
Assert.NotNull(result);
Assert.Equal(organisationId, result.OrganisationId);
}
}
public async Task GetChanges_WithInvalidCurrentSubmissionId_ThrowsInvalidOperationException()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme = helper.CreateScheme();
MemberUpload memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
var previousDataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 1, true);
previousDataReturnVersion.SubmittedDate = new DateTime(2016, 1, 1);
db.Model.SaveChanges();
var dataAccess = new GetDataReturnSubmissionEeeChangesCsvDataAccess(db.WeeeContext);
// Act, Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => dataAccess.GetChanges(Guid.NewGuid(), previousDataReturnVersion.Id));
}
}
public async void FetchSchemeBySchemeId_WitValidSchemeId_ReturnsScheme()
{
using (var database = new DatabaseWrapper())
{
var schemeId = Guid.NewGuid();
var dataAccess = new GetSchemePublicInfoDataAccess(database.WeeeContext);
// Arrange
var modelHelper = new ModelHelper(database.Model);
var scheme1 = modelHelper.CreateScheme();
scheme1.Id = schemeId;
database.Model.SaveChanges();
// Act
var result = await dataAccess.FetchSchemeBySchemeId(schemeId);
// Assert
result.Should().NotBeNull();
result.Id.Should().Be(schemeId);
}
}
public void ExecuteCountQueryWithParametersTest()
{
var tableName = "testingTable" + HelperObjectFactory.GetRandomInt(0);
var parameters = new List <SQLiteParameter>();
var aParameter = SqliteExtensions.Create("a", DbType.String, "string1");
var bParameter = SqliteExtensions.Create("b", DbType.Int32, 32);
parameters.Add(aParameter);
parameters.Add(bParameter);
DatabaseWrapper.ExecuteSql($"CREATE TABLE {tableName}(a, b);");
Assert.AreEqual(DatabaseWrapper.ExecuteCountQueryWithParameters($"SELECT COUNT(a) FROM {tableName} WHERE a = 'nothing';", parameters), 0);
DatabaseWrapper.ExecuteSqlWithParameters($"INSERT INTO {tableName}(a, b) VALUES ({aParameter.ParameterName}, {bParameter.ParameterName});", parameters);
Assert.AreEqual(DatabaseWrapper.ExecuteCountQueryWithParameters($"SELECT COUNT(a) FROM {tableName} WHERE a = {aParameter.ParameterName};", parameters), 1);
aParameter = SqliteExtensions.Create("a", DbType.String, "string2");
bParameter = SqliteExtensions.Create("b", DbType.Int32, 64);
DatabaseWrapper.ExecuteSqlWithParameters($"INSERT INTO {tableName}(a, b) VALUES ({aParameter.ParameterName}, {bParameter.ParameterName});", parameters);
Assert.AreEqual(DatabaseWrapper.ExecuteCountQueryWithParameters($"SELECT COUNT(b) FROM {tableName} WHERE b > 20;", parameters), 2);
DatabaseWrapper.ExecuteSql($"DROP TABLE {tableName};");
}
public async Task HandleAsync_GivenAatfCanBeDeleted_AatfShouldBeRemovedButOrganisationNotRemoved()
{
using (var databaseWrapper = new DatabaseWrapper())
{
var organisation = EA.Weee.Domain.Organisation.Organisation.CreatePartnership("trading");
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(databaseWrapper, organisation);
databaseWrapper.WeeeContext.Aatfs.Add(aatf);
await databaseWrapper.WeeeContext.SaveChangesAsync();
databaseWrapper.WeeeContext.Aatfs.Where(a => a.Id == aatf.Id).Should().NotBeEmpty();
var message = new DeleteAnAatf(aatf.Id, aatf.Organisation.Id);
SetAatfDeleteFlags(message);
await Handler(databaseWrapper).HandleAsync(message);
databaseWrapper.WeeeContext.Aatfs.Where(a => a.Id == aatf.Id).Should().BeEmpty();
databaseWrapper.WeeeContext.Organisations.Where(a => a.Id == organisation.Id).Should().NotBeEmpty();
}
}
public async Task Execute_GivenWeeeSentOnData_PanAreaParameter_ReturnsDataShouldBeCorrect()
{
using (var db = new DatabaseWrapper())
{
var @return = CreateSubmittedReturn(db);
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(db, @return.Organisation);
await CreateWeeSentOnData(db, aatf, @return);
var ea = db.WeeeContext.UKCompetentAuthorities.First();
var filter = db.WeeeContext.PanAreas.First();
var results = await db.StoredProcedures.GetAllAatfSentOnDataCsv(2019, string.Empty, ea.Id, filter.Id);
Assert.NotNull(results);
var data = from x in results.Tables[0].AsEnumerable()
where x.Field <string>("Name of AATF") == aatf.Name && x.Field <string>("WROS Pan Area Team") == filter.Name
select x;
data.AsQueryable().Count().Should().Be(28);
}
}
public async Task GetMemberUpload_ReturnsNull_WhenMemberUploadWithSpecifiedIdNotFound()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme = helper.CreateScheme();
MemberUpload memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2016;
db.Model.SaveChanges();
var dataAccess = new GetSubmissionChangesCsvDataAccess(db.WeeeContext);
// Act
var result = await dataAccess.GetMemberUpload(Guid.NewGuid());
// Assert
Assert.Null(result);
}
}
public async void GetComplianceYearsWithSubmittedMemberUploads_SchemeHasUnsubmittedMemberUpload_ReturnsNoYears()
{
using (var databaseWrapper = new DatabaseWrapper())
{
// Arrange
var modelHelper = new ModelHelper(databaseWrapper.Model);
var scheme = modelHelper.CreateScheme();
var memberUpload = modelHelper.CreateMemberUpload(scheme);
memberUpload.IsSubmitted = false;
await databaseWrapper.Model.SaveChangesAsync();
// Act
var dataAccess = new SchemeDataAccess(databaseWrapper.WeeeContext);
var result = await dataAccess.GetComplianceYearsWithSubmittedMemberUploads(scheme.Id);
// Assert
Assert.Empty(result);
}
}
public async Task Execute_GivenMultipleReturnsForOrganisationInSameQuarterAndYear_OnlyMostRecentDataShouldBeReturned()
{
using (var db = new DatabaseWrapper())
{
var organisation = Organisation.CreateRegisteredCompany(fixture.Create <string>(), "1234567", null);
var @return1 = CreateSubmittedReturn(db, organisation);
SystemTime.Freeze(DateTime.Now.AddDays(1));
var @return2 = ObligatedWeeeIntegrationCommon.CreateReturn(organisation, db.Model.AspNetUsers.First().Id, FacilityType.Aatf);
@return2.UpdateSubmitted(db.Model.AspNetUsers.First().Id, false);
SystemTime.Unfreeze();
db.WeeeContext.Returns.Add(@return1);
db.WeeeContext.Returns.Add(@return2);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetNonObligatedWeeeReceivedAtAatf(2019, null);
results.Count(r => r.ReturnId.Equals(@return1.Id)).Should().Be(0);
results.Count(r => r.ReturnId.Equals(@return2.Id)).Should().Be(CategoryValues().Count);
}
}
public void AuditChanges_InsertEntityWithEnums_AddsAuditLogWithExpectedEnumerationJson()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
//Arrange
Guid userId = Guid.Parse("F37FEB8F-A364-47F6-86A5-02E191E8AF20");
EntityWithEnums ewe1 = new EntityWithEnums(TestEnumeration.B, SimpleEnum.Value1);
database.TestContext.EnumEntities.Add(ewe1);
database.TestContext.SetEntityId();
//Act
database.TestContext.AuditChanges(userId);
database.TestContext.SaveChanges();
//Assert
//Audit Log stores correct Json, including the complex type
Guid ewe1Id = database.TestContext.EnumEntities.Single().Id;
String expectedJson =
"{\\\"Id\\\":\\\"" + ewe1Id + "\\\",\\\"TestEnumerationValue\\\":\\\"{\\\\\"Value\\\\\":2}\\\",\\\"SimpleEnumValue\\\":1,\\\"RowVersion\\\":null}";
Assert.Matches(expectedJson,
database.TestContext.AuditLogs.Single(al => al.RecordId == ewe1Id).NewValue);
}
}
public static List <TBMap> GetTBMaps(this DatabaseWrapper conn)
{
IDbCommand cmd = conn.CreateCommand();
cmd.CommandText = "SELECT * FROM tb_map;";
List <TBMap> data = new List <TBMap>();
using (IDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
TBMap obj = new TBMap();
obj.TBRef = (long)reader["tbref"];
obj.TBDevId = (string)reader["tb_dev_id"];
obj.TBDevName = (string)reader["tb_dname"];
obj.TBDevType = (string)reader["tb_dev_type"];
obj.TBAt = (string)reader["tb_at"];
obj.Created = (DateTime)reader["created"];
data.Add(obj);
}
}
return(data);
}
public async Task FetchAatfByReturnQuarterWindow_GivenNonMatchingComplianceYear_ReturnedListShouldNotContainAatf()
{
using (var database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var dataAccess = new FetchAatfDataAccess(database.WeeeContext, quarterWindowFactory);
var genericDataAccess = new GenericDataAccess(database.WeeeContext);
var aatf = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2020);
var @return = new Return(aatf.Organisation, new Quarter(2019, QuarterType.Q1), "created", FacilityType.Aatf);
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(@return.Quarter)).Returns(new QuarterWindow(DateTime.Now.AddDays(1), DateTime.Now.AddDays(1), QuarterType.Q1));
await genericDataAccess.AddMany <Aatf>(new List <Aatf>() { aatf });
var aatfList = await dataAccess.FetchAatfByReturnQuarterWindow(@return);
aatfList.Should().NotContain(aatf);
aatfList.Should().BeEmpty();
}
}
public async Task GetOrAddAeDeliveryLocation_ReturnsAeDeliveryLocation_ForMatchingOperatorName()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
helper.CreateAeDeliveryLocation("APR", "Operator Name1");
var location = helper.CreateAeDeliveryLocation("APR", "Operator Name2");
database.Model.SaveChanges();
var dataAccess = new DataReturnVersionBuilderDataAccess(A.Dummy <Domain.Scheme.Scheme>(), A.Dummy <Quarter>(), database.WeeeContext);
// Act
var result = await dataAccess.GetOrAddAeDeliveryLocation("APR", "Operator Name2");
// Assert
Assert.NotNull(result);
Assert.Equal("Operator Name2", result.OperatorName);
Assert.Equal(location.Id, result.Id);
}
}
public async void DataProcessor_DoesNotIncludeB2COnlyProducer_WhenB2BSpecified()
{
using (var db = new DatabaseWrapper())
{
//Arrange
ModelHelper helper = new ModelHelper(db.Model);
var scheme = helper.CreateScheme();
var memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2000;
helper.CreateProducerAsCompany(memberUpload, "PRN123", "B2C");
db.Model.SaveChanges();
// Act
GetMissingProducerDataCsvDataProcessor missingDataAccess = new GetMissingProducerDataCsvDataProcessor(db.WeeeContext);
List <MissingProducerDataCsvData> results = await missingDataAccess.FetchMissingProducerDataAsync(2000, "B2B", 1, null);
// Assert
Assert.NotNull(results);
Assert.Equal(0, results.Count);
}
}
public async void DataProcessor_ReturnsAllQuartersForProducer_WhenNoDataReturnsUploaded()
{
using (var db = new DatabaseWrapper())
{
//Arrange
ModelHelper helper = new ModelHelper(db.Model);
var scheme = helper.CreateScheme();
var memberUpload = helper.CreateSubmittedMemberUpload(scheme);
memberUpload.ComplianceYear = 2000;
helper.CreateProducerAsCompany(memberUpload, "PRN123", "B2B");
db.Model.SaveChanges();
// Act
GetMissingProducerDataCsvDataProcessor missingDataAccess = new GetMissingProducerDataCsvDataProcessor(db.WeeeContext);
var results = await missingDataAccess.FetchMissingProducerDataAsync(2000, "B2B", null, null);
// Assert
Assert.NotNull(results);
Assert.Equal(4, results.Count);
}
}
public async Task UpdateUserRoleAndStatus_UpdatesUserRoleAndStatusInDatabase()
{
using (var databaseWrapper = new DatabaseWrapper())
{
ModelHelper modelHelper = new ModelHelper(databaseWrapper.Model);
DomainHelper domainHelper = new DomainHelper(databaseWrapper.WeeeContext);
var userRole = databaseWrapper.Model.Roles.Single(r => r.Name == "InternalUser");
var user = modelHelper.GetOrCreateCompetentAuthorityUser("TestUser", 1, userRole);
databaseWrapper.Model.SaveChanges();
var competentAuthorityUser = domainHelper.GetCompetentAuthorityUser(user.Id);
var adminRole = domainHelper.GetRole("InternalAdmin");
var dataAccess = new UpdateCompetentAuthorityUserRoleAndStatusDataAccess(databaseWrapper.WeeeContext);
await dataAccess.UpdateUserRoleAndStatus(competentAuthorityUser, adminRole, Core.Shared.UserStatus.Active);
Assert.Equal(UserStatus.Active, competentAuthorityUser.UserStatus);
Assert.Equal("InternalAdmin", competentAuthorityUser.Role.Name);
}
}
public async Task Execute_GivenSubmittedReturnWithData_ExpectedDataShouldBeReturned()
{
using (var db = new DatabaseWrapper())
{
var @return = SetupSubmittedReturn(db);
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(db, organisation);
var values = CategoryValues();
db.WeeeContext.Returns.Add(@return);
foreach (var weeeCategory in values)
{
db.WeeeContext.NonObligatedWeee.Add(new NonObligatedWeee(@return, (int)weeeCategory, false, (decimal)weeeCategory));
db.WeeeContext.NonObligatedWeee.Add(new NonObligatedWeee(@return, (int)weeeCategory, true, (decimal)weeeCategory + 1));
}
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetReturnNonObligatedCsvData(@return.Id);
results.Count.Should().Be(14);
for (var countValue = 0; countValue < values.Count(); countValue++)
{
var value = values.ElementAt(countValue);
results.ElementAt(countValue).Year.Should().Be(2019);
results.ElementAt(countValue).Quarter.Should().Be("Q1");
results.ElementAt(countValue).SubmittedBy.Should()
.Be($"{db.Model.AspNetUsers.First().FirstName} {db.Model.AspNetUsers.First().Surname}");
results.ElementAt(countValue).SubmittedDate.Should().Be(date);
results.ElementAt(countValue).OrganisationName.Should().Be(organisation.Name);
results.ElementAt(countValue).Category.Should().Be($"{countValue + 1}. {value.ToDisplayString()}");
results.ElementAt(countValue).TotalNonObligatedWeeeReceived.Should().Be((decimal)value);
results.ElementAt(countValue).TotalNonObligatedWeeeReceivedFromDcf.Should().Be((decimal)value + 1);
}
}
}
public async Task Execute_GivenSubmittedReturns_HighLevelDataShouldBeCorrect()
{
using (var db = new DatabaseWrapper())
{
var org1 = Organisation.CreateRegisteredCompany(fixture.Create <string>(), "1234567", null);
var org2 = Organisation.CreateRegisteredCompany(fixture.Create <string>(), "1234567", null);
var @return1 = CreateSubmittedReturn(db, org1);
var @return2 = CreateSubmittedReturn(db, org2);
db.WeeeContext.Returns.Add(@return1);
db.WeeeContext.Returns.Add(@return2);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetNonObligatedWeeeReceivedAtAatf(2019, null);
var return1Results = results.Where(r => r.ReturnId.Equals(@return1.Id));
foreach (var nonObligatedWeeeReceivedAtAatfsData in return1Results)
{
nonObligatedWeeeReceivedAtAatfsData.Year.Should().Be(2019);
nonObligatedWeeeReceivedAtAatfsData.Quarter.Should().Be("Q1");
nonObligatedWeeeReceivedAtAatfsData.SubmittedBy.Should().Be(db.Model.AspNetUsers.First().FirstName + " " + db.Model.AspNetUsers.First().Surname);
nonObligatedWeeeReceivedAtAatfsData.SubmittedDate.Value.Date.Should().Be(@return1.SubmittedDate.Value.Date);
nonObligatedWeeeReceivedAtAatfsData.OrganisationName.Should().Be(org1.OrganisationName);
}
var return2Results = results.Where(r => r.ReturnId.Equals(@return2.Id));
foreach (var nonObligatedWeeeReceivedAtAatfsData in return2Results)
{
nonObligatedWeeeReceivedAtAatfsData.Year.Should().Be(2019);
nonObligatedWeeeReceivedAtAatfsData.Quarter.Should().Be("Q1");
nonObligatedWeeeReceivedAtAatfsData.SubmittedBy.Should().Be(db.Model.AspNetUsers.First().FirstName + " " + db.Model.AspNetUsers.First().Surname);
nonObligatedWeeeReceivedAtAatfsData.SubmittedDate.Value.Date.Should().Be(@return2.SubmittedDate.Value.Date);
nonObligatedWeeeReceivedAtAatfsData.OrganisationName.Should().Be(org2.OrganisationName);
}
}
}
public async Task Execute_WithSeveralProducers_ReturnsResultsOrderedByOrganisationName()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme1 = helper.CreateScheme();
MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2016;
memberUpload1.IsSubmitted = true;
memberUpload1.SubmittedDate = new DateTime(2015, 1, 1);
ProducerSubmission producer1 = helper.CreateProducerAsPartnership(memberUpload1, "WEE/11BBBB11");
producer1.Business.Partnership.Name = "ABCH";
ProducerSubmission producer2 = helper.CreateProducerAsCompany(memberUpload1, "WEE/22AAAA22");
producer2.Business.Company.Name = "AAAA";
ProducerSubmission producer3 = helper.CreateProducerAsPartnership(memberUpload1, "WEE/33CCCC33");
producer3.Business.Partnership.Name = "ABCD";
db.Model.SaveChanges();
// Act
List <MembersDetailsCsvData> results = await db.StoredProcedures.SpgCSVDataBySchemeComplianceYearAndAuthorisedAuthority(2016, false, false, scheme1.Id, null);
// Assert
Assert.NotNull(results);
Assert.Collection(results,
(r1) => Assert.Equal("AAAA", r1.ProducerName),
(r2) => Assert.Equal("ABCD", r2.ProducerName),
(r3) => Assert.Equal("ABCH", r3.ProducerName));
}
}
public async void GetOrganisationUsers_WithOrganisationNameFilterAndMatchingTradingName_DoesNotReturnWhenOrganisationNameDoesNotMatch()
{
using (var dbWrapper = new DatabaseWrapper())
{
// Add AspNet user
var modelHelper = new ModelHelper(dbWrapper.Model);
var user = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, fixture.Create <string>().Substring(0, 10), fixture.Create <string>().Substring(0, 10));
dbWrapper.Model.SaveChanges();
// Add organisation
var organisationName = "Waste";
var organisationTradingName = "Trash";
var organisation = Organisation.CreateSoleTrader(organisationName, organisationTradingName);
organisation.CompleteRegistration();
dbWrapper.WeeeContext.Organisations.Add(organisation);
dbWrapper.WeeeContext.SaveChanges();
// Add organisation users
var organisationUsers = new List <Domain.Organisation.OrganisationUser>
{
new Domain.Organisation.OrganisationUser(Guid.Parse(user.Id), organisation.Id, UserStatus.Active)
};
dbWrapper.WeeeContext.OrganisationUsers.AddRange(organisationUsers);
dbWrapper.WeeeContext.SaveChanges();
var dataAccess = new FindMatchingUsersDataAccess(dbWrapper.WeeeContext);
var filter = new UserFilter {
OrganisationName = "Trash"
};
var result = await dataAccess.GetOrganisationUsers(filter);
Assert.Equal(0, result.Count());
}
}
private void LoadSkills(string path)
{
string data = File.ReadAllText(path);
DatabaseWrapper <SkillData> db = JsonUtility.FromJson <DatabaseWrapper <SkillData> >(data);
foreach (SkillData skill in db.entries)
{
Skill newSkill = new Skill();
newSkill.name = skill.name;
newSkill.description = skill.description;
Enum.TryParse(skill.type, out newSkill.type);
newSkill.priority = skill.priority;
newSkill.might = skill.might;
if (skill.targetStat != null)
{
Enum.TryParse(skill.targetStat, out newSkill.targetStat);
}
newSkill.cooldown = skill.cooldown;
newSkill.isDefensive = skill.isDefensive;
newSkill.range = skill.range;
if (skill.assistType != null)
{
Enum.TryParse(skill.assistType, out newSkill.assistType);
}
foreach (string effectName in skill.effects)
{
newSkill.effects.Add(effectsDB.GetSkillEffect(effectName));
}
skills.Add(skill.name, newSkill);
}
}
public async Task HandleAsync_XmlContainsSchemaError_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);
database.Model.SaveChanges();
var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext);
var xmlGeneratorResult = new GenerateFromDataReturnXmlResult <SchemeReturn>(
"Test XML string",
A.Dummy <SchemeReturn>(),
new List <XmlValidationError> {
new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text")
});
A.CallTo(() => builder.XmlGenerator.GenerateDataReturns <SchemeReturn>(A <ProcessDataReturnXmlFile> ._))
.Returns(xmlGeneratorResult);
// 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.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime);
}
}
private List <int> GetDefaultGroupIDs()
{
List <int> defaultGroupIDs = null;
string sql = "";
try {
DbInfo = new DatabaseWrapper(Lcf);
DbInfo.Connect();
if (!DbInfo.ColumnExists(GroupQB.GROUP_TBLE_NAME, GroupQB.GROUP_DEFAULT_COL))
{
Logger.LogError(5, "Column " + GroupQB.GROUP_DEFAULT_COL + " does not exist in table " + GroupQB.GROUP_TBLE_NAME + ". Cannot get default Group IDs!");
return(null);
}
sql = GroupQB.GetSelectDefaultGroupIdsSql();
defaultGroupIDs = DbInfo.GetIntegerList(sql);
if (defaultGroupIDs == null)
{
Logger.LogError(5, "Failed to get default group IDs!");
return(null);
}
if (defaultGroupIDs.Count == 0)
{
Logger.Log("No default group is found in the system when using SQL " + sql);
}
} catch (Exception ex) {
Logger.LogError(5, "Failed to get default group IDs at: " + ex);
defaultGroupIDs = null;
} finally {
if (DbInfo != null)
{
DbInfo.Disconnect();
}
}
return(defaultGroupIDs);
}
public async void GetRegistrationNumbers_ReturnsRegistrationNumbers_ForSpecifiedComplianceYearOnly()
{
using (var database = new DatabaseWrapper())
{
// Arrange
ModelHelper modelHelper = new ModelHelper(database.Model);
Guid organisationId = Guid.NewGuid();
var scheme = modelHelper.CreateScheme();
scheme.Organisation.Id = organisationId;
var memberUpload1 = modelHelper.CreateMemberUpload(scheme);
memberUpload1.ComplianceYear = 2015;
memberUpload1.IsSubmitted = true;
modelHelper.GetOrCreateRegisteredProducer(scheme, 2015, "1234");
modelHelper.CreateProducerAsCompany(memberUpload1, "1234");
var memberUpload2 = modelHelper.CreateMemberUpload(scheme);
memberUpload2.ComplianceYear = 2016;
memberUpload2.IsSubmitted = true;
modelHelper.GetOrCreateRegisteredProducer(scheme, 2016, "987");
modelHelper.CreateProducerAsCompany(memberUpload2, "987");
database.Model.SaveChanges();
ProducerListFactoryDataAccess dataAccess = new ProducerListFactoryDataAccess(database.WeeeContext);
// Act
var result = await dataAccess.GetRegistrationNumbers(organisationId, 2015, 2);
// Assert
Assert.Equal(1, result.Count);
Assert.Equal("1234", result.First());
}
}
public async Task Execute_WithOneCurrentInSeveralYearsProducer_ReturnsTheCorrectYearsData()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(db.Model);
Scheme scheme1 = helper.CreateScheme();
MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1);
memberUpload1.ComplianceYear = 2016;
memberUpload1.IsSubmitted = true;
memberUpload1.SubmittedDate = new DateTime(2015, 1, 1);
ProducerSubmission producer1 = helper.CreateProducerAsPartnership(memberUpload1, "WEE/11AAAA11");
MemberUpload memberUpload2 = helper.CreateMemberUpload(scheme1);
memberUpload2.ComplianceYear = 2017;
memberUpload2.IsSubmitted = true;
memberUpload2.SubmittedDate = new DateTime(2015, 1, 1);
ProducerSubmission producer2 = helper.CreateProducerAsPartnership(memberUpload2, "WEE/11AAAA11");
db.Model.SaveChanges();
// Act
List <MembersDetailsCsvData> results = await db.StoredProcedures.SpgCSVDataBySchemeComplianceYearAndAuthorisedAuthority(2016, false, false, scheme1.Id, null);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
MembersDetailsCsvData result = results[0];
Assert.Equal(producer1.Business.Partnership.Name, result.ProducerName);
}
}
public async void Get_TwoUploadsForTheSameComplianceYear_OnlyReturnsTheYearOnce()
{
using (var database = new DatabaseWrapper())
{
const int complianceYear = 2995;
// Arrange
var modelHelper = new ModelHelper(database.Model);
var organisation = modelHelper.CreateOrganisation();
await database.Model.SaveChangesAsync();
var scheme = modelHelper.CreateScheme(organisation);
await database.Model.SaveChangesAsync();
var firstDataReturn = modelHelper.CreateDataReturn(scheme, complianceYear, (int)QuarterType.Q1);
await database.Model.SaveChangesAsync();
var firstDataReturnVersion = modelHelper.CreateDataReturnVersion(scheme, complianceYear, (int)QuarterType.Q1, true, firstDataReturn);
modelHelper.CreateDataReturnUpload(scheme, firstDataReturnVersion);
await database.Model.SaveChangesAsync();
var secondDataReturn = modelHelper.CreateDataReturn(scheme, complianceYear, (int)QuarterType.Q2);
await database.Model.SaveChangesAsync();
var secondDataReturnVersion = modelHelper.CreateDataReturnVersion(scheme, complianceYear, (int)QuarterType.Q2, true, secondDataReturn);
modelHelper.CreateDataReturnUpload(scheme, secondDataReturnVersion);
await database.Model.SaveChangesAsync();
// Act
var dataAccess = new GetDataReturnsActiveComplianceYearsDataAccess(database.WeeeContext);
var result = await dataAccess.Get();
// Assert
Assert.Single(result.Where(y => y == complianceYear));
}
}
public async Task Execute_ReturnsCurrentYearProducers_WhenNoPreviousYearDataReturnUpload_WithoutEeeData()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
//Arrange
ModelHelper helper = new ModelHelper(db.Model);
var scheme = helper.CreateScheme();
scheme.ApprovalNumber = "WEE/TE0000ST/SCH";
//Previous Year Data
var memberUpload2000 = helper.CreateSubmittedMemberUpload(scheme);
memberUpload2000.ComplianceYear = 2000;
helper.CreateProducerAsCompany(memberUpload2000, "PRN123", "B2C");
//Current Year Data
var memberUpload2001 = helper.CreateSubmittedMemberUpload(scheme);
memberUpload2001.ComplianceYear = 2001;
var prod1_2001 = helper.CreateProducerAsCompany(memberUpload2001, "PRN123", "Both");
var dataReturnVersion2 = helper.CreateDataReturnVersion(scheme, 2001, 1);
helper.CreateEeeOutputAmount(dataReturnVersion2, prod1_2001.RegisteredProducer, "B2C", 1, 3000);
helper.CreateEeeOutputAmount(dataReturnVersion2, prod1_2001.RegisteredProducer, "B2B", 1, 5000);
db.Model.SaveChanges();
// Act
var results = await db.StoredProcedures.SpgSchemeObligationDataCsv(2001);
//Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
SchemeObligationCsvData result = results[0];
Assert.Equal("PRN123", result.PRN);
Assert.Equal("B2C", result.ObligationTypeForPreviousYear);
Assert.Equal("Both", result.ObligationTypeForSelectedYear);
Assert.Null(result.Cat1B2CTotal);
}
}
public async Task Execute_GivenSubmittedReturnWithWithoutOptionsSelected_DataShouldNotHaveColumns()
{
using (var db = new DatabaseWrapper())
{
var @return = SetupCreatedReturn(db);
var aatf = SetupAatfWithApprovalDate(db, DateTime.MinValue, "AAA");
db.WeeeContext.Aatfs.Add(aatf);
db.WeeeContext.Returns.Add(@return);
await db.WeeeContext.SaveChangesAsync();
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetReturnObligatedCsvData(@return.Id);
results.Rows.Count.Should().Be(28);
results.Columns[TotalReceivedHeading].Should().BeNull();
results.Columns[TotalSentOnHeading].Should().BeNull();
results.Columns[TotalReusedHeading].Should().BeNull();
results.Dispose();
}
}
public async Task Execute_GivenAatfAndAatfThatShouldNotReport_AatfShouldNotBeInData()
{
using (var db = new DatabaseWrapper())
{
var @return = SetupCreatedReturn(db);
var aatf = SetupAatfWithApprovalDate(db, DateTime.MinValue, "AAA");
var aatfNotReporting = SetupAatfWithApprovalDate(db, DateTime.MaxValue, "AAA");
db.WeeeContext.Aatfs.Add(aatf);
db.WeeeContext.Aatfs.Add(aatfNotReporting);
db.WeeeContext.Returns.Add(@return);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetReturnObligatedCsvData(@return.Id);
results.Rows.Count.Should().Be(28);
results.Select($"AatfKey='{aatf.Id}'").Length.Should().Be(28);
results.Select($"AatfKey='{aatfNotReporting.Id}'").Length.Should().Be(0);
results.Dispose();
}
}
public async Task FetchDataReturnOrDefault_ResultIncludesUnsubmittedDataReturn()
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
ModelHelper helper = new ModelHelper(database.Model);
DomainHelper domainHelper = new DomainHelper(database.WeeeContext);
var scheme = helper.CreateScheme();
var dataReturn = helper.CreateDataReturn(scheme, 2016, 1);
database.Model.SaveChanges();
var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2016, QuarterType.Q1), database.WeeeContext);
// Act
var result = await dataAccess.FetchDataReturnOrDefault();
// Assert
Assert.NotNull(result);
Assert.Equal(dataReturn.Id, result.Id);
Assert.Null(dataReturn.CurrentDataReturnVersion);
}
}
