DigitalData.Core/DigitalData.Core.Tests/Infrastructure/DbRepositoryTests.cs

namespace DigitalData.Core.Tests.Infrastructure;

using DigitalData.Core.Infrastructure;
using DigitalData.Core.Tests.Mock;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Reflection;
using DigitalData.Core.Abstractions.Infrastructure;

public class DbRepositoryTests
{
    private IHost _host;

    private IRepository<User> _userRepo;

    [SetUp]
    public void Setup()
    {
        var builder = Host.CreateApplicationBuilder();

        builder.Services.AddDbContext<MockDbContext>(opt => opt.UseInMemoryDatabase("MockDB"));

        builder.Services.AddDbRepository<MockDbContext, User>(context => context.Users);

        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());

        _host = builder.Build();

        _userRepo = _host.Services.GetRequiredService<IRepository<User>>();
    }

    [TearDown]
    public void TearDown()
    {
        if (_host is IDisposable disposableHost)
            disposableHost.Dispose();
    }

    [TestCase(true, TestName = "WhenGivenMultipleUsers")]
    [TestCase(false, TestName = "WhenGivenSingleUser")]
    public void CreateAsync_ShouldNotThrow(bool multiple)
    {
        // Arrange
        var faker = Fake.CreateUserFaker();

        // Act & Assert
        if (multiple)
            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate(Random.Shared.Next(1, 10))));
        else
            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate()));
    }

    [TestCase(true, TestName = "WhenGivenMultipleUsers")]
    [TestCase(false, TestName = "WhenGivenSingleUser")]
    public async Task ReadAsync_ShouldReturnCreated(bool multiple)
    {
        // Arrange
        var faker = Fake.CreateUserFaker();
        var user = faker.Generate();

        // Act
        var createdUser = await _userRepo.CreateAsync(user);
        var readUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);

        // Assert
        Assert.That(createdUser, Is.EqualTo(readUser));
    }
}