public async Task GetProducerCSVHandler_OrganisationDoesNotExist_ThrowsArgumentException()
{
// Arrange
Guid pcsId = new Guid("62874744-6F52-4311-B4C0-3DD7767BEBF6");
int complianceYear = 2016;
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
WeeeContext context = A.Fake <WeeeContext>();
var organisations = dbContextHelper.GetAsyncEnabledDbSet <Organisation>(new List <Organisation>());
A.CallTo(() => organisations.FindAsync(pcsId)).Returns((Organisation)null);
A.CallTo(() => context.Organisations).Returns(organisations);
var schemes = dbContextHelper.GetAsyncEnabledDbSet <Scheme>(new List <Scheme>
{
new Scheme(pcsId)
});
A.CallTo(() => context.Schemes).Returns(schemes);
CsvWriterFactory csvWriterFactory = A.Fake <CsvWriterFactory>();
var handler = new GetProducerCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerCSV(pcsId, complianceYear);
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public CompleteOrganisationAdminHandlerTests()
{
this.authorization = AuthorizationBuilder.CreateUserWithAllRights();
this.dataAccess = A.Fake <IOrganisationDetailsDataAccess>();
DbContextHelper dbContextHelper = new DbContextHelper();
}
public async Task HandleAsync_WithSchemeSpecified_GeneratesCorrectFileName()
{
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
IStoredProcedures storedProcedures = A.Fake <IStoredProcedures>();
SpgSchemeWeeeCsvResult storedProcedureResult = new SpgSchemeWeeeCsvResult();
storedProcedureResult.Schemes.Add(new SpgSchemeWeeeCsvResult.SchemeResult()
{
SchemeId = new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"),
ApprovalNumber = "WEE/AA1111AA/SCH"
});
A.CallTo(() => storedProcedures.SpgSchemeWeeeCsvAsync(A <int> ._, A <Guid?> ._, A <string> ._))
.Returns(storedProcedureResult);
GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
storedProcedures,
authorization,
A.Dummy <CsvWriterFactory>());
GetSchemeWeeeCsv request = new GetSchemeWeeeCsv(2016, new Guid("C5AD2FF9-941D-4D6F-B68B-9805DD7E1FD1"), ObligationType.B2C);
// Act
SystemTime.Freeze(new DateTime(2016, 12, 31, 23, 59, 0));
FileInfo result = await handler.HandleAsync(request);
SystemTime.Unfreeze();
// Assert
Assert.Equal("2016_WEEAA1111AASCH_B2C_schemeWEEE_31122016_2359.csv", result.FileName);
}
public void CreateResults_ForDataReturnVersionWithNullWeeeCollectedDataReturnVersion_DoesNotIncludeWeeeCollectedDataReturnVersionItemsInResults()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUkWeeeCsvHandler handler = new GetUkWeeeCsvHandler(
authorization,
A.Dummy <IGetUkWeeeCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
var dataReturn = new DataReturn(A.Fake <Domain.Scheme.Scheme>(), new Quarter(2016, QuarterType.Q1));
var dataReturnVersion = new DataReturnVersion(dataReturn, null, A.Dummy <WeeeDeliveredReturnVersion>(), A.Dummy <EeeOutputReturnVersion>());
dataReturn.SetCurrentVersion(dataReturnVersion);
// Act
var result = handler.CreateResults(new List <DataReturn> {
dataReturn
});
// Assert
Assert.All(result, r => Assert.Null(r.DcfQ1));
Assert.All(result, r => Assert.Null(r.DistributorQ1));
Assert.All(result, r => Assert.Null(r.FinalHolderQ1));
}
public async Task HandleAsync_WithNoRecordForRegistrationNumberAndComplianceYear_ThrowsArgumentException()
{
// Arrange
IGetProducerDetailsDataAccess dataAccess = A.Fake <IGetProducerDetailsDataAccess>();
A.CallTo(() => dataAccess.Fetch("WEE/AA1111AA", 2016))
.Returns(new List <ProducerSubmission>());
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
IMapper mapper = A.Fake <IMapper>();
GetProducerDetailsHandler handler = new GetProducerDetailsHandler(dataAccess, authorization, mapper);
Requests.Admin.GetProducerDetails request = new Requests.Admin.GetProducerDetails()
{
RegistrationNumber = "WEE/AA1111AA",
ComplianceYear = 2016
};
// Act
Func <Task <ProducerDetails> > action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public async void HandleAsync_WithOrderByRoleAscending_ReturnsSortedResults()
{
// Arrage
var filter = fixture.Create <UserFilter>();
IFindMatchingUsersDataAccess dataAccess = CreateFakeDataAccess(filter);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
FindMatchingUsersHandler handler = new FindMatchingUsersHandler(authorization, dataAccess);
FindMatchingUsers request = new FindMatchingUsers(1, 1000, FindMatchingUsers.OrderBy.RoleAscending, filter);
// Act
UserSearchDataResult response = await handler.HandleAsync(request);
// Check the first and last results have the correct roles.
Assert.NotNull(response);
Assert.Equal(10, response.Results.Count);
Assert.Collection(response.Results,
u => Assert.Equal("User 3", u.Id),
u => Assert.Equal("User 5", u.Id),
u => Assert.Equal("User 4", u.Id),
u => Assert.Equal("User 2", u.Id),
u => Assert.Equal("User 1", u.Id),
u => Assert.Equal("User 6", u.Id),
u => Assert.Equal("User 8", u.Id),
u => Assert.Equal("User 10", u.Id),
u => Assert.Equal("User 7", u.Id),
u => Assert.Equal("User 9", u.Id));
}
public async Task HandleAsync_HappyPath_ReturnsOrganisationUserData()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
Guid organisationUserId = new Guid("10C57182-BF30-4729-BBF8-F8BCBC00EB77");
OrganisationUser organisationUser = A.Fake <OrganisationUser>();
WeeeContext context = A.Fake <WeeeContext>();
A.CallTo(() => context.OrganisationUsers.FindAsync(organisationUserId)).Returns(organisationUser);
IMap <OrganisationUser, OrganisationUserData> mapper = A.Fake <IMap <OrganisationUser, OrganisationUserData> >();
OrganisationUserData organisationUserData = new OrganisationUserData();
A.CallTo(() => mapper.Map(organisationUser)).Returns(organisationUserData);
var handler = new GetOrganisationUserHandler(context, authorization, mapper);
var request = new GetOrganisationUser(organisationUserId);
// Act
OrganisationUserData result = await handler.HandleAsync(request);
// Assert
Assert.Equal(organisationUserData, result);
}
public async Task HandleAsync_Always_ReturnsSchemesOrderedBySchemeName()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
IMap <Scheme, SchemeData> schemeMap = new SchemeMap(A.Dummy <IMapper>(), A.Fake <IMap <Address, AddressData> >(), A.Fake <IMap <Contact, ContactData> >());
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme scheme1 = new Scheme(organisation);
scheme1.UpdateScheme("Scheme C", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
scheme1.SetStatus(SchemeStatus.Approved);
Scheme scheme2 = new Scheme(organisation);
scheme2.UpdateScheme("Scheme A", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
scheme2.SetStatus(SchemeStatus.Approved);
Scheme scheme3 = new Scheme(organisation);
scheme3.UpdateScheme("Scheme D", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
scheme3.SetStatus(SchemeStatus.Approved);
Scheme scheme4 = new Scheme(organisation);
scheme4.UpdateScheme("Scheme B", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
scheme4.SetStatus(SchemeStatus.Approved);
IGetSchemesDataAccess dataAccess = A.Fake <IGetSchemesDataAccess>();
A.CallTo(() => dataAccess.GetSchemes()).Returns(
new List <Scheme>()
{
scheme1,
scheme2,
scheme3,
scheme4
});
GetSchemesHandler handler = new GetSchemesHandler(
authorization,
schemeMap,
dataAccess);
// Act
GetSchemes request = new GetSchemes(GetSchemes.FilterType.Approved);
List <SchemeData> results = await handler.HandleAsync(request);
// Assert
Assert.NotNull(results);
Assert.Equal(4, results.Count);
Assert.Collection(results,
r => Assert.Equal("Scheme A", r.SchemeName),
r => Assert.Equal("Scheme B", r.SchemeName),
r => Assert.Equal("Scheme C", r.SchemeName),
r => Assert.Equal("Scheme D", r.SchemeName));
}
public async Task HandleAsync_ReturnsComplianceYearsForProducer()
{
// Arrange
IGetProducerComplianceYearDataAccess dataAccess = A.Fake <IGetProducerComplianceYearDataAccess>();
A.CallTo(() => dataAccess.GetComplianceYears("WEE/AA1111AA"))
.Returns(new List <int> {
2018, 2016
});
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetProducerComplianceYearHandler handler = new GetProducerComplianceYearHandler(dataAccess, authorization);
Requests.Admin.GetProducerComplianceYear request = new Requests.Admin.GetProducerComplianceYear()
{
RegistrationNumber = "WEE/AA1111AA"
};
// Act
var result = await handler.HandleAsync(request);
// Assert
Assert.Equal(2, result.Count);
Assert.Collection(result,
r1 => Assert.Equal(2018, r1),
r2 => Assert.Equal(2016, r2));
}
public AddSchemeHandlerTests()
{
authorization = AuthorizationBuilder.CreateUserWithAllRights();
dataAccess = A.Fake <IUpdateSchemeInformationDataAccess>();
organisationDataAccess = A.Fake <IOrganisationDetailsDataAccess>();
handler = new AddSchemeHandler(authorization, dataAccess, organisationDataAccess);
}
public async Task HandleAsync_WithFilterSetToApprovedOrWithdrawn_ReturnsSchemesWithStatusOfApprovedOrWithdrawn()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
var mapper = new SchemeMap(A.Fake <IMapper>(), A.Fake <IMap <Address, AddressData> >(), A.Fake <IMap <Contact, ContactData> >());
Organisation organisation = Organisation.CreateSoleTrader("Test Organisation");
Scheme schemePending = new Scheme(organisation);
schemePending.UpdateScheme("Scheme Pending", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
Scheme schemeApproved = new Scheme(organisation);
schemeApproved.UpdateScheme("Scheme Approved", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
schemeApproved.SetStatus(SchemeStatus.Approved);
Scheme schemeRejected = new Scheme(organisation);
schemeRejected.UpdateScheme("Scheme Rejected", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
schemeRejected.SetStatus(SchemeStatus.Rejected);
Scheme schemeWithdrawn = new Scheme(organisation);
schemeWithdrawn.UpdateScheme("Scheme Withdrawn", "WEE/11AAAA11/SCH", "WEE1234567", ObligationType.Both, A.Dummy <UKCompetentAuthority>());
schemeWithdrawn.SetStatus(SchemeStatus.Approved);
schemeWithdrawn.SetStatus(SchemeStatus.Withdrawn);
IGetSchemesDataAccess dataAccess = A.Fake <IGetSchemesDataAccess>();
A.CallTo(() => dataAccess.GetSchemes()).Returns(
new List <Scheme>()
{
schemePending,
schemeApproved,
schemeRejected,
schemeWithdrawn
});
GetSchemesHandler handler = new GetSchemesHandler(
authorization,
mapper,
dataAccess);
// Act
GetSchemes request = new GetSchemes(GetSchemes.FilterType.ApprovedOrWithdrawn);
List <SchemeData> results = await handler.HandleAsync(request);
// Assert
Assert.NotNull(results);
Assert.Equal(2, results.Count);
Assert.Contains(results, r => r.SchemeName == "Scheme Approved");
Assert.Contains(results, r => r.SchemeName == "Scheme Withdrawn");
}
public AddAatfRequestHandlerTests()
{
addressMapper = A.Fake <IMap <AatfAddressData, AatfAddress> >();
contactMapper = A.Fake <IMap <AatfContactData, AatfContact> >();
dataAccess = A.Fake <IGenericDataAccess>();
commonDataAccess = A.Fake <ICommonDataAccess>();
handler = new AddAatfRequestHandler(AuthorizationBuilder.CreateUserWithAllRights(), dataAccess, addressMapper, contactMapper, commonDataAccess);
}
public GetAatfInfoByAatfIdRequestHandlerTests()
{
this.authorization = AuthorizationBuilder.CreateUserWithAllRights();
this.dataAccess = A.Dummy <IGetAatfsDataAccess>();
this.fakeMapper = A.Fake <IMap <Aatf, AatfData> >();
this.fixture = new Fixture();
this.handler = new GetAatfInfoByAatfIdRequestHandler(this.authorization, this.fakeMapper, this.dataAccess);
}
public async Task HandleAysnc_HappyPath_ReturnsFileInfoWithCorrectFileName()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UKCompetentAuthority authority = new UKCompetentAuthority(
A.Dummy <Guid>(),
"Environment Agency",
"EA",
A.Dummy <Country>(),
"*****@*****.**",
0);
Scheme scheme = A.Dummy <Scheme>();
A.CallTo(() => scheme.CompetentAuthority).Returns(authority);
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
scheme,
A.Dummy <string>(),
A.Dummy <string>());
memberUpload.Submit(A.Dummy <User>());
List <MemberUpload> memberUploads = new List <MemberUpload>();
memberUploads.Add(memberUpload);
SystemTime.Freeze(new DateTime(2015, 12, 31));
InvoiceRun invoiceRun = new InvoiceRun(authority, memberUploads, A.Dummy <User>());
SystemTime.Unfreeze();
ulong fileID = 123;
IbisFileData ibisFileData = new IbisFileData(fileID, "Customer File.dat", "data", "Transaction File.dat", "data");
invoiceRun.SetIbisFileData(ibisFileData);
ICommonDataAccess dataAccess = A.Fake <ICommonDataAccess>();
A.CallTo(() => dataAccess.FetchInvoiceRunAsync(A <Guid> ._)).Returns(invoiceRun);
FetchInvoiceRunIbisZipFileHandler handler = new FetchInvoiceRunIbisZipFileHandler(
authorization,
dataAccess);
// Act
FileInfo fileInfo = await handler.HandleAsync(A.Dummy <Requests.Charges.FetchInvoiceRunIbisZipFile>());
// Assert
Assert.NotNull(fileInfo);
Assert.Equal("WEEE invoice files 00123 2015-12-31.zip", fileInfo.FileName);
}
public async Task HandleAsync_SettingNonEASchemeIbisCustomerReferenceNumberToEmptyString_ReturnsSuccessResult()
{
// Arrange
UKCompetentAuthority environmentAgency = A.Dummy <UKCompetentAuthority>();
typeof(UKCompetentAuthority).GetProperty("Id").SetValue(environmentAgency, new Guid("42D3130C-4CDB-4F74-866A-BFF839A347B5"));
Scheme scheme = new Scheme(A.Dummy <Organisation>());
typeof(Entity).GetProperty("Id").SetValue(scheme, new Guid("5AE25C37-88C8-4646-8793-DB4C2F4EF0E5"));
scheme.UpdateScheme(
"Scheme 1",
"WEE/AA0000AA/SCH",
"WEE8643759",
Domain.Obligation.ObligationType.B2C,
environmentAgency);
scheme.SetStatus(Domain.Scheme.SchemeStatus.Approved);
IUpdateSchemeInformationDataAccess dataAccess = A.Fake <IUpdateSchemeInformationDataAccess>();
A.CallTo(() => dataAccess.FetchSchemeAsync(new Guid("5AE25C37-88C8-4646-8793-DB4C2F4EF0E5"))).Returns(scheme);
A.CallTo(() => dataAccess.FetchEnvironmentAgencyAsync()).Returns(environmentAgency);
A.CallTo(() => dataAccess.FetchNonRejectedEnvironmentAgencySchemesAsync())
.Returns(new List <Scheme>()
{
scheme
});
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UpdateSchemeInformationHandler handler = new UpdateSchemeInformationHandler(
authorization,
dataAccess);
// Act
UpdateSchemeInformation request = new UpdateSchemeInformation(
scheme.Id,
"Scheme 1",
"WEE/AA0000AA/SCH",
string.Empty,
ObligationType.B2C,
new Guid("61D93F16-A478-4F45-AE6B-2A581F0C0648"),
SchemeStatus.Approved);
CreateOrUpdateSchemeInformationResult result = await handler.HandleAsync(request);
// Assert
Assert.NotNull(result);
Assert.Equal(CreateOrUpdateSchemeInformationResult.ResultType.Success, result.Result);
}
public OrganisationInternalByIdHandlerTests()
{
map = A.Fake <IMap <Organisation, OrganisationData> >();
context = A.Fake <WeeeContext>();
organisationId = Guid.NewGuid();
A.CallTo(() => context.Organisations).Returns(dbHelper.GetAsyncEnabledDbSet(new List <Organisation>
{
GetOrganisationWithId(organisationId)
}));
handler = new OrganisationInternalByIdHandler(AuthorizationBuilder.CreateUserWithAllRights(),
context,
map);
}
public async Task OrganisationByIdHandler_HappyPath_ReturnsOrganisationFromId()
{
var authorization = AuthorizationBuilder.CreateUserWithAllRights();
var expectedReturnValue = new OrganisationData();
A.CallTo(() => map.Map(A <Organisation> ._)).Returns(expectedReturnValue);
var message = new GetInternalOrganisation(organisationId);
var result = await handler.HandleAsync(message);
Assert.NotNull(expectedReturnValue);
Assert.Same(expectedReturnValue, result);
}
public CreateOrganisationAdminHandlerTests()
{
this.authorization = AuthorizationBuilder.CreateUserWithAllRights();
this.dataAccess = A.Fake <IGenericDataAccess>();
this.context = A.Fake <WeeeContext>();
DbContextHelper dbContextHelper = new DbContextHelper();
Country country = new Country(countryId, "France");
DbSet <Country> countries = dbContextHelper.GetAsyncEnabledDbSet(new List <Country> {
country
});
A.CallTo(() => context.Countries).Returns(countries);
}
public async Task HandleAsync_WithUnknownUserId_ThrowsArgumentException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UserManager <ApplicationUser> userManager = A.Fake <UserManager <ApplicationUser> >();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns((ApplicationUser)null);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "TestFirstName", "TestLastName");
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public async void GetUserDataHandler_RequestingUserData_ReturnsCorrectUser()
{
// Arrange
IGetManageUserDataAccess dataAccess = CreateFakeDataAccess();
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetUserDataHandler handler = new GetUserDataHandler(userContext, authorization, dataAccess);
GetUserData request = new GetUserData(orgUserId);
// Act
var response = await handler.HandleAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(response.Email, "*****@*****.**");
Assert.Equal(response.OrganisationName, "Test ltd.");
}
public async Task HandleAsync_WhereApprovalNumberIsChangingToAValueThatAlreadyExists_ReturnsFailureResult()
{
// Arrange
UKCompetentAuthority environmentAgency = A.Dummy <UKCompetentAuthority>();
typeof(UKCompetentAuthority).GetProperty("Id").SetValue(environmentAgency, new Guid("42D3130C-4CDB-4F74-866A-BFF839A347B5"));
Scheme scheme = new Scheme(A.Dummy <Organisation>());
typeof(Entity).GetProperty("Id").SetValue(scheme, new Guid("5AE25C37-88C8-4646-8793-DB4C2F4EF0E5"));
scheme.UpdateScheme(
"Scheme 1",
"WEE/AA0000AA/SCH",
"WEE7453846",
Domain.Obligation.ObligationType.B2C,
environmentAgency);
scheme.SetStatus(Domain.Scheme.SchemeStatus.Approved);
IUpdateSchemeInformationDataAccess dataAccess = A.Fake <IUpdateSchemeInformationDataAccess>();
A.CallTo(() => dataAccess.FetchSchemeAsync(new Guid("5AE25C37-88C8-4646-8793-DB4C2F4EF0E5"))).Returns(scheme);
A.CallTo(() => dataAccess.CheckSchemeApprovalNumberInUseAsync("WEE/ZZ9999ZZ/SCH")).Returns(true);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UpdateSchemeInformationHandler handler = new UpdateSchemeInformationHandler(
authorization,
dataAccess);
// Act
UpdateSchemeInformation request = new UpdateSchemeInformation(
scheme.Id,
"Scheme 1",
"WEE/ZZ9999ZZ/SCH",
"WEE7453846",
ObligationType.B2C,
new Guid("42D3130C-4CDB-4F74-866A-BFF839A347B5"),
SchemeStatus.Approved);
CreateOrUpdateSchemeInformationResult result = await handler.HandleAsync(request);
// Assert
Assert.NotNull(result);
Assert.Equal(CreateOrUpdateSchemeInformationResult.ResultType.ApprovalNumberUniquenessFailure, result.Result);
}
public async void FindMatchingUsersHandler_WithFullNameAscendingOrdering_ReturnsResultsSortedByFullName()
{
// Arrage
var filter = fixture.Create <UserFilter>();
IFindMatchingUsersDataAccess dataAccess = CreateFakeDataAccess(filter);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
FindMatchingUsersHandler handler = new FindMatchingUsersHandler(authorization, dataAccess);
FindMatchingUsers request = new FindMatchingUsers(1, 1000, FindMatchingUsers.OrderBy.FullNameAscending, filter);
// Act
var response = await handler.HandleAsync(request);
// Check the first and last results have the correct IDs.
Assert.NotNull(response);
Assert.Equal("AGF GUI", response.Results.First().FullName);
Assert.Equal("YGR FTW", response.Results.Last().FullName);
}
public async Task GetProducerEeeDataCsvHandler_ComplianceYear_B2C_ReturnsFileContent()
{
// Arrange
int complianceYear = 2016;
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetProducerEeeDataCsvHandler handler = new GetProducerEeeDataCsvHandler(
authorization,
A.Dummy <IGetProducerEeeDataCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
GetProducerEeeDataCsv request = new GetProducerEeeDataCsv(complianceYear, null, ObligationType.B2C);
// Act
CSVFileData data = await handler.HandleAsync(request);
// Assert
Assert.NotEmpty(data.FileContent);
}
public async Task HandleAsync_Always_GeneratesCorrectFileName()
{
// Arrange
var authorization = AuthorizationBuilder.CreateUserWithAllRights();
var handler = new GetUkWeeeAtAatfsCsvHandler(
authorization,
A.Dummy <IGetUkWeeeAtAatfsCsvDataAccess>(),
A.Dummy <CsvWriterFactory>());
var request = new GetUkWeeeAtAatfsCsv(2016);
// Act
SystemTime.Freeze(new DateTime(2016, 12, 31, 23, 59, 0));
var result = await handler.HandleAsync(request);
SystemTime.Unfreeze();
// Assert
Assert.Equal("2016_UK WEEE received at AATFs_31122016_2359.csv", result.FileName);
}
public async Task HandleAsync_WithNoSchemeSpecified_GeneratesCorrectFileName()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
A.Dummy <IStoredProcedures>(),
authorization,
A.Dummy <CsvWriterFactory>());
GetSchemeWeeeCsv request = new GetSchemeWeeeCsv(2016, null, ObligationType.B2C);
// Act
SystemTime.Freeze(new DateTime(2016, 12, 31, 23, 59, 0));
FileInfo result = await handler.HandleAsync(request);
SystemTime.Unfreeze();
// Assert
Assert.Equal("2016_B2C_schemeWEEE_31122016_2359.csv", result.FileName);
}
public async Task HandleAsync_HappyPath_UpdatesSchemeCallsSaveAndReturnsSuccess()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
IUpdateSchemeInformationDataAccess dataAccess = A.Fake <IUpdateSchemeInformationDataAccess>();
Scheme scheme = new Scheme(A.Dummy <Organisation>());
A.CallTo(() => dataAccess.FetchSchemeAsync(A <Guid> ._)).Returns(scheme);
UpdateSchemeInformationHandler handler = new UpdateSchemeInformationHandler(
authorization,
dataAccess);
// Act
UpdateSchemeInformation request = new UpdateSchemeInformation(
A.Dummy <Guid>(),
"New scheme name",
"WEE/AB8888CD/SCH",
"WEE7453956",
ObligationType.B2B,
new Guid("559B69CE-865C-465F-89ED-D6A58AA8B0B9"),
SchemeStatus.Approved);
CreateOrUpdateSchemeInformationResult result = await handler.HandleAsync(request);
// Assert
Assert.Equal("New scheme name", scheme.SchemeName);
Assert.Equal("WEE/AB8888CD/SCH", scheme.ApprovalNumber);
Assert.Equal("WEE7453956", scheme.IbisCustomerReference);
Assert.Equal(Domain.Obligation.ObligationType.B2B, scheme.ObligationType);
Assert.Equal(new Guid("559B69CE-865C-465F-89ED-D6A58AA8B0B9"), scheme.CompetentAuthorityId);
Assert.Equal(Domain.Scheme.SchemeStatus.Approved, scheme.SchemeStatus);
A.CallTo(() => dataAccess.SaveAsync()).MustHaveHappened();
Assert.NotNull(result);
Assert.Equal(CreateOrUpdateSchemeInformationResult.ResultType.Success, result.Result);
}
public async Task HandleAsync_WithUnknownRegisteredProducerId_ThrowsException()
{
// Arrange
var registeredProducerId = Guid.NewGuid();
IGetProducerDetailsByRegisteredProducerIdDataAccess dataAccess = A.Fake <IGetProducerDetailsByRegisteredProducerIdDataAccess>();
A.CallTo(() => dataAccess.Fetch(registeredProducerId))
.Returns((Domain.Producer.RegisteredProducer)null);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
GetProducerDetailsByRegisteredProducerIdHandler handler = new GetProducerDetailsByRegisteredProducerIdHandler(dataAccess, authorization);
Requests.Admin.GetProducerDetailsByRegisteredProducerId request =
new Requests.Admin.GetProducerDetailsByRegisteredProducerId(registeredProducerId);
// Act
Func <Task <ProducerDetailsScheme> > action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <Exception>(action);
}
public async Task HandleAsync_WithInvoiceRunWithout1B1SFileData_ThrowsInvalidOperationException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UKCompetentAuthority authority = A.Dummy <UKCompetentAuthority>();
Scheme scheme = A.Dummy <Scheme>();
A.CallTo(() => scheme.CompetentAuthority).Returns(authority);
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
scheme,
A.Dummy <string>(),
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>());
ICommonDataAccess dataAccess = A.Fake <ICommonDataAccess>();
A.CallTo(() => dataAccess.FetchInvoiceRunAsync(A <Guid> ._)).Returns(invoiceRun);
FetchInvoiceRunIbisZipFileHandler handler = new FetchInvoiceRunIbisZipFileHandler(
authorization,
dataAccess);
// Act
Func <Task <FileInfo> > testCode = async() => await handler.HandleAsync(A.Dummy <Requests.Charges.FetchInvoiceRunIbisZipFile>());
// Assert
await Assert.ThrowsAsync <InvalidOperationException>(testCode);
}
public async Task HandleAsync_WithUnknownOrganisationUserId_ThrowsException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
Guid organisationUserId = new Guid("10C57182-BF30-4729-BBF8-F8BCBC00EB77");
WeeeContext context = A.Fake <WeeeContext>();
A.CallTo(() => context.OrganisationUsers.FindAsync(organisationUserId)).Returns((OrganisationUser)null);
IMap <OrganisationUser, OrganisationUserData> mapper = A.Fake <IMap <OrganisationUser, OrganisationUserData> >();
var handler = new GetOrganisationUserHandler(context, authorization, mapper);
var request = new GetOrganisationUser(organisationUserId);
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <Exception>(action);
}
public async Task GetComplianceYearsHandler_OrganisationDoesNotExist_ThrowsArgumentException()
{
// Arrange
Guid pcsId = new Guid("A7905BCD-8EE7-48E5-9E71-2B571F7BBC81");
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
WeeeContext context = A.Fake <WeeeContext>();
var organisations = dbContextHelper.GetAsyncEnabledDbSet <Organisation>(new List <Organisation>());
A.CallTo(() => organisations.FindAsync(pcsId)).Returns((Organisation)null);
A.CallTo(() => context.Organisations).Returns(organisations);
GetComplianceYearsHandler handler = new GetComplianceYearsHandler(authorization, context);
GetComplianceYears request = new GetComplianceYears(pcsId);
// Act
Func <Task> action = async() => await handler.HandleAsync(request);
// Asert
await Assert.ThrowsAsync <ArgumentException>(action);
}
