public CompleteOrganisationAdminHandlerTests()
{
this.authorization = AuthorizationBuilder.CreateUserWithAllRights();
this.dataAccess = A.Fake <IOrganisationDetailsDataAccess>();
DbContextHelper dbContextHelper = new DbContextHelper();
}
public AccountControllerTests()
{
apiClient = A.Fake<IWeeeClient>();
unauthenticatedUserClient = A.Fake<IUnauthenticatedUser>();
weeeAuthorization = A.Fake<IWeeeAuthorization>();
externalRouteService = A.Fake<IExternalRouteService>();
}
public FetchInvoiceRunsHandler(
IWeeeAuthorization authorization,
IFetchInvoiceRunsDataAccess dataAccess)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
}
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 GetUkNonObligatedWeeeReceivedDataCsvHandler(IWeeeAuthorization authorization, WeeeContext context,
CsvWriterFactory csvWriterFactory)
{
this.authorization = authorization;
this.context = context;
this.csvWriterFactory = csvWriterFactory;
}
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 GetAatfContactHandlerTests()
{
mapper = A.Fake <IMap <AatfContact, AatfContactData> >();
dataAccess = A.Fake <IAatfDataAccess>();
authorization = A.Fake <IWeeeAuthorization>();
handler = new GetAatfContactHandler(authorization, dataAccess, mapper);
}
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 EditSentOnAatfSiteHandler(IWeeeAuthorization authorization, IGenericDataAccess genericDataAccess, IOrganisationDetailsDataAccess orgDataAccess, IAatfSiteDataAccess offSiteDataAccess)
{
this.authorization = authorization;
this.genericDataAccess = genericDataAccess;
this.organisationDetailsDataAccess = orgDataAccess;
this.offSiteDataAccess = offSiteDataAccess;
}
public GetMemberRegistrationSchemesByComplianceYearHandler(IWeeeAuthorization authorization, IMap <Scheme, SchemeData> schemeMap, WeeeContext context, ISchemeDataAccess schemeDataAccess)
{
this.authorization = authorization;
this.schemeMap = schemeMap;
this.context = context;
this.schemeDataAccess = schemeDataAccess;
}
public async void GetSchemeByIdHandler_WithNonInternalUser_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrage
Guid schemeId = new Guid("AC9116BC-5732-4F80-9AED-A6E2A0C4C1F1");
ISchemeDataAccess dataAccess = A.Fake <ISchemeDataAccess>();
Scheme scheme = A.Fake <Scheme>();
A.CallTo(() => dataAccess.GetSchemeOrDefault(schemeId)).Returns(scheme);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
var mapper = A.Fake <IMapper>();
SchemeData schemeData = A.Fake <SchemeData>();
A.CallTo(() => mapper.Map <Scheme, SchemeData>(scheme))
.Returns(schemeData);
GetSchemeByIdHandler handler = new GetSchemeByIdHandler(dataAccess, mapper, authorization);
GetSchemeById request = new GetSchemeById(schemeId);
// Act
Func <Task <SchemeData> > action = () => handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <SecurityException>(action);
}
public GetAatfInfoByOrganisationRequestHandlerTests()
{
mapper = A.Fake <IMap <Aatf, AatfData> >();
dataAccess = A.Fake <IGenericDataAccess>();
authorization = A.Fake <IWeeeAuthorization>();
handler = new GetAatfInfoByOrganisationRequestHandler(mapper, dataAccess, authorization);
}
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 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 Task UpdateOrganisationTypeDetailsHandler_UpdateOrganisationTypeDetails_ReturnsUpdatedOrganisation()
{
var organisations = MakeOrganisation();
var context = A.Fake <WeeeContext>();
A.CallTo(() => context.Organisations).Returns(organisations);
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserAllowedToAccessOrganisation();
var handler = new UpdateOrganisationTypeDetailsHandler(context, authorization);
const string tradingName = "trading name";
const string companyName = "company name";
const string companyRegistrationNumber = "12345678";
await
handler.HandleAsync(new UpdateOrganisationTypeDetails(organisations.FirstOrDefault().Id,
OrganisationType.SoleTraderOrIndividual, companyName, tradingName, companyRegistrationNumber));
var orgInfo = organisations.FirstOrDefault();
Assert.NotNull(orgInfo);
Assert.Equal(orgInfo.OrganisationType, Domain.Organisation.OrganisationType.SoleTraderOrIndividual);
Assert.Equal(orgInfo.Name, companyName);
Assert.Equal(orgInfo.TradingName, tradingName);
Assert.Equal(orgInfo.CompanyRegistrationNumber, companyRegistrationNumber);
}
public GetProducerPublicRegisterCSVHandler(IWeeeAuthorization authorization, WeeeContext context,
CsvWriterFactory csvWriterFactory)
{
this.authorization = authorization;
this.context = context;
this.csvWriterFactory = csvWriterFactory;
}
public GetUkEeeDataCsvHandler(IWeeeAuthorization authorization, WeeeContext context,
CsvWriterFactory csvWriterFactory)
{
this.authorization = authorization;
this.context = context;
this.csvWriterFactory = csvWriterFactory;
}
public FetchPendingChargesHandler(
IWeeeAuthorization authorization,
ICommonDataAccess dataAccess)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
}
public FetchNonObligatedWeeeForReturnRequestHandler(
INonObligatedDataAccess dataAccess,
IWeeeAuthorization authDataAccess)
{
this.dataAccess = dataAccess;
this.authorization = authDataAccess;
}
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 GetSentOnAatfSiteHandler(IWeeeAuthorization authorization,
IWeeeSentOnDataAccess getSentOnAatfSiteDataAccess, IMap <AatfAddress, AatfAddressData> mapper)
{
this.authorization = authorization;
this.getSentOnAatfSiteDataAccess = getSentOnAatfSiteDataAccess;
this.mapper = mapper;
}
public FetchDataReturnComplianceYearsForSchemeHandler(
IWeeeAuthorization authorization,
IFetchDataReturnComplianceYearsForSchemeDataAccess dataAccess)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
}
public GetAdminUserStatusHandler(IGetAdminUserDataAccess dataAccess, IMap <UserStatus, Core.Shared.UserStatus> userMap,
IWeeeAuthorization authorization)
{
this.dataAccess = dataAccess;
this.userMap = userMap;
this.authorization = authorization;
}
public AddReturnSchemeHandler(IWeeeAuthorization authorization, IReturnSchemeDataAccess returnSchemeDataAccess, IReturnDataAccess returnDataAccess, ISchemeDataAccess schemeDataAccess)
{
this.authorization = authorization;
this.returnSchemeDataAccess = returnSchemeDataAccess;
this.returnDataAccess = returnDataAccess;
this.schemeDataAccess = schemeDataAccess;
}
public GetAatfIdByComplianceYearHandlerTests()
{
this.authorization = A.Fake <IWeeeAuthorization>();
this.dataAccess = A.Fake <IAatfDataAccess>();
handler = new GetAatfIdByComplianceYearHandler(authorization, dataAccess);
}
public GetSubmissionChangesCsvHandler(IWeeeAuthorization authorization, IGetSubmissionChangesCsvDataAccess dataAccess,
ICsvWriter <SubmissionChangesCsvData> csvWriter)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
this.csvWriter = csvWriter;
}
public UpdateSchemeContactDetailsHandler(IWeeeAuthorization authorization, IOrganisationDetailsDataAccess dataAccess,
IWeeeEmailService weeeEmailService)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
this.weeeEmailService = weeeEmailService;
}
public CheckApprovalNumberIsUniqueHandler(
IWeeeAuthorization authorization,
IFetchAatfDataAccess dataAccess)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
}
public FetchDataReturnForSubmissionHandler(
IWeeeAuthorization authorization,
IFetchDataReturnForSubmissionDataAccess dataAccess)
{
this.authorization = authorization;
this.dataAccess = dataAccess;
}
public GetReportOnQuestionHandlerTests()
{
dataAccess = A.Fake <IGenericDataAccess>();
authorization = A.Fake <IWeeeAuthorization>();
handler = new GetReportOnQuestionHandler(authorization, dataAccess);
}
public GetLocalAreasHandlerTests()
{
context = A.Fake <WeeeContext>();
authorization = A.Fake <IWeeeAuthorization>();
mapper = A.Fake <LocalAreaMap>();
A.CallTo(() => context.LocalAreas).Returns(dbHelper.GetAsyncEnabledDbSet(new List <LocalArea>
{
new LocalArea()
{
Name = "North", CompetentAuthorityId = Guid.NewGuid(), Id = Guid.NewGuid()
},
new LocalArea()
{
Name = "East", CompetentAuthorityId = Guid.NewGuid(), Id = Guid.NewGuid()
},
new LocalArea()
{
Name = "South", CompetentAuthorityId = Guid.NewGuid(), Id = Guid.NewGuid()
},
new LocalArea()
{
Name = "West", CompetentAuthorityId = Guid.NewGuid(), Id = Guid.NewGuid()
},
}));
handler = new GetLocalAreasHandler(context, authorization, mapper);
}
public AccountController(Func<IWeeeClient> apiClient,
IWeeeAuthorization weeeAuthorization,
IExternalRouteService externalRouteService)
{
this.apiClient = apiClient;
this.weeeAuthorization = weeeAuthorization;
this.externalRouteService = externalRouteService;
}
public GetUserDataHandlerTests()
{
context = A.Fake<WeeeContext>();
weeeAuthorization = A.Fake<IWeeeAuthorization>();
userContext = A.Fake<IUserContext>();
userHelper = new UserHelper();
helper = new DbContextHelper();
}
public AccountControllerTests()
{
apiClient = A.Fake<IWeeeClient>();
oauthClient = A.Fake<IOAuthClient>();
authenticationManager = A.Fake<IAuthenticationManager>();
userInfoClient = A.Fake<IUserInfoClient>();
externalRouteService = A.Fake<IExternalRouteService>();
weeeAuthorization = A.Fake<IWeeeAuthorization>();
}
public AccountController(
Func<IWeeeClient> apiClient,
IAuthenticationManager authenticationManager,
IExternalRouteService externalRouteService,
IWeeeAuthorization weeeAuthorization)
{
this.apiClient = apiClient;
this.authenticationManager = authenticationManager;
this.externalRouteService = externalRouteService;
this.weeeAuthorization = weeeAuthorization;
}
public IsProducerRegisteredForComplianceYearTests()
{
weeeAuthorization = A.Fake<IWeeeAuthorization>();
registeredProducerDataAccess = A.Fake<IRegisteredProducerDataAccess>();
}
public GetProducerDetailsHandlerTests()
{
authorization = A.Fake<IWeeeAuthorization>();
mapper = A.Fake<IMapper>();
}
public JoinOrganisationHandlerTests()
{
weeeAuthorization = A.Fake<IWeeeAuthorization>();
userContext = A.Fake<IUserContext>();
dataAccess = A.Fake<IJoinOrganisationDataAccess>();
}
public ErrorsControllerTests()
{
weeeAuthorization = A.Fake<IWeeeAuthorization>();
}
public ProcessDataReturnXmlFileHandlerBuilder()
{
DataAccess = A.Fake<IProcessDataReturnXmlFileDataAccess>();
Authorization = new AuthorizationBuilder()
.AllowEverything()
.Build();
XmlGenerator = A.Fake<IGenerateFromDataReturnXml>();
DataReturnVersionFromXmlBuilder = A.Fake<IDataReturnVersionFromXmlBuilder>();
dataReturnVersionFromXmlBuilderDelegate = x => DataReturnVersionFromXmlBuilder;
dataReturnVersionBuilderDelegate = A.Fake<Func<Domain.Scheme.Scheme, Quarter, IDataReturnVersionBuilder>>();
}
public ErrorsController(IWeeeAuthorization weeeAuthorization)
{
this.weeeAuthorization = weeeAuthorization;
}
public ProcessDataReturnXmlFileHandlerBuilder(WeeeContext context)
{
dataAccess = new ProcessDataReturnXmlFileDataAccess(context);
authorization = A.Fake<IWeeeAuthorization>();
XmlGenerator = A.Fake<IGenerateFromDataReturnXml>();
DataReturnVersionFromXmlBuilder = A.Fake<IDataReturnVersionFromXmlBuilder>();
dataReturnVersionFromXmlBuilderDelegate = x => DataReturnVersionFromXmlBuilder;
dataReturnVersionBuilderDelegate = A.Fake<Func<Scheme, Quarter, IDataReturnVersionBuilder>>();
}
public GetUserDataHandlerTests()
{
userContext = A.Fake<IUserContext>();
weeeAuthorization = A.Fake<IWeeeAuthorization>();
dataAccess = A.Fake<IGetManageUserDataAccess>();
}
public OrganisationBySchemeIdHandlerTests()
{
authorization = A.Fake<IWeeeAuthorization>();
organisationDataAccess = A.Fake<IOrganisationDataAccess>();
mapper = A.Fake<IMapper>();
}
public GetDataReturnsActiveComplianceYearsHandlerTests()
{
authorization = A.Fake<IWeeeAuthorization>();
dataAccess = A.Fake<IGetDataReturnsActiveComplianceYearsDataAccess>();
}
public FetchDataReturnComplianceYearsForSchemeHandlerTests()
{
authorization = A.Fake<IWeeeAuthorization>();
dataAccess = A.Fake<IFetchDataReturnComplianceYearsForSchemeDataAccess>();
}
public GetUsersByOrganisationIdHandlerTests()
{
dataAccess = A.Fake<IGetManageableOrganisationUsersDataAccess>();
weeeAuthorization = A.Fake<IWeeeAuthorization>();
mapper = A.Fake<IMap<OrganisationUser, OrganisationUserData>>();
}
public GetMemberRegistrationsActiveComplianceYearsHandlerTests()
{
authorization = A.Fake<IWeeeAuthorization>();
dataAccess = A.Fake<IGetMemberRegistrationsActiveComplianceYearsDataAccess>();
}
