public static Organisation CreateOrganisation()
{
var companyName = "Test Name" + Guid.NewGuid();
var tradingName = "Test Trading Name" + Guid.NewGuid();
const string companyRegistrationNumber = "ABC12345";
var organisation = Organisation.CreateRegisteredCompany(companyName, companyRegistrationNumber, tradingName);
return(organisation);
}
private async Task <Return> CreateReturn(DatabaseWrapper database, Organisation organisation, int year, QuarterType quarter, FacilityType facilityType)
{
var @return = new Domain.AatfReturn.Return(organisation, new Quarter(year, quarter), database.Model.AspNetUsers.First().Id, facilityType);
database.WeeeContext.Returns.Add(@return);
await database.WeeeContext.SaveChangesAsync();
return(@return);
}
private static async Task <Scheme> CreateScheme(WeeeContext context, Organisation organisation)
{
var scheme = ObligatedWeeeIntegrationCommon.CreateScheme(organisation);
context.Schemes.Add(scheme);
await context.SaveChangesAsync();
return(scheme);
}
public async Task CreateTransactionFile_ProducerSubmissionMarkedAsNotInvoiced_NotIncludedInTransactionFile()
{
// Arrange
UKCompetentAuthority authority = A.Dummy <UKCompetentAuthority>();
Organisation organisation = Organisation.CreateSoleTrader("Test organisation");
Scheme scheme = new Scheme(organisation);
scheme.UpdateScheme(
"Test scheme",
"WEE/AA1111AA/SCH",
"WEE00000001",
A.Dummy <ObligationType>(),
authority);
int complianceYear = A.Dummy <int>();
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
A.Dummy <decimal>(),
complianceYear,
scheme,
A.Dummy <string>());
var producerSubmission = A.Fake <ProducerSubmission>();
A.CallTo(() => producerSubmission.ChargeThisUpdate)
.Returns(123.45m);
A.CallTo(() => producerSubmission.Invoiced)
.Returns(false);
memberUpload.ProducerSubmissions.Add(producerSubmission);
memberUpload.Submit(A.Dummy <User>());
List <MemberUpload> memberUploads = new List <MemberUpload>();
memberUploads.Add(memberUpload);
InvoiceRun invoiceRun = new InvoiceRun(authority, memberUploads, A.Dummy <User>());
ByChargeValueTransactionFileGenerator generator = new ByChargeValueTransactionFileGenerator(
A.Dummy <ITransactionReferenceGenerator>());
// Act
var result = await generator.CreateAsync(0, invoiceRun);
TransactionFile transactionFile = result.IbisFile;
// Assert
Assert.NotNull(transactionFile);
Assert.Equal(0, transactionFile.Invoices.Count);
}
public static Aatf CreateAe(DatabaseWrapper database, Organisation organisation, short year = 2019, string name = null)
{
var aatfName = "aatfname";
if (!string.IsNullOrWhiteSpace(name))
{
aatfName = name;
}
return(new Aatf(aatfName, database.WeeeContext.UKCompetentAuthorities.First(), "number", AatfStatus.Approved, organisation, CreateAatfAddress(database), AatfSize.Large, DateTime.Now, CreateDefaultContact(database.WeeeContext.Countries.First()), FacilityType.Ae, year, database.WeeeContext.LocalAreas.First(), database.WeeeContext.PanAreas.First()));
}
public async void GetOrganisationUsers_WithStatusFilter_ReturnsFilteredResults(Core.Shared.UserStatus status)
{
using (var dbWrapper = new DatabaseWrapper())
{
// Add AspNet users
var modelHelper = new ModelHelper(dbWrapper.Model);
var activeUser = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, fixture.Create <string>().Substring(0, 10), fixture.Create <string>().Substring(0, 10));
var inactiveUser = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, fixture.Create <string>().Substring(0, 10), fixture.Create <string>().Substring(0, 10));
var pendingUser = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, fixture.Create <string>().Substring(0, 10), fixture.Create <string>().Substring(0, 10));
var rejectedUser = 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 = fixture.Create <string>();
var organisation = Organisation.CreateSoleTrader(organisationName);
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(activeUser.Id), organisation.Id, UserStatus.Active),
new Domain.Organisation.OrganisationUser(Guid.Parse(inactiveUser.Id), organisation.Id, UserStatus.Inactive),
new Domain.Organisation.OrganisationUser(Guid.Parse(pendingUser.Id), organisation.Id, UserStatus.Pending),
new Domain.Organisation.OrganisationUser(Guid.Parse(rejectedUser.Id), organisation.Id, UserStatus.Rejected)
};
dbWrapper.WeeeContext.OrganisationUsers.AddRange(organisationUsers);
dbWrapper.WeeeContext.SaveChanges();
var dataAccess = new FindMatchingUsersDataAccess(dbWrapper.WeeeContext);
var filter = new UserFilter {
Status = status, OrganisationName = organisationName
};
var result = await dataAccess.GetOrganisationUsers(filter);
UserSearchData organisationUser;
if (status == Core.Shared.UserStatus.Active)
{
Assert.Single(result.Where(r => r.FirstName == activeUser.FirstName));
organisationUser = result.Single(r => r.FirstName == activeUser.FirstName);
}
else
{
Assert.Single(result);
organisationUser = result.Single();
}
Assert.Equal(status, organisationUser.Status);
}
}
public void AddImageToOrganisation(int organisationId, string imgPath)
{
Domain.Organisation.Organisation organisation = GetOrganisation(organisationId);
if (organisation == null)
{
throw new ArgumentException("Organisation not found.");
}
organisation.ImageLocation = imgPath;
_organisationRepository.UpdateOrganisation(organisation);
}
public async Task FetchResultsAsync_WithLargeHouseHoldAppliancesAmount_ReturnsNullForAllOtherCategories()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeCollectedAmount amount1 = new WeeeCollectedAmount(
WeeeCollectedAmountSourceType.Dcf,
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m);
version.WeeeCollectedReturnVersion.AddWeeeCollectedAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.NotNull(result.Category1);
Assert.Null(result.Category2);
Assert.Null(result.Category3);
Assert.Null(result.Category4);
Assert.Null(result.Category5);
Assert.Null(result.Category6);
Assert.Null(result.Category7);
Assert.Null(result.Category8);
Assert.Null(result.Category9);
Assert.Null(result.Category10);
Assert.Null(result.Category11);
Assert.Null(result.Category12);
Assert.Null(result.Category13);
Assert.Null(result.Category14);
}
}
public ReturnMapTests()
{
mapper = A.Fake <IMapper>();
organisationMapper = A.Fake <IMap <Organisation, OrganisationData> >();
statusMapper = A.Fake <IMap <AatfStatus, Core.AatfReturn.AatfStatus> >();
map = new ReturnMap(mapper, organisationMapper, statusMapper);
aatf = A.Fake <DomainAatf>();
scheme = A.Fake <DomainScheme>();
organisation = Organisation.CreatePartnership("trading name");
}
public Domain.Organisation.Organisation AddOrganisation(string name, string identifier, string description, string color)
{
Domain.Organisation.Organisation org = new Domain.Organisation.Organisation()
{
Name = name,
Identifier = identifier,
Description = description,
Color = color
};
return(AddOrganisation(org));
}
public async Task CanCreateNonObligatedWeeeEntry(bool dcf)
{
using (DatabaseWrapper database = new DatabaseWrapper())
{
// Arrange
var context = database.WeeeContext;
var name = "Test Name" + Guid.NewGuid();
var tradingName = "Test Trading Name" + Guid.NewGuid();
const string crn = "ABC12345";
var organisation = Organisation.CreateRegisteredCompany(name, crn, tradingName);
context.Organisations.Add(organisation);
await context.SaveChangesAsync();
var quarter = new Quarter(2019, QuarterType.Q1);
var aatfReturn = new Return(organisation, quarter, database.Model.AspNetUsers.First().Id, FacilityType.Aatf);
var categoryValues = new List <NonObligatedValue>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
categoryValues.Add(new NonObligatedValue((int)category, (int)category, dcf, Guid.NewGuid()));
}
var nonObligatedRequest = new AddNonObligated
{
ReturnId = aatfReturn.Id,
OrganisationId = organisation.Id,
CategoryValues = categoryValues
};
var nonObligatedWee = new List <NonObligatedWeee>();
foreach (var categoryValue in nonObligatedRequest.CategoryValues)
{
nonObligatedWee.Add(new NonObligatedWeee(aatfReturn, categoryValue.CategoryId, categoryValue.Dcf, categoryValue.Tonnage));
}
var dataAccess = new NonObligatedDataAccess(database.WeeeContext);
// Act
await dataAccess.InsertNonObligatedWeee(aatfReturn.Id, nonObligatedWee);
// Assert
var thisTestNonObligatedWeeeArray =
context.NonObligatedWeee.Where(o => o.ReturnId == aatfReturn.Id).ToArray();
Assert.NotNull(thisTestNonObligatedWeeeArray);
Assert.NotEmpty(thisTestNonObligatedWeeeArray);
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
var foundCategory = thisTestNonObligatedWeeeArray.FirstOrDefault(o => o.CategoryId == (int)category);
foundCategory.Should().NotBeNull();
var indexNum = (int)category - 1;
Assert.Equal(foundCategory.Dcf, nonObligatedWee[indexNum].Dcf);
Assert.Equal(foundCategory.Tonnage, nonObligatedWee[indexNum].Tonnage);
Assert.Equal(foundCategory.ReturnId, nonObligatedWee[indexNum].ReturnId);
}
}
}
public static Return CreateReturn(Organisation organisation, string createdById, FacilityType facilityType = null)
{
if (organisation == null)
{
organisation = Organisation.CreateSoleTrader("Test Organisation");
}
if (facilityType == null)
{
facilityType = FacilityType.Aatf;
}
return(new Return(organisation, new Quarter(2019, QuarterType.Q1), createdById, facilityType));
}
public async Task CreateTransactionFile_WithFileID_CreatesFileWithCorrectFileID()
{
// Arrange
UKCompetentAuthority authority = A.Dummy <UKCompetentAuthority>();
Organisation organisation = Organisation.CreateSoleTrader("Test organisation");
Scheme scheme = new Scheme(organisation);
scheme.UpdateScheme(
"Test scheme",
"WEE/AA1111AA/SCH",
"WEE00000001",
A.Dummy <ObligationType>(),
authority);
int complianceYear = A.Dummy <int>();
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
123.45m,
complianceYear,
scheme,
A.Dummy <string>());
memberUpload.Submit(A.Dummy <User>());
List <MemberUpload> memberUploads = new List <MemberUpload>();
memberUploads.Add(memberUpload);
InvoiceRun invoiceRun = new InvoiceRun(authority, memberUploads, A.Dummy <User>());
ITransactionReferenceGenerator transactionReferenceGenerator = A.Fake <ITransactionReferenceGenerator>();
A.CallTo(() => transactionReferenceGenerator.GetNextTransactionReferenceAsync()).Returns("WEE800001H");
ByChargeValueTransactionFileGenerator generator = new ByChargeValueTransactionFileGenerator(transactionReferenceGenerator);
ulong id = 12345;
// Act
var result = await generator.CreateAsync(id, invoiceRun);
TransactionFile transactionFile = result.IbisFile;
// Assert
Assert.Equal((ulong)12345, transactionFile.FileID);
}
public async Task FetchResultsAsync_WithSeveralOutputAmounts_ReturnsSumOfAmounts()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
RegisteredProducer registeredProducer1 = new RegisteredProducer("WEE/AA1111AA", 2099, scheme);
RegisteredProducer registeredProducer2 = new RegisteredProducer("WEE/BB2222BB", 2099, scheme);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
EeeOutputAmount amount1 = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
100,
registeredProducer1);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amount1);
EeeOutputAmount amount2 = new EeeOutputAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
200,
registeredProducer2);
version.EeeOutputReturnVersion.AddEeeOutputAmount(amount2);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.Equal(300, result.Category1);
}
}
public async Task CreateTransactionFile_WithExceptionThrown_ReturnsError_AndNoTransactionFile()
{
// Arrange
UKCompetentAuthority authority = A.Dummy <UKCompetentAuthority>();
Organisation organisation = Organisation.CreateSoleTrader("Test organisation");
Scheme scheme = new Scheme(organisation);
scheme.UpdateScheme(
"Test scheme",
"WEE/AA1111AA/SCH",
"WEE00000001",
A.Dummy <ObligationType>(),
authority);
int complianceYear = A.Dummy <int>();
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
123.45m,
complianceYear,
scheme,
A.Dummy <string>(),
A.Dummy <string>(),
false);
memberUpload.Submit(A.Dummy <User>());
List <MemberUpload> memberUploads = new List <MemberUpload>();
memberUploads.Add(memberUpload);
ITransactionReferenceGenerator transactionReferenceGenerator = A.Fake <ITransactionReferenceGenerator>();
A.CallTo(() => transactionReferenceGenerator.GetNextTransactionReferenceAsync()).Returns((string)null); // A null value will cause the Ibis object to throw an exception.
BySubmissionTransactionFileGenerator generator = new BySubmissionTransactionFileGenerator(transactionReferenceGenerator);
InvoiceRun invoiceRun = new InvoiceRun(authority, memberUploads, A.Dummy <User>());
// Act
var result = await generator.CreateAsync(0, invoiceRun);
// Assert
Assert.Null(result.IbisFile);
Assert.NotEmpty(result.Errors);
}
public async void GetOrganisationUsers_WithOrganisationNameFilter_ReturnsMultipleFilteredResults()
{
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 organisations
var organisationOneName = "Waste";
var organisationTwoName = "Trash";
var organisationThreeName = "Recycling";
var organisationOne = Organisation.CreateSoleTrader(organisationOneName);
var organisationTwo = Organisation.CreatePartnership(organisationTwoName);
var organisationThree = Organisation.CreateRegisteredCompany(organisationThreeName, fixture.Create <string>().Substring(0, 15));
organisationOne.CompleteRegistration();
organisationTwo.CompleteRegistration();
organisationThree.CompleteRegistration();
dbWrapper.WeeeContext.Organisations.Add(organisationOne);
dbWrapper.WeeeContext.Organisations.Add(organisationTwo);
dbWrapper.WeeeContext.Organisations.Add(organisationThree);
dbWrapper.WeeeContext.SaveChanges();
// Add organisation users
var organisationUsers = new List <Domain.Organisation.OrganisationUser>
{
new Domain.Organisation.OrganisationUser(Guid.Parse(user.Id), organisationOne.Id, UserStatus.Active),
new Domain.Organisation.OrganisationUser(Guid.Parse(user.Id), organisationTwo.Id, UserStatus.Active),
new Domain.Organisation.OrganisationUser(Guid.Parse(user.Id), organisationThree.Id, UserStatus.Active)
};
dbWrapper.WeeeContext.OrganisationUsers.AddRange(organisationUsers);
dbWrapper.WeeeContext.SaveChanges();
var dataAccess = new FindMatchingUsersDataAccess(dbWrapper.WeeeContext);
var filter = new UserFilter {
OrganisationName = "as"
};
var result = await dataAccess.GetOrganisationUsers(filter);
Assert.Equal(2, result.Count());
Assert.Single(result.Where(r => r.OrganisationName == organisationOneName));
Assert.Single(result.Where(r => r.OrganisationName == organisationTwoName));
}
}
public async void GetOrganisationUsers_SameUserRejectedMultipleTimesForOneOrganisation_ButAlsoHasAnotherStatus_ReturnsTheOtherStatus(Core.Shared.UserStatus status)
{
using (var dbWrapper = new DatabaseWrapper())
{
// Add AspNet 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 organisation = Organisation.CreateSoleTrader(uniqueOrgName);
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(new UserFilter()))
.Where(ou => ou.OrganisationName == uniqueOrgName);
Assert.Single(result);
var organisationUser = result.Single();
Assert.Equal(status, organisationUser.Status);
}
}
public Domain.Organisation.Organisation ChangeOrganisation(int id, string name, string identifier, string description, string color)
{
Domain.Organisation.Organisation org = GetOrganisation(id);
if (org != null)
{
org.Name = name;
org.Identifier = identifier;
org.Description = description;
org.Color = color;
Validate(org);
return(_organisationRepository.UpdateOrganisation(org));
}
throw new ArgumentException("Organisation not found.");
}
public async Task Execute_GivenOrganisationNameParameter_OnlyReturnsPartiallyMatchingOrganisationShouldBeReturned()
{
using (var db = new DatabaseWrapper())
{
var organisation = Organisation.CreateRegisteredCompany(fixture.Create <string>(), "1234567", null);
var @return1 = CreateSubmittedReturn(db, organisation);
db.WeeeContext.Returns.Add(@return1);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetNonObligatedWeeeReceivedAtAatf(2019, organisation.OrganisationName.Substring(0, 5));
results.Count(r => r.OrganisationName.Equals(organisation.OrganisationName)).Should().Be(CategoryValues().Count);
}
}
public async Task Execute_GivenOrganisationNameParameterAndOrganisationIsPartnership_ReturnsMatchingOrganisationTradingNameShouldBeReturned()
{
using (var db = new DatabaseWrapper())
{
var organisationPartnership = Organisation.CreatePartnership(fixture.Create <string>());
var @return = CreateSubmittedReturn(db, organisationPartnership);
db.WeeeContext.Returns.Add(@return);
await db.WeeeContext.SaveChangesAsync();
var results = await db.StoredProcedures.GetNonObligatedWeeeReceivedAtAatf(2019, organisationPartnership.TradingName);
results.Where(r => r.OrganisationName.Equals(organisationPartnership.TradingName)).Should().NotBeEmpty();
}
}
public async Task GetByComplianceYearAndYear_ReturnsWithMatchingQuarterAndFacilityType_ReturnsShouldBeReturned()
{
using (var database = new DatabaseWrapper())
{
var modelHelper = new ModelHelper(database.Model);
var organisation = Organisation.CreateSoleTrader("Test Organisation");
var organisation2 = Organisation.CreateSoleTrader("Test Organisation");
var @return1 = CreateReturn(database, organisation);
var @return2 = CreateReturn(database, organisation);
var @return3 = CreateReturn(database, organisation, new Quarter(2019, QuarterType.Q2), FacilityType.Aatf);
var @return4 = CreateReturn(database, organisation, new Quarter(2019, QuarterType.Q3), FacilityType.Aatf);
var @return5 = CreateReturn(database, organisation, new Quarter(2019, QuarterType.Q4), FacilityType.Aatf);
var @return6 = CreateReturn(database, organisation, new Quarter(2018, QuarterType.Q1), FacilityType.Aatf);
var @return7 = CreateReturn(database, organisation2);
var @return8 = CreateReturn(database, organisation, new Quarter(2019, QuarterType.Q1), FacilityType.Ae);
var dataAccess = new ReturnDataAccess(database.WeeeContext);
await dataAccess.Submit(@return1);
await dataAccess.Submit(@return2);
await dataAccess.Submit(@return3);
await dataAccess.Submit(@return4);
await dataAccess.Submit(@return5);
await dataAccess.Submit(@return6);
await dataAccess.Submit(@return7);
await dataAccess.Submit(@return8);
var results = await dataAccess.GetByComplianceYearAndQuarter(@return1);
results.Count.Should().Be(2);
results.Count(r => r.Quarter.Year != 2019).Should().Be(0);
results.Count(r => r.Id != @return1.Id && r.Id != @return2.Id).Should().Be(0);
results.Count(r => r.Organisation.Id != @return1.Organisation.Id).Should().Be(0);
results.Count(r => r.FacilityType != @return1.FacilityType).Should().Be(0);
}
}
public async Task ValidateReturnQuarter_GivenFacilityTypeDoesNotMatch_ResultShouldBeFalse()
{
using (var database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var organisation = Organisation.CreatePartnership("Dummy");
await CreateReturn(database, organisation, 2019, QuarterType.Q1, FacilityType.Aatf);
var dataAccess = new ReturnFactoryDataAccess(database.WeeeContext);
var result = await dataAccess.HasReturnQuarter(organisation.Id, 2019, QuarterType.Q1, Core.AatfReturn.FacilityType.Ae);
result.Should().BeFalse();
}
}
public async Task ValidateAatfApprovalDate_GivenApprovalDateIsNull_ResultShouldBeFalse()
{
using (var database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var organisation = Organisation.CreatePartnership("Dummy");
await CreateAatf(database, organisation, null);
var dataAccess = new ReturnFactoryDataAccess(database.WeeeContext);
var result = await dataAccess.ValidateAatfApprovalDate(organisation.Id, DateTime.Now.AddDays(1), 2019, EA.Weee.Core.AatfReturn.FacilityType.Aatf);
result.Should().BeFalse();
}
}
public async Task HandleAsync_GivenAddReturnRequest_DataAccessSubmitsIsCalled(QuarterType quarterType, FacilityType facility)
{
var request = new AddReturn {
OrganisationId = Guid.NewGuid(), Quarter = quarterType, Year = year, FacilityType = Core.AatfReturn.FacilityType.Aatf
};
var @return = A.Dummy <Return>();
var organisation = new Organisation();
var userId = Guid.NewGuid();
A.CallTo(() => userContext.UserId).Returns(userId);
A.CallTo(() => genericDataAccess.GetById <Organisation>(request.OrganisationId)).Returns(organisation);
A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarterType));
await handler.HandleAsync(request);
A.CallTo(() => returnDataAccess.Submit(A <Return> .That.Matches(c => c.Quarter.Year == request.Year && (int)c.Quarter.Q == (int)quarterType && c.Organisation.Equals(organisation) && c.CreatedById.Equals(userId.ToString())))).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Remove_GivenNullEntity_EntityStateShouldNotBeUpdated()
{
using (var database = new DatabaseWrapper())
{
var dataAccess = new GenericDataAccess(database.WeeeContext);
var competentAuthorityDataAccess = new CommonDataAccess(database.WeeeContext);
var organisation = Organisation.CreateSoleTrader("Test Organisation");
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(database, organisation);
database.WeeeContext.Aatfs.Add(ObligatedWeeeIntegrationCommon.CreateAatf(database, organisation));
await database.WeeeContext.SaveChangesAsync();
dataAccess.Remove <Aatf>(null);
database.WeeeContext.ChangeTracker.Entries().Count(e => e.State == EntityState.Deleted).Should().Be(0);
}
}
public async Task FetchResultsAsync_WithQ1ReturnDataWithDeliveredToAeB2CAmount_ReturnsOneResultForQ1Type1Source1B2C()
{
using (Weee.Tests.Core.Model.DatabaseWrapper wrapper = new Weee.Tests.Core.Model.DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme = new Scheme(organisation);
Quarter quarter = new Quarter(2099, QuarterType.Q1);
DataReturn dataReturn = new DataReturn(scheme, quarter);
DataReturnVersion version = new DataReturnVersion(dataReturn);
WeeeDeliveredAmount amount1 = new WeeeDeliveredAmount(
ObligationType.B2C,
WeeeCategory.LargeHouseholdAppliances,
123.456m,
new AeDeliveryLocation("WEE/AA1111AA/AE", string.Empty));
version.WeeeDeliveredReturnVersion.AddWeeeDeliveredAmount(amount1);
wrapper.WeeeContext.DataReturns.Add(dataReturn);
await wrapper.WeeeContext.SaveChangesAsync();
dataReturn.SetCurrentVersion(version);
await wrapper.WeeeContext.SaveChangesAsync();
// Act
FetchSummaryCsvDataAccess dataAccess = new FetchSummaryCsvDataAccess(wrapper.WeeeContext);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(scheme.Id, 2099);
// Assert
Assert.NotNull(results);
Assert.Equal(1, results.Count);
DataReturnSummaryCsvData result = results[0];
Assert.NotNull(result);
Assert.Equal(1, result.Quarter);
Assert.Equal(1, result.Type);
Assert.Equal(1, result.Source);
Assert.Equal("B2C", result.ObligationType);
}
}
public async void GetOrganisationUsers_WithFullNameFilter_ReturnsFilteredResults()
{
using (var dbWrapper = new DatabaseWrapper())
{
// Add AspNet users
var modelHelper = new ModelHelper(dbWrapper.Model);
var userOne = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, "Marshall", "Eriksen");
var userTwo = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, "Lily", "Aldrin");
var userThree = modelHelper.CreateUser(fixture.Create <string>(), IdType.Guid, "Barney", "Stinson");
dbWrapper.Model.SaveChanges();
// Add organisation
var organisationName = fixture.Create <string>();
var organisation = Organisation.CreateSoleTrader(organisationName);
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(userOne.Id), organisation.Id, UserStatus.Active),
new Domain.Organisation.OrganisationUser(Guid.Parse(userTwo.Id), organisation.Id, UserStatus.Active),
new Domain.Organisation.OrganisationUser(Guid.Parse(userThree.Id), organisation.Id, UserStatus.Active)
};
dbWrapper.WeeeContext.OrganisationUsers.AddRange(organisationUsers);
dbWrapper.WeeeContext.SaveChanges();
var dataAccess = new FindMatchingUsersDataAccess(dbWrapper.WeeeContext);
var filter = new UserFilter {
Name = "y s"
};
var result = await dataAccess.GetOrganisationUsers(filter);
Assert.Single(result);
var organisationUser = result.Single();
Assert.Equal(userThree.FirstName, organisationUser.FirstName);
Assert.Equal(userThree.Surname, organisationUser.LastName);
}
}
public async Task Execute_GivenNoPCSReceivedData_ReturnsPcsAatfDiscrepancyDataShouldBeCorrect()
{
using (DatabaseWrapper db = new DatabaseWrapper())
{
// Arrange
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Domain.UKCompetentAuthority authority = db.WeeeContext.UKCompetentAuthorities.Single(c => c.Abbreviation == UKCompetentAuthorityAbbreviationType.EA);
var year = 2019;
Quarter quarter = new Quarter(year, QuarterType.Q1);
Scheme scheme1 = new Scheme(organisation);
scheme1.UpdateScheme("Test Scheme 1", "WEE/AH7453NF/SCH", "WEE9462846", Domain.Obligation.ObligationType.B2C, authority);
scheme1.SetStatus(Domain.Scheme.SchemeStatus.Approved);
var @return = CreateSubmittedReturn(db, organisation);
var aatf = new Aatf("aatfName", authority, "WEE/AA1111AA/ATF", AatfStatus.Approved, organisation, AddressHelper.GetAatfAddress(db), AatfSize.Large, DateTime.Now, ObligatedWeeeIntegrationCommon.CreateDefaultContact(db.WeeeContext.Countries.First()), FacilityType.Aatf, (short)year, null, null);
var weeeReceived = new EA.Weee.Domain.AatfReturn.WeeeReceived(scheme1, aatf, @return);
var weeeReceivedAmounts = new List <WeeeReceivedAmount>()
{
new Domain.AatfReturn.WeeeReceivedAmount(weeeReceived, 1, 2, 10)
};
db.WeeeContext.Returns.Add(@return);
db.WeeeContext.ReturnAatfs.Add(new ReturnAatf(aatf, @return));
db.WeeeContext.WeeeReceived.Add(weeeReceived);
db.WeeeContext.WeeeReceivedAmount.AddRange(weeeReceivedAmounts);
await db.WeeeContext.SaveChangesAsync();
// Act
var results = await db.StoredProcedures.GetPcsAatfComparisonDataCsvData(year, null, null);
var record = results.First(x => x.AatfApprovalNumber == "WEE/AA1111AA/ATF" && x.ObligationType == "B2B");
//Assert
Assert.NotNull(record);
Assert.Equal("WEE/AA1111AA/ATF", record.AatfApprovalNumber);
Assert.Equal("WEE/AH7453NF/SCH", record.PcsApprovalNumber);
Assert.Equal(0, record.PcsTonnage);
Assert.Equal(10, record.AatfTonnage);
Assert.Equal(-10, record.DifferenceTonnage);
}
}
public Domain.Project.Project AddProject(string title, DateTime start, DateTime end, int organisationId)
{
Domain.Organisation.Organisation org = _organisationManager.GetOrganisation(organisationId);
if (org == null)
{
throw new ArgumentException("Organisation not found.");
}
Domain.Project.Project newProject = new Domain.Project.Project()
{
Title = title,
StartDate = start,
EndDate = end,
Organisation = org
};
return(AddProject(newProject));
}
public async void UpdateAmounts_GivenAmountToUpdate_ContextShouldContainUpdatedAmounts()
{
using (var database = new DatabaseWrapper())
{
var context = database.WeeeContext;
var dataAccess = new NonObligatedDataAccess(database.WeeeContext);
var companyName = "Test Name" + Guid.NewGuid();
var tradingName = "Test Trading Name" + Guid.NewGuid();
const string companyRegistrationNumber = "ABC12345";
var organisation = Organisation.CreateRegisteredCompany(companyName, companyRegistrationNumber, tradingName);
var @return = new Return(organisation, new Quarter(2019, QuarterType.Q1), database.Model.AspNetUsers.First().Id, FacilityType.Aatf);
context.Organisations.Add(organisation);
context.Returns.Add(@return);
await context.SaveChangesAsync();
var nonObligatedWee = new List <NonObligatedWeee>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
nonObligatedWee.Add(new NonObligatedWeee(@return, (int)category, false, (int)category));
}
await dataAccess.Submit(nonObligatedWee);
AssertValues(context, @return.Id);
for (var i = 1; i <= Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>().Count(); i++)
{
var amount = context.NonObligatedWeee.First(c => c.ReturnId == @return.Id && c.CategoryId == i);
await dataAccess.UpdateAmount(amount, i + 1);
}
for (var i = 1; i <= Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>().Count(); i++)
{
var amount = context.NonObligatedWeee.First(c => c.ReturnId == @return.Id && c.CategoryId == i);
amount.Tonnage.Should().Be(i + 1);
}
}
}
