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 void DeclareScope_GET_When_PreviousOutOfScope_Then_Return_BadRequest() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "DeclareScope"); mockRouteData.Values.Add("Controller", "Organisation"); var testUserId = 2; var testOrgId = 123; DateTime lastSnapshotDate = SectorTypes.Private.GetAccountingStartDate().AddYears(-1); var mockLastScope = new OrganisationScope { OrganisationId = testOrgId, Status = ScopeRowStatuses.Active, ScopeStatus = ScopeStatuses.OutOfScope, SnapshotDate = lastSnapshotDate }; var controller = UiTestHelper.GetController <OrganisationController>( testUserId, mockRouteData, MockUsers, MockOrganisations, MockUserOrganisations, mockLastScope); Mock <IScopeBusinessLogic> mockScopeBL = AutoFacExtensions.ResolveAsMock <IScopeBusinessLogic>(true); string encOrgId = Encryption.EncryptQuerystring(testOrgId.ToString()); // Act IActionResult result = controller.DeclareScope(encOrgId); var actionResult = result as HttpStatusViewResult; // Assert Assert.NotNull(actionResult, "httpStatusResult should not be null"); Assert.AreEqual(actionResult.StatusCode, (int)HttpStatusCode.BadRequest, "Expected the StatusCode to be a 'BadRequest'"); }
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 async Task RegistrationController_VerifyEmail_GET_RedirectResult_Success() //Registration complete { //ARRANGE: //1.Arrange the test setup variables var code = "abcdefg"; var user = new User { UserId = 1, EmailAddress = "*****@*****.**", EmailVerifiedDate = null, EmailVerifySendDate = VirtualDateTime.Now, EmailVerifyHash = Crypto.GetSHA512Checksum(code) }; //Set the user up as if finished step1 which is email known etc but not sent var routeData = new RouteData(); routeData.Values.Add("Action", "VerifyEmail"); routeData.Values.Add("Controller", "Registration"); var model = new VerifyViewModel(); //var controller = UiTestHelper.GetController<RegistrationController>(); var controller = UiTestHelper.GetController <RegistrationController>(1, routeData, user); controller.AddMockQuerystringValue("code", code); //ACT: //2.Run and get the result of the test var result = await controller.VerifyEmail(code) as RedirectToActionResult; //ASSERT: Assert.NotNull(result, "Expected RedirectToActionResult"); //Check the user is return the confirmation view Assert.That(result.ActionName == "EmailConfirmed", "Email is has not been confirmed!"); //Check the user verification is now marked as sent Assert.NotNull(user.EmailVerifiedDate, "Email is has not been confirmed!"); //Check a verification has been set against user Assert.That(user.Status == UserStatuses.Active, "Email is has not been confirmed!"); }
public void AddsSuccessAlertsToViewBag(string testSuccessAlert, string expectedAlertMessage) { // Arrange User verifiedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.AccountController>( verifiedUser.UserId, mockRouteData, verifiedUser); controller.TempData.Add(testSuccessAlert, ""); // Act var viewResult = controller.ManageAccount() as ViewResult; // Assert Assert.NotNull(viewResult); Assert.IsTrue(viewResult.ViewData.ContainsKey("ChangeSuccessMessage"), "Expected change success key to exist"); Assert.IsTrue(viewResult.ViewData.Values.Contains(expectedAlertMessage), "Expected change success value to match"); }
public void AdminController_ManualChanges_GET_When_User_Is_A_Database_Admin_Returns_Empty_ManualChangesViewModel() { // Arrange User databaseAdminUser = UserHelper.GetDatabaseAdmin(); var adminController = UiTestHelper.GetController <AdminController>(databaseAdminUser.UserId, null, databaseAdminUser); // Act IActionResult manualChangesResult = adminController.ManualChanges(); Assert.NotNull(manualChangesResult); // Assert var manualChangesViewResult = manualChangesResult as ViewResult; Assert.NotNull(manualChangesViewResult, "Expected ViewResult"); var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); }
public void CompareController_RemoveEmployerJS_NoReturnUrl_ReturnsBadRequest() { // Arrange var controller = UiTestHelper.GetController <CompareController>(); var organisationId = "123aa"; var employerIdentifier = "abc123"; string returnUrl = null; controller.CompareViewService.AddToBasket(organisationId); // Act var result = controller.RemoveEmployerJs(employerIdentifier, returnUrl) as HttpStatusViewResult; // Assert Assert.NotNull(result); Assert.AreEqual((int)HttpStatusCode.BadRequest, result.StatusCode); Assert.AreEqual($"Missing {nameof(returnUrl)}", result.StatusDescription); Assert.AreEqual(controller.CompareViewService.BasketItemCount, 1); Assert.IsTrue(controller.CompareViewService.ComparedEmployers.Value.Contains(organisationId)); }
public void AdminDatabaseIntegrityChecksController_PrivateEmployersReturnsWithoutResponsiblePerson_Success() { // Arrange var invalidReturn = new Return { AccountingDate = Global.PrivateAccountingDate, CompanyLinkToGPGInfo = null, DiffMeanBonusPercent = 50, DiffMeanHourlyPayPercent = 12, DiffMedianBonusPercent = 50, DiffMedianHourlyPercent = 50, FemaleLowerPayBand = 50, FemaleMedianBonusPayPercent = 50, FemaleMiddlePayBand = 50, FemaleUpperPayBand = 50, FemaleUpperQuartilePayBand = 50, MaleLowerPayBand = 50, MaleMedianBonusPayPercent = 50, MaleMiddlePayBand = 50, MaleUpperPayBand = 50, MaleUpperQuartilePayBand = 50, OrganisationId = organisation.OrganisationId, Status = ReturnStatuses.Submitted }; var controller = UiTestHelper.GetController <AdminDatabaseIntegrityChecksController>( govEqualitiesOfficeUser.UserId, routeData, organisation, user, userOrganisation, govEqualitiesOfficeUser, invalidReturn, validReturn); // Act var result = controller.PrivateEmployersReturnsWithoutResponsiblePerson() as PartialViewResult; // Assert AssertReturnsAreDisplayed(result, invalidReturn); }
public async Task POST_SendsAccountClosedNotification() { // Arrange User verifiedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var testPassword = "******"; var testSalt = "testSalt"; verifiedUser.Salt = testSalt; verifiedUser.PasswordHash = Crypto.GetPBKDF2(testPassword, Convert.FromBase64String(verifiedUser.Salt)); verifiedUser.HashingAlgorithm = HashingAlgorithm.PBKDF2; var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.CloseAccountController>( verifiedUser.UserId, mockRouteData, verifiedUser); var mockEmailQueue = new Mock <IQueue>(); mockEmailQueue .Setup(q => q.AddMessageAsync(It.IsAny <QueueWrapper>())); // Act await controller.CloseAccount(new CloseAccountViewModel { EnterPassword = testPassword }); // Assert mockEmailQueue.Verify( x => x.AddMessageAsync( It.Is <QueueWrapper>( inst => inst.Message.Contains(verifiedUser.EmailAddress) && inst.Type == typeof(CloseAccountCompletedTemplate).FullName)), Times.Once(), $"Expected the users email address using {nameof(CloseAccountCompletedTemplate)} to be in the email send queue"); mockEmailQueue.Verify( x => x.AddMessageAsync( It.Is <QueueWrapper>( inst => inst.Message.Contains(ConfigHelpers.EmailOptions.GEODistributionList) && inst.Type == typeof(OrphanOrganisationTemplate).FullName)), Times.Never, $"Didnt expect the GEO Email addresses using {nameof(OrphanOrganisationTemplate)} to be in the email send queue"); }
public async Task AdminController_ManualChanges_POST_Delete_Submissions_Fails_When_Reference_Is_Not_On_The_Database_Async() { // Arrange User databaseAdminUser = UserHelper.GetDatabaseAdmin(); var testController = UiTestHelper.GetController <AdminController>(databaseAdminUser.UserId, null, databaseAdminUser); var manualChangesViewModelMock = Mock.Of <ManualChangesViewModel>(); manualChangesViewModelMock.Command = DeleteSubmissionsCommand; manualChangesViewModelMock.Parameters = Environment.NewLine + " =" // empty lines must not break the processing + Environment.NewLine // null lines must not break the processing + Environment.NewLine // null lines must not break the processing + "Reference_Not_On_Database=1999"; // 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 2", actualManualChangesViewModel.SuccessMessage); Assert.AreEqual( "<span style=\"color:Red\">2: ERROR: 'REFERENCE_NOT_ON_DATABASE' Cannot find organisation with this employer reference</span>\r\n", actualManualChangesViewModel.Results); Assert.AreEqual("Delete submissions", actualManualChangesViewModel.LastTestedCommand); Assert.AreEqual("; =;;Reference_Not_On_Database=1999", actualManualChangesViewModel.LastTestedInput); Assert.True(actualManualChangesViewModel.Tested, "Must be tested=true as this case is running in TEST mode"); Assert.IsNull(actualManualChangesViewModel.Comment); }); }
public void RegistrationController_ServiceActivated_GET_When_OrgScope_is_Not_Null_Then_Return_Expected_ViewData() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "ServiceActivated"); mockRouteData.Values.Add("Controller", "Registration"); var mockOrg = new Core.Entities.Organisation { OrganisationId = 52425, SectorType = SectorTypes.Private, OrganisationName = "Mock Organisation Ltd" }; var mockUser = new User { UserId = 87654, EmailAddress = "*****@*****.**", EmailVerifiedDate = VirtualDateTime.Now }; var mockReg = new UserOrganisation { UserId = 87654, OrganisationId = 52425, PINConfirmedDate = VirtualDateTime.Now }; var controller = UiTestHelper.GetController <RegistrationController>(87654, mockRouteData, mockUser, mockOrg, mockReg); controller.ReportingOrganisationId = mockOrg.OrganisationId; var testUri = new Uri("https://localhost/register/activate-service"); controller.AddMockUriHelper(testUri.ToString(), "ActivateService"); //Mock the Referrer controller.Request.Headers["Referer"] = testUri.ToString(); // Act var viewResult = controller.ServiceActivated() as ViewResult; // Assert Assert.NotNull(viewResult, "ViewResult should not be null"); Assert.AreEqual(viewResult.ViewName, "ServiceActivated", "Expected the ViewName to be 'ServiceActivated'"); // Assert ViewData Assert.That(controller.ViewBag.OrganisationName == mockOrg.OrganisationName, "Expected OrganisationName"); }
public void RegistrationController_AddSector_GET_Success() { //ARRANGE: //1.Arrange the test setup variables var user = new User { UserId = 1, EmailAddress = "*****@*****.**", EmailVerifiedDate = VirtualDateTime.Now }; //Set user email address verified code and expired sent date var routeData = new RouteData(); routeData.Values.Add("Action", nameof(RegistrationController.AddSector)); routeData.Values.Add("Controller", "Registration"); var employerResult = new PagedResult <EmployerRecord>(); employerResult.Results = new List <EmployerRecord>(); var model = new OrganisationViewModel { Employers = employerResult, ManualRegistration = true, SectorType = SectorTypes.Private }; var controller = UiTestHelper.GetController <RegistrationController>(1, routeData, user); // controller.Bind(model); //Stash the object for the unstash to happen in code controller.StashModel(model); //ACT: //2.Run and get the result of the test var result = controller.AddSector() as ViewResult; //ASSERT: Assert.NotNull(result, "Expected ViewResult"); Assert.That(result.GetType() == typeof(ViewResult), "Incorrect resultType returned"); Assert.That(result.ViewName == nameof(RegistrationController.AddSector), "Incorrect view returned"); Assert.That( result.Model != null && result.Model.GetType() == typeof(OrganisationViewModel), "Expected OrganisationViewModel or Incorrect resultType returned"); }
public void CompareController_RemoveEmployerJS_Success_ReturnAddButtons() { // Arrange var controller = UiTestHelper.GetController <CompareController>(); long organisationId = 123; string employerIdentifier = "abc123"; string returnUrl = @"\viewing\search-results"; var employer = new Core.Models.EmployerSearchModel() { OrganisationIdEncrypted = employerIdentifier, OrganisationId = organisationId.ToString() }; controller.SearchViewService.LastSearchResults = new SearchViewModel() { Employers = new PagedResult <Core.Models.EmployerSearchModel>() { Results = new List <Core.Models.EmployerSearchModel>() { employer } } }; controller.CompareViewService.AddToBasket(employer.OrganisationIdEncrypted); var model = new AddRemoveButtonViewModel() { OrganisationIdEncrypted = employer.OrganisationIdEncrypted, OrganisationName = employer.Name }; // Act var result = controller.RemoveEmployerJs(employerIdentifier, returnUrl) as PartialViewResult; // Assert Assert.NotNull(result); Assert.AreEqual(returnUrl, controller.ViewBag.ReturnUrl); Assert.AreEqual("Basket_Button", result.ViewName); CompareHelpers.Compare(model, result.Model); Assert.AreEqual(controller.CompareViewService.BasketItemCount, 0); Assert.IsFalse(controller.CompareViewService.ComparedEmployers.Value.Contains(employer.OrganisationIdEncrypted)); controller.AssertCookieDeleted(CookieNames.LastCompareQuery); }
public async Task DownloadData_Get_SuccessAsync() { string originalDownloadsLocation = ConfigHelpers.SharedOptions.DownloadsLocation; // remember so it can be reset at the end of this test // Arrange ConfigHelpers.SharedOptions.DownloadsLocation = Path.Combine(ConfigHelpers.SharedOptions.DownloadsLocation, "TestData"); var firstFileTitle = "2001-2002"; string firstFileLocation = Path.Combine(ConfigHelpers.SharedOptions.DownloadsLocation, $"GPGData_{firstFileTitle}.csv"); string firstFileContent = $"No content available for years {firstFileTitle}."; ViewingController controller = null; try { var routeData = new RouteData(); routeData.Values.Add("Action", "DownloadData"); routeData.Values.Add("Controller", "Viewing"); controller = UiTestHelper.GetController <ViewingController>(0, routeData); await controller.SharedBusinessLogic.FileRepository.WriteAsync(firstFileLocation, Encoding.UTF8.GetBytes(firstFileContent)); var year = 2001; // Act var result = await controller.DownloadData(year) as ContentResult; // Assert Assert.IsNotNull(result); Assert.AreEqual(firstFileContent, result.Content, "Invalid download content returned"); } finally { // Cleanup if (controller != null) { await controller.SharedBusinessLogic.FileRepository.DeleteFileAsync(firstFileLocation); } ConfigHelpers.SharedOptions.DownloadsLocation = originalDownloadsLocation; } }
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 CompareController_RemoveEmployerJS_NoEmployers_ReturnsNotFound() { // Arrange var controller = UiTestHelper.GetController <CompareController>(); var organisationId = "123fa"; var employerIdentifier = "abc123"; var returnUrl = @"\viewing\search-results"; controller.SearchViewService.LastSearchResults = new SearchViewModel() { Employers = null }; controller.CompareViewService.AddToBasket(organisationId); // Act var exception = Assert.Throws <HttpException>(() => controller.RemoveEmployerJs(employerIdentifier, returnUrl)); Assert.AreEqual((int)HttpStatusCode.BadRequest, exception.StatusCode); Assert.AreEqual($"Bad employer identifier {employerIdentifier}", exception.Message); Assert.AreEqual(controller.CompareViewService.BasketItemCount, 1); }
public void GET_ReturnsUserAccountWhenUserIsAuthorized() { // Arrange User verifiedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.AccountController>( verifiedUser.UserId, mockRouteData, verifiedUser); // Act var viewResult = controller.ManageAccount() as ViewResult; // Assert Assert.NotNull(viewResult); Assert.IsInstanceOf(typeof(ManageAccountViewModel), viewResult.Model); var actualModel = (ManageAccountViewModel)viewResult.Model; actualModel.Compare(verifiedUser, caseSensitive: false); }
public async Task ManageOrganisation_GET_When_Org_has_Multiple_Users_Then_Model_Contains_Assoc_Users() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "ManageOrganisation"); mockRouteData.Values.Add("Controller", "Submission"); var testUserId = 2; var testOrgId = 123; var controller = UiTestHelper.GetController <ManageOrganisationsController>( testUserId, mockRouteData, MockUsers, MockUserOrganisations); //Mock an existing explicit scope to prevent redirect to DeclareScope page Mock <IScopeBusinessLogic> mockScopeBl = AutoFacExtensions.ResolveAsMock <IScopeBusinessLogic>(); mockScopeBl.Setup(x => x.GetLatestScopeStatusForSnapshotYearAsync(It.IsAny <long>(), It.IsAny <int>())) .ReturnsAsync(ScopeStatuses.InScope); string encOrgId = Encryption.EncryptQuerystring(testOrgId.ToString()); // Act IActionResult actionResult = await controller.ManageOrganisation(encOrgId); // Assert var viewResult = actionResult as ViewResult; Assert.NotNull(viewResult, "viewResult should not be null"); var model = (ManageOrganisationModel)viewResult.Model; Assert.NotNull(model, "model should not be null"); Assert.NotNull(model.AssociatedUserOrgs, "AssociatedUserOrgs should not be null"); Assert.AreEqual(model.AssociatedUserOrgs.Count, 1, "AssociatedUserOrgs should contain 1 user org"); Assert.AreEqual(model.AssociatedUserOrgs[0], MockUserOrganisations[0], "Expected the User org to match"); }
RegistrationController_ReadPrivacyStatement_POST_When_PrivacyStatementModel_Accept_is_Yes_Then_Redirect_to_ManageOrganisationsAsync() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "ReadPrivacyStatement"); mockRouteData.Values.Add("Controller", "Home"); var mockUser = new User { UserId = 87654, EmailAddress = "*****@*****.**", EmailVerifiedDate = VirtualDateTime.Now, UserSettings = new HashSet <UserSetting>() }; var mockModel = new PrivacyStatementModel { Accept = "Yes" }; string testDate = VirtualDateTime.Now.ToString(); var controller = UiTestHelper.GetController <HomeController>(-1, mockRouteData, mockUser); // Act var result = await controller.PrivacyPolicy("Continue") as RedirectToActionResult; // Assert Assert.NotNull(result, "RedirectToActionResult should not be null"); Assert.AreEqual("ManageOrganisations", result.ActionName, "Expected the Action to be 'ManageOrganisations'"); Assert.AreEqual("Registrations", result.ControllerName, "Expected the Controller to be 'Home'"); // Assert User Settings UserSetting acceptedSetting = mockUser.UserSettings.FirstOrDefault(u => u.Key == UserSettingKeys.AcceptedPrivacyStatement); Assert.AreEqual(1, mockUser.UserSettings.Count, "UserSettings should have one element on the list"); Assert.NotNull(acceptedSetting, "AcceptedPrivacyStatement setting should exist"); Assert.GreaterOrEqual( DateTime.Parse(acceptedSetting.Value), DateTime.Parse(testDate), "AcceptedPrivacyStatement value should be a new date"); }
public async Task POST_SavesChangeDetailsModelToUserEntity() { // Arrange User verifiedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.ChangeDetailsController>( verifiedUser.UserId, mockRouteData, verifiedUser); var testViewModel = new ChangeDetailsViewModel { FirstName = $"NewFirstName{verifiedUser.UserId}", LastName = $"NewLastName{verifiedUser.UserId}", JobTitle = $"NewJobTitle{verifiedUser.UserId}", ContactPhoneNumber = $"NewContactPhoneNumber{verifiedUser.UserId}", AllowContact = !verifiedUser.AllowContact, SendUpdates = !verifiedUser.SendUpdates }; // Act var redirectToActionResult = await controller.ChangeDetails(testViewModel) as RedirectToActionResult; // Assert Assert.NotNull(redirectToActionResult); Assert.AreEqual( nameof(ModernSlavery.WebUI.Areas.Account.Controllers.AccountController.ManageAccount), redirectToActionResult.ActionName); // Assert success flag Assert.IsTrue(controller.TempData.ContainsKey(nameof(AccountResources.ChangeDetailsSuccessAlert))); // Assert user details testViewModel.Compare(verifiedUser); // Assert contact point details Assert.AreEqual(verifiedUser.ContactFirstName, testViewModel.FirstName, "Expected ContactFirstName to match"); Assert.AreEqual(verifiedUser.ContactLastName, testViewModel.LastName, "Expected ContactLastName to match"); Assert.AreEqual(verifiedUser.ContactJobTitle, testViewModel.JobTitle, "Expected ContactJobTitle to match"); }
public void CompareController_AddEmployerJS_WrongEmployer_ReturnsNotFound() { // Arrange var controller = UiTestHelper.GetController <CompareController>(); string employerIdentifier = "abc123"; string returnUrl = @"\viewing\search-results"; controller.SearchViewService.LastSearchResults = new SearchViewModel() { Employers = new PagedResult <Core.Models.EmployerSearchModel>() { Results = new List <Core.Models.EmployerSearchModel>() } }; // Act var exception = Assert.Throws <HttpException>(() => controller.AddEmployerJs(employerIdentifier, returnUrl)); Assert.AreEqual((int)HttpStatusCode.BadRequest, exception.StatusCode); Assert.AreEqual($"Bad employer identifier {employerIdentifier}", exception.Message); Assert.AreEqual(controller.CompareViewService.BasketItemCount, 0); }
public void OrganisationController_ManageOrganisations_GET_When_UserSettings_AcceptedPrivacyStatement_is_Null_Then_Return() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "ManageOrganisations"); mockRouteData.Values.Add("Controller", "Registrations"); var mockUser = new User { UserId = 87654, EmailAddress = "*****@*****.**", EmailVerifiedDate = VirtualDateTime.Now, UserSettings = new UserSetting[0] }; var controller = UiTestHelper.GetController <ManageOrganisationsController>(-1, mockRouteData, mockUser); // Acts var result = controller.Home() as RedirectToActionResult; // Assert Assert.NotNull(result, "RedirectToActionResult should not be null"); Assert.AreEqual(result.ActionName, "PrivacyPolicy", "Expected the Action to be 'PrivacyPolicy'"); Assert.AreEqual(result.ControllerName, "Home", "Expected the Controller to be 'Home'"); }
public void CompareController_SortEmployers_SuccessChange_RedirectToReturnUrl() { // Arrange var controller = UiTestHelper.GetController <CompareController>(); string column = "OrganisationName"; string returnUrl = @"\viewing\search-results"; controller.CompareViewService.SortColumn = "MaleUpperQuartilePayBand"; controller.CompareViewService.SortAscending = false; // Act var result = controller.SortEmployers(column, returnUrl) as LocalRedirectResult; // Assert //Test the google analytics tracker was executed once on the controller controller.WebTracker.GetMockFromObject().Verify(mock => mock.TrackPageView(It.IsAny <Controller>(), "sort-employers: OrganisationName Descending", "/compare-employers/sort-employers?OrganisationName=Descending"), Times.Once()); Assert.NotNull(result); Assert.AreEqual(returnUrl, result.Url); Assert.AreEqual(controller.CompareViewService.SortColumn, column); Assert.AreEqual(controller.CompareViewService.SortAscending, true); }
public void GET_SoleRegistrationFlagIsSavedInViewModel(long testUserId, bool expectedToBeSoleUser) { // Arrange object[] registations = UserOrganisationHelper.CreateRegistrations(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.CloseAccountController>( testUserId, mockRouteData, registations); // Act var viewResult = controller.CloseAccount() as ViewResult; // Assert Assert.NotNull(viewResult); var actualViewModel = viewResult.Model as CloseAccountViewModel; Assert.NotNull(actualViewModel); Assert.AreEqual(expectedToBeSoleUser, actualViewModel.IsSoleUserOfOneOrMoreOrganisations); }
RegistrationController_AboutYou_GET_When_PendingFastrack_Cookie_Then_ViewModel_Should_Contain_Scope_Contact_DetailsAsync() { // Arrange var mockRouteData = new RouteData(); mockRouteData.Values.Add("Action", "AboutYou"); mockRouteData.Values.Add("Controller", "Registration"); var controller = UiTestHelper.GetController <RegistrationController>(0, mockRouteData); await controller.Cache.RemoveAsync($"{controller.HttpContext.GetUserHostAddress()}:lastFasttrackDate"); // Ensure we call the scope service GetScopeFromFastTrackCode implementation Mock <IScopePresenter> mockScopeBL = Mock.Get(controller.ScopePresentation); mockScopeBL.CallBase = true; //Populate the PendingFasttrackCodes controller.PendingFasttrackCodes = "EmployerRef:SecurityCode:ExpectedContactFirstname:ExpectedContactLastname:ExpectedContactEmailAddress"; // Act IActionResult actionResult = await controller.AboutYou(); // Assert Assert.NotNull(actionResult, "ViewResult should not be null"); var viewResult = actionResult as ViewResult; Assert.AreEqual(viewResult.ViewName, "AboutYou", "Expected the ViewName to be 'AboutYou'"); var viewModel = (SignUpViewModel)viewResult.Model; Assert.AreEqual(viewModel.FirstName, "ExpectedContactFirstname", "Expected the FirstName to be 'ExpectedContactFirstname'"); Assert.AreEqual(viewModel.LastName, "ExpectedContactLastname", "Expected the LastName to be 'ExpectedContactLastname'"); Assert.AreEqual( viewModel.EmailAddress, "ExpectedContactEmailAddress", "Expected the EmailAddress to be 'ExpectedContactEmailAddress'"); }
public async Task POST_RemovesAllRetiredUserRegistrations() { // Arrange var testPassword = "******"; object[] registrations = UserOrganisationHelper.CreateRegistrationsInScope(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.CloseAccountController>( 23322, mockRouteData, registrations); // check we start with the expected amount Assert.AreEqual(2, controller.CurrentUser.UserOrganisations.Count, "Expected to start with 2 registrations"); // Act await controller.CloseAccount(new CloseAccountViewModel { EnterPassword = testPassword }); // Assert user org removed Assert.AreEqual(0, controller.CurrentUser.UserOrganisations.Count, "Expected no registrations after closing account"); }
public async Task ShouldReplaceEmployerSicCodes() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testSicCodeData, testOrgSicCodeData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1111", "23TYLBLB=3333"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); thisTestManualChangesVm.LastTestedCommand = SetOrganisationSicCodesCommand; thisTestManualChangesVm.LastTestedInput = thisTestParameters.ReplaceI(Environment.NewLine, ";"); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(3, actualResults.Length); Core.Entities.Organisation org1 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "6B2LF57C"); Assert.AreEqual("1111", org1.GetSicCodeIdsString()); Assert.AreEqual("1: 6B2LF57C: SIC codes=1 has been set to 1111", actualResults[0]); Core.Entities.Organisation org2 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "23TYLBLB"); Assert.AreEqual("3333", org2.GetSicCodeIdsString()); Assert.AreEqual("2: 23TYLBLB: SIC codes=3 has been set to 3333", actualResults[1]); }
public async Task ShouldFailWhenAddressFieldLongerThan100() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", $"6B2LF57C={"".PadLeft(101, 'z')},a2,a3,t1,c1,c2,pc1", $"23TYLBLB=a1,{"".PadLeft(101, 'z')},a3,t1,c1,c2,pc1", $"RWT2TY62=a1,a2,{"".PadLeft(101, 'z')},t1,c1,c2,pc1", $"ADCE324T=a1,a2,a3,{"".PadLeft(101, 'z')},c1,c2,pc1", $"GR2H67UI=a1,a2,a3,t1,{"".PadLeft(101, 'z')},c2,pc1", $"FG34RT65=a1,a2,a3,t1,c1,{"".PadLeft(101, 'z')},pc1", $"D43TYU76=a1,a2,a3,t1,c1,c2,{"".PadLeft(101, 'z')}"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(8, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(Address1IsGreaterThan100), "Expected true when address1 is greater 100 chars"); Assert.IsTrue(actualResults[1].Contains(Address2IsGreaterThan100), "Expected true when address2 is greater 100 chars"); Assert.IsTrue(actualResults[2].Contains(Address3IsGreaterThan100), "Expected true when address3 is greater 100 chars"); Assert.IsTrue(actualResults[3].Contains(TownCityIsGreaterThan100), "Expected true when town\\city is greater 100 chars"); Assert.IsTrue(actualResults[4].Contains(CountyIsGreaterThan100), "Expected true when county is greater 100 chars"); Assert.IsTrue(actualResults[5].Contains(CountryIsGreaterThan100), "Expected true when country is greater 100 chars"); Assert.IsTrue(actualResults[6].Contains(PostcodeIsGreaterThan100), "Expected true when postcode is greater 100 chars"); }
public async Task AdminController_ManualChanges_POST_When_User_Is_Not_A_Database_Admin_Returns_Unauthorized_ResultAsync() { // Arrange User notAdminUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, notAdminUser); // Act IActionResult actualResult = await adminController.ManualChanges(new ManualChangesViewModel()); Assert.NotNull(actualResult, "Expected Manual changes to return a result"); var httpUnauthorisedResult = actualResult as HttpUnauthorizedResult; Assert.NotNull( httpUnauthorisedResult, "As we are calling 'Manual changes POST' with a user that is NOT an admin, we were expecting an 'Unauthorised result' back"); // Assert Assert.NotNull(httpUnauthorisedResult.StatusCode, "This response should have return a status code"); Assert.AreEqual( HttpStatusCode.Unauthorized.ToInt32(), httpUnauthorisedResult.StatusCode, "Unauthorised result status code 401 was expected"); }
public async Task POST_ReturnsChangeDetailsViewWhenModelStateIsInValid() { // Arrange User verifiedUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress(); var controller = UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.ChangeDetailsController>( verifiedUser.UserId, mockRouteData, verifiedUser); var model = new ChangeDetailsViewModel(); // Act controller.ModelState.AddModelError("FirstName", "Required"); var viewResult = await controller.ChangeDetails(model) as ViewResult; // Assert Assert.NotNull(viewResult); Assert.AreEqual( nameof(ModernSlavery.WebUI.Areas.Account.Controllers.ChangeDetailsController.ChangeDetails), viewResult.ViewName); Assert.IsFalse(controller.TempData.ContainsKey(AccountResources.ChangeDetailsSuccessAlert)); Assert.IsInstanceOf(typeof(ChangeDetailsViewModel), viewResult.Model); }