AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_The_New_Name_Exists_In_Another_Org_In_Database_Async()
{
// Arrange
Core.Entities.Organisation organisationToChangeName = OrganisationHelper.GetMockedOrganisation("EmployerReference565658");
organisationToChangeName.OrganisationName = "Old name";
Core.Entities.Organisation organisationWithSameNameInDb = OrganisationHelper.GetMockedOrganisation("EmployerReference55441122");
organisationWithSameNameInDb.OrganisationName = "Another org with this name limited";
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisationToChangeName, organisationWithSameNameInDb }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand,
Parameters =
$"{organisationToChangeName.EmployerReference.ToLower()}=Another org with this name limited" // This name already exists in another org in DB
};
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual(
"SUCCESSFULLY TESTED 'Add organisations latest name': 0 of 1",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"<span style=\"color:Red\">1: ERROR: 'EMPLOYERREFERENCE565658' Another organisation exists with this company name</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Add organisations latest name", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual(
"employerreference565658=Another org with this name limited",
actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
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 IActionResult Revalidate(RevalidateModel model)
{
var user = UserHelper.GetUser(model.id);
// Uses the hasher to compare the user's password and the
// password that they just entered.
if (Hasher.ValidatePassword(model.Password, user.Password))
{
// Let them update their details if they got it right.
UpdateUser ret = new UpdateUser()
{
UserID = user.UserID,
Username = user.Username,
Firstname = user.First_Name,
Lastname = user.Last_Name
};
return(View("Update", ret));
}
// If the user got the password wrong
// they probably aren't the user
// so log them out.
UserHelper.LogOut(HttpContext.Session);
OrganisationHelper.LogOut(HttpContext.Session);
return(RedirectToAction("Index", "Home"));
}
public void Is_False_When_ModifiedDate_Is_Late_And_OutOfScope(SectorTypes sector, ScopeStatuses scopeStatus)
{
var totalYearOffsets = 4;
for (var yearOffset = 0; yearOffset < totalYearOffsets; yearOffset++)
{
// Arrange
int testYear = VirtualDateTime.Now.Year - yearOffset;
DateTime snapshotDate = sector.GetAccountingStartDate(testYear);
DateTime nextSnapshotDate = snapshotDate.AddYears(1);
DateTime modifiedDate = nextSnapshotDate.AddDays(2);
Organisation testOrganisation = sector == SectorTypes.Private
? OrganisationHelper.GetPrivateOrganisation()
: OrganisationHelper.GetPublicOrganisation();
OrganisationScope testScope = ScopeHelper.CreateScope(scopeStatus, snapshotDate);
Return testReturn = ReturnHelper.CreateLateReturn(testOrganisation, snapshotDate, modifiedDate, testScope);
// Act
bool actual = testReturn.IsLateSubmission;
// Assert
Assert.AreEqual(false, actual);
}
}
public async Task AdminController_ManualChanges_POST_Fix_Database_Error_Missing_Latest_Return_Works_When_Run_In_Test_Mode_Async()
{
// Arrange
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
#region Set up organisation missing the latest return link so it's picked up by the test
Core.Entities.Organisation organisation_MissingLatestReturn = OrganisationHelper.GetPrivateOrganisation("EmployerReference985");
UserOrganisation userOrganisation_MissingLatestReturn =
UserOrganisationHelper.LinkUserWithOrganisation(notAdminUser, organisation_MissingLatestReturn);
Return return_MissingLatestReturn = ReturnHelper.GetSubmittedReturnForOrganisationAndYear(
userOrganisation_MissingLatestReturn,
VirtualDateTime.Now.AddYears(-1).Year);
organisation_MissingLatestReturn.Returns.Add(return_MissingLatestReturn); // latest return indeed exists for this organisation
organisation_MissingLatestReturn.LatestRegistration = userOrganisation_MissingLatestReturn;
organisation_MissingLatestReturn.LatestReturn = null; // missing latest return -link-
#endregion
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisation_MissingLatestReturn }.AsQueryable());
var manualChangesViewModel = new ManualChangesViewModel {
Command = FixDatabaseErrorsCommand
};
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual("SUCCESSFULLY TESTED 'Fix database errors': 1 items", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"No organisations missing a latest registration\r\n001: Organisation 'EmployerReference985:Org123' missing a latest return will be fixed\r\nNo organisations missing a latest scope\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Fix database errors", actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
AdminController_ManualChanges_POST_Fix_Database_Error_Missing_Latest_Registration_Works_When_Run_In_Live_Mode_Async()
{
// Arrange
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
#region Set up organisation missing the latest registration link so it's picked up by the test
Core.Entities.Organisation organisationMissingLatestRegistration = OrganisationHelper.GetPrivateOrganisation("EmployerReference96585");
UserOrganisationHelper.LinkUserWithOrganisation(
notAdminUser,
organisationMissingLatestRegistration); // user registered link indeed exists for this organisation
organisationMissingLatestRegistration.LatestRegistration = null; // missing latest registration -link-
#endregion
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisationMissingLatestRegistration }.AsQueryable());
var manualChangesViewModel = new ManualChangesViewModel {
Command = FixDatabaseErrorsCommand
};
/* live */
manualChangesViewModel.LastTestedCommand = manualChangesViewModel.Command;
manualChangesViewModel.LastTestedInput = null;
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual("SUCCESSFULLY EXECUTED 'Fix database errors': 1 items", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"001: Organisation 'EmployerReference96585:Org123' missing a latest registration was successfully fixed\r\nNo organisations missing a latest return\r\nNo organisations missing a latest scope\r\n",
actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be tested=false as this case is running in LIVE mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public IActionResult Logout(string returnUrl)
{
UserHelper.LogOut(HttpContext.Session);
OrganisationHelper.LogOut(HttpContext.Session);
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
public void CompareController_DownloadCompareData_WithYear_SameSortAsync()
{
// Arrange
var routeData = new RouteData();
routeData.Values.Add("Action", nameof(CompareController.DownloadCompareData));
routeData.Values.Add("Controller", "Viewing");
var controller = UiTestHelper.GetController <CompareController>(0, routeData);
controller.CompareViewService.SortColumn = "OrganisationSize";
controller.CompareViewService.SortAscending = false;
var firstReportingYear = Global.FirstReportingYear;
var mockOrg = OrganisationHelper.GetOrganisationInScope("MockedOrg", firstReportingYear);
DateTime accountingDateTime = mockOrg.SectorType.GetAccountingStartDate(firstReportingYear);
//create the comparison data
var expectedModel = ViewingServiceHelper.GetCompareTestData(5).ToList();
//Setup the mocked business logic
var mockOrgBL = new Mock <IOrganisationBusinessLogic>();
mockOrgBL
.Setup(x => x.GetCompareData(It.IsAny <IEnumerable <string> >(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(expectedModel);
var expectedData = expectedModel.ToDataTable();
mockOrgBL
.Setup(x => x.GetCompareDatatable(It.IsAny <IEnumerable <CompareReportModel> >()))
.Returns(expectedData);
controller.OrganisationBusinessLogic = mockOrgBL.Object;
// Act
var result = controller.DownloadCompareData(firstReportingYear) as ContentResult;
// Assert
//Test the google analytics tracker was executed once on the controller
var filename = $"Compared GPG Data {ReportingYearsHelper.FormatYearAsReportingPeriod(firstReportingYear)}.csv";
controller.WebTracker.GetMockFromObject().Verify(mock => mock.TrackPageView(It.IsAny <Controller>(), filename, null), Times.Once());
Assert.NotNull(result);
Assert.AreEqual(result.ContentType, "text/csv");
Assert.AreEqual(controller.Response.Headers["Content-Disposition"], $"attachment; filename=\"{filename}\"");
Assert.AreEqual(controller.CompareViewService.SortColumn, "OrganisationSize");
Assert.AreEqual(controller.CompareViewService.SortAscending, false);
Assert.NotNull(result.Content);
Assert.AreEqual(result.Content, expectedData.ToCSV());
}
public async Task AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_The_New_Name_Was_Already_Set_Async()
{
// Arrange
Core.Entities.Organisation organisationToChangeName = OrganisationHelper.GetPrivateOrganisation("EmployerReference373737");
organisationToChangeName.OrganisationName = "New name limited";
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisationToChangeName }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand,
Parameters =
$"{organisationToChangeName.EmployerReference.ToLower()}={organisationToChangeName.OrganisationName}" // We're calling change name, but in reality we're setting the same one
};
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual(
"SUCCESSFULLY TESTED 'Add organisations latest name': 1 of 1",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"<span style=\"color:Orange\">1: WARNING: 'EMPLOYERREFERENCE373737' 'New name limited' already set to 'New name limited'</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Add organisations latest name", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("employerreference373737=New name limited", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public async Task AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Works_When_Run_In_Live_Mode_Async()
{
// Arrange
Core.Entities.Organisation organisationToChangeName = OrganisationHelper.GetPrivateOrganisation("EmployerReference3335");
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisationToChangeName }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand,
Parameters = $"{organisationToChangeName.EmployerReference.ToLower()}=New name ltd"
};
#endregion
/* live */
manualChangesViewModel.LastTestedCommand = manualChangesViewModel.Command;
manualChangesViewModel.LastTestedInput = manualChangesViewModel.Parameters;
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual(
"SUCCESSFULLY EXECUTED 'Add organisations latest name': 1 of 1",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("1: EMPLOYERREFERENCE3335: 'Org123' set to 'New name ltd'\r\n", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be tested=false as this case is running in LIVE mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
/// <inheritdoc />
public Task CreateOrganisationAsync(
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
return(OrganisationHelper.CreateOrganisationAsync(
logger: this.logger,
data: this.data,
who: who,
auditEvent: auditEvent,
organisation: organisation));
}
public void BeforeEach()
{
_testOrganisation = OrganisationHelper.GetPublicOrganisation();
var mocked2017Return = ReturnHelper.CreateTestReturn(_testOrganisation);
OrganisationHelper.LinkOrganisationAndReturn(_testOrganisation, mocked2017Return);
var mocked2018Return = ReturnHelper.CreateTestReturn(_testOrganisation, 2018);
OrganisationHelper.LinkOrganisationAndReturn(_testOrganisation, mocked2018Return);
}
public void WhenOnManageOrganisationPage_IfHasSubmittedAfterTheDeadline_ThenReportStatusSubmittedLate()
{
Return ret = ReturnHelper.CreateLateReturn(PastReportingYear, organisationInScopeForPastYear, 3);
OrganisationHelper.LinkOrganisationAndReturn(organisationInScopeForPastYear, ret);
var viewModel = new ManageOrganisationDetailsForYearViewModel(organisationInScopeForPastYear, PastReportingYear, null);
string reportTagText = viewModel.GetReportTagText();
Assert.AreEqual("Report submitted late", reportTagText);
}
public void CompareController_CompareEmployers_WithYear_SameSortAsync()
{
// Arrange
var routeData = new RouteData();
routeData.Values.Add("Action", nameof(CompareController.CompareEmployers));
routeData.Values.Add("Controller", "Viewing");
var controller = UiTestHelper.GetController <CompareController>(0, routeData);
//Setup the mock url helper
var testUri = new Uri("https://localhost/Viewing/compare-employers");
controller.AddMockUriHelper(testUri.ToString(), "CompareEmployers");
controller.CompareViewService.SortColumn = "OrganisationSize";
controller.CompareViewService.SortAscending = false;
var firstReportingYear = Global.FirstReportingYear;
var mockOrg = OrganisationHelper.GetOrganisationInScope("MockedOrg", firstReportingYear);
DateTime accountingDateTime = mockOrg.SectorType.GetAccountingStartDate(firstReportingYear);
//create the comparison data
var expectedModel = ViewingServiceHelper.GetCompareTestData(5).ToList();
//Setup the mocked business logic
var mockOrgBL = new Mock <IOrganisationBusinessLogic>();
mockOrgBL
.Setup(x => x.GetCompareData(It.IsAny <IEnumerable <string> >(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(expectedModel);
controller.OrganisationBusinessLogic = mockOrgBL.Object;
// Act
var result = controller.CompareEmployers(firstReportingYear) as ViewResult;
// Assert
Assert.NotNull(result);
Assert.AreEqual(result.ViewName, "CompareEmployers");
Assert.AreEqual(controller.ViewBag.ReturnUrl, testUri.PathAndQuery);
Assert.AreEqual(controller.CompareViewService.SortColumn, "OrganisationSize");
Assert.AreEqual(controller.CompareViewService.SortAscending, false);
var actualModel = result.Model as CompareViewModel;
Assert.NotNull(actualModel);
Assert.NotNull(actualModel.CompareReports);
Assert.IsTrue(actualModel.CompareReports.All(obj => actualModel.Year == firstReportingYear));
actualModel.CompareReports.Compare(expectedModel);
}
AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_Employer_Reference_Is_Duplicated_Async()
{
// Arrange
Core.Entities.Organisation organisationToChangeName = OrganisationHelper.GetPrivateOrganisation("EmployerReference0111");
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { organisationToChangeName }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand,
Parameters = $"{organisationToChangeName.EmployerReference.ToLower()}=New name ltd"
+ Environment.NewLine
+ $"{organisationToChangeName.EmployerReference.ToLower()}=New name ltd"
};
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.AreEqual("SUCCESSFULLY TESTED 'Add organisations latest name': 1 of 2", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"1: EMPLOYERREFERENCE0111: 'Org123' set to 'New name ltd'\r\n<span style=\"color:Red\">2: ERROR: 'EMPLOYERREFERENCE0111' duplicate organisation</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Add organisations latest name", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual(
"employerreference0111=New name ltd;employerreference0111=New name ltd",
actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
}
public async Task AdminController_ManualChanges_POST_Delete_Submissions_Works_When_Run_In_Test_Mode_Async()
{
// Arrange
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
Core.Entities.Organisation publicOrganisationWithSubmissionsToBeDeleted =
OrganisationHelper.GetPublicOrganisation("EmployerReference05");
Return mockedReturn = ReturnHelper.CreateTestReturn(
publicOrganisationWithSubmissionsToBeDeleted,
VirtualDateTime.Now.AddYears(-1).Year);
var testController = UiTestHelper.GetController <AdminController>(
databaseAdminUser.UserId,
null,
databaseAdminUser,
publicOrganisationWithSubmissionsToBeDeleted,
mockedReturn);
var manualChangesViewModelMock = Mock.Of <ManualChangesViewModel>();
manualChangesViewModelMock.Command = DeleteSubmissionsCommand;
manualChangesViewModelMock.Parameters =
$"{publicOrganisationWithSubmissionsToBeDeleted.EmployerReference}={mockedReturn.AccountingDate.Year}";
// Act
IActionResult actualManualChangesResult = await testController.ManualChanges(manualChangesViewModelMock);
// Assert
Assert.NotNull(actualManualChangesResult, "Expected a Result");
var manualChangesViewResult = actualManualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual("SUCCESSFULLY TESTED 'Delete submissions': 1 of 1", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
$"1: EMPLOYERREFERENCE05: Org123 Year='{VirtualDateTime.Now.AddYears(-1).Year}' Status='Submitted' set to 'Deleted'\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Delete submissions", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual(
$"EmployerReference05={mockedReturn.AccountingDate.Year}",
actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public void WhenOnManageOrganisationPage_IfHasSubmittedBeforeTheDeadline_ThenReportStatusSubmitted()
{
UserOrganisation userOrg = UserOrganisationHelper.LinkUserWithOrganisation(user, organisationInScope);
Return ret = ReturnHelper.GetSubmittedReturnForOrganisationAndYear(userOrg, ReportingYear);
OrganisationHelper.LinkOrganisationAndReturn(organisationInScope, ret);
var viewModel = new ManageOrganisationDetailsForYearViewModel(organisationInScope, ReportingYear, null);
string reportTagText = viewModel.GetReportTagText();
Assert.AreEqual("Report submitted", reportTagText);
}
public async Task AdminController_ManualChanges_POST_Set_Organisation_DUNS_Number_Works_When_Run_In_Test_Mode_Async()
{
Core.Entities.Organisation orgWhoseDUNSNumberWillBeSet = OrganisationHelper.GetPrivateOrganisation("EmployerReference012");
#region setting up database and controller
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(databaseAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(databaseAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { orgWhoseDUNSNumberWillBeSet }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = SetOrganisationDUNSNumberCommand, Parameters = $"{orgWhoseDUNSNumberWillBeSet.EmployerReference}=123456789"
};
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual(
"SUCCESSFULLY TESTED 'Set organisation DUNS number': 1 of 1",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"1: EMPLOYERREFERENCE012: Org123 DUNS Number='123456789' set to '123456789'\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Set organisation DUNS number", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("EmployerReference012=123456789", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public async Task AdminController_ManualChanges_POST_Convert_Private_To_Public_Works_When_Run_In_Test_Mode_Async()
{
// Arrange
Core.Entities.Organisation privateOrganisationToBeChangedToPublic = OrganisationHelper.GetPrivateOrganisation("EmployerReference04");
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <Core.Entities.Organisation>())
.Returns(new[] { privateOrganisationToBeChangedToPublic }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = ConvertPrivateToPublicCommand, Parameters = privateOrganisationToBeChangedToPublic.EmployerReference
};
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModel);
// Assert
Assert.NotNull(manualChangesResult, "Expected a Result");
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual("SUCCESSFULLY TESTED 'Convert private to public': 1 of 1", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"1: EMPLOYERREFERENCE04: Org123 sector Private set to 'Public'\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual(ConvertPrivateToPublicCommand, actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("EmployerReference04", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public async Task AdminController_ManualChanges_POST_Delete_Submissions_Fails_When_No_Parameters_Are_Provided_Async(
string nullOrEmptyParameter)
{
// Arrange
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
Core.Entities.Organisation publicOrganisationWithSubmissionsToBeDeleted =
OrganisationHelper.GetPublicOrganisation("EmployerReference05");
Return mockedReturn = ReturnHelper.CreateTestReturn(
publicOrganisationWithSubmissionsToBeDeleted,
VirtualDateTime.Now.AddYears(-1).Year);
var testController = UiTestHelper.GetController <AdminController>(
databaseAdminUser.UserId,
null,
databaseAdminUser,
publicOrganisationWithSubmissionsToBeDeleted,
mockedReturn);
var manualChangesViewModelMock = Mock.Of <ManualChangesViewModel>();
manualChangesViewModelMock.Command = DeleteSubmissionsCommand;
manualChangesViewModelMock.Parameters = nullOrEmptyParameter;
// Act
IActionResult actualManualChangesResult = await testController.ManualChanges(manualChangesViewModelMock);
// Assert
Assert.NotNull(actualManualChangesResult, "Expected a Result");
var manualChangesViewResult = actualManualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
ModelStateEntry modelState = testController.ModelState[""];
ModelError reportedError = modelState.Errors.First();
Assert.AreEqual("ERROR: You must supply 1 or more input parameters", reportedError.ErrorMessage);
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.False(actualManualChangesViewModel.Tested, "Must be false as this case has failed");
}
public async Task AdminController_ManualChanges_POST_Delete_Submissions_Fails_When_Year_Parameter_Is_Not_Valid_Async()
{
// Arrange
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
Core.Entities.Organisation publicOrganisationWithSubmissions =
OrganisationHelper.GetPublicOrganisation("EmployerReference656262");
Return mockedReturn = ReturnHelper.CreateTestReturn(publicOrganisationWithSubmissions, VirtualDateTime.Now.AddYears(-1).Year);
var testController = UiTestHelper.GetController <AdminController>(
databaseAdminUser.UserId,
null,
databaseAdminUser,
publicOrganisationWithSubmissions,
mockedReturn);
var manualChangesViewModelMock = Mock.Of <ManualChangesViewModel>();
manualChangesViewModelMock.Command = DeleteSubmissionsCommand;
manualChangesViewModelMock.Parameters = "EmployerReference656262=Invalid_Year_Parameter";
// Act
IActionResult actualManualChangesResult = await testController.ManualChanges(manualChangesViewModelMock);
// Assert
Assert.NotNull(actualManualChangesResult, "Expected a Result");
var manualChangesViewResult = actualManualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.Multiple(
() => {
Assert.AreEqual("SUCCESSFULLY TESTED 'Delete submissions': 0 of 1", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"<span style=\"color:Red\">1: ERROR: 'EMPLOYERREFERENCE656262' invalid year 'Invalid_Year_Parameter'</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Delete submissions", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("EmployerReference656262=Invalid_Year_Parameter", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public IActionResult Lost(UpdateUser model)
{
// Gets the user from the database
var user = UserHelper.GetUser(model.Username, OrganisationHelper.GetOrganisationID(HttpContext.Session));
// Get the userID of the person making this request
var userid = UserHelper.GetUserId(HttpContext.Session);
// Check he has permission to be this
if (user.OrganisationID == UserHelper.GetUser(userid).OrganisationID&& UserHelper.UserInRole(userid, UserHelper.ROLE_ADMIN))
{
//Update the password and pass it to the database.
user.Password = Hasher.Hash(model.Password);
DatabaseConnector.Update(model.Password);
DatabaseConnector.PushChanges();
}
return(Unauthorized());
}
public async Task AdminController_ManualChanges_POST_Delete_Submissions_Fails_When_Return_Is_Not_On_The_Database_Async()
{
// Arrange
int yearToTest = VirtualDateTime.Now.AddYears(-1).Year;
User databaseAdminUser = UserHelper.GetDatabaseAdmin();
Core.Entities.Organisation publicOrganisationWithSubmissionsToBeDeleted =
OrganisationHelper.GetPublicOrganisation("EmployerReference99778");
var testController = UiTestHelper.GetController <AdminController>(
databaseAdminUser.UserId,
null,
databaseAdminUser,
publicOrganisationWithSubmissionsToBeDeleted);
var manualChangesViewModelMock = Mock.Of <ManualChangesViewModel>();
manualChangesViewModelMock.Command = DeleteSubmissionsCommand;
manualChangesViewModelMock.Parameters = $"{publicOrganisationWithSubmissionsToBeDeleted.EmployerReference}={yearToTest}";
// Act
IActionResult actualManualChangesResult = await testController.ManualChanges(manualChangesViewModelMock);
// Assert
Assert.NotNull(actualManualChangesResult, "Expected a Result");
var manualChangesViewResult = actualManualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
Assert.AreEqual("SUCCESSFULLY TESTED 'Delete submissions': 0 of 1", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
$"<span style=\"color:Orange\">1: WARNING: 'EMPLOYERREFERENCE99778' Cannot find submitted data for year {yearToTest}</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Delete submissions", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual($"EmployerReference99778={yearToTest}", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode");
Assert.IsNull(actualManualChangesViewModel.Comment);
}
public async Task ScopePresentation_CreateOrganisationViewModel_When_Data_Is_Valid_It_SucceedsAsync()
{
// Arrange
var employerRef = "6MQP1ETH";
User mockUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress();
Organisation mockOrg = OrganisationHelper.GetPrivateOrganisation(employerRef);
mockOrg.SetSecurityCode(VirtualDateTime.Now.AddDays(1));
UserOrganisation mockUserOrg = UserOrganisationHelper.LinkUserWithOrganisation(mockUser, mockOrg);
var dataRepo = new Mock <IDataRepository>();
dataRepo.SetupGetAll(mockOrg);
var organisationBusinessLogic = new OrganisationBusinessLogic(
testCommonBL,
dataRepo.Object,
new Mock <ISubmissionBusinessLogic>().Object,
new Mock <IScopeBusinessLogic>().Object,
new Mock <IEncryptionHandler>().Object,
new Mock <ISecurityCodeBusinessLogic>().Object,
new Mock <IDnBOrgsRepository>().Object,
new Mock <IObfuscator>().Object);
var scopePresenter = new ScopePresenter(
mockScopeBL.Object,
dataRepo.Object,
organisationBusinessLogic,
testCommonBL);
var testModel = new EnterCodesViewModel {
EmployerReference = mockOrg.EmployerReference, SecurityToken = mockOrg.SecurityCode
};
// Act
OrganisationViewModel actual = await scopePresenter.CreateOrganisationViewModelAsync(testModel, mockUser);
// Assert
Assert.NotNull(actual, "Expected an organisation view model");
Assert.AreEqual(employerRef, actual.Employers.Results[0].EmployerReference);
Assert.False(actual.IsSecurityCodeExpired, "the security code was set to expire tomorrow");
}
public void OrganisationController_Manageorganisations_GET_When_Creates_New_Model()
{
// ARRANGE
User mockUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress();
mockUser.UserSettings = new[] { new UserSetting(UserSettingKeys.AcceptedPrivacyStatement, VirtualDateTime.Now.ToString()) };
Core.Entities.Organisation mockOrg = OrganisationHelper.GetPublicOrganisation();
Core.Entities.Organisation mockOrg2 = OrganisationHelper.GetPublicOrganisation();
Core.Entities.Organisation mockOrg3 = OrganisationHelper.GetPublicOrganisation();
UserOrganisation mockUserOrg1 = UserOrganisationHelper.LinkUserWithOrganisation(mockUser, mockOrg);
UserOrganisation mockUserOrg2 = UserOrganisationHelper.LinkUserWithOrganisation(mockUser, mockOrg2);
UserOrganisation mockUserOrg3 = UserOrganisationHelper.LinkUserWithOrganisation(mockUser, mockOrg3);
// route data
var routeData = new RouteData();
routeData.Values.Add("action", "ManageOrganisations");
routeData.Values.Add("Controller", "Registrations");
var controller = UiTestHelper.GetController <ManageOrganisationsController>(
-1,
routeData,
mockUser,
mockOrg,
mockOrg2,
mockOrg3,
mockUserOrg1,
mockUserOrg2,
mockUserOrg3);
// Acts
var result = controller.Home() as ViewResult;
object actualUserOrganisationViewModel = result.Model;
// Assert
Assert.NotNull(result);
Assert.NotNull(actualUserOrganisationViewModel);
Assert.AreEqual(result.ViewName, "ManageOrganisations");
}
public IActionResult Update(UpdateUser model)
{
// Check if the user has enetered correct details
if (!ModelState.IsValid)
{
return(View(model));
}
// Check that the user hasn't passed a XSS attack
// or tried to update form data.
if (UserHelper.GetUserId(HttpContext.Session) == model.UserID)
{
var user = UserHelper.GetUser(model.UserID);
// Checks if the user has updated their password
if (!string.IsNullOrWhiteSpace(model.Password) && !string.IsNullOrWhiteSpace(model.VerifyPassword))
{
// If the password and verification are not the same
// return the model with an error.
if (model.Password != model.VerifyPassword)
{
return(View(model));
}
// if they are update the users password.
user.Password = Hasher.Hash(model.Password);
}
// Update their names to things that have changed.
user.First_Name = model.Firstname;
user.Last_Name = model.Lastname;
user.Username = model.Username;
// Update the database
DatabaseConnector.Update(user);
return(View("Index", user));
}
// If their is an XSS attempt log the user out.
UserHelper.LogOut(HttpContext.Session);
OrganisationHelper.LogOut(HttpContext.Session);
return(RedirectToAction("Index", "Home"));
}
public void CompareController_AddEmployerJS_NoEmployers_ReturnsNotFound()
{
// Arrange
var org = OrganisationHelper.GetMockedOrganisation("abc123");
var controller = UiTestHelper.GetController <CompareController>();
string returnUrl = @"\viewing\search-results";
controller.SearchViewService.LastSearchResults = new SearchViewModel()
{
Employers = null
};
var mockedObfuscatorToSetup = AutoFacExtensions.ResolveAsMock <IObfuscator>();
mockedObfuscatorToSetup
.Setup(x => x.DeObfuscate(org.EmployerReference))
.Returns((int)org.OrganisationId);
// Act
Assert.Throws <HttpException>(() => controller.AddEmployerJs(org.EmployerReference, returnUrl), "Expected IdentityNotMappedException");
}
public void SubmissionBusinessLogic_IsInScopeForThisReportYear_ReturnsTrueFalseCorrectly(int returnId,
int maxEmployees,
ScopeStatuses scope,
bool expected)
{
// Arrange
var submissionBusinessLogic = new SubmissionBusinessLogic(Mock.Of <IDataRepository>());
Organisation organisation = OrganisationHelper.GetOrganisationInAGivenScope(scope, "employerRefInScope", 2017);
Return returnToConvert = ReturnHelper.CreateTestReturn(organisation);
returnToConvert.ReturnId = returnId;
returnToConvert.MaxEmployees = maxEmployees;
// Act
ReturnViewModel actualConvertedReturnViewModel =
submissionBusinessLogic.ConvertSubmissionReportToReturnViewModel(returnToConvert);
// Assert
Assert.AreEqual(expected, actualConvertedReturnViewModel.IsInScopeForThisReportYear);
}
public void Is_True_When_ModifiedDate_Is_Late_And_InScope(SectorTypes sector, ScopeStatuses scopeStatus)
{
// Arrange
int testYear = GetRandomReportingYear(ignoreYearsExcludedFromLateFlagEnforcement: true);
DateTime snapshotDate = sector.GetAccountingStartDate(testYear);
DateTime modifiedDate = ReportingYearsHelper.GetDeadlineForAccountingDate(snapshotDate).AddDays(2);
Organisation testOrganisation = sector == SectorTypes.Private
? OrganisationHelper.GetPrivateOrganisation()
: OrganisationHelper.GetPublicOrganisation();
OrganisationScope testScope = ScopeHelper.CreateScope(scopeStatus, snapshotDate);
Return testReturn = ReturnHelper.CreateLateReturn(testOrganisation, snapshotDate, modifiedDate, testScope);
// Act
bool actual = testReturn.IsLateSubmission;
// Assert
Assert.AreEqual(true, actual);
}
public static object[] CreateRegistrationsInScope()
{
List <User> users = UserHelpers.CreateUsers();
var organisations = new List <Organisation> {
OrganisationHelper.GetOrganisationInScope(),
OrganisationHelper.GetOrganisationInScope(),
OrganisationHelper.GetOrganisationInScope()
};
var registrations = new List <UserOrganisation> {
LinkUserWithOrganisation(users.Where(u => u.UserId == 23322).FirstOrDefault(), organisations[0]),
LinkUserWithOrganisation(users.Where(u => u.UserId == 21555).FirstOrDefault(), organisations[0]),
LinkUserWithOrganisation(users.Where(u => u.UserId == 23322).FirstOrDefault(), organisations[1]),
LinkUserWithOrganisation(users.Where(u => u.UserId == 24572).FirstOrDefault(), organisations[2])
};
return(new List <object> {
users, organisations, registrations
}.ToArray());
}
