schengen-visa/SchengenVisaApi/VisaApiTests/Tests/Infrastructure/Database/Repositories/VisaApplicationsRepositoryTests.cs

using ApplicationLayer.InfrastructureServicesInterfaces;
using ApplicationLayer.Services.VisaApplications.NeededServices;
using Domains.VisaApplicationDomain;
using FluentAssertions;
using Infrastructure.Database;
using Infrastructure.Database.VisaApplications.Repositories;
using Infrastructure.Database.VisaApplications.Repositories.Exceptions;
using VisaApi.Fakers.Applicants;
using VisaApi.Fakers.Users;
using VisaApi.Fakers.VisaApplications;
using VisaApi.Services;
using Xunit;

namespace VisaApi.Tests.Infrastructure.Database.Repositories;

[Collection(Collections.ContextUsingTestCollection)]
public class VisaApplicationsRepositoryTests
{
    private readonly static UserFaker userFaker = new();
    private readonly static ApplicantFaker applicantFaker = new(GetDateTimeProvider());
    private readonly static VisaApplicationFaker applicationFaker = new(GetDateTimeProvider());

    /// <summary> Returns <see cref="IVisaApplicationsRepository"/> </summary>
    /// <param name="context"> Database context </param>
    /// <returns>Repository</returns>
    private static IVisaApplicationsRepository GetRepository(DatabaseContext context)
        => new VisaApplicationsRepository(context, context);

    /// <summary> Returns <see cref="IDateTimeProvider"/> </summary>
    private static IDateTimeProvider GetDateTimeProvider() => new TestDateTimeProvider();

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetOfApplicantAsync"/> method that should return empty if no applications added
    /// </summary>
    [Fact]
    private async Task GetOfApplicantForEmptyShouldReturnEmpty()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            await context.SaveChangesAsync();

            var result = await repository.GetOfApplicantAsync(applicant.Id, CancellationToken.None);

            result.Should().BeEmpty();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetOfApplicantAsync"/> method that should return added entities
    /// </summary>
    [Fact]
    private async Task GetOfApplicantForExistingShouldReturnEntities()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            var applications = new List<VisaApplication>();
            for (var i = 0; i < 5; i++)
            {
                var application = applicationFaker.GenerateValid(applicant);
                applications.Add(application);
                await context.AddAsync(application);
            }

            await context.SaveChangesAsync();

            var result = await repository.GetOfApplicantAsync(applicant.Id, CancellationToken.None);

            result.Should().Contain(applications).And.HaveSameCount(applications);
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetByApplicantAndApplicationIdAsync"/> method that should throw exception for not existing entities
    /// </summary>
    [Fact]
    private async Task GetApplicantIdByUserIdForNotExistingShouldThrow()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            ApplicationNotFoundByApplicantAndApplicationIdException? result = null;

            await context.SaveChangesAsync();

            try
            {
                await repository.GetByApplicantAndApplicationIdAsync(Guid.NewGuid(), Guid.NewGuid(), CancellationToken.None);
            }
            catch (Exception e)
            {
                result = e as ApplicationNotFoundByApplicantAndApplicationIdException;
            }

            result.Should().NotBeNull();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetByApplicantAndApplicationIdAsync"/> method that should throw exception for not existing applicant
    /// </summary>
    [Fact]
    private async Task GetApplicantIdByUserIdForNotExistingApplicantShouldThrow()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            var application = applicationFaker.GenerateValid(applicant);
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            await context.AddAsync(application);
            ApplicationNotFoundByApplicantAndApplicationIdException? result = null;

            await context.SaveChangesAsync();

            try
            {
                await repository.GetByApplicantAndApplicationIdAsync(Guid.NewGuid(), application.Id, CancellationToken.None);
            }
            catch (Exception e)
            {
                result = e as ApplicationNotFoundByApplicantAndApplicationIdException;
            }

            result.Should().NotBeNull();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetByApplicantAndApplicationIdAsync"/> method that should throw exception for not existing application
    /// </summary>
    [Fact]
    private async Task GetApplicantIdByUserIdForNotExistingApplicationShouldThrow()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            ApplicationNotFoundByApplicantAndApplicationIdException? result = null;

            await context.SaveChangesAsync();

            try
            {
                await repository.GetByApplicantAndApplicationIdAsync(applicant.Id, Guid.NewGuid(), CancellationToken.None);
            }
            catch (Exception e)
            {
                result = e as ApplicationNotFoundByApplicantAndApplicationIdException;
            }

            result.Should().NotBeNull();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetByApplicantAndApplicationIdAsync"/> method
    /// that should throw exception for not accessible application
    /// </summary>
    [Fact]
    private async Task GetApplicantIdByUserIdForNotAccessibleApplicationShouldThrow()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            var otherUser = userFaker.Generate();
            var otherApplicant = applicantFaker.Generate();
            otherApplicant.UserId = user.Id;
            var notAccessibleApplication = applicationFaker.GenerateValid(otherApplicant);
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            await context.AddAsync(otherUser);
            await context.AddAsync(otherApplicant);
            await context.AddAsync(notAccessibleApplication);
            ApplicationNotFoundByApplicantAndApplicationIdException? result = null;

            await context.SaveChangesAsync();

            try
            {
                await repository.GetByApplicantAndApplicationIdAsync(applicant.Id, notAccessibleApplication.Id, CancellationToken.None);
            }
            catch (Exception e)
            {
                result = e as ApplicationNotFoundByApplicantAndApplicationIdException;
            }

            result.Should().NotBeNull();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetByApplicantAndApplicationIdAsync"/> method
    /// that should return application for valid identifiers
    /// </summary>
    [Fact]
    private async Task GetApplicantIdByUserIdForValidIdsShouldReturnApplication()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            var application = applicationFaker.GenerateValid(applicant);
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            await context.AddAsync(application);

            await context.SaveChangesAsync();

            var result = await repository.GetByApplicantAndApplicationIdAsync(applicant.Id, application.Id, CancellationToken.None);

            result.Should().Be(application);
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetPendingApplicationsAsync"/> method that should return empty from empty db
    /// </summary>
    [Fact]
    private async Task GetPendingApplicationsForEmptyShouldReturnEmpty()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);

            var result = await repository.GetPendingApplicationsAsync(CancellationToken.None);

            result.Should().BeEmpty();
        }

    /// <summary>
    /// Test for <see cref="IVisaApplicationsRepository.GetPendingApplicationsAsync"/> method that should return pending applications from not empty db
    /// </summary>
    [Fact]
    private async Task GetPendingApplicationsForExistingShouldReturnExistingPending()
    {
            await using var context = InMemoryContextProvider.GetDbContext();
            var repository = GetRepository(context);
            var user = userFaker.Generate();
            var applicant = applicantFaker.Generate();
            applicant.UserId = user.Id;
            var applicationPending = applicationFaker.GenerateValid(applicant);
            applicationPending.Status = ApplicationStatus.Pending;
            var applicationNotPending = applicationFaker.GenerateValid(applicant);
            applicationNotPending.Status = ApplicationStatus.Approved;
            await context.AddAsync(user);
            await context.AddAsync(applicant);
            await context.AddAsync(applicationPending);
            await context.AddAsync(applicationNotPending);

            await context.SaveChangesAsync();

            var result = await repository.GetPendingApplicationsAsync(CancellationToken.None);

            result.Should().Contain(applicationPending).And.HaveCount(1);
        }
}