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