monorepo/LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateUploadInfoServiceTest.cs

using LCU.Library.Internal.LoanRateModels.Entities;
using LCU.API.Internal.LoanRateLib.Repositories;
using LCU.API.Internal.LoanRate.Services;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.LcuClassPatterns.CrudTests.Tests;
using LCU.Library.Internal.LcuClassPatterns.CrudTests.Utilities;
using LCU.Library.Internal.LoanRateModels.Requests;
using LCU.Library.Internal.TypeExtensions.ObjectExtensions;

namespace LCU.API.Internal.LoanRateTests.ServiceTests;

public class RateUploadInfoServiceTest : CrudServiceTest<RateUploadInfo>
{
    private readonly Mock<IRateUploadInfoRepository> _mockRateUploadInfoRepository = new();
    private readonly Mock<IRateService> _mockRateService = new();
    private readonly IRateUploadInfoService _service;
    
    public RateUploadInfoServiceTest()
    {
        _service = new RateUploadInfoService(_mockRateUploadInfoRepository.Object, _mockRateService.Object);
    }
    
    [Fact]
    public async void RateUploadInfo_GetLatest_Success()
    {
        var version = (int)typeof(int).GetRandomValue();
        var dateNow = DateTime.Now;
        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            EffectiveDate = dateNow,
            Version = version
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync()).ReturnsAsync(rateUploadInfo).Verifiable();

        var result = await _service.GetLatestAsync();
        
        Assert.NotNull(result);
        Assert.Equal(rateUploadInfo.Version, result.Version);
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
    }

    [Fact]
    public async void RateUploadInfo_GetLatest_Success_NotFound()
    {
        RateUploadInfo? previousRateUploadInfo = null;

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
            .ReturnsAsync(previousRateUploadInfo).Verifiable();

        var result = await _service.GetLatestAsync();
        Assert.Null(result);
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
    }

    [Fact]
    public void RateUploadInfo_GetLatest_Failure_Exception()
    {
        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetLatestAsync());

        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
    }
    
    [Fact]
    public async void RateUploadInfo_GetByVersion_Success()
    {
        var version = (int)typeof(int).GetRandomValue();
        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            Version = version
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
            .ReturnsAsync(rateUploadInfo).Verifiable();

        var result = await _service.GetByVersionAsync(version, effectiveDate);
        
        Assert.NotNull(result);
        Assert.Equal(rateUploadInfo.RateUploadInfoId, result.RateUploadInfoId);
        Assert.Equal(rateUploadInfo.Version, result.Version);
        _mockRateUploadInfoRepository.Verify(x => x.FindByVersionAsync(version, effectiveDate), Times.Once);
    }

    [Fact]
    public async void RateUploadInfo_GetByVersion_Success_NotFound()
    {
        var version = (int)typeof(int).GetRandomValue();
        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
        RateUploadInfo rateUploadInfo = null;

        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
            .ReturnsAsync(rateUploadInfo).Verifiable();

        var result = await _service.GetByVersionAsync(version, effectiveDate);
        Assert.Null(result);
        _mockRateUploadInfoRepository.Verify(x => x.FindByVersionAsync(version, effectiveDate), Times.Once);
    }

    [Fact]
    public void RateUploadInfo_GetByVersion_Failure_Exception()
    {
        var version = (int)typeof(int).GetRandomValue();
        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
        RateUploadInfo rateUploadInfo = null;
        
        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetByVersionAsync(version, effectiveDate));

        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
    }
    
    [Fact]
    public async void RateUploadInfo_GetLatestVersionByDate_Success()
    {
        var version = (int)typeof(int).GetRandomValue();
        var dateNow = DateTime.Now;
        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            EffectiveDate = dateNow,
            Version = version
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow)).ReturnsAsync(rateUploadInfo).Verifiable();

        var result = await _service.GetLatestVersionOnDate(dateNow);
        
        Assert.NotNull(result);
        Assert.Equal(rateUploadInfo.Version, result.Version);
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(dateNow), Times.Once);
    }

    [Fact]
    public async void RateUploadInfo_GetLatestVersionByDate_Success_NotFound()
    {
        RateUploadInfo? previousRateUploadInfo = null;
        var dateNow = DateTime.Now;

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow))
            .ReturnsAsync(previousRateUploadInfo).Verifiable();

        var result = await _service.GetLatestVersionOnDate(dateNow);
        Assert.Null(result);
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(dateNow), Times.Once);
    }

    [Fact]
    public void RateUploadInfo_GetLatestVersionByDate_Failure_Exception()
    {
        var dateNow = DateTime.Now;
        
        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetLatestVersionOnDate(dateNow));

        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
    }
    
    [Fact]
    public async void RateUploadInfo_ComplexSave_Success()
    {
        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
        var version = (int)typeof(int).GetRandomValue();

        var rates = new List<Rate>
        {
            new() { RateId = (int)typeof(int).GetRandomValue() },
            new() { RateId = (int)typeof(int).GetRandomValue() },
            new() { RateId = (int)typeof(int).GetRandomValue() }
        };    
        
        var request = new RateUploadInfoRequest
        {
            EffectiveDate = effectiveDate,
            Rates = rates
        };

        var originalRateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            Version = version,
            EffectiveDate = effectiveDate.AddDays(-25)
        };

        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            Version = version + 1,
            EffectiveDate = effectiveDate,
            Filename = "Complex Save Test",
            ClosedRates = rates,
            Rates = rates.DeepCopy()
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(effectiveDate))
            .ReturnsAsync(originalRateUploadInfo).Verifiable();

        _mockRateUploadInfoRepository.Setup(x => x.AddAsync(It.IsAny<RateUploadInfo>()))
            .ReturnsAsync(rateUploadInfo).Verifiable();

        var result = await _service.ComplexSave(request);
        
        Assert.NotNull(result);
        Assert.Equal(rateUploadInfo.RateUploadInfoId, result.RateUploadInfoId);
        Assert.Equal(rateUploadInfo.Version, result.Version);
        Assert.Equal(rateUploadInfo.Rates.Count, result.ClosedRates?.Count);
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(effectiveDate), Times.Once);
        _mockRateUploadInfoRepository.Verify(x => x.AddAsync(It.IsAny<RateUploadInfo>()), Times.Once);
    }
    
    [Fact]
    public void RateUploadInfo_ComplexSave_Failure_Exception()
    {
        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
        RateUploadInfoRequest request = null;
        
        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(effectiveDate))
            .Throws(new Exception("Test")).Verifiable();

        Assert.ThrowsAsync<ServiceException>(async () => await _service.ComplexSave(request));

        _mockRateUploadInfoRepository.Verify(x => x.AddAsync(It.IsAny<RateUploadInfo>()), Times.Never);
    }
    
    [Fact]
    public async void RateUploadInfo_ComplexDelete_Success()
    {
        var closedRates = new List<Rate>
        {
            new () { RateId = (int)typeof(int).GetRandomValue() },
            new () { RateId = (int)typeof(int).GetRandomValue() },
            new() { RateId = (int)typeof(int).GetRandomValue() }
        };
        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            Rates = new List<Rate>
            {
                new () { RateId = (int)typeof(int).GetRandomValue() },
                new () { RateId = (int)typeof(int).GetRandomValue() },
                new() { RateId = (int)typeof(int).GetRandomValue() }
            }
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
            .ReturnsAsync(rateUploadInfo).Verifiable();
        _mockRateService.Setup(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId))
            .ReturnsAsync(closedRates).Verifiable();
        _mockRateUploadInfoRepository.Setup(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId))
            .ReturnsAsync(rateUploadInfo).Verifiable();

        await _service.ComplexDelete(rateUploadInfo.RateUploadInfoId);
        
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
        _mockRateService.Verify(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Once);
        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(rateUploadInfo), Times.Once);
    }
    
    [Fact]
    public async void RateUploadInfo_ComplexDelete_Success_NoClosedRates()
    {
        var closedRates = new List<Rate>();
        var rateUploadInfo = new RateUploadInfo
        {
            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
            Rates = new List<Rate>
            {
                new () { RateId = (int)typeof(int).GetRandomValue() },
                new () { RateId = (int)typeof(int).GetRandomValue() },
                new() { RateId = (int)typeof(int).GetRandomValue() }
            }
        };

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
            .ReturnsAsync(rateUploadInfo).Verifiable();
        _mockRateService.Setup(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId))
            .ReturnsAsync(closedRates).Verifiable();
        _mockRateUploadInfoRepository.Setup(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId))
            .ReturnsAsync(rateUploadInfo).Verifiable();

        await _service.ComplexDelete(rateUploadInfo.RateUploadInfoId);
        
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
        _mockRateService.Verify(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(rateUploadInfo), Times.Once);
    }

    [Fact]
    public async void RateUploadInfo_ComplexDelete_Failure_Exception()
    {
        var rateUploadInfoId = (int)typeof(int).GetRandomValue();

        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
            .Throws(new Exception("Test")).Verifiable();

        await Assert.ThrowsAsync<ServiceException>(async () => await _service.ComplexDelete(rateUploadInfoId));
        
        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
        _mockRateUploadInfoRepository.Verify(x => x.FindPreviousVersion(It.IsAny<RateUploadInfo>()), Times.Never);
        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
    }

}