From 7250dda9347e54c6cbe289d6142b5ecf2a4e0cbc Mon Sep 17 00:00:00 2001 From: Kyle Linden Date: Tue, 1 Nov 2016 12:37:06 -0400 Subject: [PATCH] tighter validation and model updates Updates to validation to validate correct values for Response fields. Also moved around and removed some fields from the model to reflect UI changes. --- .../ApplicationSubmissionValidator.cs | 23 +--- .../Validators/EmployeeValidator.cs | 2 +- .../Validators/EmployerValidator.cs | 22 +-- .../Validators/WIOAWorkerValidator.cs | 2 +- .../Validators/WageTypeInfoValidator.cs | 2 +- .../Validators/WorkSiteValidator.cs | 2 +- .../ApplicationDbContext.cs | 10 +- .../DOL.WHD.Section14c.DataAccess.csproj | 7 + ...4_MoveProvidingFacilitiesField.Designer.cs | 29 ++++ ...1011606064_MoveProvidingFacilitiesField.cs | 68 ++++++++++ ...11606064_MoveProvidingFacilitiesField.resx | 126 ++++++++++++++++++ .../DOL.WHD.Section14c.Domain.csproj | 2 +- .../Submission/ApplicationSubmission.cs | 32 ----- .../Models/Submission/EmployerInfo.cs | 21 ++- ...erInfoProvidingFacilitiesDeductionType.cs} | 6 +- .../ApplicationSubmissionValidatorTests.cs | 63 +++------ .../Validators/EmployeeValidatorTests.cs | 7 + .../Validators/EmployerValidatorTests.cs | 60 ++++++++- .../HourlyWageInfoValidatorTests.cs | 7 + .../PieceRateWageInfoValidatorTests.cs | 7 + .../Validators/WIOAWorkerValidatorTests.cs | 7 + .../Validators/WorkSiteValidatorTests.cs | 7 + 22 files changed, 387 insertions(+), 125 deletions(-) create mode 100644 DOL.WHD.Section14c.DataAccess/Migrations/201611011606064_MoveProvidingFacilitiesField.Designer.cs create mode 100644 DOL.WHD.Section14c.DataAccess/Migrations/201611011606064_MoveProvidingFacilitiesField.cs create mode 100644 DOL.WHD.Section14c.DataAccess/Migrations/201611011606064_MoveProvidingFacilitiesField.resx rename DOL.WHD.Section14c.Domain/Models/Submission/{ApplicationSubmissionProvidingFacilitiesDeductionType.cs => EmployerInfoProvidingFacilitiesDeductionType.cs} (53%) diff --git a/DOL.WHD.Section14c.Business/Validators/ApplicationSubmissionValidator.cs b/DOL.WHD.Section14c.Business/Validators/ApplicationSubmissionValidator.cs index 57080383..067d5eed 100644 --- a/DOL.WHD.Section14c.Business/Validators/ApplicationSubmissionValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/ApplicationSubmissionValidator.cs @@ -9,38 +9,21 @@ public class ApplicationSubmissionValidator : BaseValidator a.RepresentativePayeeSocialSecurityBenefits).NotNull(); - RuleFor(a => a.ProvidingFacilities).NotNull(); - RuleFor(a => a.ReviewedDocumentation).NotNull(); RuleFor(a => a.EIN).NotEmpty(); - RuleFor(a => a.ApplicationTypeId).NotNull(); + RuleFor(a => a.ApplicationTypeId).NotNull().GreaterThanOrEqualTo(1).LessThanOrEqualTo(2); RuleFor(a => a.HasPreviousApplication).NotNull(); RuleFor(a => a.HasPreviousCertificate).NotNull(); - RuleFor(a => a.EstablishmentType).NotNull().Must(et => et.Any()); + RuleFor(a => a.EstablishmentType).NotNull().Must(et => et.Any() && !et.Any(x => x.EstablishmentTypeId < 3) && !et.Any(x => x.EstablishmentTypeId > 6)); RuleFor(a => a.ContactName).NotEmpty(); RuleFor(a => a.ContactPhone).NotEmpty(); RuleFor(a => a.ContactEmail).NotEmpty(); - RuleFor(a => a.PayTypeId).NotEmpty(); + RuleFor(a => a.PayTypeId).NotEmpty().GreaterThanOrEqualTo(21).LessThanOrEqualTo(23); RuleFor(a => a.TotalNumWorkSites).NotNull(); RuleFor(a => a.Employer).NotNull().SetValidator(employerValidator); RuleFor(a => a.WorkSites).NotNull().Must(w => w.Any()).SetCollectionValidator(workSiteValidator); RuleFor(a => a.WIOA).NotNull().SetValidator(wioaValidator); // conditional required - RuleFor(a => a.NumEmployeesRepresentativePayee) - .NotEmpty() - .When(a => a.RepresentativePayeeSocialSecurityBenefits.GetValueOrDefault()); - - When(a => a.ProvidingFacilities.GetValueOrDefault(), () => - { - RuleFor(a => a.ProvidingFacilitiesDeductionType) - .NotNull() - .Must(p => p.Any()); - RuleFor(a => a.ProvidingFacilitiesDeductionTypeOther) - .NotEmpty() - .When(a => a.ProvidingFacilitiesDeductionType != null && a.ProvidingFacilitiesDeductionType.Any(x => x.ProvidingFacilitiesDeductionTypeId == 20)); - }); - RuleFor(a => a.CertificateNumber) .NotEmpty() .When(a => a.HasPreviousCertificate.GetValueOrDefault()); diff --git a/DOL.WHD.Section14c.Business/Validators/EmployeeValidator.cs b/DOL.WHD.Section14c.Business/Validators/EmployeeValidator.cs index 53f694d7..363218fe 100644 --- a/DOL.WHD.Section14c.Business/Validators/EmployeeValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/EmployeeValidator.cs @@ -8,7 +8,7 @@ public class EmployeeValidator : BaseValidator, IEmployeeValidator public EmployeeValidator() { RuleFor(e => e.Name).NotEmpty(); - RuleFor(e => e.PrimaryDisabilityId).NotNull(); + RuleFor(e => e.PrimaryDisabilityId).NotNull().GreaterThanOrEqualTo(31).LessThanOrEqualTo(38); RuleFor(e => e.WorkType).NotEmpty(); RuleFor(e => e.NumJobs).NotNull(); RuleFor(e => e.AvgWeeklyHours).NotNull(); diff --git a/DOL.WHD.Section14c.Business/Validators/EmployerValidator.cs b/DOL.WHD.Section14c.Business/Validators/EmployerValidator.cs index 941fed6e..c22e2f64 100644 --- a/DOL.WHD.Section14c.Business/Validators/EmployerValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/EmployerValidator.cs @@ -1,4 +1,5 @@ -using DOL.WHD.Section14c.Domain.Models.Submission; +using System.Linq; +using DOL.WHD.Section14c.Domain.Models.Submission; using FluentValidation; namespace DOL.WHD.Section14c.Business.Validators @@ -14,19 +15,27 @@ public EmployerValidator(IAddressValidator addressValidator, IWorkerCountInfoVal RuleFor(e => e.PhysicalAddress).NotNull().SetValidator(addressValidator); RuleFor(e => e.HasDifferentMailingAddress).NotNull(); RuleFor(e => e.HasParentOrg).NotNull(); - RuleFor(e => e.EmployerStatusId).NotNull(); + RuleFor(e => e.EmployerStatusId).NotNull().GreaterThanOrEqualTo(7).LessThanOrEqualTo(10); RuleFor(e => e.IsEducationalAgency).NotNull(); RuleFor(e => e.FiscalQuarterEndDate).NotEmpty(); RuleFor(e => e.NumSubminimalWageWorkers).NotNull().SetValidator(workerCountInfoValidator); RuleFor(e => e.PCA).NotNull(); - RuleFor(e => e.SCAId).NotNull(); - RuleFor(e => e.EO13658Id).NotNull(); + RuleFor(e => e.SCAId).NotNull().GreaterThanOrEqualTo(11).LessThanOrEqualTo(13); + RuleFor(e => e.EO13658Id).NotNull().GreaterThanOrEqualTo(14).LessThanOrEqualTo(16); RuleFor(e => e.RepresentativePayee).NotNull(); RuleFor(e => e.TakeCreditForCosts).NotNull(); - RuleFor(e => e.ProvidingFacilitiesDeductionTypeId).NotNull(); RuleFor(e => e.TemporaryAuthority).NotNull(); // conditional required + When(a => a.TakeCreditForCosts.GetValueOrDefault(), () => + { + RuleFor(a => a.ProvidingFacilitiesDeductionType) + .NotNull() + .Must(p => p.Any() && !p.Any(x => x.ProvidingFacilitiesDeductionTypeId < 17) && !p.Any(x => x.ProvidingFacilitiesDeductionTypeId > 20)); + RuleFor(a => a.ProvidingFacilitiesDeductionTypeOther) + .NotEmpty() + .When(a => a.ProvidingFacilitiesDeductionType != null && a.ProvidingFacilitiesDeductionType.Any(x => x.ProvidingFacilitiesDeductionTypeId == 20)); + }); RuleFor(e => e.TradeName).NotEmpty().When(e => e.HasTradeName.GetValueOrDefault()); RuleFor(e => e.PriorLegalName).NotEmpty().When(e => e.LegalNameHasChanged.GetValueOrDefault()); When(e => e.HasParentOrg.GetValueOrDefault(), () => @@ -37,9 +46,6 @@ public EmployerValidator(IAddressValidator addressValidator, IWorkerCountInfoVal RuleFor(e => e.SendMailToParent).NotNull(); }); RuleFor(e => e.EmployerStatusOther).NotEmpty().When(e => e.EmployerStatusId == 10); - RuleFor(e => e.ProvidingFacilitiesDeductionTypeOther) - .NotEmpty() - .When(e => e.ProvidingFacilitiesDeductionTypeId == 20); } } } diff --git a/DOL.WHD.Section14c.Business/Validators/WIOAWorkerValidator.cs b/DOL.WHD.Section14c.Business/Validators/WIOAWorkerValidator.cs index 796d469d..d380f521 100644 --- a/DOL.WHD.Section14c.Business/Validators/WIOAWorkerValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/WIOAWorkerValidator.cs @@ -8,7 +8,7 @@ public class WIOAWorkerValidator : BaseValidator, IWIOAWorkerValidat public WIOAWorkerValidator() { RuleFor(w => w.FullName).NotEmpty(); - RuleFor(w => w.WIOAWorkerVerifiedId).NotNull(); + RuleFor(w => w.WIOAWorkerVerifiedId).NotNull().GreaterThanOrEqualTo(39).LessThanOrEqualTo(41); } } } diff --git a/DOL.WHD.Section14c.Business/Validators/WageTypeInfoValidator.cs b/DOL.WHD.Section14c.Business/Validators/WageTypeInfoValidator.cs index 893aed65..7595f03f 100644 --- a/DOL.WHD.Section14c.Business/Validators/WageTypeInfoValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/WageTypeInfoValidator.cs @@ -10,7 +10,7 @@ public WageTypeInfoValidator(IPrevailingWageSurveyInfoValidator prevailingWageSu RuleFor(w => w.NumWorkers).NotNull(); RuleFor(w => w.JobName).NotEmpty(); RuleFor(w => w.JobDescription).NotEmpty(); - RuleFor(w => w.PrevailingWageMethodId).NotNull(); + RuleFor(w => w.PrevailingWageMethodId).NotNull().GreaterThanOrEqualTo(24).LessThanOrEqualTo(26); RuleFor(w => w.AttachmentId).NotNull(); // conditional diff --git a/DOL.WHD.Section14c.Business/Validators/WorkSiteValidator.cs b/DOL.WHD.Section14c.Business/Validators/WorkSiteValidator.cs index 72983d92..e69df594 100644 --- a/DOL.WHD.Section14c.Business/Validators/WorkSiteValidator.cs +++ b/DOL.WHD.Section14c.Business/Validators/WorkSiteValidator.cs @@ -8,7 +8,7 @@ public class WorkSiteValidator : BaseValidator, IWorkSiteValidator { public WorkSiteValidator(IAddressValidator addressValidator, IEmployeeValidator employeeValidator) { - RuleFor(w => w.WorkSiteType).NotNull().Must(wst => wst.Any()); + RuleFor(w => w.WorkSiteType).NotNull().Must(wst => wst.Any() && !wst.Any(x => x.WorkSiteTypeId < 27) && !wst.Any(x => x.WorkSiteTypeId > 30)); RuleFor(w => w.Name).NotEmpty(); RuleFor(w => w.Address).NotNull().SetValidator(addressValidator); RuleFor(w => w.SCA).NotNull(); diff --git a/DOL.WHD.Section14c.DataAccess/ApplicationDbContext.cs b/DOL.WHD.Section14c.DataAccess/ApplicationDbContext.cs index 0c0326f5..3f25f6b3 100644 --- a/DOL.WHD.Section14c.DataAccess/ApplicationDbContext.cs +++ b/DOL.WHD.Section14c.DataAccess/ApplicationDbContext.cs @@ -41,9 +41,6 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) modelBuilder.Entity().Property(a => a.PrevailingWageProvidedBySource).IsRequired(); modelBuilder.Entity().Property(a => a.DataRetrieved).IsRequired(); // ApplicationSubmission - modelBuilder.Entity().Property(a => a.RepresentativePayeeSocialSecurityBenefits).IsRequired(); - modelBuilder.Entity().Property(a => a.ProvidingFacilities).IsRequired(); - modelBuilder.Entity().Property(a => a.ReviewedDocumentation).IsRequired(); modelBuilder.Entity().Property(a => a.EIN).IsRequired(); modelBuilder.Entity().Property(a => a.ApplicationTypeId).IsRequired(); modelBuilder.Entity().Property(a => a.HasPreviousApplication).IsRequired(); @@ -86,7 +83,6 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) modelBuilder.Entity().Property(a => a.EO13658Id).IsRequired(); modelBuilder.Entity().Property(a => a.RepresentativePayee).IsRequired(); modelBuilder.Entity().Property(a => a.TakeCreditForCosts).IsRequired(); - modelBuilder.Entity().Property(a => a.ProvidingFacilitiesDeductionTypeId).IsRequired(); modelBuilder.Entity().Property(a => a.TemporaryAuthority).IsRequired(); modelBuilder.Entity().HasRequired(a => a.PhysicalAddress); modelBuilder.Entity().HasRequired(a => a.NumSubminimalWageWorkers); @@ -147,9 +143,9 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) .ToTable("AppSubmissionEstablishmentType") .HasKey(k => new {k.ApplicationSubmissionId, k.EstablishmentTypeId}); - modelBuilder.Entity() - .ToTable("AppSubmissionFacilitiesDeductionType") - .HasKey(k => new { k.ApplicationSubmissionId, k.ProvidingFacilitiesDeductionTypeId }); + modelBuilder.Entity() + .ToTable("EmployerInfoFacilitiesDeductionType") + .HasKey(k => new { k.EmployerInfoId, k.ProvidingFacilitiesDeductionTypeId }); modelBuilder.Entity() .ToTable("WorkSiteWorkSiteType") diff --git a/DOL.WHD.Section14c.DataAccess/DOL.WHD.Section14c.DataAccess.csproj b/DOL.WHD.Section14c.DataAccess/DOL.WHD.Section14c.DataAccess.csproj index 612242a4..65e6b0ac 100644 --- a/DOL.WHD.Section14c.DataAccess/DOL.WHD.Section14c.DataAccess.csproj +++ b/DOL.WHD.Section14c.DataAccess/DOL.WHD.Section14c.DataAccess.csproj @@ -195,6 +195,10 @@ 201610301837290_TableKeyUpdates.cs + + + 201611011606064_MoveProvidingFacilitiesField.cs + @@ -281,6 +285,9 @@ 201610301837290_TableKeyUpdates.cs + + 201611011606064_MoveProvidingFacilitiesField.cs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/DOL.WHD.Section14c.Domain/DOL.WHD.Section14c.Domain.csproj b/DOL.WHD.Section14c.Domain/DOL.WHD.Section14c.Domain.csproj index 40b5721e..dd41fc30 100644 --- a/DOL.WHD.Section14c.Domain/DOL.WHD.Section14c.Domain.csproj +++ b/DOL.WHD.Section14c.Domain/DOL.WHD.Section14c.Domain.csproj @@ -73,7 +73,7 @@ - + diff --git a/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmission.cs b/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmission.cs index b0bb12a5..19651c70 100644 --- a/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmission.cs +++ b/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmission.cs @@ -13,38 +13,6 @@ public ApplicationSubmission() public Guid Id { get; set; } - #region Assurances - - public bool? RepresentativePayeeSocialSecurityBenefits { get; set; } - - public int? NumEmployeesRepresentativePayee { get; set; } - - public bool? ProvidingFacilities { get; set; } - - public IEnumerable ProvidingFacilitiesDeductionTypeId - { - set - { - if (value != null) - { - ProvidingFacilitiesDeductionType = value.Select( - x => - new ApplicationSubmissionProvidingFacilitiesDeductionType - { - ProvidingFacilitiesDeductionTypeId = x, - ApplicationSubmissionId = Id - }).ToList(); - } - } - } - public ICollection ProvidingFacilitiesDeductionType { get; set; } - - public string ProvidingFacilitiesDeductionTypeOther { get; set; } - - public bool? ReviewedDocumentation { get; set; } - - #endregion - #region Application Info public string EIN { get; set; } diff --git a/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfo.cs b/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfo.cs index 4abf99b5..deb2ec2b 100644 --- a/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfo.cs +++ b/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfo.cs @@ -1,4 +1,6 @@ using System; +using System.Collections.Generic; +using System.Linq; namespace DOL.WHD.Section14c.Domain.Models.Submission { @@ -62,8 +64,23 @@ public EmployerInfo() public bool? TakeCreditForCosts { get; set; } - public int? ProvidingFacilitiesDeductionTypeId { get; set; } - public virtual Response ProvidingFacilitiesDeductionType { get; set; } + public IEnumerable ProvidingFacilitiesDeductionTypeId + { + set + { + if (value != null) + { + ProvidingFacilitiesDeductionType = value.Select( + x => + new EmployerInfoProvidingFacilitiesDeductionType + { + ProvidingFacilitiesDeductionTypeId = x, + EmployerInfoId = Id + }).ToList(); + } + } + } + public ICollection ProvidingFacilitiesDeductionType { get; set; } public string ProvidingFacilitiesDeductionTypeOther { get; set; } diff --git a/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmissionProvidingFacilitiesDeductionType.cs b/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfoProvidingFacilitiesDeductionType.cs similarity index 53% rename from DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmissionProvidingFacilitiesDeductionType.cs rename to DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfoProvidingFacilitiesDeductionType.cs index 9abf77f0..c5ec1be6 100644 --- a/DOL.WHD.Section14c.Domain/Models/Submission/ApplicationSubmissionProvidingFacilitiesDeductionType.cs +++ b/DOL.WHD.Section14c.Domain/Models/Submission/EmployerInfoProvidingFacilitiesDeductionType.cs @@ -2,10 +2,10 @@ namespace DOL.WHD.Section14c.Domain.Models.Submission { - public class ApplicationSubmissionProvidingFacilitiesDeductionType + public class EmployerInfoProvidingFacilitiesDeductionType { - public Guid ApplicationSubmissionId { get; set; } - public ApplicationSubmission ApplicationSubmission { get; set; } + public Guid EmployerInfoId { get; set; } + public EmployerInfo EmployerInfo { get; set; } public int ProvidingFacilitiesDeductionTypeId { get; set; } public Response ProvidingFacilitiesDeductionType { get; set; } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/ApplicationSubmissionValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/ApplicationSubmissionValidatorTests.cs index 67a91955..338ab598 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/ApplicationSubmissionValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/ApplicationSubmissionValidatorTests.cs @@ -21,24 +21,6 @@ public ApplicationSubmissionValidatorTests() _applicationSubmissionValidator = new ApplicationSubmissionValidator(employerValidatorMock.Object, hourlyWageInfoValidatorMock.Object, pieceRateWageInfoValidatorMock.Object, workSiteValidatorMock.Object, wioaValidatorMock.Object); } - [TestMethod] - public void Should_Require_RepresentativePayeeSocialSecurityBenefits() - { - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.RepresentativePayeeSocialSecurityBenefits, null as bool?); - } - - [TestMethod] - public void Should_Require_ProvidingFacilities() - { - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilities, null as bool?); - } - - [TestMethod] - public void Should_Require_ReviewedDocumentation() - { - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ReviewedDocumentation, null as bool?); - } - [TestMethod] public void Should_Require_EIN() { @@ -113,30 +95,6 @@ public void Should_Require_WIOA() _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.WIOA, null as WIOA); } - [TestMethod] - public void Should_Require_NumEmployeesRepresentativePayee() - { - _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.NumEmployeesRepresentativePayee, null as int?); - var model = new ApplicationSubmission {RepresentativePayeeSocialSecurityBenefits = true, NumEmployeesRepresentativePayee = null}; - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.NumEmployeesRepresentativePayee, model); - } - - [TestMethod] - public void Should_Require_ProvidingFacilitiesDeductionType() - { - _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, null as ICollection); - var model = new ApplicationSubmission {ProvidingFacilities = true, ProvidingFacilitiesDeductionType = null}; - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, model); - } - - [TestMethod] - public void Should_Require_ProvidingFacilitiesDeductionTypeOther() - { - _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, ""); - var model = new ApplicationSubmission { ProvidingFacilities = true, ProvidingFacilitiesDeductionTypeId = new List { 20 }, ProvidingFacilitiesDeductionTypeOther = null}; - _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, model); - } - [TestMethod] public void Should_Require_CertificateNumber() { @@ -168,5 +126,26 @@ public void Should_Validate_ContactEmail() { _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ContactEmail, "foo123"); } + + [TestMethod] + public void Should_Validate_ApplicationType() + { + _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.ApplicationTypeId, 5); + _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.ApplicationTypeId, 2); + } + + [TestMethod] + public void Should_Validate_EstablishmentType() + { + _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.EstablishmentType, new List { new ApplicationSubmissionEstablishmentType { EstablishmentTypeId = 9 } }); + _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.EstablishmentType, new List { new ApplicationSubmissionEstablishmentType { EstablishmentTypeId = 5 } }); + } + + [TestMethod] + public void Should_Validate_PayType() + { + _applicationSubmissionValidator.ShouldHaveValidationErrorFor(x => x.PayTypeId, 30); + _applicationSubmissionValidator.ShouldNotHaveValidationErrorFor(x => x.PayTypeId, 22); + } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/EmployeeValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/EmployeeValidatorTests.cs index 73ca9359..3905abd6 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/EmployeeValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/EmployeeValidatorTests.cs @@ -89,5 +89,12 @@ public void Should_Require_PrimaryDisabilityOther() model = new Employee { PrimaryDisabilityId = 38, PrimaryDisabilityOther = null}; _employeeValidator.ShouldHaveValidationErrorFor(e => e.PrimaryDisabilityOther, model); } + + [TestMethod] + public void Should_Validate_PrimaryDisability() + { + _employeeValidator.ShouldHaveValidationErrorFor(x => x.PrimaryDisabilityId, 40); + _employeeValidator.ShouldNotHaveValidationErrorFor(x => x.PrimaryDisabilityId, 35); + } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/EmployerValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/EmployerValidatorTests.cs index 639bc344..8d2370c0 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/EmployerValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/EmployerValidatorTests.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using DOL.WHD.Section14c.Business.Validators; using DOL.WHD.Section14c.Domain.Models; using DOL.WHD.Section14c.Domain.Models.Submission; @@ -111,9 +112,19 @@ public void Should_Require_TakeCreditForCosts() } [TestMethod] - public void Should_Require_ProvidingFacilitiesDeductionTypeId() + public void Should_Require_ProvidingFacilitiesDeductionType() { - _employerValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeId, null as int?); + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, null as ICollection); + var model = new EmployerInfo { TakeCreditForCosts = true, ProvidingFacilitiesDeductionType = null }; + _employerValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, model); + } + + [TestMethod] + public void Should_Require_ProvidingFacilitiesDeductionTypeOther() + { + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, ""); + var model = new EmployerInfo { TakeCreditForCosts = true, ProvidingFacilitiesDeductionTypeId = new List { 20 }, ProvidingFacilitiesDeductionTypeOther = null }; + _employerValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, model); } [TestMethod] @@ -179,11 +190,48 @@ public void Should_Require_EmployerStatusOther() } [TestMethod] - public void Should_Require_ProvidingFacilitiesDeductionTypeOther() + public void Should_Validate_EmployerStatus() { - _employerValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, ""); - var model = new EmployerInfo { ProvidingFacilitiesDeductionTypeId = 20, ProvidingFacilitiesDeductionTypeOther = "" }; - _employerValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionTypeOther, model); + _employerValidator.ShouldHaveValidationErrorFor(x => x.EmployerStatusId, 11); + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.EmployerStatusId, 8); + } + + [TestMethod] + public void Should_Validate_SCA() + { + _employerValidator.ShouldHaveValidationErrorFor(x => x.SCAId, 14); + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.SCAId, 11); + } + + [TestMethod] + public void Should_Validate_EO13658() + { + _employerValidator.ShouldHaveValidationErrorFor(x => x.EO13658Id, 19); + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.EO13658Id, 14); + } + + [TestMethod] + public void Should_Validate_ProvidingFacilitiesDeductionType() + { + var model = new EmployerInfo + { + ProvidingFacilitiesDeductionType = new List + { + new EmployerInfoProvidingFacilitiesDeductionType {ProvidingFacilitiesDeductionTypeId = 22} + }, + TakeCreditForCosts = true + }; + _employerValidator.ShouldHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, model); + + model = new EmployerInfo + { + ProvidingFacilitiesDeductionType = new List + { + new EmployerInfoProvidingFacilitiesDeductionType {ProvidingFacilitiesDeductionTypeId = 19} + }, + TakeCreditForCosts = true + }; + _employerValidator.ShouldNotHaveValidationErrorFor(x => x.ProvidingFacilitiesDeductionType, model); } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/HourlyWageInfoValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/HourlyWageInfoValidatorTests.cs index 14b44abe..bc0886c4 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/HourlyWageInfoValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/HourlyWageInfoValidatorTests.cs @@ -82,5 +82,12 @@ public void Should_Require_SCAWageDeterminationId() model = new HourlyWageInfo { PrevailingWageMethodId = 26, SCAWageDeterminationId = null }; _hourlyWageInfoValidator.ShouldHaveValidationErrorFor(x => x.SCAWageDeterminationId, model); } + + [TestMethod] + public void Should_Validate_PrevailingWageMethod() + { + _hourlyWageInfoValidator.ShouldHaveValidationErrorFor(x => x.PrevailingWageMethodId, 28); + _hourlyWageInfoValidator.ShouldNotHaveValidationErrorFor(x => x.PrevailingWageMethodId, 25); + } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/PieceRateWageInfoValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/PieceRateWageInfoValidatorTests.cs index 0d7231ec..831d032d 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/PieceRateWageInfoValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/PieceRateWageInfoValidatorTests.cs @@ -100,5 +100,12 @@ public void Should_Require_SCAWageDeterminationId() model = new PieceRateWageInfo { PrevailingWageMethodId = 26, SCAWageDeterminationId = null }; _pieceRateWageInfoValidator.ShouldHaveValidationErrorFor(x => x.SCAWageDeterminationId, model); } + + [TestMethod] + public void Should_Validate_PrevailingWageMethod() + { + _pieceRateWageInfoValidator.ShouldHaveValidationErrorFor(x => x.PrevailingWageMethodId, 28); + _pieceRateWageInfoValidator.ShouldNotHaveValidationErrorFor(x => x.PrevailingWageMethodId, 25); + } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/WIOAWorkerValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/WIOAWorkerValidatorTests.cs index 832918aa..c8938511 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/WIOAWorkerValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/WIOAWorkerValidatorTests.cs @@ -25,5 +25,12 @@ public void Should_Require_WIOAWorkerVerifiedId() { _wioaWorkerValidator.ShouldHaveValidationErrorFor(x => x.WIOAWorkerVerifiedId, null as int?); } + + [TestMethod] + public void Should_Validate_WIOAWorkerVerified() + { + _wioaWorkerValidator.ShouldHaveValidationErrorFor(x => x.WIOAWorkerVerifiedId, 42); + _wioaWorkerValidator.ShouldNotHaveValidationErrorFor(x => x.WIOAWorkerVerifiedId, 39); + } } } diff --git a/DOL.WHD.Section14c.Test/Business/Validators/WorkSiteValidatorTests.cs b/DOL.WHD.Section14c.Test/Business/Validators/WorkSiteValidatorTests.cs index 536f0585..064512f7 100644 --- a/DOL.WHD.Section14c.Test/Business/Validators/WorkSiteValidatorTests.cs +++ b/DOL.WHD.Section14c.Test/Business/Validators/WorkSiteValidatorTests.cs @@ -62,5 +62,12 @@ public void Should_Require_Employees() { _workSiteValidator.ShouldHaveValidationErrorFor(x => x.Employees, null as ICollection); } + + [TestMethod] + public void Should_Validate_WorkSiteType() + { + _workSiteValidator.ShouldHaveValidationErrorFor(x => x.WorkSiteType, new List { new WorkSiteWorkSiteType { WorkSiteTypeId = 35 } }); + _workSiteValidator.ShouldNotHaveValidationErrorFor(x => x.WorkSiteType, new List { new WorkSiteWorkSiteType { WorkSiteTypeId = 28 } }); + } } }