prtsie/schengen-visa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tests

Browse Source
This commit is contained in:
prtsie
2024-09-22 19:54:03 +03:00
parent a80076e2e6
commit 078e20d80e
13 changed files with 605 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
SchengenVisaApi/VisaApiTests/Fakers/Applicants/Requests/PlaceOfWorkModelFaker.cs
View File

@@ -1,6 +1,5 @@
using ApplicationLayer.Services.Applicants.Models;
using Bogus;
using Domains.ApplicantDomain;
namespace VisaApi.Fakers.Applicants.Requests;

4
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/PastVisaFaker.cs
View File

@@ -21,8 +21,8 @@ public sealed class PastVisaFaker : Faker<PastVisa>
public PastVisa GenerateValid()
{
var result = Generate();
result.IssueDate = dateTimeProvider.Now().AddDays(Random.Shared.Next(11, 900));
result.IssueDate = dateTimeProvider.Now().AddDays(-Random.Shared.Next(11, 900));
result.ExpirationDate = result.IssueDate.AddDays(Random.Shared.Next(1, 11));
return result;
}
}
}

4
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/PastVisitFaker.cs
View File

@@ -21,8 +21,8 @@ public sealed class PastVisitFaker : Faker<PastVisit>
public PastVisit GenerateValid()
{
var result = Generate();
result.StartDate = dateTimeProvider.Now().AddDays(Random.Shared.Next(11, 900));
result.StartDate = dateTimeProvider.Now().AddDays(-Random.Shared.Next(11, 900));
result.EndDate = result.StartDate.AddDays(Random.Shared.Next(1, 11));
return result;
}
}
}

10
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/PermissionToDestCountryFaker.cs
View File

@@ -11,9 +11,9 @@ public sealed class PermissionToDestCountryFaker : Faker<PermissionToDestCountry
{
public PermissionToDestCountryFaker(IDateTimeProvider dateTimeProvider)
{
RuleFor(p => p.Issuer, f => f.Company.CompanyName());
RuleFor(p => p.Issuer, f => f.Company.CompanyName());
RuleFor(p => p.ExpirationDate,
f => f.Date.Future(4, dateTimeProvider.Now()));
}
}
RuleFor(p => p.ExpirationDate,
f => f.Date.Future(4, dateTimeProvider.Now()));
}
}

28
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/Requests/PastVisaModelFaker.cs Normal file
View File

@@ -0,0 +1,28 @@
using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.VisaApplications.Models;
using Bogus;
namespace VisaApi.Fakers.VisaApplications.Requests;
/// <summary>
/// Generates past visas
/// </summary>
public sealed class PastVisaModelFaker : Faker<PastVisaModel>
{
private IDateTimeProvider dateTimeProvider;
public PastVisaModelFaker(IDateTimeProvider dateTimeProvider)
{
this.dateTimeProvider = dateTimeProvider;
RuleFor(pv => pv.Name, f => f.Random.Words());
}
public PastVisaModel GenerateValid()
{
var result = Generate();
result.IssueDate = dateTimeProvider.Now().AddDays(-Random.Shared.Next(11, 900));
result.ExpirationDate = result.IssueDate.AddDays(Random.Shared.Next(1, 11));
return result;
}
}

28
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/Requests/PastVisitModelFaker.cs Normal file
View File

@@ -0,0 +1,28 @@
using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.VisaApplications.Models;
using Bogus;
namespace VisaApi.Fakers.VisaApplications.Requests;
/// <summary>
/// Generates past visas
/// </summary>
public sealed class PastVisitModelFaker : Faker<PastVisitModel>
{
private IDateTimeProvider dateTimeProvider;
public PastVisitModelFaker(IDateTimeProvider dateTimeProvider)
{
this.dateTimeProvider = dateTimeProvider;
RuleFor(pv => pv.DestinationCountry, f => f.Address.Country());
}
public PastVisitModel GenerateValid()
{
var result = Generate();
result.StartDate = dateTimeProvider.Now().AddDays(-Random.Shared.Next(11, 900));
result.EndDate = result.StartDate.AddDays(Random.Shared.Next(1, 11));
return result;
}
}

17
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/Requests/PermissionToDestCountryModelFaker.cs Normal file
View File

@@ -0,0 +1,17 @@
using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.VisaApplications.Models;
using Bogus;
namespace VisaApi.Fakers.VisaApplications.Requests
{
public sealed class PermissionToDestCountryModelFaker : Faker<PermissionToDestCountryModel>
{
public PermissionToDestCountryModelFaker(IDateTimeProvider dateTimeProvider)
{
RuleFor(p => p.Issuer, f => f.Company.CompanyName());
RuleFor(p => p.ExpirationDate,
f => f.Date.Future(4, dateTimeProvider.Now()));
}
}
}

21
SchengenVisaApi/VisaApiTests/Fakers/VisaApplications/Requests/ReentryPermitModelFaker.cs Normal file
View File

@@ -0,0 +1,21 @@
using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.VisaApplications.Models;
using Bogus;
using Domains;
namespace VisaApi.Fakers.VisaApplications.Requests;
/// <summary>
/// Generates re-entry permissions
/// </summary>
public sealed class ReentryPermitModelFaker : Faker<ReentryPermitModel>
{
public ReentryPermitModelFaker(IDateTimeProvider dateTimeProvider)
{
RuleFor(p => p.Number,
f => f.Random.String(ConfigurationConstraints.ReentryPermitNumberLength, 'a', 'z'));
RuleFor(p => p.ExpirationDate,
f => f.Date.Future(4, dateTimeProvider.Now()));
}
}

1
SchengenVisaApi/VisaApiTests/Tests/Application/Validation/Auth/RegisterRequestValidatorTests.cs
View File

@@ -1,4 +1,3 @@
using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.AuthServices.Common;
using ApplicationLayer.Services.AuthServices.Requests;
using ApplicationLayer.Services.AuthServices.Requests.Validation;

140
SchengenVisaApi/VisaApiTests/Tests/Application/Validation/VisaApplications/PastVisaModelValidatorTests.cs Normal file
View File

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

142
SchengenVisaApi/VisaApiTests/Tests/Application/Validation/VisaApplications/PastVisitModelValidatorTests.cs Normal file
View File

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

110
SchengenVisaApi/VisaApiTests/Tests/Application/Validation/VisaApplications/PermissionToDestCountryModelValidatorTests.cs Normal file
View File

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

110
SchengenVisaApi/VisaApiTests/Tests/Application/Validation/VisaApplications/ReentryPermitModelValidatorTests.cs Normal file
View File

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