public async Task AdminController_ManualChanges_POST_Fix_Organisation_Names_Works_When_Run_In_Live_Mode_Async()
{
// Arrange
var orgThatWillBeFixed = new OrganisationName {
Name = "Org to fix ltd", Created = VirtualDateTime.Now, OrganisationId = 55
};
var orgThatWontBeSelectedToBeFixed = new OrganisationName {
Name = "Org not to be fixed", Created = VirtualDateTime.Now, OrganisationId = 66
};
#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 <OrganisationName>())
.Returns(new[] { orgThatWillBeFixed, orgThatWontBeSelectedToBeFixed }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = FixOrganisationNamesCommand
};
#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 'Fix organisation names': 1 items", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"An email will be sent to '*****@*****.**' when the background task 'FixOrganisationsNamesAsync' has completed\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 async Task ManageOrganisation_GET_When_NewOrg_PresumedScope_Then_RedirectToDeclareScope()
{
// 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.PresumedInScope);
string encOrgId = Encryption.EncryptQuerystring(testOrgId.ToString());
// Act
var actionResult = await controller.ManageOrganisation(encOrgId) as RedirectToActionResult;
// Assert
Assert.IsNotNull(actionResult, "actionResult should not be null");
Assert.AreEqual(actionResult.ActionName, "DeclareScope", "Expected redirect to DeclareScope");
Assert.AreEqual(actionResult.RouteValues["id"], encOrgId, "Wrong organisation id returned");
}
AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_Organisation_Name_Is_Not_Specified_Async()
{
// Arrange
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);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand, Parameters = "OrgNameNotSpecified="
};
// Act
var retireOrgActionResult = await adminController.ManualChanges(manualChangesViewModel) as ViewResult;
Assert.NotNull(retireOrgActionResult);
var actualManualChangesViewModel = (ManualChangesViewModel)retireOrgActionResult.Model;
// Assert
Assert.AreEqual("SUCCESSFULLY TESTED 'Add organisations latest name': 0 of 1", actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"<span style=\"color:Red\">1: ERROR: 'ORGNAMENOTSPECIFIED' No organisation name specified</span>\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Add organisations latest name", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("OrgNameNotSpecified=", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be true as this case is running in test mode");
}
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);
});
}
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 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);
});
}
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);
});
}
public async Task AdminController_ManualChanges_POST_Update_Search_Indexes_Works_When_Run_In_Live_Mode_Async()
{
// Arrange
User databaseAdmin = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(databaseAdmin.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(databaseAdmin);
Mock <IAdminService> configurableAdmin = AutoFacExtensions.ResolveAsMock <IAdminService>();
configurableAdmin
.Setup(x => x.SearchBusinessLogic.EmployerSearchRepository.GetDocumentCountAsync())
.ReturnsAsync(12545L);
var manualChangesViewModel = new ManualChangesViewModel {
Command = UpdateSearchIndexesCommand
};
/* 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 'Update search indexes': 12545 items",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"An email will be sent to '*****@*****.**' when the background task 'UpdateSearchIndexesAsync' has completed\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 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);
});
}
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_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_Update_Search_Indexes_Works_When_Run_In_Test_Mode_Async()
{
// Arrange
User databaseAdmin = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(databaseAdmin.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(databaseAdmin);
Mock <IAdminService> configurableAdmin = AutoFacExtensions.ResolveAsMock <IAdminService>();
configurableAdmin
.Setup(x => x.SearchBusinessLogic.EmployerSearchRepository.GetDocumentCountAsync())
.ReturnsAsync(65488L);
var manualChangesViewModel = new ManualChangesViewModel {
Command = UpdateSearchIndexesCommand
};
// 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 'Update search indexes': 65488 items",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.AreEqual("Update search indexes", 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);
});
}
public void DeclareScope_GET_When_PreviousInScope_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.InScope,
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 actionResult = controller.DeclareScope(encOrgId);
// Assert
Expect(actionResult != null, "actionResult should not be null");
// Assert
var httpStatusResult = actionResult as HttpStatusViewResult;
Assert.NotNull(httpStatusResult, "httpStatusResult should not be null");
Assert.AreEqual(httpStatusResult.StatusCode, (int)HttpStatusCode.BadRequest, "Expected the StatusCode to be a 'BadRequest'");
}
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 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");
}
AdminController_ManualChanges_POST_Add_Organisation_Latest_Name_Fails_When_Reference_Is_Not_On_The_Database_Async()
{
// Arrange
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);
var manualChangesViewModel = new ManualChangesViewModel {
Command = AddOrganisationsLatestNameCommand,
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=Missing_Reference"
};
// Act
var retireOrgActionResult = await adminController.ManualChanges(manualChangesViewModel) as ViewResult;
Assert.NotNull(retireOrgActionResult);
var actualManualChangesViewModel = (ManualChangesViewModel)retireOrgActionResult.Model;
// Assert
Assert.AreEqual("SUCCESSFULLY TESTED 'Add organisations latest name': 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); // Note "2: ERROR" instead of "1: ERROR" here
Assert.AreEqual("Add organisations latest name", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual("; =;;Reference_Not_On_Database=Missing_Reference", actualManualChangesViewModel.LastTestedInput);
Assert.True(actualManualChangesViewModel.Tested, "Must be true as this case is running in test mode");
}
public async Task AdministrationController_ManualChanges_prevAddress_SetStatus_Address_Statuses_Retired()
{
// Arrange
var existingAddressExpectedToBeRetired = new OrganisationAddress {
Address1 = "Previous Address1",
Address2 = "Previous Address2",
Address3 = "Previous Address3",
TownCity = "Previous TownCity",
County = "Previous County",
Country = "Previous Country",
PostCode = "Previous PostCode",
Status = AddressStatuses.Active
};
Core.Entities.Organisation privateOrgWhoseAddressWillBeChanged = OrganisationHelper.GetPrivateOrganisation("Employer_Reference_989898");
privateOrgWhoseAddressWillBeChanged.LatestAddress = existingAddressExpectedToBeRetired;
#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[] { privateOrgWhoseAddressWillBeChanged }.AsQueryable().BuildMock().Object);
var manualChangesViewModel = new ManualChangesViewModel {
Command = SetOrganisationAddressesCommand,
Parameters =
$"{privateOrgWhoseAddressWillBeChanged.EmployerReference}=New Address1, New Address2, New Address3, New TownCity, New County, New Country, New PostCode"
};
#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 addresses': 1 of 1",
actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual(
"1: EMPLOYER_REFERENCE_989898:Org123 Address=Previous Address1, Previous Address2, Previous Address3, Previous TownCity, Previous County, Previous Country, Previous PostCode will be set to New Address1, New Address2, New Address3, New TownCity, New County, New Country, New PostCode\r\n",
actualManualChangesViewModel.Results);
Assert.AreEqual("Set organisation addresses", actualManualChangesViewModel.LastTestedCommand);
Assert.AreEqual(
"Employer_Reference_989898=New Address1, New Address2, New Address3, New TownCity, New County, New Country, New PostCode",
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_POST_When_Model_LastYearPresumedInScope_Then_SaveInScopeAsync()
{
// Arrange
var mockRouteData = new RouteData();
mockRouteData.Values.Add("Action", "DeclareScope");
mockRouteData.Values.Add("Controller", "Organisation");
User currentUser = MockUsers.First(u => u.UserId == 2);
var testUserId = 2;
var testOrgId = 123;
DateTime thisSnapshotDate = SectorTypes.Private.GetAccountingStartDate();
DateTime lastSnapshotDate = thisSnapshotDate.AddYears(-1);
var mockLastScope = new OrganisationScope
{
OrganisationId = testOrgId,
Status = ScopeRowStatuses.Active,
ScopeStatus = ScopeStatuses.PresumedInScope,
SnapshotDate = lastSnapshotDate
};
var mockThisScope = new OrganisationScope
{
OrganisationId = testOrgId,
Status = ScopeRowStatuses.Active,
ScopeStatus = ScopeStatuses.OutOfScope,
SnapshotDate = thisSnapshotDate
};
var controller = UiTestHelper.GetController <OrganisationController>(
testUserId,
mockRouteData,
MockUsers,
MockOrganisations,
MockUserOrganisations,
mockLastScope,
mockThisScope);
Mock <IScopeBusinessLogic> mockScopeBL = AutoFacExtensions.ResolveAsMock <IScopeBusinessLogic>(true);
string encOrgId = Encryption.EncryptQuerystring(testOrgId.ToString());
var model = new DeclareScopeModel {
SnapshotDate = lastSnapshotDate, ScopeStatus = ScopeStatuses.InScope
};
// Act
var actionResult = controller.DeclareScope(model, encOrgId) as ViewResult;
// Assert
Expect(actionResult != null, "actionResult should not be null");
// Assert
Expect(actionResult.ViewName.EqualsI("ScopeDeclared"), "Expected ScopeDeclared view");
Expect(actionResult.ViewData.ModelState.IsValid, "Expected Valid viewstate");
IQueryable <OrganisationScope> orgScopes =
controller.DataRepository.GetAll <OrganisationScope>().Where(os => os.OrganisationId == testOrgId);
Expect(orgScopes.Count() == 3, "Expected three organisation scopes");
//Check the new expicit scope is correct
OrganisationScope newScope =
orgScopes.FirstOrDefault(os => os.SnapshotDate == lastSnapshotDate && os.Status == ScopeRowStatuses.Active);
Expect(newScope != null, "Submitted scope expected ");
Expect(newScope.ContactEmailAddress == currentUser.EmailAddress, "Expected user email address to be saved with scope");
Expect(newScope.ContactFirstname == currentUser.Firstname, "Expected user first name to be saved with scope");
Expect(newScope.ContactLastname == currentUser.Lastname, "Expected user last name to be saved with scope");
Expect(newScope.ScopeStatus == model.ScopeStatus.Value, "Expected new last years scope status to be same as model");
//Check the old presumed scope is correct
OrganisationScope oldScope =
orgScopes.FirstOrDefault(os => os.SnapshotDate == lastSnapshotDate && os.Status == ScopeRowStatuses.Retired);
Expect(oldScope != null, "Retired scope expected");
Expect(oldScope.ScopeStatus == mockLastScope.ScopeStatus, "Expected old scope to be presumed scope");
Expect(oldScope.ScopeStatusDate < newScope.ScopeStatusDate, "Expected oldscope status to be older than new scope");
Expect(oldScope.OrganisationScopeId == mockLastScope.OrganisationScopeId, "Expected old scope to be same original");
}
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);
}
public async Task AdminController_ManualChanges_POST_When_A_Generic_Exception_Happens_It_Is_Reported_Async()
{
// Arrange
var deepestLevelExceptionMessage = "Deepest level exception 'Crash'";
var deepestException = new Exception(deepestLevelExceptionMessage);
var lowestLevelExceptionMessage = "'Boom' lowest level";
var lowestLevelException = new Exception(lowestLevelExceptionMessage, deepestException);
var midLevelExceptionMessage = "Mid level 'Bang'";
var midLevelException = new Exception(midLevelExceptionMessage, lowestLevelException);
var topGenericExceptionMessage = "Top level Agregate 'Roxette'";
var topGenericException = new Exception(topGenericExceptionMessage, midLevelException);
#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 <OrganisationName>())
.Throws(topGenericException);
ManualChangesViewModel manualChangesViewModelMockObject =
ManualChangesViewModelHelper.GetMock("Fix organisation names", string.Empty);
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModelMockObject);
Assert.NotNull(manualChangesResult);
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
ModelStateEntry modelState = adminController.ModelState[""];
// Assert
int actualNumberOfErrors = modelState.Errors.Count;
Assert.AreEqual(1, actualNumberOfErrors, "This test must return only one error");
ModelError actualMidLevelError = modelState.Errors.FirstOrDefault();
Assert.Multiple(
() => {
Assert.AreEqual(deepestLevelExceptionMessage, actualMidLevelError.ErrorMessage); // only reports 'deepest level' error
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.IsFalse(actualManualChangesViewModel.Tested);
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public async Task AdminController_ManualChanges_POST_When_An_Aggregate_Exception_Happens_It_Is_Reported_Async()
{
// Arrange
var nestedExceptionMessage = "Nested exception 'smash'";
var midLevelExceptionMessage = "Mid level 'Badaboom'";
var deepestLevelExceptionMessage = "Deepest level exception 'Blam'";
var nestedException = new Exception(nestedExceptionMessage);
var arrayOfInnerExceptions = new List <Exception> {
new Exception(midLevelExceptionMessage),
new Exception("'Kaboom' lowest level", nestedException), // Message 'Kaboom' WILL NOT be showing
new Exception(deepestLevelExceptionMessage)
};
var topAggregateException = new AggregateException("Top level Agregate 'Boom'", arrayOfInnerExceptions);
#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 <OrganisationName>())
.Throws(topAggregateException);
ManualChangesViewModel manualChangesViewModelMockObject =
ManualChangesViewModelHelper.GetMock("Fix organisation names", string.Empty);
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModelMockObject);
Assert.NotNull(manualChangesResult);
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
ModelStateEntry modelState = adminController.ModelState[""];
// Assert
int actualNumberOfErrors = modelState.Errors.Count;
Assert.AreEqual(3, actualNumberOfErrors, "This test must return three errors");
ModelError actualNestedError = modelState.Errors.First(x => x.ErrorMessage == nestedExceptionMessage);
Assert.NotNull(actualNestedError, $"List of errors was expected to contain nested error message [{nestedExceptionMessage}]");
ModelError actualMidLevelError = modelState.Errors.First(x => x.ErrorMessage == midLevelExceptionMessage);
Assert.NotNull(
actualMidLevelError,
$"List of errors was expected to contain mid level error message [{midLevelExceptionMessage}]");
ModelError actualDeepestError = modelState.Errors.First(x => x.ErrorMessage == deepestLevelExceptionMessage);
Assert.NotNull(
actualNestedError,
$"List of errors was expected to contain deepest error message [{deepestLevelExceptionMessage}]");
Assert.Multiple(
() => {
Assert.AreEqual(midLevelExceptionMessage, actualMidLevelError.ErrorMessage); // only reports 'mid level' error
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.IsFalse(actualManualChangesViewModel.Tested);
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
