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