649 lines
21 KiB
C#
649 lines
21 KiB
C#
using LCU.Library.Internal.Exceptions;
|
|
using LCU.Library.Internal.LoanRateModels.Entities;
|
|
using LCU.API.Internal.LoanRateLib.Repositories;
|
|
using LCU.API.Internal.LoanRate.Services;
|
|
using LCU.Library.Internal.LcuEvaluationModels.Enums;
|
|
|
|
namespace LCU.API.Internal.LoanRateTests.ServiceTests;
|
|
|
|
public class RateServiceTest
|
|
{
|
|
private readonly Mock<IRateRepository> _mockRateRepository;
|
|
private readonly Mock<IRateSheetService> _mockRateSheetService;
|
|
private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
|
|
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
|
|
private readonly IRateService _service;
|
|
|
|
public RateServiceTest()
|
|
{
|
|
_mockRateRepository = new Mock<IRateRepository>();
|
|
_mockRateSheetService = new Mock<IRateSheetService>();
|
|
_mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
|
|
_mockUnitOfWork = new Mock<IUnitOfWork>();
|
|
_service = new RateService(_mockUnitOfWork.Object,
|
|
_mockRateRepository.Object,
|
|
_mockRateSheetService.Object,
|
|
_mockLoadTestRunInfoService.Object);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetAsync_Success()
|
|
{
|
|
var rates = new List<Rate>
|
|
{
|
|
new() { RateId = 1 },
|
|
new() { RateId = 2 },
|
|
new() { RateId = 3 }
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindAsync())
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var result = (await _service.GetAsync()).ToList();
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rates.First().RateId, result.First().RateId);
|
|
Assert.Equal(rates.Count, result.Count);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetAsync_Success_NotFound()
|
|
{
|
|
List<Rate>? rates = null;
|
|
|
|
_mockRateRepository.Setup(x => x.FindAsync())
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var result = await _service.GetAsync();
|
|
Assert.NotNull(result);
|
|
Assert.Empty(result);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindAsync())
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.GetAsync());
|
|
|
|
_mockRateRepository.Verify(x => x.FindAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByIdAsync_Success()
|
|
{
|
|
var rateId = 1;
|
|
var rate = new Rate
|
|
{
|
|
RateId = rateId
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
|
|
var result = await _service.GetByIdAsync(rateId);
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rate.RateId, result.RateId);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByIdAsync_Success_NotFound()
|
|
{
|
|
var rateId = 1;
|
|
Rate? rate = null;
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
|
|
var result = await _service.GetByIdAsync(rateId);
|
|
Assert.Null(result);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetByIdAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.GetByIdAsync(It.IsAny<int>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByDateAsync_Success()
|
|
{
|
|
var rateId = 1;
|
|
var rates = new List<Rate>{
|
|
new Rate
|
|
{
|
|
RateId = rateId
|
|
}
|
|
};
|
|
var date = Convert.ToDateTime("1/1/2023");
|
|
_mockRateRepository.Setup(x => x.FindByDateAsync(date))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var results = await _service.GetByDateAsync(date);
|
|
Assert.NotNull(results);
|
|
Assert.NotEmpty(results);
|
|
var result = results.FirstOrDefault();
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rateId, result.RateId);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByDateAsync_Success_NotFound()
|
|
{
|
|
List<Rate>? rate = null;
|
|
var date = Convert.ToDateTime("1/1/2023");
|
|
_mockRateRepository.Setup(x => x.FindByDateAsync(date))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
|
|
var results = await _service.GetByDateAsync(date);
|
|
Assert.NotNull(results);
|
|
Assert.Empty(results);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetByDateAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindByDateAsync(It.IsAny<DateTime>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.GetByDateAsync(It.IsAny<DateTime>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByDateAsync(It.IsAny<DateTime>()), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetRateHistoryAsync_Success()
|
|
{
|
|
var rate = new Rate
|
|
{
|
|
RateId = 1,
|
|
Column = "A",
|
|
Row = "2",
|
|
RateSheetId = 1
|
|
};
|
|
var rateHistory = new List<Rate>
|
|
{
|
|
new()
|
|
{
|
|
Column = rate.Column,
|
|
Row = rate.Row,
|
|
RateSheetId = rate.RateSheetId
|
|
},
|
|
new()
|
|
{
|
|
Column = rate.Column,
|
|
Row = rate.Row,
|
|
RateSheetId = rate.RateSheetId
|
|
},
|
|
new()
|
|
{
|
|
Column = rate.Column,
|
|
Row = rate.Row,
|
|
RateSheetId = rate.RateSheetId
|
|
}
|
|
};
|
|
_mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
|
|
.ReturnsAsync(rateHistory).Verifiable();
|
|
|
|
var results = (await _service.GetRateHistory(rate))?.ToList();
|
|
Assert.NotNull(results);
|
|
Assert.NotEmpty(results);
|
|
|
|
var result = results.FirstOrDefault();
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rate.RateSheetId, result.RateSheetId);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetRateHistoryAsync_Success_NotFound()
|
|
{
|
|
Rate? rate = null;
|
|
List<Rate>? rateHistory = null;
|
|
_mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
|
|
.ReturnsAsync(rateHistory).Verifiable();
|
|
|
|
var results = await _service.GetRateHistory(rate);
|
|
Assert.NotNull(results);
|
|
Assert.Empty(results);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetRateHistoryAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindRateHistoryAsync(It.IsAny<Rate>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.GetRateHistory(It.IsAny<Rate>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindRateHistoryAsync(It.IsAny<Rate>()), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetRangeByIdAsync_Success()
|
|
{
|
|
var rates = new List<Rate>
|
|
{
|
|
new() { RateId = 1 },
|
|
new() { RateId = 2 },
|
|
new() { RateId = 3 }
|
|
};
|
|
var ids = rates.Select(x => x.RateId).ToList();
|
|
|
|
_mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var results = (await _service.GetRangeByIdAsync(ids)).ToList();
|
|
Assert.NotNull(results);
|
|
Assert.Equal(rates.First().RateId, results.First().RateId);
|
|
Assert.Equal(rates.Count, results.Count);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetRangeByIdAsync_Success_NotFound()
|
|
{
|
|
List<Rate>? rates = null;
|
|
var ids = new List<int>
|
|
{
|
|
1,2,3
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var result = await _service.GetRangeByIdAsync(ids);
|
|
Assert.NotNull(result);
|
|
Assert.Empty(result);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetRangeByIdAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRangeByIdAsync(It.IsAny<List<int>>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success()
|
|
{
|
|
var rateId = 1;
|
|
var rateSheetId = 1;
|
|
var date = Convert.ToDateTime("1/1/2023");
|
|
var rates = new List<Rate>{
|
|
new Rate
|
|
{
|
|
RateId = rateId,
|
|
RateSheetId = rateSheetId,
|
|
RateStartDate = date
|
|
}
|
|
};
|
|
var evaluationIds = new List<int> { 10 };
|
|
var evaluationType = EvaluationTypes.Rule;
|
|
_mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var results = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
|
|
Assert.NotNull(results);
|
|
Assert.NotEmpty(results);
|
|
var result = results.FirstOrDefault();
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rateId, result.RateId);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success_NotFound()
|
|
{
|
|
var date = Convert.ToDateTime("1/1/2023");
|
|
List<Rate>? rates = null;
|
|
var evaluationIds = new List<int> { 10 };
|
|
var evaluationType = EvaluationTypes.Rule;
|
|
_mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
var result = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
|
|
Assert.NotNull(result);
|
|
Assert.Empty(result);
|
|
_mockRateRepository.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_SaveAsync_Success()
|
|
{
|
|
var rate = new Rate
|
|
{
|
|
Value = 4.59m
|
|
};
|
|
var RateReturned = new Rate
|
|
{
|
|
RateId = 1,
|
|
Value = 4.9m
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.AddAsync(rate))
|
|
.ReturnsAsync(RateReturned).Verifiable();
|
|
|
|
var result = await _service.SaveAsync(rate);
|
|
Assert.NotNull(result);
|
|
Assert.Equal(RateReturned.RateId, result.RateId);
|
|
Assert.Equal(RateReturned.Value, result.Value);
|
|
|
|
_mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_SaveAsync_Failure_ReturnedNull()
|
|
{
|
|
var rate = new Rate
|
|
{
|
|
Value = 4.59m
|
|
};
|
|
Rate? rateReturned = null;
|
|
|
|
_mockRateRepository.Setup(x => x.AddAsync(rate))
|
|
.ReturnsAsync(rateReturned).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveAsync(rate));
|
|
|
|
_mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_SaveAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.AddAsync(It.IsAny<Rate>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.SaveAsync(It.IsAny<Rate>()));
|
|
|
|
_mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_SaveRangeAsync_Success()
|
|
{
|
|
var rates = new List<Rate>
|
|
{
|
|
new() { Value = 4.59m },
|
|
new() { Value = 4.9m },
|
|
new() { Value = 4m }
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.AddRangeAsync(rates)).Verifiable();
|
|
|
|
await _service.SaveRangeAsync(rates);
|
|
_mockRateRepository.Verify(x =>
|
|
x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_SaveRangeAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.SaveRangeAsync(It.IsAny<IEnumerable<Rate>>()));
|
|
|
|
_mockRateRepository.Verify(x =>
|
|
x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_UpdateAsync_Success()
|
|
{
|
|
var rate = new Rate
|
|
{
|
|
RateId = 1,
|
|
Value = 4.59m
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
|
|
var result = await _service.UpdateAsync(rate);
|
|
Assert.NotNull(result);
|
|
Assert.Equal(rate.RateId, result.RateId);
|
|
Assert.Equal(rate.Value, result.Value);
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_UpdateAsync_Failure_ReturnedNull()
|
|
{
|
|
var rate = new Rate
|
|
{
|
|
Value = 4.59m
|
|
};
|
|
Rate? rateReturned = null;
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
|
|
.ReturnsAsync(rateReturned).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateAsync(rate));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_UpdateAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
|
|
.ThrowsAsync(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.UpdateAsync(It.IsAny<Rate>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_UpdateRangeAsync_Success()
|
|
{
|
|
var rates = new List<Rate>
|
|
{
|
|
new()
|
|
{
|
|
RateId = 1,
|
|
Value = 4.59m
|
|
},
|
|
new()
|
|
{
|
|
RateId = 2,
|
|
Value = 4.9m
|
|
},
|
|
new()
|
|
{
|
|
RateId = 3,
|
|
Value = 4m
|
|
}
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.UpdateRange(rates)).Verifiable();
|
|
|
|
await _service.UpdateRangeAsync(rates);
|
|
|
|
_mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Once());
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_UpdateRangeAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.UpdateRange(It.IsAny<List<Rate>>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.UpdateRangeAsync(It.IsAny<List<Rate>>()));
|
|
|
|
_mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_DeleteAsync_Success()
|
|
{
|
|
var rateId = 1;
|
|
|
|
var rate = new Rate
|
|
{
|
|
RateId = rateId,
|
|
Value = 4.59m
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
_mockRateRepository.Setup(x => x.Remove(rate)).Verifiable();
|
|
|
|
await _service.DeleteAsync(rateId);
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
|
|
_mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Once());
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_DeleteAsync_Failure_ReturnedNull()
|
|
{
|
|
var rateId = 1;
|
|
Rate? rate = null;
|
|
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
|
|
.ReturnsAsync(rate).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteAsync(rateId));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
|
|
_mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_DeleteAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.DeleteAsync(It.IsAny<int>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public async void Rate_DeleteRangeAsync_Success()
|
|
{
|
|
var rateIds = new List<int>
|
|
{
|
|
1,
|
|
2,
|
|
3
|
|
};
|
|
var rates = new List<Rate>
|
|
{
|
|
new()
|
|
{
|
|
RateId = rateIds[0],
|
|
Value = 4.59m
|
|
},
|
|
new()
|
|
{
|
|
RateId = rateIds[1],
|
|
Value = 4.9m
|
|
},
|
|
new()
|
|
{
|
|
RateId = rateIds[2],
|
|
Value = 4m
|
|
}
|
|
};
|
|
|
|
_mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds)).ReturnsAsync(rates).Verifiable();
|
|
_mockRateRepository.Setup(x => x.RemoveRange(rates)).Verifiable();
|
|
|
|
await _service.DeleteRangeAsync(rateIds);
|
|
|
|
_mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
|
|
_mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Once());
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_DeleteRangeAsync_Failure_ReturnedNull()
|
|
{
|
|
var rateIds = new List<int>
|
|
{
|
|
1,
|
|
2,
|
|
3
|
|
};
|
|
List<Rate>? rates = null;
|
|
|
|
_mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds))
|
|
.ReturnsAsync(rates).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteRangeAsync(rateIds));
|
|
|
|
_mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
|
|
_mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
[Fact]
|
|
public void Rate_DeleteRangeAsync_Failure_Exception()
|
|
{
|
|
_mockRateRepository.Setup(x => x.RemoveRange(It.IsAny<List<Rate>>()))
|
|
.Throws(new Exception("Test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () =>
|
|
await _service.DeleteRangeAsync(It.IsAny<List<int>>()));
|
|
|
|
_mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
|
|
_mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
|
|
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
} |