public async Task ReportCountIsControlledBySubmissionOptions(SectorTypes testSector, int testEditableReportCount)
{
// Arrange
var testConfig = new SubmissionOptions {
EditableReportCount = testEditableReportCount
};
var testOrg = new Organisation {
OrganisationId = 1, SectorType = testSector
};
var testUserOrg = new UserOrganisation {
Organisation = testOrg
};
DateTime testSnapshotDate = mockSharedBusinessLogic.GetAccountingStartDate(testOrg.SectorType);
var mockService = new Mock <SubmissionPresenter>(
mockDataRepo.Object,
mockScopeBL.Object,
null,
mockDraftFileBL.Object,
MoqHelpers.CreateIOptionsSnapshotMock(testConfig));
// Call the real functions unless overridden
mockService.CallBase = true;
// Act
SubmissionPresenter testService = mockService.Object;
List <ReportInfoModel> actualResults = await testService.GetAllEditableReportsAsync(testUserOrg, testSnapshotDate);
// Assert
Assert.AreEqual(
testEditableReportCount,
actualResults.Count,
$"Expected editable report count to be {testEditableReportCount}");
}
public async Task DraftFile_GetDraftFile_Returns_A_Valid_DraftAsync()
{
// Arrange
User mockedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress();
Organisation mockedOrganisation = OrganisationHelper.GetPublicOrganisation();
mockedOrganisation.OrganisationId = new Random().Next(1000, 9999);
UserOrganisation mockedUserOrganisation = UserOrganisationHelper.LinkUserWithOrganisation(mockedUser, mockedOrganisation);
Return mockedReturn = ReturnHelper.GetSubmittedReturnForOrganisationAndYear(mockedUserOrganisation, ConfigHelpers.SharedOptions.FirstReportingYear);
OrganisationHelper.LinkOrganisationAndReturn(mockedOrganisation, mockedReturn);
var testDraftFileBL = new DraftFileBusinessLogic(null, new SystemFileRepository(new StorageOptions()));
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), testDraftFileBL);
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Act
Draft actualDraft = await testPresenter.GetDraftFileAsync(
mockedOrganisation.OrganisationId,
mockedOrganisation.SectorType.GetAccountingStartDate().Year,
mockedUser.UserId);
// Assert
Assert.NotNull(actualDraft);
Assert.True(actualDraft.IsUserAllowedAccess);
Assert.AreEqual(mockedUser.UserId, actualDraft.LastWrittenByUserId);
// Clean up
await testDraftFileBL.DiscardDraftAsync(actualDraft);
}
public void IsCurrentSnapshotYear_Returns_true_When_SnapshotYear_is_the_Current_Year()
{
var currentSnapshotYear = 2001;
var testSnapshotYear = 2001;
// Mocks
var mockService = new Mock <SubmissionPresenter>(
mockDataRepo.Object,
mockScopeBL.Object,
mockFileRepo.Object,
_mockDraftFileBL.Object,
null);
mockService.CallBase = true;
// Override GetReportingStartDate and return expectedYear
mockService.Setup(ss => ss.GetSnapshotDate(It.IsAny <SectorTypes>(), It.IsAny <int>()))
.Returns(new DateTime(currentSnapshotYear, 4, 5));
// Sanity checks
Expect(currentSnapshotYear == testSnapshotYear, "SanityCheck: curReportingYear should equal the testReportingStartYear");
// Assert
SubmissionPresenter testService = mockService.Object;
Expect(testService.IsCurrentSnapshotYear(SectorTypes.Private, testSnapshotYear));
}
public void ReturnsFalseWhenNotCurrentYear(SectorTypes testSector, int testYear)
{
// Arrange
DateTime testSnapshotDate = mockSharedBusinessLogic.GetAccountingStartDate(testSector);
var expectCalledGetSnapshotDate = false;
// Mocks
var mockService = new Mock <SubmissionPresenter>(
mockDataRepo.Object,
mockScopeBL.Object,
mockFileRepo.Object,
mockDraftFileBL.Object,
null);
mockService.CallBase = true;
// Override GetPreviousReportingStartDate and return expectedYear
mockService.Setup(ss => ss.GetSnapshotDate(It.IsIn(testSector), It.IsAny <int>()))
.Returns(
() => {
expectCalledGetSnapshotDate = true;
return(testSnapshotDate);
});
// Assert
SubmissionPresenter testService = mockService.Object;
bool actual = testService.IsCurrentSnapshotYear(testSector, testYear);
Assert.IsTrue(expectCalledGetSnapshotDate, "Expected to call GetSnapshotDate");
Assert.IsFalse(actual, "Expected IsCurrentSnapshotYear to return true");
}
public async Task GetSubmissionForSnapshotYear_Returns_null_when_year_does_not_exist()
{
// Mocks
mockDataRepo.Setup(dr => dr.GetAll <Return>())
.Returns(
new[] {
new Return {
ReturnId = 1, OrganisationId = 2, AccountingDate = new DateTime(1999, 1, 1)
},
new Return {
ReturnId = 2, OrganisationId = 1, AccountingDate = new DateTime(1999, 1, 2)
},
new Return {
ReturnId = 3, OrganisationId = 1, AccountingDate = new DateTime(2000, 1, 3)
},
new Return {
ReturnId = 4, OrganisationId = 1, AccountingDate = new DateTime(2000, 1, 4)
},
new Return {
ReturnId = 5, OrganisationId = 2, AccountingDate = new DateTime(2000, 1, 5)
}
}.AsQueryable()
.BuildMock()
.Object);
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert
Return actualReturn = await testPresenter.GetReturnFromDatabaseAsync(1, 1998);
Expect(actualReturn == null);
}
public void GetSubmissionChangeSummary_Detects_when_the_website_url_has_changed()
{
var testOldReturn = new Return {
CompanyLinkToGPGInfo = "", Organisation = new Organisation {
SectorType = SectorTypes.Private
}
};
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
// Mocks
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Copy the original
var testNewReturn = (Return)testOldReturn.CopyProperties(new Return());
// Make the change
testNewReturn.CompanyLinkToGPGInfo = "http://unittesting";
// Assert
SubmissionChangeSummary testChangeSummary = testPresenter.GetSubmissionChangeSummary(testNewReturn, testOldReturn);
string failMessage = $"Assert: Failed to detect {nameof(testNewReturn.CompanyLinkToGPGInfo)} had changed";
Expect(testChangeSummary.HasChanged, failMessage);
Expect(testChangeSummary.FiguresChanged == false, failMessage);
Expect(testChangeSummary.OrganisationSizeChanged == false, failMessage);
Expect(testChangeSummary.PersonResonsibleChanged == false, failMessage);
Expect(testChangeSummary.WebsiteUrlChanged, failMessage);
}
public void ReturnsTrueForCurrentYear(SectorTypes testSector)
{
// Arrange
DateTime testSnapshotDate = mockSharedBusinessLogic.GetAccountingStartDate(testSector);
int testYear = testSnapshotDate.Year;
// Mocks
var testSubmissionService = new SubmissionService(mockSharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert
bool actual = testPresenter.IsCurrentSnapshotYear(testSector, testYear);
Assert.IsTrue(actual, "Expected IsCurrentSnapshotYear to return true");
}
public void GetSubmissionChangeSummary_Detects_no_changes()
{
var testOldReturn = new Return {
DiffMeanBonusPercent = 100,
DiffMeanHourlyPayPercent = 99,
DiffMedianBonusPercent = 98,
DiffMedianHourlyPercent = 97,
FemaleLowerPayBand = 96,
FemaleMedianBonusPayPercent = 95,
FemaleMiddlePayBand = 94,
FemaleUpperPayBand = 93,
FemaleUpperQuartilePayBand = 92,
MaleLowerPayBand = 91,
MaleMedianBonusPayPercent = 90,
MaleUpperQuartilePayBand = 89,
MaleMiddlePayBand = 88,
MaleUpperPayBand = 87,
FirstName = "Test",
LastName = "User",
JobTitle = "QA",
CompanyLinkToGPGInfo = "http://unittesting",
MinEmployees = 250,
MaxEmployees = 499,
Organisation = new Organisation {
SectorType = SectorTypes.Private
}
};
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
// Mocks
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Copy the original
var testNewReturn = (Return)testOldReturn.CopyProperties(new Return());
// Assert
SubmissionChangeSummary testChangeSummary = testPresenter.GetSubmissionChangeSummary(testNewReturn, testOldReturn);
string failMessage = $"Assert: Failed to detect {nameof(testNewReturn.CompanyLinkToGPGInfo)} had changed";
Expect(testChangeSummary.HasChanged == false, failMessage);
Expect(testChangeSummary.FiguresChanged == false, failMessage);
Expect(testChangeSummary.OrganisationSizeChanged == false, failMessage);
Expect(testChangeSummary.PersonResonsibleChanged == false, failMessage);
Expect(testChangeSummary.WebsiteUrlChanged == false, failMessage);
}
public void ShouldUpdateLatestReturn_When_LatestReturn_is_null_returns_true()
{
// Setup
var testOrg = new Organisation {
LatestReturn = null
};
var testSnapshotYear = 2000;
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert
bool actual = testPresenter.ShouldUpdateLatestReturn(testOrg, testSnapshotYear);
Expect(actual);
}
GetViewModelForSubmission_Given_a_new_submission_Then_returns_empty_model_with_org_id_and_reporting_date_onlyAsync()
{
var testUserId = 123;
int testYear = VirtualDateTime.Now.AddYears(-1).Year;
// Mocks
var testOrganisation = new Organisation {
OrganisationId = 524124, SectorType = SectorTypes.Private
};
mockDataRepo.Setup(dr => dr.GetAll <UserOrganisation>())
.Returns(
new[] {
new UserOrganisation {
UserId = testUserId, OrganisationId = testOrganisation.OrganisationId, Organisation = testOrganisation
}
}.AsQueryable()
.BuildMock()
.Object);
mockDataRepo.Setup(dr => dr.GetAll <Return>())
.Returns(new Return[] { }.AsQueryable().BuildMock().Object);
var testDraftFileFileBusinessLogic = new DraftFileBusinessLogic(null, new SystemFileRepository(new StorageOptions()));
Draft actualDraftFile = await testDraftFileFileBusinessLogic.GetExistingOrNewAsync(
testOrganisation.OrganisationId,
testYear,
testUserId);
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), testDraftFileFileBusinessLogic);
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Test
ReturnViewModel actualModel = await testPresenter.GetReturnViewModelAsync(testOrganisation.OrganisationId, testYear, testUserId);
// Assert
Assert.NotNull(actualModel);
Assert.AreEqual(testOrganisation.OrganisationId, actualModel.OrganisationId);
Assert.AreEqual(testYear, actualModel.AccountingDate.Year);
await testDraftFileFileBusinessLogic.DiscardDraftAsync(actualDraftFile);
}
public void ShouldUpdateLatestReturn_when_LatestReturnYear_greaterthan_ReportingStartYear_returns_false()
{
// Setup
var testOrg = new Organisation {
LatestReturn = new Return {
AccountingDate = new DateTime(2018, 4, 5)
}
};
var testSnapshotYear = 2017;
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert
bool actual = testPresenter.ShouldUpdateLatestReturn(testOrg, testSnapshotYear);
Expect(actual == false);
}
public void GetViewModelForSubmission_Throws_AuthenticationException_when_the_user_organisation_isnt_found()
{
var testUserId = 123;
var testOrganisationId = 524124;
// Mocks
mockDataRepo.Setup(dr => dr.GetAll <UserOrganisation>()).Returns(new UserOrganisation[] { }.AsQueryable().BuildMock().Object);
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Test
var ex = Assert.ThrowsAsync <AuthenticationException>(
() => testPresenter.GetReturnViewModelAsync(testOrganisationId, 2001, testUserId));
// Assert
Assert.That(
ex.Message.Contains(
$"GetViewModelForSubmission: Failed to find the UserOrganisation for userId {testUserId} and organisationId {testOrganisationId}"));
}
public async Task GetSubmissionForSnapshotYear_Returns_latest_submission_for_specified_org_and_yearAsync()
{
// Mocks
var returns = new[] {
new Return {
ReturnId = 1, OrganisationId = 2, AccountingDate = new DateTime(1999, 1, 1), Status = ReturnStatuses.Submitted
},
new Return {
ReturnId = 2, OrganisationId = 1, AccountingDate = new DateTime(1999, 1, 2), Status = ReturnStatuses.Submitted
},
new Return {
ReturnId = 3, OrganisationId = 1, AccountingDate = new DateTime(2000, 1, 3), Status = ReturnStatuses.Submitted
},
new Return {
ReturnId = 4, OrganisationId = 1, AccountingDate = new DateTime(2000, 1, 4), Status = ReturnStatuses.Submitted
},
new Return {
ReturnId = 5, OrganisationId = 2, AccountingDate = new DateTime(2000, 1, 5), Status = ReturnStatuses.Submitted
}
};
mockDataRepo.SetupGetAll((ICollection <Return>)returns);
var mockService = new Mock <SubmissionPresenter>(
mockDataRepo.Object,
mockScopeBL.Object,
mockFileRepo.Object,
_mockDraftFileBL.Object,
null);
mockService.CallBase = true;
mockService.Setup(s => s.IsValidSnapshotYear(It.IsAny <int>())).Returns(true);
// Assert
SubmissionPresenter testService = mockService.Object;
Return actualReturn = await testService.GetReturnFromDatabaseAsync(1, 2000);
Expect(actualReturn != null);
Expect(actualReturn.ReturnId == 4);
}
public void GetSubmissionChangeSummary_Detects_when_the_person_responsible_has_changed()
{
var testOldReturn = new Return {
FirstName = "Test", LastName = "User", JobTitle = "QA", Organisation = new Organisation {
SectorType = SectorTypes.Private
}
};
string[] personProps = { nameof(testOldReturn.FirstName), nameof(testOldReturn.LastName), nameof(testOldReturn.JobTitle) };
var changeValue = "Mr T";
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
// Mocks
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert all figures
foreach (string personPropName in personProps)
{
// Restore the original
var testNewReturn = (Return)testOldReturn.CopyProperties(new Return());
// Make the change
testNewReturn.SetProperty(personPropName, changeValue);
// Assert
SubmissionChangeSummary testChangeSummary = testPresenter.GetSubmissionChangeSummary(testNewReturn, testOldReturn);
string failMessage = $"Assert: Failed to detect {personPropName} had changed";
Expect(testChangeSummary.HasChanged, failMessage);
Expect(testChangeSummary.FiguresChanged == false, failMessage);
Expect(testChangeSummary.OrganisationSizeChanged == false, failMessage);
Expect(testChangeSummary.PersonResonsibleChanged, failMessage);
Expect(testChangeSummary.WebsiteUrlChanged == false, failMessage);
}
}
public async Task GetViewModelForSubmission_Given_an_existing_submission_Then_returns_return_dataAsync()
{
var testUserId = 123;
var testOrganisationId = 524124;
var testYear = 2001;
var testReturn = new Return {
AccountingDate = new DateTime(testYear, 1, 1),
OrganisationId = testOrganisationId,
DiffMeanBonusPercent = 100,
DiffMeanHourlyPayPercent = 99,
DiffMedianBonusPercent = 98,
DiffMedianHourlyPercent = 97,
FemaleLowerPayBand = 96,
FemaleMedianBonusPayPercent = 95,
FemaleMiddlePayBand = 94,
FemaleUpperPayBand = 93,
FemaleUpperQuartilePayBand = 92,
MaleLowerPayBand = 91,
MaleMedianBonusPayPercent = 90,
MaleUpperQuartilePayBand = 89,
MaleMiddlePayBand = 88,
MaleUpperPayBand = 87,
FirstName = "Test",
LastName = "User",
JobTitle = "QA",
CompanyLinkToGPGInfo = "http://unittesting",
MinEmployees = 250,
MaxEmployees = 499,
Status = ReturnStatuses.Submitted,
Organisation = new Organisation {
SectorType = SectorTypes.Private
}
};
// Mocks
mockDataRepo.Setup(dr => dr.GetAll <UserOrganisation>())
.Returns(
new[] {
new UserOrganisation {
UserId = testUserId, OrganisationId = testOrganisationId, Organisation = testReturn.Organisation
}
}.AsQueryable()
.BuildMock()
.Object);
mockDataRepo.Setup(dr => dr.GetAll <Return>()).Returns(new[] { testReturn }.AsQueryable().BuildMock().Object);
var mockService = new Mock <SubmissionPresenter>(
mockDataRepo.Object,
mockScopeBL.Object,
mockFileRepo.Object,
_mockDraftFileBL.Object,
null);
mockService.CallBase = true;
mockService.Setup(s => s.IsValidSnapshotYear(It.IsIn(testYear))).Returns(true);
// Test
SubmissionPresenter testService = mockService.Object;
ReturnViewModel actualModel = await testService.GetReturnViewModelAsync(testOrganisationId, testYear, testUserId);
// Assert
Expect(actualModel != null);
Expect(actualModel.OrganisationId == testOrganisationId);
Expect(actualModel.AccountingDate.Year == testYear);
var testOrgSizeRange = actualModel.OrganisationSize.GetAttribute <RangeAttribute>();
Expect(testReturn.CompanyLinkToGPGInfo == actualModel.CompanyLinkToGPGInfo);
Expect(testReturn.DiffMeanBonusPercent == actualModel.DiffMeanBonusPercent.Value);
Expect(testReturn.DiffMeanHourlyPayPercent == actualModel.DiffMeanHourlyPayPercent.Value);
Expect(testReturn.DiffMedianBonusPercent == actualModel.DiffMedianBonusPercent.Value);
Expect(testReturn.DiffMedianHourlyPercent == actualModel.DiffMedianHourlyPercent.Value);
Expect(testReturn.FemaleLowerPayBand == actualModel.FemaleLowerPayBand.Value);
Expect(testReturn.FemaleMedianBonusPayPercent == actualModel.FemaleMedianBonusPayPercent.Value);
Expect(testReturn.FemaleMiddlePayBand == actualModel.FemaleMiddlePayBand.Value);
Expect(testReturn.FemaleUpperPayBand == actualModel.FemaleUpperPayBand.Value);
Expect(testReturn.FemaleUpperQuartilePayBand == actualModel.FemaleUpperQuartilePayBand.Value);
Expect(testReturn.FirstName == actualModel.FirstName);
Expect(testReturn.LastName == actualModel.LastName);
Expect(testReturn.JobTitle == actualModel.JobTitle);
Expect(testReturn.MaleLowerPayBand == actualModel.MaleLowerPayBand.Value);
Expect(testReturn.MaleMedianBonusPayPercent == actualModel.MaleMedianBonusPayPercent.Value);
Expect(testReturn.MaleUpperQuartilePayBand == actualModel.MaleUpperQuartilePayBand.Value);
Expect(testReturn.MaleMiddlePayBand == actualModel.MaleMiddlePayBand.Value);
Expect(testReturn.MaleUpperPayBand == actualModel.MaleUpperPayBand.Value);
Expect(testReturn.MinEmployees == (int)testOrgSizeRange.Minimum);
Expect(testReturn.MaxEmployees == (int)testOrgSizeRange.Maximum);
}
public async Task SubmitController_DraftComplete_POST_MaleBonusIsZero_ShowsErrors()
{
// Arrange
var user = new User {
UserId = 1, EmailAddress = "*****@*****.**", EmailVerifiedDate = VirtualDateTime.Now
};
var organisation = new Core.Entities.Organisation {
OrganisationId = 1, SectorType = SectorTypes.Public
};
var userOrganisation = new UserOrganisation {
OrganisationId = organisation.OrganisationId,
Organisation = organisation,
UserId = 1,
PINConfirmedDate = VirtualDateTime.Now,
PIN = "1"
};
//set mock routeData
var routeData = new RouteData();
routeData.Values.Add("action", "EnterCalculations");
routeData.Values.Add("controller", "submit");
DateTime PrivateAccountingDate = SectorTypeHelper.SnapshotDateHelper.PrivateAccountingDate;
var returnViewModel = new ReturnViewModel {
AccountingDate = PrivateAccountingDate,
MaleMedianBonusPayPercent = 0,
FemaleMedianBonusPayPercent = 50,
DiffMeanBonusPercent = -50,
DiffMedianBonusPercent = -50,
DiffMedianHourlyPercent = 50,
DiffMeanHourlyPayPercent = 50,
FemaleLowerPayBand = 50,
FemaleMiddlePayBand = 50,
FemaleUpperPayBand = 50,
FemaleUpperQuartilePayBand = 50,
MaleLowerPayBand = 50,
MaleMiddlePayBand = 50,
MaleUpperPayBand = 50,
MaleUpperQuartilePayBand = 50,
SectorType = SectorTypes.Private
};
var controller = UiTestHelper.GetController <SubmissionController>(1, routeData, user, organisation, userOrganisation);
controller.Bind(returnViewModel);
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
var testDraftFileBL = new DraftFileBusinessLogic(null, new SystemFileRepository(new StorageOptions()));
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), testDraftFileBL);
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
returnViewModel.ReportInfo.Draft = await testPresenter.GetDraftFileAsync(
organisation.OrganisationId,
organisation.SectorType.GetAccountingStartDate().Year,
user.UserId);
// Act
controller.StashModel(returnViewModel);
controller.ReportingOrganisationId = 1;
var result = await controller.SaveDraftAsync(returnViewModel) as ViewResult;
// Assert
Assert.NotNull(result, "Expected ViewResult");
Assert.Null(result.ViewName, "Incorrect view returned");
Assert.NotNull(result.Model as ReturnViewModel, "Expected ReturnViewModel");
Assert.AreEqual(
"Do not enter a bonus difference if 0% of your male employees received a bonus",
result.ViewData.ModelState["DiffMedianBonusPercent"].Errors[0].ErrorMessage);
Assert.AreEqual(
"Do not enter a bonus difference if 0% of your male employees received a bonus",
result.ViewData.ModelState["DiffMeanBonusPercent"].Errors[0].ErrorMessage);
}
public void CreateDraftSubmissionFromViewModel_Converts_View_Model_to_Return()
{
Organisation mockedOrganisation = OrganisationHelper.GetPublicOrganisation();
var testModel = new ReturnViewModel {
AccountingDate = new DateTime(1999, 4, 5),
CompanyLinkToGPGInfo = "https://CompanyLinkToGPGInfo",
DiffMeanBonusPercent = 100,
DiffMeanHourlyPayPercent = 99,
DiffMedianBonusPercent = 98,
DiffMedianHourlyPercent = 97,
FemaleLowerPayBand = 96,
FemaleMedianBonusPayPercent = 95,
FemaleMiddlePayBand = 94,
FemaleUpperPayBand = 93,
FemaleUpperQuartilePayBand = 92,
FirstName = "Test",
LastName = "User",
JobTitle = "QA",
MaleLowerPayBand = 91,
MaleMedianBonusPayPercent = 90,
MaleUpperQuartilePayBand = 89,
MaleMiddlePayBand = 88,
MaleUpperPayBand = 87,
OrganisationId = mockedOrganisation.OrganisationId,
OrganisationSize = OrganisationSizes.Employees250To499,
LateReason = "A LateReason"
};
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
// Mocks
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
mockDataRepo.Setup(x => x.Get <Organisation>(It.IsAny <long>())).Returns(mockedOrganisation);
// Assert
Return testReturn = testPresenter.CreateDraftSubmissionFromViewModel(testModel);
var testOrgSizeRange = testModel.OrganisationSize.GetAttribute <RangeAttribute>();
Expect(testReturn.AccountingDate == testModel.AccountingDate);
Expect(testReturn.CompanyLinkToGPGInfo == testModel.CompanyLinkToGPGInfo);
Expect(testReturn.DiffMeanBonusPercent == testModel.DiffMeanBonusPercent.Value);
Expect(testReturn.DiffMeanHourlyPayPercent == testModel.DiffMeanHourlyPayPercent.Value);
Expect(testReturn.DiffMedianBonusPercent == testModel.DiffMedianBonusPercent.Value);
Expect(testReturn.DiffMedianHourlyPercent == testModel.DiffMedianHourlyPercent.Value);
Expect(testReturn.FemaleLowerPayBand == testModel.FemaleLowerPayBand.Value);
Expect(testReturn.FemaleMedianBonusPayPercent == testModel.FemaleMedianBonusPayPercent.Value);
Expect(testReturn.FemaleMiddlePayBand == testModel.FemaleMiddlePayBand.Value);
Expect(testReturn.FemaleUpperPayBand == testModel.FemaleUpperPayBand.Value);
Expect(testReturn.FemaleUpperQuartilePayBand == testModel.FemaleUpperQuartilePayBand.Value);
Expect(testReturn.FirstName == testModel.FirstName);
Expect(testReturn.LastName == testModel.LastName);
Expect(testReturn.JobTitle == testModel.JobTitle);
Expect(testReturn.MaleLowerPayBand == testModel.MaleLowerPayBand.Value);
Expect(testReturn.MaleMedianBonusPayPercent == testModel.MaleMedianBonusPayPercent.Value);
Expect(testReturn.MaleUpperQuartilePayBand == testModel.MaleUpperQuartilePayBand.Value);
Expect(testReturn.MaleMiddlePayBand == testModel.MaleMiddlePayBand.Value);
Expect(testReturn.MaleUpperPayBand == testModel.MaleUpperPayBand.Value);
Expect(testReturn.Status == ReturnStatuses.Draft);
Expect(testReturn.OrganisationId == testModel.OrganisationId);
Expect(testReturn.MinEmployees == (int)testOrgSizeRange.Minimum);
Expect(testReturn.MaxEmployees == (int)testOrgSizeRange.Maximum);
Expect(testReturn.LateReason == testModel.LateReason);
}
public void GetSubmissionChangeSummary_Detects_when_the_figures_have_changed()
{
var testOldReturn = new Return {
DiffMeanBonusPercent = 100,
DiffMeanHourlyPayPercent = 99,
DiffMedianBonusPercent = 98,
DiffMedianHourlyPercent = 97,
FemaleLowerPayBand = 96,
FemaleMedianBonusPayPercent = 95,
FemaleMiddlePayBand = 94,
FemaleUpperPayBand = 93,
FemaleUpperQuartilePayBand = 92,
MaleLowerPayBand = 91,
MaleMedianBonusPayPercent = 90,
MaleUpperQuartilePayBand = 89,
MaleMiddlePayBand = 88,
MaleUpperPayBand = 87,
Organisation = new Organisation {
SectorType = SectorTypes.Private
}
};
string[] figureProps =
{
nameof(testOldReturn.DiffMeanBonusPercent),
nameof(testOldReturn.DiffMeanHourlyPayPercent),
nameof(testOldReturn.DiffMedianBonusPercent),
nameof(testOldReturn.DiffMedianHourlyPercent),
nameof(testOldReturn.FemaleLowerPayBand),
nameof(testOldReturn.FemaleMedianBonusPayPercent),
nameof(testOldReturn.FemaleMiddlePayBand),
nameof(testOldReturn.FemaleUpperPayBand),
nameof(testOldReturn.FemaleUpperQuartilePayBand),
nameof(testOldReturn.MaleLowerPayBand),
nameof(testOldReturn.MaleMedianBonusPayPercent),
nameof(testOldReturn.MaleUpperQuartilePayBand),
nameof(testOldReturn.MaleMiddlePayBand),
nameof(testOldReturn.MaleUpperPayBand)
};
decimal changeValue = 0;
var sharedBusinessLogic = UiTestHelper.DIContainer.Resolve <ISharedBusinessLogic>();
// Mocks
var testSubmissionService = new SubmissionService(sharedBusinessLogic, Mock.Of <ISubmissionBusinessLogic>(), Mock.Of <IScopeBusinessLogic>(), Mock.Of <IDraftFileBusinessLogic>());
var testPresenter = new SubmissionPresenter(testSubmissionService, ConfigHelpers.SubmissionOptions, null);
// Assert all figures
foreach (string figurePropName in figureProps)
{
// Restore the original
var testNewReturn = (Return)testOldReturn.CopyProperties(new Return());
// Make the change
testNewReturn.SetProperty(figurePropName, changeValue);
// Assert
SubmissionChangeSummary testChangeSummary = testPresenter.GetSubmissionChangeSummary(testNewReturn, testOldReturn);
string failMessage = $"Assert: Failed to detect {figurePropName} had changed";
Expect(testChangeSummary.HasChanged, failMessage);
Expect(testChangeSummary.FiguresChanged, failMessage);
Expect(testChangeSummary.OrganisationSizeChanged == false, failMessage);
Expect(testChangeSummary.PersonResonsibleChanged == false, failMessage);
Expect(testChangeSummary.WebsiteUrlChanged == false, failMessage);
}
}
