monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestorTests/Services/IngestionOperationServices/DocumentProcessorServiceTest.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.DocumentIngestor.Services.IngestionOperationServices;
using LCU.Library.Internal.DocumentIngestorModels.Models;
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
using LCU.API.Internal.DocumentIngestor.Services.QueueServices;
using LCU.API.Internal.DocumentIngestor.Services.DocumentProcessorServices;
using LCU.API.Internal.DocumentIngestor.Configurations;
using LCU.API.Internal.DocumentIngestor.Services.IndexParserServices;
using LCU.Library.Internal.DocumentIngestorModels.Enums;
using LCU.Library.Internal.DocumentIngestorModels.Models.IndexFileDocuments;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.LCUServiceFactory.Services;

namespace LCU.API.Internal.DocumentIngestorTests.Services.IngestionOperationServices;

public class DocumentProcessorServiceTest
{
	private DocumentProcessorService _documentProcessorService;

	private ApiConfiguration _apiConfiguration;
	private Mock<IQueueDocumentProcessingService> _mockQueueDocumentProcessingService;
	private Mock<IQueueCompletionService> _mockQueueCompletionService;
	private Mock<IFileOperationsApiService> _mockFileOperationsApiService;
	private Mock<ILcuServiceFactory<IDocumentProcessingService>> _mockLcuServiceFactory;

    private IDictionary<Type, object> _handlerServicesByType;

	[SetUp]
	public void Setup()
	{
		_apiConfiguration = new ApiConfiguration
		{
			DocumentProcessingReQueueCountLimit = 1
		};
		_mockQueueDocumentProcessingService = new Mock<IQueueDocumentProcessingService>();
		_mockQueueCompletionService = new Mock<IQueueCompletionService>();
		_mockFileOperationsApiService = new Mock<IFileOperationsApiService>();
		_mockLcuServiceFactory = new Mock<ILcuServiceFactory<IDocumentProcessingService>>();
		_documentProcessorService = new DocumentProcessorService(_apiConfiguration,
																 _mockQueueDocumentProcessingService.Object,
																 _mockQueueCompletionService.Object,
																 _mockFileOperationsApiService.Object,
																 _mockLcuServiceFactory.Object);
	}

	[Test]
	public void HandleIngestion_Exception_RequestNull()
	{
		ProcessingRequest request = null;
		Assert.ThrowsAsync<ArgumentNullException>(async () => await _documentProcessorService.HandleProcessing(request));
		_mockFileOperationsApiService.Verify(x => x.ValidateFileExistsAndNotArchived(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
		_mockQueueCompletionService.Verify(x => x.QueueCompletionRequest(It.IsAny<ProcessingRequest>(), It.IsAny<ProcessResult>()), Times.Never);
		_mockLcuServiceFactory.Verify(x => x.GetService(It.IsAny<IngestorTypes>()), Times.Never);
		_mockFileOperationsApiService.Verify(x => x.DirectMoveFile(It.IsAny<string>(),
																   It.IsAny<string>(),
																   It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task HandleIngestion_DocumentDoesNotNeedProcessing_Update_Return()
	{
		var filePath = "\\Test\\Test\\000001Test.pdf";
		var archiveFilePath = "\\Test\\Test\\Archived\\000001Test.pdf";

		_mockFileOperationsApiService.Setup(service => service.ValidateFileExistsAndNotArchived(filePath, archiveFilePath))
									  .ReturnsAsync(false);
		
		var ingestorRequest = new IngestorRequest
		{
			RootPath = "\\Test\\Test"
		};
		var request = new ProcessingRequest()
		{
			DocumentFileName = "000001Test.pdf",
			IngestorRequest = ingestorRequest
		};

		await _documentProcessorService.HandleProcessing(request);
		_mockFileOperationsApiService.Verify(x => x.ValidateFileExistsAndNotArchived(filePath,
																					 archiveFilePath), Times.Once);
		_mockQueueCompletionService.Verify(x => x.QueueCompletionRequest(request, It.Is<ProcessResult>(y => y.Success == true
																										 && y.AttemptToArchive == false
																										 && y.MessageStack.Count == 1
																										 && y.ProcessStatusType == ProcessStatusTypes.Completed)
																									   ), Times.Once);
		
		_mockLcuServiceFactory.Verify(x => x.GetService(It.IsAny<IngestorTypes>()), Times.Never);
		_mockFileOperationsApiService.Verify(x => x.DirectMoveFile(It.IsAny<string>(),
																   It.IsAny<string>(),
																   It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task HandlePostProcessingFailure_ProcessResult_SuccessFalse_QueueDocumentProcessing()
	{
		var request = new ProcessingRequest
		{
			IngestorRequest = new()
			{
				IngestorType = IngestorTypes.FosLoanStatement
			},
			RetryCount = 0
		};
		var result = new ProcessResult
		{
			Success = false,
			ProcessStatusType = ProcessStatusTypes.CriticalFailure
		};
		
		await _documentProcessorService.HandlePostProcessingFailure(request, result);
		
		_mockQueueDocumentProcessingService.Verify(x => x.QueueDocumentProcessingRequest(It.IsAny<ProcessingRequest>()), Times.Once);
		_mockQueueCompletionService.Verify(x => x.QueueCompletionRequest(It.IsAny<ProcessingRequest>(), It.IsAny<ProcessResult>()), Times.Never);
	}

	[Test]
	public async Task HandlePostProcessingFailure_ProcessResult_SuccessFalse_QueueCompletion()
	{
		var request = new ProcessingRequest
		{
			RetryCount = 1
		};
		var result = new ProcessResult
		{
			Success = false,
			ProcessStatusType = ProcessStatusTypes.CriticalFailure
		};
		await _documentProcessorService.HandlePostProcessingFailure(request, result);
		_mockQueueDocumentProcessingService.Verify(x => x.QueueDocumentProcessingRequest(It.IsAny<ProcessingRequest>()), Times.Never);
		_mockQueueCompletionService.Verify(x => x.QueueCompletionRequest(It.IsAny<ProcessingRequest>(), It.IsAny<ProcessResult>()), Times.Once);
	}
	
	[TestCase(IngestorTypes.FosTaxStatement, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.FosDnaDocument, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.FosLoanStatement, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.XdiDnaNotice, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.OsgDnaNoticesDocument, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.XdiActionNotice, typeof(IDocumentProcessingService))]
	[TestCase(IngestorTypes.OsgHistoricalDocument, typeof(IDocumentProcessingService))]
	[Test]
	public async Task HandleProcessing_ByTypedRequest_HandledByMatchingServiceAndArchived(IngestorTypes type, Type handlerType)
	{
		var request = new ProcessingRequest
		{
			IngestorRequest = new IngestorRequest
			{
				IngestorType = type,
				RootPath = Guid.NewGuid().ToString(),
			},
			DocumentFileName = Guid.NewGuid().ToString()
		};
		
		var result = new ProcessResult
		{
			Success = true
		};
		
		var documentProcessorService = new Mock<IDocumentProcessingService>();
		_mockLcuServiceFactory.Setup(x => x.GetService(request.IngestorRequest.IngestorType)).Returns(documentProcessorService.Object); 
		documentProcessorService.Setup(x => x.ProcessRequest(request)).ReturnsAsync(result);
		
		_mockFileOperationsApiService
			.Setup
			(
				fs => fs.ValidateFileExistsAndNotArchived
				(
					request.IngestorRequest.RootPath + request.DocumentFileName,
					request.IngestorRequest.ArchivePath + request.DocumentFileName
				)
			)
			.ReturnsAsync(true);
		_mockFileOperationsApiService
			.Setup(fs => fs.DirectMoveFile(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
			.ReturnsAsync(new RequestResponse { IsSuccessful = true });

		await _documentProcessorService.HandleProcessing(request);
		
		_mockLcuServiceFactory.Verify(x => x.GetService(request.IngestorRequest.IngestorType), Times.Once);
		_mockFileOperationsApiService
			.Verify
			(
				s => s.DirectMoveFile
				(
					request.IngestorRequest.RootPath,
					request.DocumentFileName,
					request.IngestorRequest.ArchivePath
				),
				Times.Once
			);
	}
	
}