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 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");
}
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");
}
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 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 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 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 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 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");
}
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 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);
});
}
public async Task AdminController_ManualChanges_POST_ShouldFailWhenMoreThanOnePublicSectorTypeEntered()
{
// 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=1,2",
"23TYLBLB=1",
"RWT2TY62=4,8,6");
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(CanOnlyAssignOneSectorType),
"Expected to fail when multiple public sector types are given");
Assert.IsFalse(
actualResults[1].Contains(CanOnlyAssignOneSectorType),
"Expected to succeed when single public sector type is given");
Assert.IsTrue(
actualResults[2].Contains(CanOnlyAssignOneSectorType),
"Expected to fail when multiple public sector types are given");
}
public async Task AdminController_ManualChanges_POST_When_A_Generic_Exception_Happens_It_Is_Reported_Async()
{
// Arrange
var deepestLevelExceptionMessage = "Deepest level exception 'Crash'";
var deepestException = new Exception(deepestLevelExceptionMessage);
var lowestLevelExceptionMessage = "'Boom' lowest level";
var lowestLevelException = new Exception(lowestLevelExceptionMessage, deepestException);
var midLevelExceptionMessage = "Mid level 'Bang'";
var midLevelException = new Exception(midLevelExceptionMessage, lowestLevelException);
var topGenericExceptionMessage = "Top level Agregate 'Roxette'";
var topGenericException = new Exception(topGenericExceptionMessage, midLevelException);
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <OrganisationName>())
.Throws(topGenericException);
ManualChangesViewModel manualChangesViewModelMockObject =
ManualChangesViewModelHelper.GetMock("Fix organisation names", string.Empty);
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModelMockObject);
Assert.NotNull(manualChangesResult);
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
ModelStateEntry modelState = adminController.ModelState[""];
// Assert
int actualNumberOfErrors = modelState.Errors.Count;
Assert.AreEqual(1, actualNumberOfErrors, "This test must return only one error");
ModelError actualMidLevelError = modelState.Errors.FirstOrDefault();
Assert.Multiple(
() => {
Assert.AreEqual(deepestLevelExceptionMessage, actualMidLevelError.ErrorMessage); // only reports 'deepest level' error
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.IsFalse(actualManualChangesViewModel.Tested);
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
public async Task AdminController_ManualChanges_POST_When_An_Aggregate_Exception_Happens_It_Is_Reported_Async()
{
// Arrange
var nestedExceptionMessage = "Nested exception 'smash'";
var midLevelExceptionMessage = "Mid level 'Badaboom'";
var deepestLevelExceptionMessage = "Deepest level exception 'Blam'";
var nestedException = new Exception(nestedExceptionMessage);
var arrayOfInnerExceptions = new List <Exception> {
new Exception(midLevelExceptionMessage),
new Exception("'Kaboom' lowest level", nestedException), // Message 'Kaboom' WILL NOT be showing
new Exception(deepestLevelExceptionMessage)
};
var topAggregateException = new AggregateException("Top level Agregate 'Boom'", arrayOfInnerExceptions);
#region setting up database and controller
User notAdminUser = UserHelper.GetDatabaseAdmin();
var adminController = UiTestHelper.GetController <AdminController>(notAdminUser.UserId, null, null);
Mock <IDataRepository> configurableDataRepository = AutoFacExtensions.ResolveAsMock <IDataRepository>();
configurableDataRepository
.Setup(x => x.Get <User>(It.IsAny <long>()))
.Returns(notAdminUser);
configurableDataRepository
.Setup(x => x.GetAll <OrganisationName>())
.Throws(topAggregateException);
ManualChangesViewModel manualChangesViewModelMockObject =
ManualChangesViewModelHelper.GetMock("Fix organisation names", string.Empty);
#endregion
// Act
IActionResult manualChangesResult = await adminController.ManualChanges(manualChangesViewModelMockObject);
Assert.NotNull(manualChangesResult);
var manualChangesViewResult = manualChangesResult as ViewResult;
Assert.NotNull(manualChangesViewResult, "Expected ViewResult");
var actualManualChangesViewModel = manualChangesViewResult.Model as ManualChangesViewModel;
Assert.NotNull(actualManualChangesViewModel, "Expected ManualChangesViewModel");
ModelStateEntry modelState = adminController.ModelState[""];
// Assert
int actualNumberOfErrors = modelState.Errors.Count;
Assert.AreEqual(3, actualNumberOfErrors, "This test must return three errors");
ModelError actualNestedError = modelState.Errors.First(x => x.ErrorMessage == nestedExceptionMessage);
Assert.NotNull(actualNestedError, $"List of errors was expected to contain nested error message [{nestedExceptionMessage}]");
ModelError actualMidLevelError = modelState.Errors.First(x => x.ErrorMessage == midLevelExceptionMessage);
Assert.NotNull(
actualMidLevelError,
$"List of errors was expected to contain mid level error message [{midLevelExceptionMessage}]");
ModelError actualDeepestError = modelState.Errors.First(x => x.ErrorMessage == deepestLevelExceptionMessage);
Assert.NotNull(
actualNestedError,
$"List of errors was expected to contain deepest error message [{deepestLevelExceptionMessage}]");
Assert.Multiple(
() => {
Assert.AreEqual(midLevelExceptionMessage, actualMidLevelError.ErrorMessage); // only reports 'mid level' error
Assert.IsNull(actualManualChangesViewModel.SuccessMessage);
Assert.AreEqual("", actualManualChangesViewModel.Results);
Assert.IsNull(actualManualChangesViewModel.LastTestedCommand);
Assert.IsNull(actualManualChangesViewModel.LastTestedInput);
Assert.IsFalse(actualManualChangesViewModel.Tested);
Assert.IsNull(actualManualChangesViewModel.Comment);
});
}
