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

VisaApiTests/Tests/Application/Validation/Applicants/NameModelValidatorTests.cs

@@ -0,0 +1,170 @@
+using System.Text;
+using ApplicationLayer.Services.Applicants.Models;
+using ApplicationLayer.Services.Applicants.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.Applicants.Requests;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.Applicants;
+
+public class NameModelValidatorTests
+{
+    private readonly static IValidator<NameModel> validator = new NameModelValidator();
+    private readonly static NameModelFaker faker = new();
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should throw for empty first name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyFirstNameShouldThrow()
+    {
+        var name = faker.Generate();
+        name.FirstName = null!;
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.FirstName))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should throw for empty surname
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptySurnameShouldThrow()
+    {
+        var name = faker.Generate();
+        name.Surname = null!;
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Surname))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return no errors for empty patronymic
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyPatronymicShouldReturnNoErrors()
+    {
+        var name = faker.Generate();
+        name.Patronymic = null;
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Patronymic))
+            .Should().BeEmpty();
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for too long first name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongFirstNameShouldReturnError()
+    {
+        var name = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('h', ConfigurationConstraints.NameLength + 1);
+        name.FirstName = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.FirstName))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for too long surname
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongSurnameShouldReturnError()
+    {
+        var name = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('h', ConfigurationConstraints.NameLength + 1);
+        name.Surname = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Surname))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for too long patronymic
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongPatronymicShouldReturnError()
+    {
+        var name = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('h', ConfigurationConstraints.NameLength + 1);
+        name.Patronymic = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Patronymic))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for not valid firstname
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidFirstNameShouldReturnError()
+    {
+        var name = faker.Generate();
+        name.FirstName = "&&7!**|";
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.FirstName))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for not valid surname
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidSurnameShouldReturnError()
+    {
+        var name = faker.Generate();
+        name.Surname = "&&7!**|";
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Surname))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return error for not valid patronymic
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidPatronymicShouldReturnError()
+    {
+        var name = faker.Generate();
+        name.Patronymic = "&&7!**|";
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Where(error => error.PropertyName == nameof(name.Patronymic))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="NameModel"/> validator that should return no errors for valid name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForValidNameShouldReturnNoErrors()
+    {
+        var name = faker.Generate();
+
+        var result = await validator.ValidateAsync(name);
+
+        result.Errors.Should().BeEmpty();
+    }
+}

VisaApiTests/Tests/Application/Validation/Applicants/PassportModelValidatorTests.cs

@@ -0,0 +1,174 @@
+using System.Text;
+using ApplicationLayer.InfrastructureServicesInterfaces;
+using ApplicationLayer.Services.Applicants.Models;
+using ApplicationLayer.Services.Applicants.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.Applicants.Requests;
+using VisaApi.Services;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.Applicants;
+
+public class PassportModelValidatorTests
+{
+    private readonly static IDateTimeProvider dateTimeProvider = new TestDateTimeProvider();
+    private readonly static IValidator<PassportModel> validator = new PassportModelValidator(dateTimeProvider);
+    private readonly static PassportModelFaker faker = new();
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> 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="PassportModel"/> validator that should return error for too long number
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongNumberShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('d', ConfigurationConstraints.PassportNumberLength + 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="PassportModel"/> validator that should return error for not valid number
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidNumberShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Number = "&?%$24asd\\]|";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.Number))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> 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="PassportModel"/> validator that should return error for too long issuer
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongIssuerShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('d', 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="PassportModel"/> validator that should return error for not valid issuer
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidIssuerShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Issuer = "&?%$24asd\\]|";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.Issuer))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> validator that should return error for expired passport
+    /// </summary>
+    [Fact]
+    private async Task ValidateForExpiredPassportShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.ExpirationDate = dateTimeProvider.Now().AddDays(-10);
+        model.IssueDate = model.ExpirationDate.AddDays(-10);
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.ExpirationDate))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> validator that should return error for passport from future
+    /// </summary>
+    [Fact]
+    private async Task ValidateForPassportFromFutureShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.ExpirationDate = dateTimeProvider.Now().AddDays(10);
+        model.IssueDate = model.ExpirationDate.AddDays(-3);
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.IssueDate))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> validator that should return error for passport that expired before issue
+    /// </summary>
+    [Fact]
+    private async Task ValidateForPassportExpiredBeforeIssueShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.ExpirationDate = dateTimeProvider.Now().AddDays(10);
+        model.IssueDate = model.ExpirationDate.AddDays(3);
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.IssueDate))
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PassportModel"/> validator that should return no errors for valid passport
+    /// </summary>
+    [Fact]
+    private async Task ValidateForValidPassportShouldReturnNoErrors()
+    {
+        var model = faker.Generate();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Should().BeEmpty();
+    }
+}

VisaApiTests/Tests/Application/Validation/Applicants/PlaceOfWorkModelValidatorTests.cs

@@ -0,0 +1,353 @@
+using System.Text;
+using ApplicationLayer.Services.Applicants.Models;
+using ApplicationLayer.Services.Applicants.Models.Validation;
+using Domains;
+using FluentAssertions;
+using FluentValidation;
+using VisaApi.Fakers.Applicants.Requests;
+using Xunit;
+
+namespace VisaApi.Tests.Application.Validation.Applicants;
+
+public class PlaceOfWorkModelValidatorTests
+{
+    private readonly static IValidator<PlaceOfWorkModel> validator = new PlaceOfWorkModelValidator();
+    private readonly static PlaceOfWorkModelFaker faker = new();
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty phone num
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyPhoneNumShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.PhoneNum = string.Empty;
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.PhoneNum))
+            .Should().NotBeEmpty();
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for long phone num
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongPhoneNumShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('8', ConfigurationConstraints.PhoneNumberLength + 1);
+        model.PhoneNum = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.PhoneNum))
+            .Should().NotBeEmpty();
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for short phone num
+    /// </summary>
+    [Fact]
+    private async Task ValidateForShortPhoneNumShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('8', ConfigurationConstraints.PhoneNumberMinLength - 1);
+        model.PhoneNum = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.PhoneNum))
+            .Should()
+            .HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for not valid phone num
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidPhoneNumShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('a', ConfigurationConstraints.PhoneNumberMinLength);
+        model.PhoneNum = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == nameof(model.PhoneNum))
+            .Should()
+            .HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should throw exception for null address
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyAddressShouldThrow()
+    {
+        var model = faker.Generate();
+        model.Address = null!;
+        NullReferenceException? result = null;
+
+        try
+        {
+            await validator.ValidateAsync(model);
+        }
+        catch (Exception e)
+        {
+            result = e as NullReferenceException;
+        }
+
+        result.Should().NotBeNull();
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty Country
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyCountryShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Country = "";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Country")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for too long Country
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongCountryShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('a', ConfigurationConstraints.CountryNameLength + 1);
+        model.Address.Country = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Country")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for not valid Country
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidCountryShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Country = "|&%";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Country")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty City
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyCityShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.City = "";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.City")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for too long city
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongCityShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('a', ConfigurationConstraints.CityNameLength + 1);
+        model.Address.City = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.City")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for not valid city
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidCityShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.City = "|&%";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.City")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty street
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyStreetShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Street = "";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Street")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for too long street
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongStreetShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('a', ConfigurationConstraints.StreetNameLength + 1);
+        model.Address.Street = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Street")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for not valid street
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidStreetShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Street = "|&%";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Street")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty building        /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyBuildingShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Building = "";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Building")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for too long building
+    /// </summary>
+    [Fact]
+    private async Task ValidateForLongBuildingShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('a', ConfigurationConstraints.BuildingNumberLength + 1);
+        model.Address.Building = stringBuilder.ToString();
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Building")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for not valid building
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidBuildingShouldReturnError()
+    {
+        var model = faker.Generate();
+        model.Address.Building = "|&%";
+
+        var result = await validator.ValidateAsync(model);
+
+        result.Errors.Where(error => error.PropertyName == "Address.Building")
+            .Should().HaveCount(1);
+    }
+
+    /// <summary>
+    /// Test for <see cref="PlaceOfWorkModel"/> validator that should return error for empty name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForEmptyNameShouldReturnError()
+    {
+        var model = faker.Generate();
+        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="PlaceOfWorkModel"/> validator that should return error for too long name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForTooLongNameShouldReturnError()
+    {
+        var model = faker.Generate();
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append('g', ConfigurationConstraints.PlaceOfWorkNameLength + 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="PlaceOfWorkModel"/> validator that should return error for not valid name
+    /// </summary>
+    [Fact]
+    private async Task ValidateForNotValidNameShouldReturnError()
+    {
+        var model = faker.Generate();
+        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="PlaceOfWorkModel"/> 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();
+    }
+}