public bool VerifyEnrolled(decimal amount, string currency, string orderId = null, string configName = "default")
{
Transaction response = new AuthorizationBuilder(TransactionType.VerifyEnrolled, this)
.WithAmount(amount)
.WithCurrency(currency)
.WithOrderId(orderId)
.Execute(configName);
if (response.ThreeDSecure != null)
{
ThreeDSecure = response.ThreeDSecure;
ThreeDSecure.Amount = amount;
ThreeDSecure.Currency = currency;
ThreeDSecure.OrderId = response.OrderId;
if (new List <string> {
"N", "U"
}.Contains(ThreeDSecure.Enrolled))
{
ThreeDSecure.Xid = null;
if (ThreeDSecure.Enrolled == "N")
{
ThreeDSecure.Eci = CardType == "MC" ? 1 : 6;
}
else if (ThreeDSecure.Enrolled == "U")
{
ThreeDSecure.Eci = CardType == "MC" ? 0 : 7;
}
}
return(ThreeDSecure.Enrolled == "Y");
}
return(false);
}
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 async void GetSchemesHandlerTest_HappyPath_ReturnsSchemeDatasOrderedByName()
{
// Arrage
IGetSchemesDataAccess dataAccess = CreateFakeDataAccess();
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
IMap<Scheme, SchemeData> schemeMap = CreateFakeSchemeMap();
GetSchemesHandler handler = new GetSchemesHandler(dataAccess, schemeMap, authorization);
GetSchemes request = new GetSchemes();
// Act
List<SchemeData> results = await handler.HandleAsync(request);
// Assert
Assert.Collection(
results,
(element1) => Assert.Equal(schemeData2, element1),
(element2) => Assert.Equal(schemeData1, element2),
(element3) => Assert.Equal(schemeData3, element3));
}
public async Task HandleAsync_ReturnsFileContent()
{
// Arrange
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var dataAccess = A.Fake<IGetDataReturnSubmissionEeeChangesCsvDataAccess>();
var csvWriter = A.Fake<ICsvWriter<DataReturnSubmissionEeeChangesCsvData>>();
var handler = new GetDataReturnSubmissionEeeChangesCsvHandler(authorization, dataAccess, csvWriter);
var currentSubmissionId = Guid.NewGuid();
var previousSubmissionId = Guid.NewGuid();
var request = new GetDataReturnSubmissionEeeChangesCsv(currentSubmissionId, previousSubmissionId);
A.CallTo(() => csvWriter.Write(A<IEnumerable<DataReturnSubmissionEeeChangesCsvData>>._))
.Returns("CsvData");
// Act
var result = await handler.HandleAsync(request);
// Assert
A.CallTo(() => dataAccess.GetChanges(currentSubmissionId, previousSubmissionId))
.MustHaveHappened();
A.CallTo(() => csvWriter.Write(A<IEnumerable<DataReturnSubmissionEeeChangesCsvData>>._))
.MustHaveHappened();
Assert.NotEmpty(result.FileContent);
Assert.Equal("CsvData", result.FileContent);
}
public Transaction ProcessSecure3d(Secure3dBuilder builder)
{
TransactionType transType = builder.TransactionType;
if (transType.Equals(TransactionType.VerifyEnrolled))
{
AuthorizationBuilder authBuilder = new AuthorizationBuilder(transType, builder.PaymentMethod)
.WithAmount(builder.Amount)
.WithCurrency(builder.Currency)
.WithOrderId(builder.OrderId);
return(ProcessAuthorization(authBuilder));
}
else if (transType.Equals(TransactionType.VerifySignature))
{
// get our three d secure object
ThreeDSecure secureEcom = builder.ThreeDSecure;
// create our transaction reference
TransactionReference reference = new TransactionReference {
OrderId = secureEcom.OrderId
};
ManagementBuilder managementBuilder = new ManagementBuilder(transType)
.WithAmount(secureEcom.Amount)
.WithCurrency(secureEcom.Currency)
.WithPayerAuthenticationResponse(builder.PayerAuthenticationResponse)
.WithPaymentMethod(reference);
return(ManageTransaction(managementBuilder));
}
throw new UnsupportedTransactionException(string.Format("Unknown transaction type {0}", transType));
}
public async void GetSchemesHandlerTest_HappyPath_ReturnsSchemeDatasOrderedByName()
{
// Arrage
IGetSchemesDataAccess dataAccess = CreateFakeDataAccess();
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
IMap <Scheme, SchemeData> schemeMap = CreateFakeSchemeMap();
GetSchemesHandler handler = new GetSchemesHandler(dataAccess, schemeMap, authorization);
GetSchemes request = new GetSchemes();
// Act
List <SchemeData> results = await handler.HandleAsync(request);
// Assert
Assert.Collection(
results,
(element1) => Assert.Equal(schemeData2, element1),
(element2) => Assert.Equal(schemeData1, element2),
(element3) => Assert.Equal(schemeData3, element3));
}
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_NotOrganisationUser_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyOrganisationAccess().Build();
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
Func <Task> action = async() => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <SecurityException>(action);
}
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_ReturnsFileContent()
{
// Arrange
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var dataAccess = A.Fake <IGetDataReturnSubmissionEeeChangesCsvDataAccess>();
var csvWriter = A.Fake <ICsvWriter <DataReturnSubmissionEeeChangesCsvData> >();
var handler = new GetDataReturnSubmissionEeeChangesCsvHandler(authorization, dataAccess, csvWriter);
var currentSubmissionId = Guid.NewGuid();
var previousSubmissionId = Guid.NewGuid();
var request = new GetDataReturnSubmissionEeeChangesCsv(currentSubmissionId, previousSubmissionId);
A.CallTo(() => csvWriter.Write(A <IEnumerable <DataReturnSubmissionEeeChangesCsvData> > ._))
.Returns("CsvData");
// Act
var result = await handler.HandleAsync(request);
// Assert
A.CallTo(() => dataAccess.GetChanges(currentSubmissionId, previousSubmissionId))
.MustHaveHappened();
A.CallTo(() => csvWriter.Write(A <IEnumerable <DataReturnSubmissionEeeChangesCsvData> > ._))
.MustHaveHappened();
Assert.NotEmpty(result.FileContent);
Assert.Equal("CsvData", result.FileContent);
}
public async Task GetOrganisationOverviewHandler_NoOrganisationAccess_ThrowsSecurityException()
{
var authorization = AuthorizationBuilder.CreateUserDeniedFromAccessingOrganisation();
var handler = new GetOrganisationOverviewHandler(authorization, A.Dummy <IGetOrganisationOverviewDataAccess>());
await Assert.ThrowsAsync <SecurityException>(() => handler.HandleAsync(A.Dummy <GetOrganisationOverview>()));
}
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 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));
}
/// <summary>
/// Invokes a request against the BillPay gateway using the AuthorizationBuilder
/// </summary>
/// <param name="builder">The <see cref="AuthorizationBuilder">AuthroizationBuilder</see> containing the required information to build the request</param>
/// <returns>A Transaction response</returns>
public Transaction ProcessAuthorization(AuthorizationBuilder builder)
{
return(new AuthorizationRequest(Credentials, ServiceUrl, Timeout)
.WithRequestLogger(RequestLogger)
.WithWebProxy(WebProxy)
.Execute(builder, IsBillDataHosted));
}
private Transaction CreditAuth(decimal amount)
{
CreditTrackData track = TestCards.VisaSwipe();
AuthorizationBuilder builder = track.Authorize(amount)
.WithCurrency("USD");
if (configName.Equals("NoBatch"))
{
builder.WithBatchNumber(batchProvider.GetBatchNumber(), batchProvider.GetSequenceNumber());
}
Transaction response = builder.Execute(configName);
Assert.IsNotNull(response);
Assert.AreEqual("000", response.ResponseCode);
Transaction capture = response.Capture().Execute();
Assert.IsNotNull(capture);
System.Diagnostics.Debug.WriteLine("Auth Capture:");
System.Diagnostics.Debug.WriteLine(capture.HostResponseDate);
System.Diagnostics.Debug.WriteLine(capture.SystemTraceAuditNumber);
Assert.AreEqual("000", capture.ResponseCode);
return(capture);
}
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 void GetSchemeByIdHandler_HappyPath_ReturnsSchemeData()
{
// 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 = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
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
SchemeData result = await handler.HandleAsync(request);
// Assert
Assert.Equal(schemeData, result);
}
public async void GetAdminUserStatusHandler_HappyPath_ReturnsUserStaus()
{
// Arrange
Guid userId = new Guid("AC9116BC-5732-4F80-9AED-A6E2A0C4C1F1");
IGetAdminUserDataAccess dataAccess = A.Fake<IGetAdminUserDataAccess>();
Domain.Admin.CompetentAuthorityUser user = A.Fake<Domain.Admin.CompetentAuthorityUser>();
A.CallTo(() => dataAccess.GetAdminUserOrDefault(userId)).Returns(user);
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
var userMap = A.Fake<IMap<Domain.User.UserStatus, UserStatus>>();
A.CallTo(() => userMap.Map(user.UserStatus)).Returns(UserStatus.Active);
GetAdminUserStatusHandler handler = new GetAdminUserStatusHandler(dataAccess, userMap, authorization);
GetAdminUserStatus request = new GetAdminUserStatus(userId.ToString());
// Act
UserStatus result = await handler.HandleAsync(request);
// Assert
Assert.Equal(UserStatus.Active, result);
}
private string GetEntryMode(AuthorizationBuilder builder)
{
if (builder.PaymentMethod is ICardData card)
{
if (card.ReaderPresent)
{
return(card.CardPresent ? "MANUAL" : "IN_APP");
}
else
{
return(card.CardPresent ? "MANUAL" : "ECOM");
}
}
else if (builder.PaymentMethod is ITrackData track)
{
if (builder.TagData != null)
{
return(track.EntryMethod.Equals(EntryMethod.Swipe) ? "CHIP" : "CONTACTLESS_CHIP");
}
else if (builder.HasEmvFallbackData)
{
return("CONTACTLESS_SWIPE");
}
return("SWIPE");
}
return("ECOM");
}
public async void GetSchemeByIdHandler_HappyPath_ReturnsSchemeData()
{
// 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 = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
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
SchemeData result = await handler.HandleAsync(request);
// Assert
Assert.Equal(schemeData, result);
}
/// <summary>
/// Validates that the AuthorizationBuilder is configured correctly for a Bill Payment
/// </summary>
protected void ValidateTransaction(AuthorizationBuilder builder)
{
var validationErrors = new List <string>();
if (builder.Bills == null || builder.Bills.Count() < 1)
{
validationErrors.Add("Bill Payments must have at least one bill to pay.");
}
else
{
if (builder.Amount != builder.Bills.Sum(x => x.Amount))
{
validationErrors.Add("The sum of the bill amounts must match the amount charged.");
}
}
if (builder.Currency != "USD")
{
validationErrors.Add("Bill Pay only supports currency USD.");
}
if (validationErrors.Count > 0)
{
throw new ValidationException(validationErrors);
}
}
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 async void GetAdminUserStatusHandler_WithUnknownId_ThrowsArgumentException()
{
// Arrange
Guid badUserId = new Guid("88C60FAC-1172-43F2-9AA5-7E79A8877F92");
IGetAdminUserDataAccess dataAccess = A.Fake <IGetAdminUserDataAccess>();
A.CallTo(() => dataAccess.GetAdminUserOrDefault(badUserId)).Returns((Domain.Admin.CompetentAuthorityUser)null);
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
var userMap = A.Fake <IMap <Domain.User.UserStatus, UserStatus> >();
GetAdminUserStatusHandler handler = new GetAdminUserStatusHandler(dataAccess, userMap, authorization);
GetAdminUserStatus request = new GetAdminUserStatus(badUserId.ToString());
// Act
Func <Task <UserStatus> > action = () => handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public async Task HandleAsync_ThrowsInvalidOperationExceptionIfMemberUploadIsNotSubmitted()
{
// Arrange
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var dataAccess = A.Fake<IGetSubmissionChangesCsvDataAccess>();
var csvWriter = A.Fake<ICsvWriter<SubmissionChangesCsvData>>();
var memberUpload = A.Fake<MemberUpload>();
A.CallTo(() => memberUpload.IsSubmitted)
.Returns(false);
A.CallTo(() => dataAccess.GetMemberUpload(A<Guid>._))
.Returns(memberUpload);
var handler = new GetSubmissionChangesCsvHandler(authorization, dataAccess, csvWriter);
// Act
var exception = await Record.ExceptionAsync(() => handler.HandleAsync(A.Dummy<GetSubmissionChangesCsv>()));
// Assert
A.CallTo(() => dataAccess.GetMemberUpload(A<Guid>._))
.MustHaveHappened();
Assert.IsType<InvalidOperationException>(exception);
}
private string MapCardDataSource(AuthorizationBuilder builder)
{
IPaymentMethod paymentMethod = builder.PaymentMethod;
if (paymentMethod is ICardData card)
{
if (card.ReaderPresent)
{
return(card.CardPresent ? "MANUAL" : "PHONE|MAIL");
}
else
{
return(card.CardPresent ? "MANUAL" : "INTERNET");
}
}
else if (paymentMethod is ITrackData track)
{
if (builder.TagData != null)
{
return(track.EntryMethod.Equals(EntryMethod.Swipe) ? "EMV" : "EMV_CONTACTLESS");
}
else if (builder.HasEmvFallbackData)
{
return("FALLBACK_SWIPE");
}
return("SWIPE");
}
throw new UnsupportedTransactionException();
}
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 CompleteOrganisationAdminHandlerTests()
{
this.authorization = AuthorizationBuilder.CreateUserWithAllRights();
this.dataAccess = A.Fake <IOrganisationDetailsDataAccess>();
DbContextHelper dbContextHelper = new DbContextHelper();
}
public async Task GetAatfAeReturnDataCSVHandler_Returns_MatchingFileContent()
{
var complianceYear = 2019;
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake <WeeeContext>();
var aatfDataAccess = A.Fake <IGetAatfsDataAccess>();
var csvWriterFactory = A.Fake <CsvWriterFactory>();
var storedProcedures = A.Fake <IStoredProcedures>();
A.CallTo(() => context.StoredProcedures)
.Returns(storedProcedures);
DataTable obligatedDataTable = CreateDummyDatatable();
A.CallTo(() => storedProcedures
.GetAatfObligatedCsvData(A.Dummy <Guid>(), A <int> ._, A <int> ._, A.Dummy <Guid>()))
.Returns(obligatedDataTable);
var handler = new GetAatfObligatedDataHandler(authorization, context, csvWriterFactory, aatfDataAccess);
var request = new GetAatfObligatedData(complianceYear, 1, A.Dummy <Guid>(), A.Dummy <Guid>());
// Act
var data = await handler.HandleAsync(request);
data.FileContent.Contains("2019,Q1,TestAatf1,WEE/AC0005ZT/ATF,T User,24/04/2019,1. Large Household Appliances,B2C,33,15,");
data.FileContent.Contains("2019,Q1,TestAatf2,WEE/AC0005ZT/ATF,T User,24/04/2019,1. Large Household Appliances,B2C,33,15,");
data.FileContent.Contains("2019,Q1,TestAatf3,WEE/AC0005ZT/ATF,T User,24/04/2019,1. Large Household Appliances,B2C,33,15,");
data.FileContent.Contains("2019,Q1,TestAatf4,WEE/AC0005ZT/ATF,T User,24/04/2019,1. Large Household Appliances,B2C,33,15,");
data.FileContent.Contains("2019,Q1,TestAatf5,WEE/AC0005ZT/ATF,T User,24/04/2019,1. Large Household Appliances,B2C,33,15,");
}
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);
}
private async Task ActionAndAssertApprovalDate(Action <Guid> assertion, DateTime?approvalDate, DateTime windowStartDate)
{
using (database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var userContext = A.Fake <IUserContext>();
A.CallTo(() => userContext.UserId).Returns(Guid.Parse(database.Model.AspNetUsers.First().Id));
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(A <Quarter> ._))
.Returns(new Domain.DataReturns.QuarterWindow(windowStartDate, windowStartDate.AddDays(1), QuarterType.Q1));
await CreateReturnToCopy(approvalDate);
var message = new CopyReturn(@return.Id);
var authorization = new AuthorizationBuilder().AllowEverything().Build();
handler = new CopyReturnHandler(authorization,
database.WeeeContext,
userContext,
quarterWindowFactory);
var result = await handler.HandleAsync(message);
@return = database.WeeeContext.Returns.AsNoTracking().First(r => r.Id == message.ReturnId);
copiedReturn = database.WeeeContext.Returns.First(r => r.Id == result);
assertion(result);
}
}
private async Task ArrangeActAndCallAssertions(Action <Guid> assertions)
{
using (database = new DatabaseWrapper())
{
// Arrange
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var userContext = A.Fake <IUserContext>();
A.CallTo(() => userContext.UserId).Returns(Guid.Parse(database.Model.AspNetUsers.First().Id));
await CreateReturnToCopy(DateTime.Now);
var message = new CopyReturn(@return.Id);
var authorization = new AuthorizationBuilder().AllowEverything().Build();
handler = new CopyReturnHandler(authorization,
database.WeeeContext,
userContext,
quarterWindowFactory);
// Act
var result = await handler.HandleAsync(message);
@return = database.WeeeContext.Returns.AsNoTracking().First(r => r.Id == message.ReturnId);
copiedReturn = database.WeeeContext.Returns.First(r => r.Id == result);
// Assert
assertions(result);
}
}
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 async Task HandleAsync_ThrowsInvalidOperationExceptionIfMemberUploadIsNotSubmitted()
{
// Arrange
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var dataAccess = A.Fake <IGetSubmissionChangesCsvDataAccess>();
var csvWriter = A.Fake <ICsvWriter <SubmissionChangesCsvData> >();
var memberUpload = A.Fake <MemberUpload>();
A.CallTo(() => memberUpload.IsSubmitted)
.Returns(false);
A.CallTo(() => dataAccess.GetMemberUpload(A <Guid> ._))
.Returns(memberUpload);
var handler = new GetSubmissionChangesCsvHandler(authorization, dataAccess, csvWriter);
// Act
var exception = await Record.ExceptionAsync(() => handler.HandleAsync(A.Dummy <GetSubmissionChangesCsv>()));
// Assert
A.CallTo(() => dataAccess.GetMemberUpload(A <Guid> ._))
.MustHaveHappened();
Assert.IsType <InvalidOperationException>(exception);
}
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 void Patch(FunctionHostBuilder builder, string newAssemblyNamespace)
{
AuthorizationBuilder authorizationBuilder = (AuthorizationBuilder)builder.AuthorizationBuilder;
Type validationResultType = typeof(ValidationResult);
foreach (AbstractFunctionDefinition definition in builder.FunctionDefinitions)
{
definition.Namespace = newAssemblyNamespace;
definition.IsUsingValidator = builder.ValidatorType != null;
definition.CommandDeserializerType = definition.CommandDeserializerType ??
((SerializationBuilder)(builder.SerializationBuilder)).DefaultCommandDeserializerType;
if (CommandRequiresNoHandler(definition.CommandType))
{
definition.NoCommandHandler = true; // don't skip the if statement, this may also be set through options
}
if (definition is HttpFunctionDefinition httpFunctionDefinition)
{
CompleteHttpFunctionDefinition(builder, httpFunctionDefinition, authorizationBuilder, validationResultType);
}
else if (definition is CosmosDbFunctionDefinition cosmosDbFunctionDefinition)
{
CompleteCosmosDbFunctionDefinition(cosmosDbFunctionDefinition);
}
}
}
public async void GetSchemeByIdHandler_WithUnknownId_ThrowsArgumentException()
{
// Arrage
Guid badSchemeId = new Guid("88C60FAC-1172-43F2-9AA5-7E79A8877F92");
ISchemeDataAccess dataAccess = A.Fake <ISchemeDataAccess>();
A.CallTo(() => dataAccess.GetSchemeOrDefault(badSchemeId)).Returns((Scheme)null);
IWeeeAuthorization authorization = new AuthorizationBuilder()
.AllowInternalAreaAccess()
.Build();
var mapper = A.Fake <IMapper>();
GetSchemeByIdHandler handler = new GetSchemeByIdHandler(dataAccess, mapper, authorization);
GetSchemeById request = new GetSchemeById(badSchemeId);
// Act
Func <Task <SchemeData> > action = () => handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public async Task HandleAsync_NoAccessToScheme_ThrowsSecurityException()
{
var authorization = new AuthorizationBuilder().DenySchemeAccess().Build();
var handler = new FetchDataReturnForSubmissionHandler(authorization, A.Dummy<IFetchDataReturnForSubmissionDataAccess>());
await Assert.ThrowsAsync<SecurityException>(() => handler.HandleAsync(A.Dummy<Requests.DataReturns.FetchDataReturnForSubmission>()));
}
public async Task HandleAsync_WithNonInternalUser_ThrowsSecurityException()
{
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
var dataAccess = A.Dummy<IFetchIssuedChargesCsvDataAccess>();
var csvWriterFactory = A.Dummy<CsvWriterFactory>();
var handler = new FetchIssuedChargesCsvHandler(authorization, dataAccess, csvWriterFactory);
await Assert.ThrowsAsync<SecurityException>(() => handler.HandleAsync(A.Dummy<FetchIssuedChargesCsv>()));
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException()
{
IWeeeAuthorization authorization = new AuthorizationBuilder()
.DenyInternalAreaAccess()
.Build();
var handler = new UpdateCompetentAuthorityUserRoleAndStatusHandler(A.Dummy<IUserContext>(), A.Dummy<IUpdateCompetentAuthorityUserRoleAndStatusDataAccess>(),
authorization);
await Assert.ThrowsAsync<SecurityException>(() => handler.HandleAsync(A.Dummy<UpdateCompetentAuthorityUserRoleAndStatus>()));
}
public async Task HandleAsync_ReturnsFileContent()
{
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var dataAccess = A.Dummy<IFetchIssuedChargesCsvDataAccess>();
var csvWriterFactory = A.Dummy<CsvWriterFactory>();
var handler = new FetchIssuedChargesCsvHandler(authorization, dataAccess, csvWriterFactory);
var data = await handler.HandleAsync(A.Dummy<FetchIssuedChargesCsv>());
Assert.NotEmpty(data.Data);
}
public async Task HandleAsync_ReturnsFileContent()
{
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Dummy<WeeeContext>();
var dataAccess = A.Dummy<ICommonDataAccess>();
var csvWriterFactory = A.Dummy<CsvWriterFactory>();
var handler = new FetchInvoiceRunCsvHandler(authorization, context, dataAccess, csvWriterFactory);
var data = await handler.HandleAsync(A.Dummy<FetchInvoiceRunCsv>());
Assert.NotEmpty(data.FileContent);
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
var authorization = AuthorizationBuilder.CreateFromUserType(userType);
var dataAccess = A.Fake<IOrganisationDetailsDataAccess>();
var handler = new UpdateOrganisationDetailsHandler(dataAccess, authorization);
// Act
Func<Task> action = async () => await handler.HandleAsync(A.Dummy<UpdateOrganisationDetails>());
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async void HandleAsync_WithNonInternalUser_ThrowSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
var authorization = AuthorizationBuilder.CreateFromUserType(userType);
var emailService = A.Fake<IWeeeEmailService>();
SendTestEmailHandler handler = new SendTestEmailHandler(authorization, emailService);
// Act
Func<Task<bool>> action = () => handler.HandleAsync(A.Dummy<SendTestEmail>());
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder()
.DenyInternalAreaAccess()
.Build();
var handler = new GetRolesHandler(authorization, A.Dummy<WeeeContext>());
// Act
Func<Task> action = async () => await handler.HandleAsync(A.Dummy<GetRoles>());
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalUser_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
FetchInvoiceRunIbisZipFileHandler handler = new FetchInvoiceRunIbisZipFileHandler(
authorization,
A.Dummy<ICommonDataAccess>());
// Act
Func<Task<FileInfo>> testCode = async () => await handler.HandleAsync(A.Dummy<Requests.Charges.FetchInvoiceRunIbisZipFile>());
// Assert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
public async Task HandleAsync_WithNoInternalAccess_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
FetchComplianceYearsWithInvoicesHandler handler = new FetchComplianceYearsWithInvoicesHandler(
authorization,
A.Dummy<ICommonDataAccess>());
// Act
Func<Task<IReadOnlyList<int>>> testCode = async () => await handler.HandleAsync(A.Dummy<Requests.Charges.FetchComplianceYearsWithInvoices>());
// Assert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
public async Task HandleAsync_WithNonInternalUser_ThrowSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
var authorization = AuthorizationBuilder.CreateFromUserType(userType);
var handler = new GetSubmissionChangesCsvHandler(
authorization,
A.Dummy<IGetSubmissionChangesCsvDataAccess>(),
A.Dummy<ICsvWriter<SubmissionChangesCsvData>>());
// Act
Func<Task<CSVFileData>> action = () => handler.HandleAsync(A.Dummy<GetSubmissionChangesCsv>());
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser(Guid.NewGuid().ToString(), "TestFirstName", "TestLastName");
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task GetProducerAmendmentsHistoryCSVHandler_PRNIsNullOrEmpty_ThrowsArgumentException(string prn)
{
// Arrange
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake<WeeeContext>();
var csvWriterFactory = A.Fake<CsvWriterFactory>();
var handler = new GetProducerAmendmentsHistoryCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerAmendmentsHistoryCSV(prn);
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<ArgumentException>(action);
}
public async Task HandleAsync_WhenUserCannotAccessInternalArea_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
GetSchemesHandler handler = new GetSchemesHandler(
authorization,
A.Dummy<IMap<Scheme, SchemeData>>(),
A.Dummy<IGetSchemesDataAccess>());
// Act
Func<Task> testCode = async () => await handler.HandleAsync(A.Dummy<GetSchemes>());
// Asert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
public async Task GetProducerAmendmentsHistoryCSVHandler_WithBrandNamesLongerThanMaxLength_ThrowsException()
{
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake<WeeeContext>();
var storedProcedures = A.Fake<IStoredProcedures>();
var csvWriterFactory = A.Fake<CsvWriterFactory>();
A.CallTo(() => context.StoredProcedures)
.Returns(storedProcedures);
var csvData1 = new ProducerAmendmentsHistoryCSVData
{
ProducerName = "Producer1",
DateRegistered = new DateTime(2000, 3, 2, 11, 25, 13),
BrandNames = new string('A', GetMembersDetailsCsvHandler.MaxBrandNamesLength + 1)
};
var csvData2 = new ProducerAmendmentsHistoryCSVData
{
ProducerName = "Producer1",
DateRegistered = new DateTime(2001, 7, 12, 16, 12, 54),
BrandNames = "BrandName2"
};
var csvData3 = new ProducerAmendmentsHistoryCSVData
{
ProducerName = "Producer1",
DateRegistered = new DateTime(2002, 8, 5, 9, 3, 28),
BrandNames = new string('A', GetMembersDetailsCsvHandler.MaxBrandNamesLength + 1)
};
A.CallTo(() => storedProcedures
.SpgProducerAmendmentsCSVDataByPRN(A<string>._))
.Returns(new List<ProducerAmendmentsHistoryCSVData> { csvData1, csvData2, csvData3 });
var handler = new GetProducerAmendmentsHistoryCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerAmendmentsHistoryCSV("PRN");
// Act
var exception = await Record.ExceptionAsync(() => handler.HandleAsync(request));
// Assert
Assert.NotNull(exception);
Assert.Contains("02/03/2000 11:25:13", exception.Message);
Assert.Contains("05/08/2002 09:03:28", exception.Message);
Assert.Contains("brand names", exception.Message);
}
public async Task SetSchemeStatusHandler_WithNonInternalUser_ThrowsSecurityException(
AuthorizationBuilder.UserType userType)
{
// Arrange
var authorization = AuthorizationBuilder.CreateFromUserType(userType);
var handler = new SetSchemeStatusHandler(context, authorization);
var schemeId = new Guid("3C367528-AE93-427F-A4C5-E23F0D317633");
var request = new SetSchemeStatus(schemeId, SchemeStatus.Approved);
// Act
Func<Task<Guid>> action = () => handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNoInternalAccess_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
IssuePendingChargesHandler handler = new IssuePendingChargesHandler(
authorization,
A.Dummy<IIssuePendingChargesDataAccess>(),
A.Dummy<IIbisFileDataGenerator>(),
A.Dummy<IDomainUserContext>());
// Act
Func<Task<IssuePendingChargesResult>> testCode = async () => await handler.HandleAsync(A.Dummy<Requests.Charges.IssuePendingCharges>());
// Assert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
public async Task HandleAsync_WithNonInternalUser_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
IGetProducerDetailsByRegisteredProducerIdDataAccess dataAccess = A.Dummy<IGetProducerDetailsByRegisteredProducerIdDataAccess>();
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
GetProducerDetailsByRegisteredProducerIdHandler handler = new GetProducerDetailsByRegisteredProducerIdHandler(dataAccess, authorization);
Requests.Admin.GetProducerDetailsByRegisteredProducerId request =
new Requests.Admin.GetProducerDetailsByRegisteredProducerId(Guid.NewGuid());
// Act
Func<Task<ProducerDetailsScheme>> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalUser_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder()
.DenyInternalAreaAccess()
.Build();
UpdateSchemeInformationHandler handler = new UpdateSchemeInformationHandler(
authorization,
A.Dummy<IUpdateSchemeInformationDataAccess>());
// Act
Func<Task<UpdateSchemeInformationResult>> testCode = async () => await handler.HandleAsync(A.Dummy<UpdateSchemeInformation>());
// Assert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
public async Task GetProducerAmendmentsHistoryCSVHandler_ReturnsFileContent()
{
// Arrange
var prn = "WEE/MM0001DD";
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake<WeeeContext>();
var csvWriterFactory = A.Fake<CsvWriterFactory>();
var handler = new GetProducerAmendmentsHistoryCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerAmendmentsHistoryCSV(prn);
// Act
CSVFileData data = await handler.HandleAsync(request);
// Assert
Assert.NotEmpty(data.FileContent);
}
public async Task GetProducerPublicRegisterCSVHandler_ComplianceYear_ReturnsFileContent()
{
// Arrange
var complianceYear = 2016;
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake<WeeeContext>();
var csvWriterFactory = A.Fake<CsvWriterFactory>();
var handler = new GetProducerPublicRegisterCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerPublicRegisterCSV(complianceYear);
// Act
CSVFileData data = await handler.HandleAsync(request);
// Assert
Assert.NotEmpty(data.FileContent);
}
public async Task GetProducerPublicRegisterCSVHandler_NoComplianceYear_ThrowsArgumentException()
{
// Arrange
var complianceYear = 0;
var authorization = new AuthorizationBuilder().AllowInternalAreaAccess().Build();
var context = A.Fake<WeeeContext>();
var csvWriterFactory = A.Fake<CsvWriterFactory>();
var handler = new GetProducerPublicRegisterCSVHandler(authorization, context, csvWriterFactory);
var request = new GetProducerPublicRegisterCSV(complianceYear);
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<ArgumentException>(action);
}
public async Task GetComplianceYearsHandler_NotOrganisationUser_ThrowsSecurityException()
{
// Arrange
Guid pcsId = new Guid("A7905BCD-8EE7-48E5-9E71-2B571F7BBC81");
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalOrOrganisationAccess().Build();
WeeeContext context = A.Fake<WeeeContext>();
GetComplianceYearsHandler handler = new GetComplianceYearsHandler(authorization, context);
GetComplianceYears request = new GetComplianceYears(pcsId);
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Asert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithNonInternalUser_ThrowsSecurityException()
{
// Arrange
IWeeeAuthorization authorization = new AuthorizationBuilder().DenyInternalAreaAccess().Build();
GetSchemeWeeeCsvHandler handler = new GetSchemeWeeeCsvHandler(
A.Dummy<IStoredProcedures>(),
authorization,
A.Dummy<CsvWriterFactory>());
GetSchemeWeeeCsv request = new GetSchemeWeeeCsv(A.Dummy<int>(), A.Dummy<Guid?>(), A.Dummy<ObligationType>());
// Act
Func<Task<FileInfo>> testCode = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(testCode);
}
