public async Task AdminController_ManualChanges_POST_ShouldFailWhenEmployerIsNotPublicSector() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1", "DR994D7L=2", "23TYLBLB=3", "SNGNB4BH=4", "RWT2TY62=5"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetPublicSectorTypeCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(6, actualResults.Length); Assert.IsFalse(actualResults[0].Contains(IsNotPublicSector), "Expected false when organisation is not public sector"); Assert.IsTrue(actualResults[1].Contains(IsNotPublicSector), "Expected true when organisation is public sector"); Assert.IsFalse(actualResults[2].Contains(IsNotPublicSector), "Expected false when organisation is not public sector"); Assert.IsTrue(actualResults[3].Contains(IsNotPublicSector), "Expected true when organisation is public sector"); Assert.IsFalse(actualResults[4].Contains(IsNotPublicSector), "Expected false when organisation is not public sector"); }
public async Task ShouldFailEachLineMissingEqualsCharacter() { // Arrange var thisTestDbObjects = new object[] { testUser }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "test=passed", "this line should fail", "red=passed", "this line should fail also"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(5, actualResults.Length); Assert.IsFalse(actualResults[0].Contains(DoesNotContainEquals), "Expected false when line contains '='"); Assert.IsTrue(actualResults[1].Contains(DoesNotContainEquals), "Expected true when line does not contain '='"); Assert.IsFalse(actualResults[2].Contains(DoesNotContainEquals), "Expected false when line contains '='"); Assert.IsTrue(actualResults[3].Contains(DoesNotContainEquals), "Expected true when line does not contain '='"); }
public async Task ShouldFailDuplicateEmployers() { // Arrange var thisTestDbObjects = new object[] { testUser }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = " =" + Environment.NewLine + string.Join(Environment.NewLine, "EMP1=1", "EMP2=2", "EMP3=3", "EMP2=4", "EMP4=4"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(6, actualResults.Length); Assert.IsFalse(actualResults[0].Contains(DuplicateOrganisation), "Expected false when employer is not duplicate"); Assert.IsFalse(actualResults[1].Contains(DuplicateOrganisation), "Expected false when employer is not duplicate"); Assert.IsFalse(actualResults[2].Contains(DuplicateOrganisation), "Expected false when employer is not duplicate"); Assert.IsTrue(actualResults[3].Contains(DuplicateOrganisation), "Expected true when employer is a duplicate"); Assert.IsFalse(actualResults[4].Contains(DuplicateOrganisation), "Expected false when employer is not duplicate"); }
public async Task ShouldFailWhenSicCodesDontExist() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testSicCodeData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1111", "DR994D7L=2", "23TYLBLB=3333", "SNGNB4BH=4", "RWT2TY62=5555"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(6, actualResults.Length); Assert.IsFalse(actualResults[0].Contains(SicCodeDoesntExist), "Expected false when sic code exists"); Assert.IsFalse(actualResults[1].Contains(SicCodeDoesntExist), "Expected true when sic code does not exist"); Assert.IsFalse(actualResults[2].Contains(SicCodeDoesntExist), "Expected false when sic code exists"); Assert.IsFalse(actualResults[3].Contains(SicCodeDoesntExist), "Expected true when sic code does not exist"); Assert.IsFalse(actualResults[4].Contains(SicCodeDoesntExist), "Expected false when sic code exists"); }
public async Task AdminController_ManualChanges_POST_ShouldFailWhenNoValueAfterEqualsCharacter() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=", "23TYLBLB=", "RWT2TY62=4"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetPublicSectorTypeCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(4, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(MustContainPublicSectorTypeCode), "Expected true when line contains a value"); Assert.IsTrue(actualResults[1].Contains(MustContainPublicSectorTypeCode), "Expected true when line contains a value"); Assert.IsFalse(actualResults[2].Contains(MustContainPublicSectorTypeCode), "Expected true when line contains a value"); }
public async Task AdminController_ManualChanges_POST_ShouldFailWhenPublicSectorTypeNotInteger() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testOrgSecTypesData, testSecTypesData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=TEST", "23TYLBLB=ABCD", "RWT2TY62=4"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetPublicSectorTypeCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(4, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(PublicSectorTypeMustBeInteger), "Expected to fail when input not an integer"); Assert.IsTrue(actualResults[1].Contains(PublicSectorTypeMustBeInteger), "Expected to fail when input not an integer"); Assert.IsFalse(actualResults[2].Contains(PublicSectorTypeMustBeInteger), "Expected to succeed when input is an integer"); }
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); }); }
public async Task ShouldFailWhenEmployerHasCompanyNumber() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=address", "DR994D7L=address", "23TYLBLB=address", "SNGNB4BH=address", "RWT2TY62=address"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(6, actualResults.Length); Assert.IsFalse(actualResults[0].Contains(HasCompanyNumber), "Expected false when organisation doesnt have a company number"); Assert.IsTrue(actualResults[1].Contains(HasCompanyNumber), "Expected true when organisation has a company number"); Assert.IsFalse(actualResults[2].Contains(HasCompanyNumber), "Expected false when organisation doesnt have a company number"); Assert.IsTrue(actualResults[3].Contains(HasCompanyNumber), "Expected true when organisation has a company number"); Assert.IsFalse(actualResults[4].Contains(HasCompanyNumber), "Expected false when organisation doesnt have a company number"); }
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"); }
public async Task ShouldFailWhenMissingAddressEntries() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=a1,a2", "DR994D7L=a1,a2,a3,t1,c1,c2,pc1", "23TYLBLB=1,2,3,4", "SNGNB4BH=a1,a2,a3,t1,c1,c2,pc1", "RWT2TY62=1,2,3,4,5"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(6, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(IncorrectNumberOfAddressFields), "Expected true when Sic code is not an integer"); Assert.IsFalse(actualResults[1].Contains(IncorrectNumberOfAddressFields), "Expected false when Sic code is an integer"); Assert.IsTrue(actualResults[2].Contains(IncorrectNumberOfAddressFields), "Expected true when Sic code is not an integer"); Assert.IsFalse(actualResults[3].Contains(IncorrectNumberOfAddressFields), "Expected false when Sic code is an integer"); Assert.IsTrue(actualResults[4].Contains(IncorrectNumberOfAddressFields), "Expected true when Sic code is not an integer"); }
public async Task ShouldFailWhenRequiredFieldIsMissing() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=,a2,a3,t1,c1,c2,pc1", "23TYLBLB=a1,a2,a3,,c1,c2,pc1", "RWT2TY62=a1,a2,a3,t1,c1,c2,"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(4, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(Address1IsRequired), "Expected true when address1 is missing"); Assert.IsTrue(actualResults[1].Contains(TownCityIsRequired), "Expected true when town\\city is missing"); Assert.IsTrue(actualResults[2].Contains(PostcodeIsRequired), "Expected true when postcode is missing"); }
public async Task ShouldFailWhenOrganisationIsNotActive() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "TY67R5T6=1311", "DR994D7L=1241"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(3, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(OrganisationMustBeActive), "Expected true when an organisation is not active"); Assert.IsFalse(actualResults[1].Contains(OrganisationMustBeActive), "Expected false when an organisation is active"); }
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 AdminController_ManualChanges_POST_ShouldFailWhenPublicSectorTypeDoesNotExist() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testOrgSecTypesData, testSecTypesData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1412", "DR994D7L=2", "23TYLBLB=355"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetPublicSectorTypeCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(4, actualResults.Length); Assert.IsTrue( actualResults[0].Contains("public sector type 1412 does not exist"), "Expected false when public sector type doesn't exist"); Assert.IsFalse(actualResults[1].Contains("does not exist"), "Expected true when public sector type exists"); Assert.IsTrue( actualResults[2].Contains("public sector type 355 does not exist"), "Expected false when public sector type doesn't exist"); }
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_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_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_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 async Task ShouldFailWhenNoLinesSupplied() { // Arrange var thisTestDbObjects = new object[] { testUser }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); var thisTestParameters = ""; ManualChangesViewModel testManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act IActionResult result = await thisTestAdminController.ManualChanges(testManualChangesVm); // Assert Assert.AreEqual(MustSupplyOneOrMore, thisTestAdminController.ModelState[""].Errors[0].ErrorMessage); }
public async Task ShouldPassWhenLinesAreSupplied() { // Arrange var thisTestDbObjects = new object[] { testUser }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); var thisTestParameters = "SOMETHING"; ManualChangesViewModel testManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); // Act var manualChangesViewResult = await thisTestAdminController.ManualChanges(testManualChangesVm) as ViewResult; // Assert Assert.NotNull(manualChangesViewResult, "Expected ViewResult"); var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); }
public async Task ShouldReplaceEmployerAddress() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=Some House,1 Some Street,,Some Town,,,PC1 11RT", "D43TYU76=PO BOX 12,,,Another Town,,,PC2 55RT"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); thisTestManualChangesVm.LastTestedCommand = SetOrganisationAddressesCommand; thisTestManualChangesVm.LastTestedInput = thisTestParameters.ReplaceI(Environment.NewLine, ";"); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(3, actualResults.Length); Core.Entities.Organisation org1 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "6B2LF57C"); Assert.AreEqual("Some House, 1 Some Street, Some Town, PC1 11RT", org1.LatestAddress.GetAddressString()); Assert.AreEqual( "1: 6B2LF57C: Address=No previous address has been set to Some House,1 Some Street,,Some Town,,,PC1 11RT", actualResults[0]); Core.Entities.Organisation org2 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "D43TYU76"); Assert.AreEqual("PO BOX 12, Another Town, PC2 55RT", org2.LatestAddress.GetAddressString()); Assert.AreEqual( "2: D43TYU76: Address=No previous address has been set to PO BOX 12,,,Another Town,,,PC2 55RT", actualResults[1]); }
public async Task AdminController_ManualChanges_POST_ShouldUpdateOrganisationPublicSectorType() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testSecTypesData, testOrgSecTypesData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1", "D43TYU76=2"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetPublicSectorTypeCommand, thisTestParameters); thisTestManualChangesVm.LastTestedCommand = SetPublicSectorTypeCommand; thisTestManualChangesVm.LastTestedInput = thisTestParameters.ReplaceI(Environment.NewLine, ";"); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(3, actualResults.Length); Core.Entities.Organisation org1 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "6B2LF57C"); Assert.AreEqual(1, org1.LatestPublicSectorType.PublicSectorTypeId); Assert.AreEqual( "1: 6B2LF57C:org 1 public sector type=No previous public sector type has been set to public sector type 1", actualResults[0]); Core.Entities.Organisation org2 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "D43TYU76"); Assert.AreEqual(2, org2.LatestPublicSectorType.PublicSectorTypeId); Assert.AreEqual( "2: D43TYU76:org 9 public sector type=No previous public sector type has been set to public sector type 2", actualResults[1]); }
public async Task ShouldReplaceEmployerSicCodes() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData, testSicCodeData, testOrgSicCodeData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", "6B2LF57C=1111", "23TYLBLB=3333"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationSicCodesCommand, thisTestParameters); thisTestManualChangesVm.LastTestedCommand = SetOrganisationSicCodesCommand; thisTestManualChangesVm.LastTestedInput = thisTestParameters.ReplaceI(Environment.NewLine, ";"); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(3, actualResults.Length); Core.Entities.Organisation org1 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "6B2LF57C"); Assert.AreEqual("1111", org1.GetSicCodeIdsString()); Assert.AreEqual("1: 6B2LF57C: SIC codes=1 has been set to 1111", actualResults[0]); Core.Entities.Organisation org2 = thisTestAdminController.SharedBusinessLogic.DataRepository.GetAll <Core.Entities.Organisation>() .SingleOrDefault(x => x.EmployerReference == "23TYLBLB"); Assert.AreEqual("3333", org2.GetSicCodeIdsString()); Assert.AreEqual("2: 23TYLBLB: SIC codes=3 has been set to 3333", actualResults[1]); }
public async Task ShouldFailWhenAddressFieldLongerThan100() { // Arrange var thisTestDbObjects = new object[] { testUser, testOrgData }; var thisTestAdminController = UiTestHelper.GetController <AdminController>(testUser.UserId, null, thisTestDbObjects); string thisTestParameters = string.Join( "\r\n", $"6B2LF57C={"".PadLeft(101, 'z')},a2,a3,t1,c1,c2,pc1", $"23TYLBLB=a1,{"".PadLeft(101, 'z')},a3,t1,c1,c2,pc1", $"RWT2TY62=a1,a2,{"".PadLeft(101, 'z')},t1,c1,c2,pc1", $"ADCE324T=a1,a2,a3,{"".PadLeft(101, 'z')},c1,c2,pc1", $"GR2H67UI=a1,a2,a3,t1,{"".PadLeft(101, 'z')},c2,pc1", $"FG34RT65=a1,a2,a3,t1,c1,{"".PadLeft(101, 'z')},pc1", $"D43TYU76=a1,a2,a3,t1,c1,c2,{"".PadLeft(101, 'z')}"); ManualChangesViewModel thisTestManualChangesVm = ManualChangesViewModelHelper.GetMock(SetOrganisationAddressesCommand, thisTestParameters); // Act var thisManualChangesVr = await thisTestAdminController.ManualChanges(thisTestManualChangesVm) as ViewResult; // Assert Assert.NotNull(thisManualChangesVr, "Expected ViewResult"); var actualManualChangesViewModel = thisManualChangesVr.Model as ManualChangesViewModel; Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel"); string[] actualResults = actualManualChangesViewModel.Results.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None); Assert.AreEqual(8, actualResults.Length); Assert.IsTrue(actualResults[0].Contains(Address1IsGreaterThan100), "Expected true when address1 is greater 100 chars"); Assert.IsTrue(actualResults[1].Contains(Address2IsGreaterThan100), "Expected true when address2 is greater 100 chars"); Assert.IsTrue(actualResults[2].Contains(Address3IsGreaterThan100), "Expected true when address3 is greater 100 chars"); Assert.IsTrue(actualResults[3].Contains(TownCityIsGreaterThan100), "Expected true when town\\city is greater 100 chars"); Assert.IsTrue(actualResults[4].Contains(CountyIsGreaterThan100), "Expected true when county is greater 100 chars"); Assert.IsTrue(actualResults[5].Contains(CountryIsGreaterThan100), "Expected true when country is greater 100 chars"); Assert.IsTrue(actualResults[6].Contains(PostcodeIsGreaterThan100), "Expected true when postcode is greater 100 chars"); }
public async Task AdminController_ManualChanges_POST_When_Command_Was_Not_Implemented_Returns_Error_Async() { // Arrange User notAdminUser = UserHelper.GetDatabaseAdmin(); var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, notAdminUser); ManualChangesViewModel manualChangesViewModelMockObject = ManualChangesViewModelHelper.GetMock("Some undefined command", string.Empty); // 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[""]; ModelError reportedError = modelState.Errors.First(); // Assert Assert.Multiple( () => { Assert.AreEqual("ERROR: The command 'Some undefined command' has not yet been implemented", reportedError.ErrorMessage); Assert.IsNull(actualManualChangesViewModel.SuccessMessage); Assert.AreEqual("", actualManualChangesViewModel.Results); Assert.IsNull(actualManualChangesViewModel.LastTestedCommand); Assert.IsNull(actualManualChangesViewModel.LastTestedInput); Assert.IsFalse(actualManualChangesViewModel.Tested); Assert.IsNull(actualManualChangesViewModel.Comment); }); }