public async Task <bool> HandleAsync(AddAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId);
var address = new AatfAddress(
message.AddressData.Name,
message.AddressData.Address1,
message.AddressData.Address2,
message.AddressData.TownOrCity,
message.AddressData.CountyOrRegion,
message.AddressData.Postcode,
country);
var weeeReused = await genericDataAccess.GetManyByExpression <WeeeReused>(new WeeeReusedByAatfIdAndReturnIdSpecification(message.AatfId, message.ReturnId));
var weeeReusedSite = new WeeeReusedSite(
weeeReused.Last(),
address);
await offSiteDataAccess.Submit(weeeReusedSite);
return(true);
}
public void AatfContact_GivenNullOrEmptyRequiredParameters_ThrowsArgumentException(string name, string address, string town)
{
Action constructor = () =>
{
var @return = new AatfAddress(name, address, A.Dummy <string>(), town, A.Dummy <string>(), A.Dummy <string>(), A.Dummy <Country>());
};
constructor.Should().Throw <ArgumentException>();
}
public void AatfAddress_GiveCountryIsNull_ThrowsArgumentException()
{
Action constructor = () =>
{
var @return = new AatfAddress(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), null);
};
constructor.Should().Throw <ArgumentException>();
}
public void AatfAddress_GivenPostcodeIsGreaterThan10Characters_ThrowsArgumentException()
{
Action constructor = () =>
{
var @return = new AatfAddress(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), new string('*', 11), A.Dummy <Country>());
};
constructor.Should().Throw <ArgumentException>();
}
public async Task HandleAsync_GivenAatfCanBeCopied_OriginalAatfShouldNotBeChanged()
{
using (var databaseWrapper = new DatabaseWrapper())
{
var organisation = EA.Weee.Domain.Organisation.Organisation.CreatePartnership("trading");
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(databaseWrapper, organisation);
var competentAuthority = new Core.Shared.UKCompetentAuthorityData()
{
Id = databaseWrapper.WeeeContext.UKCompetentAuthorities.First().Id,
Abbreviation = databaseWrapper.WeeeContext.UKCompetentAuthorities.First().Abbreviation
};
var country = await databaseWrapper.WeeeContext.Countries.SingleAsync(c => c.Name == "France");
var newContact = A.Dummy <AatfContactData>();
var contact = new AatfContact("FirstName1", "LastName1", "Position1", "Address11", "Address21", "Town1", "County1", "PO12ST341", country, "Telephone1", "Email1");
var siteAddress = A.Dummy <AatfAddressData>();
var aatfAddress = new AatfAddress("Site name", "Site address 1", "Site address 2", "Site town", "Site county", "GU22 7UY", country);
var aatfdata = new AatfData(Guid.NewGuid(), aatf.Name, aatf.ApprovalNumber, 2020,
competentAuthority,
Core.AatfReturn.AatfStatus.Approved, siteAddress, Core.AatfReturn.AatfSize.Large, DateTime.Parse("01/01/2020"),
null, null)
{
FacilityType = Core.AatfReturn.FacilityType.Aatf
};
databaseWrapper.WeeeContext.Aatfs.Add(aatf);
await databaseWrapper.WeeeContext.SaveChangesAsync();
A.CallTo(() => addressMapper.Map(siteAddress)).Returns(aatfAddress);
A.CallTo(() => contactMapper.Map(newContact)).Returns(contact);
var message = new AddAatf()
{
Aatf = aatfdata,
OrganisationId = organisation.Id,
AatfId = aatf.AatfId,
AatfContact = newContact
};
await Handler(databaseWrapper).HandleAsync(message);
databaseWrapper.WeeeContext.Aatfs.Where(a => a.Id == aatf.Id).Should().NotBeEmpty();
databaseWrapper.WeeeContext.Aatfs.Where(a => a.AatfId == aatf.AatfId).Count().Should().Be(2);
databaseWrapper.WeeeContext.Aatfs.Where(a => a.Id == aatf.Id && a.ComplianceYear == 2019).Should().NotBeEmpty();
databaseWrapper.WeeeContext.Aatfs.Where(a => a.AatfId == aatf.AatfId && a.ComplianceYear == 2020).Count().Should().Be(1);
}
}
public Task UpdateAddress(AatfAddress oldDetails, AatfAddress newDetails, Country country)
{
oldDetails.UpdateAddress(
newDetails.Name,
newDetails.Address1,
newDetails.Address2,
newDetails.TownOrCity,
newDetails.CountyOrRegion,
newDetails.Postcode,
country);
return(context.SaveChangesAsync());
}
public void Map_GivenSource_AddressDataIsMapped()
{
var aatfAddress = new AatfAddress(
"Name",
"Address1",
"Address2",
"Town",
"County",
"PO12 3ST",
country);
var aatfAddress2 = new AatfAddress(
"Name2",
"Address12",
"Address22",
"Town2",
"County2",
"PO12 3ST2",
country);
var aatfAddressList = new List <AatfAddress>()
{
aatfAddress, aatfAddress2
};
var weeeReusedList = new List <WeeeReusedAmount>();
var source = new AatfAddressObligatedAmount(aatfAddressList, weeeReusedList);
var result = map.Map(source);
result.AddressData.Count(a => a.Name == "Name" &&
a.Address1 == "Address1" &&
a.Address2 == "Address2" &&
a.TownOrCity == "Town" &&
a.CountyOrRegion == "County" &&
a.Postcode == "PO12 3ST" &&
a.CountryId == countryId &&
a.CountryName == "UK - England").Should().Be(1);
result.AddressData.Count(a => a.Name == "Name2" &&
a.Address1 == "Address12" &&
a.Address2 == "Address22" &&
a.TownOrCity == "Town2" &&
a.CountyOrRegion == "County2" &&
a.Postcode == "PO12 3ST2" &&
a.CountryId == countryId &&
a.CountryName == "UK - England").Should().Be(1);
result.AddressData.Count().Should().Be(2);
}
public async void HandleAsync_GivenWeeeSentOnByIdRequest_AddressDataShouldBeMapped()
{
var operatorAddress = new AatfAddress("OpName", "OpAdd1", "OpAdd2", "OpTown", "OpCounty", "PostOp", A.Fake <Country>());
var siteAddress = new AatfAddress("SiteName", "SiteAdd1", "SiteAdd2", "SiteTown", "SiteCounty", "PostSite", A.Fake <Country>());
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, A.Fake <Aatf>(), A.Fake <Return>());
var weeeSentOnId = weeeSentOn.Id;
var request = new GetWeeeSentOnById(weeeSentOnId);
A.CallTo(() => getSentOnAatfSiteDataAccess.GetWeeeSentOnById(weeeSentOnId)).Returns(weeeSentOn);
await handler.HandleAsync(request);
A.CallTo(() => addressMapper.Map(A <AatfAddress> .That.IsSameAs(weeeSentOn.OperatorAddress))).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => addressMapper.Map(A <AatfAddress> .That.IsSameAs(weeeSentOn.SiteAddress))).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_GivenGetSentOnAatfSiteRequest_DataAccessIsCalled()
{
var siteAddressId = Guid.NewGuid();
var weeeReusedSiteId = Guid.NewGuid();
var siteAddress = new AatfAddress();
var weeeReusedSite = new WeeeReusedSite();
var weeeReusedSiteReturned = new WeeeReusedSite();
A.CallTo(() => genericDataAccess.GetById <AatfAddress>(siteAddressId)).Returns(siteAddress);
A.CallTo(() => genericDataAccess.GetSingleByExpression <WeeeReusedSite>(A <WeeeReusedByAddressIdSpecification> .That.Matches(w => w.SiteId == siteAddressId))).Returns(weeeReusedSite);
A.CallTo(() => genericDataAccess.GetById <WeeeReusedSite>(weeeReusedSite.Id)).Returns(weeeReusedSiteReturned);
await handler.HandleAsync(new RemoveAatfSite(siteAddressId));
A.CallTo(() => genericDataAccess.Remove(weeeReusedSiteReturned)).MustHaveHappened(Repeated.Exactly.Once)
.Then(A.CallTo(() => genericDataAccess.Remove(siteAddress)).MustHaveHappened(Repeated.Exactly.Once))
.Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
private string GetSiteAddressString(AatfAddress address)
{
var addressString = address.Address1 + ", ";
if (address.Address2 != null)
{
addressString += address.Address2 + ", ";
}
addressString += address.TownOrCity + ", ";
if (address.CountyOrRegion != null)
{
addressString += address.CountyOrRegion;
}
return(addressString);
}
private static async Task CreateWeeeSentOnAmounts(
ObligatedSentOnDataAccess dataAccess,
Return @return,
Aatf aatf,
AatfAddress siteAddress,
AatfAddress operatorAddress)
{
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, aatf, @return);
var weeeSentOnAmount = new List <WeeeSentOnAmount>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
weeeSentOnAmount.Add(new WeeeSentOnAmount(weeeSentOn, (int)category, (decimal?)category, (decimal?)category + 1));
}
await dataAccess.Submit(weeeSentOnAmount);
}
public void UpdateAddress_GivenNewData_SaveChangesAsyncShouldBeCalled()
{
var oldDetails = A.Fake <AatfAddress>();
var newDetails = new AatfAddress();
var country = A.Fake <Country>();
dataAccess.UpdateAddress(oldDetails, newDetails, country);
A.CallTo(() => oldDetails.UpdateAddress(
newDetails.Name,
newDetails.Address1,
newDetails.Address2,
newDetails.TownOrCity,
newDetails.CountyOrRegion,
newDetails.Postcode,
country)).MustHaveHappenedOnceExactly()
.Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappenedOnceExactly());
}
public void AatfAddress_GivenValidParameters_AatfAddressPropertiesShouldBeSet()
{
var name = "Name";
var address1 = "Address1";
var address2 = "Address2";
var town = "Town";
var county = "County";
var postcode = "Postcode";
var country = new Country(Guid.NewGuid(), "Country");
var contact = new AatfAddress(name, address1, address2, town, county, postcode, country);
contact.Name.Should().Be(name);
contact.Address1.Should().Be(address1);
contact.Address2.Should().Be(address2);
contact.TownOrCity.Should().Be(town);
contact.CountyOrRegion.Should().Be(county);
contact.Postcode.Should().Be(postcode);
contact.Country.Should().Be(country);
}
public async Task <Guid> HandleAsync(EditSentOnAatfSiteWithOperator message)
{
authorization.EnsureCanAccessExternalArea();
var sentOn = await genericDataAccess.GetById <WeeeSentOn>((Guid)message.WeeeSentOnId);
Country operatorCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.OperatorAddressData.CountryId);
var operatorAddress = new AatfAddress(
message.OperatorAddressData.Name,
message.OperatorAddressData.Address1,
message.OperatorAddressData.Address2,
message.OperatorAddressData.TownOrCity,
message.OperatorAddressData.CountyOrRegion,
message.OperatorAddressData.Postcode,
operatorCountry);
await sentOnDataAccess.UpdateWithOperatorAddress(sentOn, operatorAddress);
return(sentOn.Id);
}
public void Submit_GivenReusedSiteData_ValuesShouldBeAddedToContext()
{
var aatfAddress = new AatfAddress(
"Name",
"Address",
A.Dummy <string>(),
"TownOrCity",
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <Country>());
var weeeReused = new WeeeReused(aatfId, A.Dummy <Guid>());
var weeeReusedSite = new WeeeReusedSite(weeeReused, aatfAddress);
var weeeReusedSiteDbSet = dbContextHelper.GetAsyncEnabledDbSet(new List <WeeeReusedSite>());
A.CallTo(() => context.WeeeReusedSite).Returns(weeeReusedSiteDbSet);
dataAccess.Submit(weeeReusedSite);
context.WeeeReusedSite.Should().AllBeEquivalentTo(weeeReusedSite);
}
private static async Task CreateWeeeReusedAmounts(
ObligatedReusedDataAccess obligatedReusedDataAccess,
AatfSiteDataAccess aatfSiteDataAccess,
Return @return,
Aatf aatf,
AatfAddress address)
{
var weeeReused = new WeeeReused(aatf.Id, @return.Id);
var weeeReusedAmount = new List <WeeeReusedAmount>();
foreach (var category in Enum.GetValues(typeof(WeeeCategory)).Cast <WeeeCategory>())
{
weeeReusedAmount.Add(new WeeeReusedAmount(weeeReused, (int)category, (int)category, (int)category + 1));
}
var weeeReusedSite = new WeeeReusedSite(weeeReused, address);
await obligatedReusedDataAccess.Submit(weeeReusedAmount);
await aatfSiteDataAccess.Submit(weeeReusedSite);
}
public async void HandleAsync_GivenWeeeSentOnId_ReturnedListShouldContainOnly1Element()
{
var aatfId = Guid.NewGuid();
var returnId = Guid.NewGuid();
var sentOnList = new List <WeeeSentOn>();
var operatorAddress = new AatfAddress("OpName", "OpAdd1", "OpAdd2", "OpTown", "OpCounty", "PostOp", A.Fake <Country>());
var siteAddress = new AatfAddress("SiteName", "SiteAdd1", "SiteAdd2", "SiteTown", "SiteCounty", "PostSite", A.Fake <Country>());
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, A.Fake <Aatf>(), A.Fake <Return>());
sentOnList.Add(weeeSentOn);
var weeeSentOnId = weeeSentOn.Id;
var request = new GetWeeeSentOn(aatfId, returnId, weeeSentOnId);
A.CallTo(() => getSentOnAatfSiteDataAccess.GetWeeeSentOnByReturnAndAatf(aatfId, returnId)).Returns(sentOnList);
var result = await handler.HandleAsync(request);
result.Count.Should().Be(1);
}
public async Task UpdateWithOperatorAddress_GivenAatfAndReturnId_UpdateMustHaveHappened()
{
var aatfId = Guid.NewGuid();
var returnId = Guid.NewGuid();
var operatorAddress = new AatfAddress("TEST", "TEST", "TEST", "TEST", "TEST", "GU22 7UY", A.Dummy <Country>());
var weeeSentOn = A.Fake <WeeeSentOn>();
A.CallTo(() => context.AatfAddress).Returns(dbContextHelper.GetAsyncEnabledDbSet(new List <AatfAddress>()
{
operatorAddress
}));
A.CallTo(() => weeeSentOn.AatfId).Returns(aatfId);
A.CallTo(() => weeeSentOn.ReturnId).Returns(returnId);
A.CallTo(() => context.WeeeSentOn).Returns(dbContextHelper.GetAsyncEnabledDbSet(new List <WeeeSentOn>()
{
weeeSentOn
}));
await dataAccess.UpdateWithOperatorAddress(weeeSentOn, operatorAddress);
A.CallTo(() => weeeSentOn.UpdateWithOperatorAddress(operatorAddress)).MustHaveHappened(Repeated.Exactly.Once).Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task HandleAsync_GivenEditSentOnAatfSiteWithOperatorRequest_DataAccessIsCalled()
{
var request = new EditSentOnAatfSiteWithOperator()
{
WeeeSentOnId = Guid.NewGuid(),
OperatorAddressData = new OperatorAddressData()
{
Name = "OpName",
Address1 = "Address1",
Address2 = "Address2",
TownOrCity = "Town",
CountyOrRegion = "County",
Postcode = "GU22 7UY",
CountryId = Guid.NewGuid()
}
};
var weeeSentOn = new WeeeSentOn();
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => genericDataAccess.GetById <WeeeSentOn>((Guid)request.WeeeSentOnId)).Returns(weeeSentOn);
A.CallTo(() => orgDataAccess.FetchCountryAsync(request.OperatorAddressData.CountryId)).Returns(country);
var operatorAddress = new AatfAddress(
request.OperatorAddressData.Name,
request.OperatorAddressData.Address1,
request.OperatorAddressData.Address2,
request.OperatorAddressData.TownOrCity,
request.OperatorAddressData.CountyOrRegion,
request.OperatorAddressData.Postcode,
country);
await handler.HandleAsync(request);
A.CallTo(() => sentOnDataAccess.UpdateWithOperatorAddress(weeeSentOn, operatorAddress)).WhenArgumentsMatch(p => p.Get <AatfAddress>("request").Address1 == operatorAddress.Address1);
}
public async void HandleAsync_GivenGetSentOnAatfSiteRequest_AddressDataShouldBeMapped()
{
var aatfId = Guid.NewGuid();
var returnId = Guid.NewGuid();
var sentOnList = new List <WeeeSentOn>();
var operatorAddress = new AatfAddress("OpName", "OpAdd1", "OpAdd2", "OpTown", "OpCounty", "PostOp", A.Fake <Country>());
var siteAddress = new AatfAddress("SiteName", "SiteAdd1", "SiteAdd2", "SiteTown", "SiteCounty", "PostSite", A.Fake <Country>());
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, A.Fake <Aatf>(), A.Fake <Return>());
sentOnList.Add(weeeSentOn);
var request = new GetWeeeSentOn(aatfId, returnId, null);
A.CallTo(() => getSentOnAatfSiteDataAccess.GetWeeeSentOnByReturnAndAatf(aatfId, returnId)).Returns(sentOnList);
await handler.HandleAsync(request);
for (var i = 0; i < sentOnList.Count; i++)
{
A.CallTo(() => addressMapper.Map(A <AatfAddress> .That.IsSameAs(sentOnList[i].OperatorAddress))).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => addressMapper.Map(A <AatfAddress> .That.IsSameAs(sentOnList[i].SiteAddress))).MustHaveHappened(Repeated.Exactly.Once);
}
}
public void Submit_GivenSentOnData_ValuesShouldBeAddedToContext()
{
var aatf = A.Fake <Aatf>();
var @return = A.Fake <Return>();
var aatfAddress = new AatfAddress(
"Name",
"Address",
A.Dummy <string>(),
"TownOrCity",
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <Country>());
var weeeSentOn = new WeeeSentOn(aatfAddress, aatf, @return);
var weeeSentDbSet = dbContextHelper.GetAsyncEnabledDbSet(new List <WeeeSentOn>());
A.CallTo(() => context.WeeeSentOn).Returns(weeeSentDbSet);
dataAccess.Submit(weeeSentOn);
context.WeeeSentOn.Should().AllBeEquivalentTo(weeeSentOn);
}
public async Task <Guid> HandleAsync(AddSentOnAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var siteCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.SiteAddressData.CountryId);
var operatorCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.OperatorAddressData.CountryId);
var @return = await returnDataAccess.GetById(message.ReturnId);
var aatf = await genericDataAccess.GetById <Aatf>(message.AatfId);
var siteAddress = new AatfAddress(
message.SiteAddressData.Name,
message.SiteAddressData.Address1,
message.SiteAddressData.Address2,
message.SiteAddressData.TownOrCity,
message.SiteAddressData.CountyOrRegion,
message.SiteAddressData.Postcode,
siteCountry);
var operatorAddress = new AatfAddress(
message.OperatorAddressData.Name,
message.OperatorAddressData.Address1,
message.OperatorAddressData.Address2,
message.OperatorAddressData.TownOrCity,
message.OperatorAddressData.CountyOrRegion,
message.OperatorAddressData.Postcode,
operatorCountry);
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, aatf, @return);
await sentOnDataAccess.Submit(weeeSentOn);
return(weeeSentOn.Id);
}
public void Map_GivenSource_ObligatedWeeeSentOnValuesShouldBeMapped()
{
var @return = GetReturn();
var siteAddress = new AatfAddress("TEST", "TEST", "TEST", "TEST", "TEST", "TEST", A.Fake <Country>());
var weeeSentOn = ReturnWeeeSentOn(siteAddress, aatf, @return);
var obligated = new List <WeeeSentOnAmount>()
{
new WeeeSentOnAmount(weeeSentOn, 1, 1.000m, 2.000m),
new WeeeSentOnAmount(weeeSentOn, 2, 3.000m, 4.000m)
};
var source = new ReturnQuarterWindow(GetReturn(), GetQuarterWindow(), A.Fake <List <Aatf> >(), A.Fake <List <NonObligatedWeee> >(),
A.Fake <List <WeeeReceivedAmount> >(), A.Fake <List <WeeeReusedAmount> >(), organisation, obligated, A.Fake <List <ReturnScheme> >(),
A.Fake <List <ReturnReportOn> >(),
A.Dummy <DateTime>());
var result = map.Map(source);
result.ObligatedWeeeSentOnData.Count(o => o.CategoryId == 1 && o.B2C == 1 && o.B2B == 2).Should().Be(1);
result.ObligatedWeeeSentOnData.Count(o => o.CategoryId == 2 && o.B2C == 3 && o.B2B == 4).Should().Be(1);
result.ObligatedWeeeSentOnData.Count().Should().Be(2);
}
private async Task <WeeeSentOn> CreateWeeeSentOnOperatorInContext(WeeeSentOnDataAccess dataAccess, AatfAddress operatorAddress, AatfAddress siteAddress, DatabaseWrapper database)
{
var organisation = ObligatedWeeeIntegrationCommon.CreateOrganisation();
var scheme = ObligatedWeeeIntegrationCommon.CreateScheme(organisation);
var aatf = ObligatedWeeeIntegrationCommon.CreateAatf(database, organisation);
var @return = ObligatedWeeeIntegrationCommon.CreateReturn(organisation, database.Model.AspNetUsers.First().Id);
database.WeeeContext.Organisations.Add(organisation);
database.WeeeContext.Schemes.Add(scheme);
database.WeeeContext.Aatfs.Add(aatf);
database.WeeeContext.Returns.Add(@return);
await database.WeeeContext.SaveChangesAsync();
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, aatf, @return);
await dataAccess.Submit(weeeSentOn);
return(weeeSentOn);
}
public WeeeSentOn ReturnWeeeSentOn(AatfAddress siteAddress, DomainAatf aatf, Return @return)
{
var weeeReused = new WeeeSentOn(siteAddress, aatf, @return);
return(weeeReused);
}
public Task UpdateWithOperatorAddress(WeeeSentOn weeeSentOn, AatfAddress address)
{
weeeSentOn.UpdateWithOperatorAddress(address);
return(context.SaveChangesAsync());
}
