monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestorTests/Services/MicroApiServices/FileOperationsApiServiceTest.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using LCU.Library.Internal.LcuMassTransitModels;
using LCU.Library.Internal.DocumentIngestorModels.Models;
using LCU.Library.Internal.Exceptions;
using LCU.API.Internal.DocumentIngestor.Configurations;
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
using LCU.API.Internal.DocumentIngestor.DataAccess;
using LCU.Library.Internal.FileOperationsModels.Models;
namespace LCU.API.Internal.DocumentIngestorTests.Services.MicroApiServices;

public class FileOperationsApiServiceTest
{
	private FileOperationsApiService _fileOperationsApiService;
	private Mock<IFileOperationsApiDao> _mockFileOperationsApiDao;

	[SetUp]
	public void Setup()
	{
		_mockFileOperationsApiDao = new Mock<IFileOperationsApiDao>();
		_fileOperationsApiService = new FileOperationsApiService(_mockFileOperationsApiDao.Object);
	}

	[Test]
	public void DirectMoveFile_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectMoveFile(It.IsAny<MoveFileRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var path = "\\path\\";
		var file = "file.pdf";
		var destination = "\\destination\\";
		var completionRequest = new CompletionRequest();
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectMoveFile(path, file, destination));
		_mockFileOperationsApiDao.Verify(x => x.DirectMoveFile(It.IsAny<MoveFileRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectMoveFile_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectMoveFile(It.IsAny<MoveFileRequest>()));

		var path = "\\path\\";
		var file = "file.pdf";
		var destination = "\\destination\\";
		var completionRequest = new CompletionRequest();
		await _fileOperationsApiService.DirectMoveFile(path, file, destination);
		_mockFileOperationsApiDao.Verify(x => x.DirectMoveFile(It.IsAny<MoveFileRequest>()), Times.Once);
	}

	[Test]
	public void DirectWriteFile_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectWriteFile(It.IsAny<WriteFileRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var fileName = "file";
		var extension = ".csv";
		var fileData = "testFile";
		var destination = "\\destination\\";
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectWriteFile(fileName, extension, fileData, destination));
		_mockFileOperationsApiDao.Verify(x => x.DirectWriteFile(It.IsAny<WriteFileRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectWriteFile_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectWriteFile(It.IsAny<WriteFileRequest>()));

		var fileName = "file";
		var extension = ".csv";
		var fileData = "testFile";
		var destination = "\\destination\\";
		await _fileOperationsApiService.DirectWriteFile(fileName, extension, fileData, destination);
		_mockFileOperationsApiDao.Verify(x => x.DirectWriteFile(It.IsAny<WriteFileRequest>()), Times.Once);
	}

	[Test]
	public void DirectCreateDirectory_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectCreateDirectory(It.IsAny<CreateDirectoryRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var directoryPath = "\\path\\";
		var directoryName = "newFolder";
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectCreateDirectory(directoryPath, directoryName));
		_mockFileOperationsApiDao.Verify(x => x.DirectCreateDirectory(It.IsAny<CreateDirectoryRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectCreateDirectory_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectCreateDirectory(It.IsAny<CreateDirectoryRequest>()));

		var directoryPath = "\\path\\";
		var directoryName = "newFolder";
		await _fileOperationsApiService.DirectCreateDirectory(directoryPath, directoryName);
		_mockFileOperationsApiDao.Verify(x => x.DirectCreateDirectory(It.IsAny<CreateDirectoryRequest>()), Times.Once);
	}

	[Test]
	public void DirectUnzipFile_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectUnzipFile(It.IsAny<UnzipFileRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var sourceDirectory = "\\oldPath\\";
		var destinationPath = "\\newPath\\";
		var zipFileName = "newFolder";
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectUnzipFile(sourceDirectory, zipFileName, destinationPath, true));
		_mockFileOperationsApiDao.Verify(x => x.DirectUnzipFile(It.IsAny<UnzipFileRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectUnzipFile_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectUnzipFile(It.IsAny<UnzipFileRequest>()));

		var sourceDirectory = "\\oldPath\\";
		var destinationPath = "\\newPath\\";
		var zipFileName = "newFolder";
		await _fileOperationsApiService.DirectUnzipFile(sourceDirectory, zipFileName, destinationPath, true);
		_mockFileOperationsApiDao.Verify(x => x.DirectUnzipFile(It.IsAny<UnzipFileRequest>()), Times.Once);
	}

	[Test]
	public void DirectZipDirectory_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectZipDirectory(It.IsAny<ZipDirectoryRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var sourceDirectory = "\\oldPath\\";
		var zipPath = "\\newPath\\";
		var zipFileName = "newFolder";
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectZipDirectory(sourceDirectory, zipPath, zipFileName));
		_mockFileOperationsApiDao.Verify(x => x.DirectZipDirectory(It.IsAny<ZipDirectoryRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectZipDirectory_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectZipDirectory(It.IsAny<ZipDirectoryRequest>()));

		var sourceDirectory = "\\oldPath\\";
		var zipPath = "\\newPath\\";
		var zipFileName = "newFolder";
		await _fileOperationsApiService.DirectZipDirectory(sourceDirectory, zipPath, zipFileName);
		_mockFileOperationsApiDao.Verify(x => x.DirectZipDirectory(It.IsAny<ZipDirectoryRequest>()), Times.Once);
	}


	[Test]
	public void DirectDeleteDirectory_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectDeleteDirectory(It.IsAny<DeleteDirectoryRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var directoryName = "folder";
		var directoryRootPath = "\\testPath\\";
		var maxAmountOfDirectories = 1;
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.DirectDeleteDirectory(directoryName, directoryRootPath, maxAmountOfDirectories));
		_mockFileOperationsApiDao.Verify(x => x.DirectDeleteDirectory(It.IsAny<DeleteDirectoryRequest>()), Times.Once);
	}

	[Test]
	public async Task DirectDeleteDirectory_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.DirectDeleteDirectory(It.IsAny<DeleteDirectoryRequest>()));

		var directoryName = "folder";
		var directoryRootPath = "\\testPath\\";
		var maxAmountOfDirectories = 1;
		await _fileOperationsApiService.DirectDeleteDirectory(directoryName, directoryRootPath, maxAmountOfDirectories);
		_mockFileOperationsApiDao.Verify(x => x.DirectDeleteDirectory(It.IsAny<DeleteDirectoryRequest>()), Times.Once);
	}

	[Test]
	public void GetFileContent_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.GetFileContent(It.IsAny<string>()))
								  .ThrowsAsync(new Exception("Error"));

		var filePath = "\\path\\file.pdf";
		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.GetFileContent(filePath));
		_mockFileOperationsApiDao.Verify(x => x.GetFileContent(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task GetFileContent_Success()
	{
		var content = "test, test, test";
		_mockFileOperationsApiDao.Setup(x => x.GetFileContent(It.IsAny<string>())).ReturnsAsync(content);

		var filePath = "\\path\\file.pdf";
		var result = await _fileOperationsApiService.GetFileContent(filePath);
		Assert.AreEqual(content, result);
		_mockFileOperationsApiDao.Verify(x => x.GetFileContent(It.IsAny<string>()), Times.Once);
	}


	[Test]
	public void GetContentBytes_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.GetPdfByteContent(It.IsAny<string>()))
								  .ThrowsAsync(new Exception("Error"));

		var documentPath = "\\path\\";
		var documentFileName = "file.pdf";
		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.GetContentBytes(documentPath, documentFileName));
		_mockFileOperationsApiDao.Verify(x => x.GetPdfByteContent(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task GetContentBytes_Success()
	{
		var content = "test, test, test";
		var contentBytes = Encoding.ASCII.GetBytes(content);
		_mockFileOperationsApiDao.Setup(x => x.GetPdfByteContent(It.IsAny<string>())).ReturnsAsync(contentBytes);

		var documentPath = "\\path\\";
		var documentFileName = "file.pdf";
		var result = await _fileOperationsApiService.GetContentBytes(documentPath, documentFileName);
		Assert.AreEqual(contentBytes, result);
		_mockFileOperationsApiDao.Verify(x => x.GetPdfByteContent(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public void ValidateFileExists_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(It.IsAny<string>()))
								  .ThrowsAsync(new Exception("Error"));

		var filePath = "\\path\\file.pdf";
		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.ValidateFileExists(filePath));
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task ValidateFileExists_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(It.IsAny<string>())).ReturnsAsync(true);

		var filePath = "\\path\\file.pdf";
		var result = await _fileOperationsApiService.ValidateFileExists(filePath);
		Assert.IsTrue(result);
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public void ValidateFileExistsAndNotArchived_ValidateFileExists_FilePath_Exception()
	{
		var filePath = "\\path\\file.pdf";
		var archiveFilePath = "\\path\\archive\\file.pdf";
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(filePath))
								  .ThrowsAsync(new Exception("Error"));


		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.ValidateFileExistsAndNotArchived(filePath, archiveFilePath));
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public void ValidateFileExistsAndNotArchived_ValidateFileExists_ArchiveFilePath_Exception()
	{
		var filePath = "\\path\\file.pdf";
		var archiveFilePath = "\\path\\archive\\file.pdf";
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(filePath)).ReturnsAsync(false);

		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(archiveFilePath))
								 .ThrowsAsync(new Exception("Error"));


		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.ValidateFileExistsAndNotArchived(filePath, archiveFilePath));
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Exactly(2));
	}

	[Test]
	public async Task ValidateFileExistsAndNotArchived_True()
	{
		var filePath = "\\path\\file.pdf";
		var archiveFilePath = "\\path\\archive\\file.pdf";
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(filePath)).ReturnsAsync(true);

		var result = await _fileOperationsApiService.ValidateFileExistsAndNotArchived(filePath, archiveFilePath);
		Assert.IsTrue(result);
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task ValidateFileExistsAndNotArchived_False()
	{
		var filePath = "\\path\\file.pdf";
		var archiveFilePath = "\\path\\archive\\file.pdf";
		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(filePath)).ReturnsAsync(false);

		_mockFileOperationsApiDao.Setup(x => x.ValidateFileExists(archiveFilePath)).ReturnsAsync(true);


		var result = await _fileOperationsApiService.ValidateFileExistsAndNotArchived(filePath, archiveFilePath);
		Assert.IsFalse(result);
		_mockFileOperationsApiDao.Verify(x => x.ValidateFileExists(It.IsAny<string>()), Times.Exactly(2));
	}

	[Test]
	public async Task ValidatePdfPageExists_Success()
	{
		var requestResponse = new RequestResponse()
		{
			IsSuccessful = true
		};
		_mockFileOperationsApiDao.Setup(x => x.ValidatePdfPageExists(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(requestResponse);

		var filePath = "\\path\\file.pdf";
		var result = await _fileOperationsApiService.ValidatePdfPageExists(filePath, "5");
		_mockFileOperationsApiDao.Verify(x => x.ValidatePdfPageExists(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public void ValidatePdfPageExists_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.ValidatePdfPageExists(It.IsAny<string>(), It.IsAny<string>()))
								  .ThrowsAsync(new Exception("Error"));

		var filePath = "\\path\\file.pdf";
		Assert.ThrowsAsync<ServiceException>(async () =>
				await _fileOperationsApiService.ValidatePdfPageExists(filePath, "5"));
		_mockFileOperationsApiDao.Verify(x => x.ValidatePdfPageExists(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task QueueBatchPdfParser_Success()
	{
		_mockFileOperationsApiDao.Setup(x => x.QueueBatchPdfParser(It.IsAny<BatchParsePdfRequest>()));

		var batchParsePdfRequest = new BatchParsePdfRequest();
		await _fileOperationsApiService.QueueBatchPdfParser(batchParsePdfRequest);
		_mockFileOperationsApiDao.Verify(x => x.QueueBatchPdfParser(It.IsAny<BatchParsePdfRequest>()), Times.Once);
	}

	[Test]
	public void QueueBatchPdfParser_Exception()
	{
		_mockFileOperationsApiDao.Setup(x => x.QueueBatchPdfParser(It.IsAny<BatchParsePdfRequest>()))
								  .ThrowsAsync(new Exception("Error"));

		var batchParsePdfRequest = new BatchParsePdfRequest();
		Assert.ThrowsAsync<ServiceException>(async () => await _fileOperationsApiService.QueueBatchPdfParser(batchParsePdfRequest));
		_mockFileOperationsApiDao.Verify(x => x.QueueBatchPdfParser(It.IsAny<BatchParsePdfRequest>()), Times.Once);
	}
}