Вытащил солюшен на уровень выше, чтобы прощё было дотнетить

VisaApiTests/Tests/Application/Validation/VisaApplications/PastVisaModelValidatorTests.cs

@@ -0,0 +1,140 @@
+using System.Text;
+using ApplicationLayer.InfrastructureServicesInterfaces;
+using ApplicationLayer.Services.VisaApplications.Models;
+using ApplicationLayer.Services.VisaApplications.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.VisaApplications.Requests;
+using VisaApi.Services;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.VisaApplications
+{
+    public class PastVisaModelValidatorTests
+    {
+        private readonly static IDateTimeProvider dateTimeProvider = new TestDateTimeProvider();
+        private readonly static IValidator<PastVisaModel> validator = new PastVisaModelValidator(dateTimeProvider);
+        private readonly static PastVisaModelFaker faker = new(dateTimeProvider);
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for empty expiration date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyExpirationDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.ExpirationDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(2); //expected error + error because of expiration date less than issue date
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for expiration date less than issue date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForExpirationDateLessThanIssueDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.ExpirationDate = model.IssueDate.AddDays(-4);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for empty issue date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyIssueDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.IssueDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.IssueDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for issue date greater than current date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForIssueDateGreaterThanCurrentDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.IssueDate = dateTimeProvider.Now().AddDays(4);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.IssueDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for empty name
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyNameShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.Name = string.Empty;
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Name))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for too long name
+        /// </summary>
+        [Fact]
+        private async Task ValidateForTooLongNameShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append('d', ConfigurationConstraints.VisaNameLength + 1);
+            model.Name = stringBuilder.ToString();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Name))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return error for not valid name
+        /// </summary>
+        [Fact]
+        private async Task ValidateForNotValidNameShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.Name = "|}{%^&";
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Name))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisaModel"/> validator that should return no errors for valid model
+        /// </summary>
+        [Fact]
+        private async Task ValidateForValidShouldReturnNoErrors()
+        {
+            var model = faker.GenerateValid();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Should().BeEmpty();
+        }
+    }
+}

VisaApiTests/Tests/Application/Validation/VisaApplications/PastVisitModelValidatorTests.cs

@@ -0,0 +1,142 @@
+using System.Text;
+using ApplicationLayer.InfrastructureServicesInterfaces;
+using ApplicationLayer.Services.VisaApplications.Models;
+using ApplicationLayer.Services.VisaApplications.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.VisaApplications.Requests;
+using VisaApi.Services;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.VisaApplications
+{
+    public class PastVisitModelValidatorTests
+    {
+        private readonly static IDateTimeProvider dateTimeProvider = new TestDateTimeProvider();
+        private readonly static IValidator<PastVisitModel> validator = new PastVisitModelValidator(dateTimeProvider);
+        private readonly static PastVisitModelFaker faker = new(dateTimeProvider);
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for empty start date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyStartDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.StartDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.StartDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for start date greater than end date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForStartDateGreaterThanEndDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.EndDate = dateTimeProvider.Now().AddDays(-10);
+            model.StartDate = model.EndDate.AddDays(4);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.StartDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for empty end date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyEndDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.EndDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.EndDate))
+                .Should().HaveCount(1); //expected error + error because of end date less than start date
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for start date greater than current date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForStartDateGreaterThanCurrentDateShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.StartDate = dateTimeProvider.Now().AddDays(4);
+            model.EndDate = model.StartDate.AddDays(4);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.StartDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for empty destination Country
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyDestinationCountryShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.DestinationCountry = string.Empty;
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.DestinationCountry))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for too long destination Country
+        /// </summary>
+        [Fact]
+        private async Task ValidateForTooLongDestinationCountryShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append('d', ConfigurationConstraints.CountryNameLength + 1);
+            model.DestinationCountry = stringBuilder.ToString();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.DestinationCountry))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return error for not valid destination Country
+        /// </summary>
+        [Fact]
+        private async Task ValidateForNotValidDestinationCountryShouldReturnError()
+        {
+            var model = faker.GenerateValid();
+            model.DestinationCountry = "|}{%^&";
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.DestinationCountry))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PastVisitModel"/> validator that should return no errors for valid model
+        /// </summary>
+        [Fact]
+        private async Task ValidateForValidShouldReturnNoErrors()
+        {
+            var model = faker.GenerateValid();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Should().BeEmpty();
+        }
+    }
+}

VisaApiTests/Tests/Application/Validation/VisaApplications/PermissionToDestCountryModelValidatorTests.cs

@@ -0,0 +1,110 @@
+using System.Text;
+using ApplicationLayer.InfrastructureServicesInterfaces;
+using ApplicationLayer.Services.VisaApplications.Models;
+using ApplicationLayer.Services.VisaApplications.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.VisaApplications.Requests;
+using VisaApi.Services;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.VisaApplications
+{
+    public class PermissionToDestCountryModelValidatorTests
+    {
+        private readonly static IDateTimeProvider dateTimeProvider = new TestDateTimeProvider();
+        private readonly static IValidator<PermissionToDestCountryModel> validator = new PermissionToDestCountryModelValidator(dateTimeProvider);
+        private readonly static PermissionToDestCountryModelFaker faker = new(dateTimeProvider);
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return error for empty expiration date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyExpirationDateShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.ExpirationDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(2); //expected error + error because of expired
+        }
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return error for expiration date less than current date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForExpirationDateLessThanCurrentDateShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.ExpirationDate = dateTimeProvider.Now().AddDays(-1);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return error for empty issuer
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyIssuerShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.Issuer = string.Empty;
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Issuer))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return error for not valid issuer
+        /// </summary>
+        [Fact]
+        private async Task ValidateForNotValidIssuerShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.Issuer = "}{)(*&*^%#!#!:";
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Issuer))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return error for too long issuer
+        /// </summary>
+        [Fact]
+        private async Task ValidateForTooLongIssuerShouldReturnError()
+        {
+            var model = faker.Generate();
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append('g', ConfigurationConstraints.IssuerNameLength + 1);
+            model.Issuer = stringBuilder.ToString();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Issuer))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="PermissionToDestCountryModel"/> validator that should return no errors for valid model
+        /// </summary>
+        [Fact]
+        private async Task ValidateForValidShouldReturnNoErrors()
+        {
+            var model = faker.Generate();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Should().BeEmpty();
+        }
+    }
+}

VisaApiTests/Tests/Application/Validation/VisaApplications/ReentryPermitModelValidatorTests.cs

@@ -0,0 +1,110 @@
+using System.Text;
+using ApplicationLayer.InfrastructureServicesInterfaces;
+using ApplicationLayer.Services.VisaApplications.Models;
+using ApplicationLayer.Services.VisaApplications.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.VisaApplications.Requests;
+using VisaApi.Services;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.VisaApplications
+{
+    public class ReentryPermitModelValidatorTests
+    {
+        private readonly static IDateTimeProvider dateTimeProvider = new TestDateTimeProvider();
+        private readonly static IValidator<ReentryPermitModel> validator = new ReentryPermitModelValidator(dateTimeProvider);
+        private readonly static ReentryPermitModelFaker faker = new(dateTimeProvider);
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return error for empty expiration date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyExpirationDateShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.ExpirationDate = new();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(2); //expected error + error because of expired
+        }
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return error for expiration date less than current date
+        /// </summary>
+        [Fact]
+        private async Task ValidateForExpirationDateLessThanCurrentDateShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.ExpirationDate = dateTimeProvider.Now().AddDays(-1);
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return error for empty number
+        /// </summary>
+        [Fact]
+        private async Task ValidateForEmptyNumberShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.Number = string.Empty;
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Number))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return error for not valid number
+        /// </summary>
+        [Fact]
+        private async Task ValidateForNotValidNumberShouldReturnError()
+        {
+            var model = faker.Generate();
+            model.Number = "}{)(*&*^%#!#!:";
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Number))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return error for too long number
+        /// </summary>
+        [Fact]
+        private async Task ValidateForTooLongNumberShouldReturnError()
+        {
+            var model = faker.Generate();
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append('g', ConfigurationConstraints.ReentryPermitNumberLength + 1);
+            model.Number = stringBuilder.ToString();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Where(error => error.PropertyName == nameof(model.Number))
+                .Should().HaveCount(1);
+        }
+
+        /// <summary>
+        /// Test for <see cref="ReentryPermitModel"/> validator that should return no errors for valid model
+        /// </summary>
+        [Fact]
+        private async Task ValidateForValidShouldReturnNoErrors()
+        {
+            var model = faker.Generate();
+
+            var result = await validator.ValidateAsync(model);
+
+            result.Errors.Should().BeEmpty();
+        }
+    }
+}