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);
}
