monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestorTests/Services/OwnerOverrideInfoServiceTest.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Moq;
using NUnit.Framework;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.Exceptions;
using LCU.API.Internal.DocumentIngestor.Services;
using LCU.API.Internal.DocumentIngestorLib.Repositories;

namespace LCU.API.Internal.DocumentIngestorTests.Services;

public class OwnerOverrideInfoServiceTest
{
	private OwnerOverrideInfoService _ownerOverrideInfoService;
	private Mock<IUnitOfWork> _unitOfWork;
	private Mock<IOwnerOverrideInfoRepository> _mockOwnerOverrideInfoRepository;
	private Mock<IProcessingLogService> _mockProcessingLogService;

	[SetUp]
	public void Setup()
	{
		_unitOfWork = new Mock<IUnitOfWork>();
		_mockOwnerOverrideInfoRepository = new Mock<IOwnerOverrideInfoRepository>();
		_mockProcessingLogService = new Mock<IProcessingLogService>();
		_ownerOverrideInfoService = new OwnerOverrideInfoService(_unitOfWork.Object, _mockOwnerOverrideInfoRepository.Object);
	}

	[Test]
	public async Task GetAsync_OwnerOverrideInfos_Returned()
	{
		var id = 1;
		var ownerOverrideInfos = new List<OwnerOverrideInfo>()
		{
			new OwnerOverrideInfo()
			{
				OwnerOverrideInfoId = id
			}
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindAsync()).ReturnsAsync(ownerOverrideInfos);
		var result = await _ownerOverrideInfoService.GetAsync();
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindAsync(), Times.Once);
	}

	[Test]
	public void GetAsync_Exception()
	{
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindAsync()).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.GetAsync());
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindAsync(), Times.Once);
	}

	[Test]
	public async Task GetByIdAsync_OwnerOverrideInfo_Returned()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(ownerOverrideInfo);
		var result = await _ownerOverrideInfoService.GetByIdAsync(id);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(id, result.OwnerOverrideInfoId);
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public void GetByIdAsync_Exception()
	{
		var id = 1;
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.GetByIdAsync(id));
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public async Task GetByDocumentProcessingInfoIdAsync_OwnerOverrideInfos_Returned()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfos = new List<OwnerOverrideInfo>()
		{
			new OwnerOverrideInfo()
			{
				OwnerOverrideInfoId = id,
				DocumentProcessingInfoId = documentProcessingInfoId
			}
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByDocumentProcessingInfoIdAsync(documentProcessingInfoId)).ReturnsAsync(ownerOverrideInfos);
		var result = await _ownerOverrideInfoService.GetByDocumentProcessingInfoIdAsync(documentProcessingInfoId);
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByDocumentProcessingInfoIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public void GetByDocumentProcessingInfoIdAsync_Exception()
	{
		var documentProcessingInfoId = 2;
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByDocumentProcessingInfoIdAsync(documentProcessingInfoId)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.GetByDocumentProcessingInfoIdAsync(documentProcessingInfoId));
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByDocumentProcessingInfoIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public async Task SaveAsync_OwnerOverrideInfo_Returned()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.AddAsync(ownerOverrideInfo)).ReturnsAsync(ownerOverrideInfo);
		var result = await _ownerOverrideInfoService.SaveAsync(ownerOverrideInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(id, result.OwnerOverrideInfoId);
		_mockOwnerOverrideInfoRepository.Verify(x => x.AddAsync(It.IsAny<OwnerOverrideInfo>()), Times.Once);
	}

	[Test]
	public void SaveAsync_Exception()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.AddAsync(ownerOverrideInfo)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.SaveAsync(ownerOverrideInfo));
		_mockOwnerOverrideInfoRepository.Verify(x => x.AddAsync(It.IsAny<OwnerOverrideInfo>()), Times.Once);
	}

	[Test]
	public async Task Delete_Success()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(ownerOverrideInfo);
		_mockOwnerOverrideInfoRepository.Setup(x => x.Remove(ownerOverrideInfo));

		await _ownerOverrideInfoService.Delete(id);
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockOwnerOverrideInfoRepository.Verify(x => x.Remove(It.IsAny<OwnerOverrideInfo>()), Times.Once);
	}

	[Test]
	public void Delete_FindByIdAsync_ThrowsException()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.Delete(id));
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockOwnerOverrideInfoRepository.Verify(x => x.Remove(It.IsAny<OwnerOverrideInfo>()), Times.Never);
	}

	[Test]
	public void Delete_Remove_ThrowsException()
	{
		var id = 1;
		var documentProcessingInfoId = 2;
		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			OwnerOverrideInfoId = id,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockOwnerOverrideInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(ownerOverrideInfo);
		_mockOwnerOverrideInfoRepository.Setup(x => x.Remove(ownerOverrideInfo)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _ownerOverrideInfoService.Delete(id));
		_mockOwnerOverrideInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockOwnerOverrideInfoRepository.Verify(x => x.Remove(It.IsAny<OwnerOverrideInfo>()), Times.Once);
	}
}