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 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 void BeforeEach()
{
// mock data
var dbContext = AutoFacHelpers.CreateInMemoryTestDatabase(UserOrganisationHelper.CreateRegistrations());
mockDataRepo = new SqlRepository(dbContext);
mockLogRecordLogger = new Mock <IRegistrationLogger>();
// service under test
testRegistrationBusinessLogic = new RegistrationBusinessLogic(mockDataRepo, mockLogRecordLogger.Object);
}
public void BeforeEach()
{
// mock data
GpgDatabaseContext dbContext = AutoFacHelpers.CreateInMemoryTestDatabase(UserOrganisationHelper.CreateRegistrations());
mockDataRepo = new SqlRepository(dbContext);
var auditLoggerWithMocks = new AuditLogger(Mock.Of <IDataRepository>());
// service under test
testRegistrationRepo =
new GenderPayGap.WebUI.Repositories.RegistrationRepository(mockDataRepo, auditLoggerWithMocks, null, null);
}
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 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 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 async Task ScopePresentation_CreateOrganisationViewModel_When_Record_Not_Found_Returns_NullAsync()
{
// Arrange
var employerRef = "SomeThatWillBeInDatabase";
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 = "NotFoundInDB", SecurityToken = mockOrg.SecurityCode
};
// Act
OrganisationViewModel actual = await scopePresenter.CreateOrganisationViewModelAsync(testModel, mockUser);
// Assert
Assert.Null(actual, "When the combination EmployerReference/SecurityCode is not found in DB, this method must return null");
}
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);
}
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 POST_SendsAccountClosedNotifications()
{
// Arrange
object[] registrations = UserOrganisationHelper.CreateRegistrationsInScope();
var controller =
UiTestHelper.GetController <ModernSlavery.WebUI.Areas.Account.Controllers.CloseAccountController>(
23322,
mockRouteData,
registrations);
var verifiedUser = controller.SharedBusinessLogic.DataRepository.Get <User>((long)23322);
var mockEmailQueue = new Mock <IQueue>();
mockEmailQueue
.Setup(q => q.AddMessageAsync(It.IsAny <QueueWrapper>()));
// Act
await controller.CloseAccount(new CloseAccountViewModel { EnterPassword = "******" });
// 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.Once(),
$"Expected the GEO Email addresses using {nameof(OrphanOrganisationTemplate)} to be in the email send queue");
}
public async Task RegistrationController_ConfirmOrganisation_Get_SuccessAsync()
{
// Arrange
User mockUser = UserHelper.GetNotAdminUserWithVerifiedEmailAddress();
Core.Entities.Organisation mockOrg = OrganisationHelper.GetPublicOrganisation();
UserOrganisation mockUserOrg = UserOrganisationHelper.LinkUserWithOrganisation(mockUser, mockOrg);
Return mockReturn = ReturnHelper.GetNewReturnForOrganisationAndYear(mockUserOrg, ConfigHelpers.SharedOptions.FirstReportingYear);
OrganisationHelper.LinkOrganisationAndReturn(mockOrg, mockReturn);
var mockRouteData = new RouteData();
mockRouteData.Values.Add("Action", "ServiceActivated");
mockRouteData.Values.Add("Controller", "Registration");
var controller = UiTestHelper.GetController <RegistrationController>(-1, mockRouteData, mockUser, mockOrg, mockUserOrg, mockReturn);
controller.ReportingOrganisationId = mockOrg.OrganisationId;
controller.StashModel(new OrganisationViewModel());
var testUri = new Uri("https://localhost/register/activate-service");
controller.AddMockUriHelper(testUri.ToString(), "ActivateService");
//Mock the Referrer
controller.Request.Headers["Referer"] = testUri.ToString();
var result = await controller.ConfirmOrganisation() as ViewResult;
Assert.NotNull(result);
Assert.AreEqual("ConfirmOrganisation", result.ViewName);
}
public async Task AdminController_ManualChanges_POST_Fix_Database_Error_Missing_Latest_Scope_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 scope link so it's picked up by the test
Core.Entities.Organisation organisation_MissingLatestScope = OrganisationHelper.GetPrivateOrganisation("EmployerReference5487548");
UserOrganisation userOrganisation_MissingLatestScope =
UserOrganisationHelper.LinkUserWithOrganisation(notAdminUser, organisation_MissingLatestScope);
organisation_MissingLatestScope.LatestRegistration = userOrganisation_MissingLatestScope;
Return return_MissingLatestScope = ReturnHelper.GetSubmittedReturnForOrganisationAndYear(
userOrganisation_MissingLatestScope,
VirtualDateTime.Now.AddYears(-1).Year);
organisation_MissingLatestScope.Returns.Add(return_MissingLatestScope);
organisation_MissingLatestScope.LatestReturn = return_MissingLatestScope;
OrganisationScope scope_MissingLatestScope = ScopeHelper.CreateScope(ScopeStatuses.InScope, VirtualDateTime.Now.AddYears(-1));
organisation_MissingLatestScope.OrganisationScopes.Add(
scope_MissingLatestScope); // latest scope indeed exists for this organisation
organisation_MissingLatestScope.LatestScope = null; // missing latest scope -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_MissingLatestScope }.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.AreEqual("SUCCESSFULLY EXECUTED 'Fix database errors': 1 items", actualManualChangesViewModel.SuccessMessage);
var expectedManualChangesViewModelResults =
"No organisations missing a latest registration\r\nNo organisations missing a latest return\r\n001: Organisation 'EmployerReference5487548:Org123' missing a latest scope was successfully fixed\r\n";
Assert.AreEqual(
expectedManualChangesViewModelResults,
actualManualChangesViewModel.Results,
$"EXPECTED -{expectedManualChangesViewModelResults}- BUT WAS -{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);
}
