957 lines
38 KiB
C#
957 lines
38 KiB
C#
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;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Enums;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Models;
|
|
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
|
|
|
|
namespace LCU.API.Internal.DocumentIngestorTests.Services;
|
|
|
|
public class DocumentProcessingInfoServiceTest
|
|
{
|
|
private DocumentProcessingInfoService _documentProcessingInfoService;
|
|
private Mock<IUnitOfWork> _unitOfWork;
|
|
private Mock<IDocumentProcessingInfoRepository> _mockDocumentProcessingInfoRepository;
|
|
private Mock<IProcessingLogService> _mockProcessingLogService;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_unitOfWork = new Mock<IUnitOfWork>();
|
|
_mockDocumentProcessingInfoRepository = new Mock<IDocumentProcessingInfoRepository>();
|
|
_mockProcessingLogService = new Mock<IProcessingLogService>();
|
|
_documentProcessingInfoService = new DocumentProcessingInfoService(_unitOfWork.Object, _mockDocumentProcessingInfoRepository.Object, _mockProcessingLogService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetAsync_DocumentProcessingInfos_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfos = new List<DocumentProcessingInfo>()
|
|
{
|
|
new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
}
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindAsync()).ReturnsAsync(documentProcessingInfos);
|
|
var result = await _documentProcessingInfoService.GetAsync();
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(1, result.Count());
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindAsync(), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetAsync_Exception()
|
|
{
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindAsync()).ThrowsAsync(new Exception("Error"));
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.GetAsync());
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindAsync(), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByIdAsync_DocumentProcessingInfo_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
var result = await _documentProcessingInfoService.GetByIdAsync(id);
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetByIdAsync_Exception()
|
|
{
|
|
var id = 1;
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.GetByIdAsync(id));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByIngestorRunInfoIdAsync_DocumentProcessingInfos_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfos = new List<DocumentProcessingInfo>()
|
|
{
|
|
new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
}
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIngestorRunInfoIdAsync(ingestorRunInfoId)).ReturnsAsync(documentProcessingInfos);
|
|
var result = await _documentProcessingInfoService.GetByIngestorRunInfoIdAsync(ingestorRunInfoId);
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(1, result.Count());
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIngestorRunInfoIdAsync(It.IsAny<Guid>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetByIngestorRunInfoIdAsync_Exception()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIngestorRunInfoIdAsync(ingestorRunInfoId)).ThrowsAsync(new Exception("Error"));
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.GetByIngestorRunInfoIdAsync(ingestorRunInfoId));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIngestorRunInfoIdAsync(It.IsAny<Guid>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SaveAsync_DocumentProcessingInfo_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.AddAsync(documentProcessingInfo)).ReturnsAsync(documentProcessingInfo);
|
|
var result = await _documentProcessingInfoService.SaveAsync(documentProcessingInfo);
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.AddAsync(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void SaveAsync_Exception()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.AddAsync(documentProcessingInfo)).ThrowsAsync(new Exception("Error"));
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.SaveAsync(documentProcessingInfo));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.AddAsync(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Update_DocumentProcessingInfo_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo));
|
|
|
|
var result = await _documentProcessingInfoService.Update(documentProcessingInfo);
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void Update_FindByIdAsync_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.Update(documentProcessingInfo));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public void Update_Update_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo)).Throws(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.Update(documentProcessingInfo));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateStatusAndAddLog_ById_SingleLog_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo));
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail",
|
|
UserName = "User"
|
|
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
var result = await _documentProcessingInfoService.UpdateStatusAndAddLog(id, ProcessStatusTypes.DataMappingFailure, "Account fail", "User");
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_ById_SingleLog_FindByIdAsync_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(id, ProcessStatusTypes.DataMappingFailure, "Account fail", "User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_ById_SingleLog_Update_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo)).Throws(new Exception("Error")); ;
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail"
|
|
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(id, ProcessStatusTypes.DataMappingFailure, "Account fail", "User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateStatusAndAddLog_ById_TwoLog_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo));
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail",
|
|
UserName = "User"
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
var logMessages = new List<string>()
|
|
{
|
|
"Account fail",
|
|
"Name fail"
|
|
};
|
|
|
|
var result = await _documentProcessingInfoService.UpdateStatusAndAddLog(id, ProcessStatusTypes.DataMappingFailure, logMessages, "User");
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Exactly(2));
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_ById_TwoLog_FindByIdAsync_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
|
|
var logMessages = new List<string>()
|
|
{
|
|
"Account fail",
|
|
"Name fail"
|
|
};
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(id,
|
|
ProcessStatusTypes.DataMappingFailure,
|
|
logMessages,
|
|
"User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_ById_TwoLog_Update_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo)).Throws(new Exception("Error")); ;
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail"
|
|
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
var logMessages = new List<string>()
|
|
{
|
|
"Account fail",
|
|
"Name fail"
|
|
};
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(id,
|
|
ProcessStatusTypes.DataMappingFailure,
|
|
logMessages,
|
|
"User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateStatusAndAddLog_Returned()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo));
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail",
|
|
UserName = "User"
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
var result = await _documentProcessingInfoService.UpdateStatusAndAddLog(documentProcessingInfo,
|
|
ProcessStatusTypes.DataMappingFailure,
|
|
"Account fail",
|
|
"User");
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(ingestorRunInfoId, result.IngestorRunInfoId);
|
|
Assert.AreEqual(id, result.DocumentProcessingInfoId);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_FindByIdAsync_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(documentProcessingInfo,
|
|
ProcessStatusTypes.DataMappingFailure,
|
|
"Account fail",
|
|
"User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateStatusAndAddLog_Update_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(documentProcessingInfo)).Throws(new Exception("Error")); ;
|
|
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
LogTimeStamp = Convert.ToDateTime("1/1/2022"),
|
|
LogMessage = "Account fail",
|
|
UserName = "User"
|
|
};
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(processingLog);
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateStatusAndAddLog(documentProcessingInfo,
|
|
ProcessStatusTypes.DataMappingFailure,
|
|
"Account fail",
|
|
"User"));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(id), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(documentProcessingInfo), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Delete_Success()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Remove(documentProcessingInfo));
|
|
|
|
await _documentProcessingInfoService.Delete(id);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Remove(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void Delete_FindByIdAsync_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.Delete(id));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Remove(It.IsAny<DocumentProcessingInfo>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public void Delete_Remove_ThrowsException()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var id = 1;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = id,
|
|
IngestorRunInfoId = ingestorRunInfoId
|
|
};
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(id)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Remove(documentProcessingInfo)).Throws(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.Delete(id));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Remove(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FilterPaged_Ok()
|
|
{
|
|
var pagedDocumentProcessingInfoResult = new PagedResult<DocumentProcessingInfo>();
|
|
|
|
var filter = new Filter()
|
|
{
|
|
Page = 1,
|
|
Limit = 2,
|
|
StatusFilters = null,
|
|
SortableFields = null,
|
|
DocBusinessName = "EAgreement"
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(repo => repo.FilteredListAsync(filter))
|
|
.ReturnsAsync(pagedDocumentProcessingInfoResult).Verifiable();
|
|
|
|
// Act
|
|
var result = await _documentProcessingInfoService.GetFilteredDocumentProcessingInfo(filter);
|
|
|
|
// Assert
|
|
Assert.NotNull(result);
|
|
Assert.AreEqual(pagedDocumentProcessingInfoResult, result);
|
|
}
|
|
|
|
[Test]
|
|
public async Task CountCompletedFirstPassByIngestorRunInfoIdAsync_RepositoryReturnsCount_ReturnsCount()
|
|
{
|
|
var runId = Guid.NewGuid();
|
|
var count = DateTime.Now.Millisecond;
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(r => r.CountCompletedFirstPassByIngestorRunInfoIdAsync(runId))
|
|
.ReturnsAsync(count);
|
|
|
|
var actualCount = await _documentProcessingInfoService.CountCompletedFirstPassByIngestorRunInfoIdAsync(runId);
|
|
|
|
Assert.AreEqual(count, actualCount);
|
|
}
|
|
|
|
[Test]
|
|
public void CountCompletedFirstPassByIngestorRunInfoIdAsync_RepositoryThrows_ThrowsServiceException()
|
|
{
|
|
var runId = Guid.NewGuid();
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(r => r.CountCompletedFirstPassByIngestorRunInfoIdAsync(runId))
|
|
.ThrowsAsync(new Exception());
|
|
|
|
Assert.ThrowsAsync<ServiceException>(() => _documentProcessingInfoService.CountCompletedFirstPassByIngestorRunInfoIdAsync(runId));
|
|
}
|
|
|
|
|
|
[Test]
|
|
public async Task SetDocumentsToEntityUnknown_Success()
|
|
{
|
|
var ids = new List<int>() { 1, 2, 3 };
|
|
var documentProcessingInfos = new List<DocumentProcessingInfo>()
|
|
{
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[0],
|
|
},
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[1],
|
|
},
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[2],
|
|
}
|
|
};
|
|
var request = new EntityUnknownRequest()
|
|
{
|
|
UserName = "System",
|
|
DocumentProcessingInfoIds = documentProcessingInfos.Select(x => x.DocumentProcessingInfoId).ToList()
|
|
};
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = 1,
|
|
LogMessage = "Log test",
|
|
LogTimeStamp = DateTime.Now,
|
|
UserName = "System"
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindListByIdAsync(ids)).ReturnsAsync(documentProcessingInfos);
|
|
_mockDocumentProcessingInfoRepository.SetupSequence(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(documentProcessingInfos[0])
|
|
.ReturnsAsync(documentProcessingInfos[1])
|
|
.ReturnsAsync(documentProcessingInfos[2]);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(It.IsAny<DocumentProcessingInfo>()));
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(() => processingLog);
|
|
|
|
var result = await _documentProcessingInfoService.SetDocumentsToEntityUnknown(request);
|
|
var trueCount = result.Where(x => x.EntityUnknown).ToList().Count();
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(documentProcessingInfos.Count, result.Count());
|
|
Assert.AreEqual(documentProcessingInfos.Count(), trueCount);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindListByIdAsync(It.IsAny<List<int>>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Exactly(3));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Exactly(3));
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Exactly(3));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SetDocumentsToEntityUnknown_ThrowsException_Failure()
|
|
{
|
|
var ids = new List<int>() { 1, 2, 3 };
|
|
var documentProcessingInfos = new List<DocumentProcessingInfo>()
|
|
{
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[0],
|
|
},
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[1],
|
|
},
|
|
new()
|
|
{
|
|
DocumentProcessingInfoId = ids[2],
|
|
}
|
|
};
|
|
var request = new EntityUnknownRequest()
|
|
{
|
|
UserName = "System",
|
|
DocumentProcessingInfoIds = documentProcessingInfos.Select(x => x.DocumentProcessingInfoId).ToList()
|
|
};
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = 1,
|
|
LogMessage = "Log test",
|
|
LogTimeStamp = DateTime.Now,
|
|
UserName = "System"
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindListByIdAsync(ids)).ReturnsAsync(documentProcessingInfos);
|
|
_mockDocumentProcessingInfoRepository.SetupSequence(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(documentProcessingInfos[0])
|
|
.ReturnsAsync(documentProcessingInfos[1])
|
|
.ReturnsAsync(documentProcessingInfos[2]);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(It.IsAny<DocumentProcessingInfo>()));
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(() => processingLog);
|
|
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).Throws(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.SetDocumentsToEntityUnknown(request));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindListByIdAsync(It.IsAny<List<int>>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Once);
|
|
}
|
|
|
|
//
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentProcessingInfoStatus_Success()
|
|
{
|
|
var documentProcessingInfoId = DateTime.Now.Millisecond;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
StatusType = ProcessStatusTypes.ArchiveFailure
|
|
};
|
|
var request = new DocumentProcessingInfoStatusRequest()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
ProcessStatus = ProcessStatusTypes.Reprocessing,
|
|
ReasonMessage = Guid.NewGuid().ToString(),
|
|
Username = Guid.NewGuid().ToString()
|
|
};
|
|
var processingLog = new ProcessingLog()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
LogMessage = request.ReasonMessage,
|
|
LogTimeStamp = DateTime.Now,
|
|
UserName = request.Username
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(It.IsAny<DocumentProcessingInfo>()));
|
|
_mockProcessingLogService.Setup(x => x.SaveAsync(It.IsAny<ProcessingLog>())).ReturnsAsync(() => processingLog);
|
|
|
|
var result = await _documentProcessingInfoService.UpdateDocumentProcessingInfoStatus(request);
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(result?.StatusType, request.ProcessStatus);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentProcessingInfoStatus_ThrowsException_Failure()
|
|
{
|
|
var documentProcessingInfoId = DateTime.Now.Millisecond;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
StatusType = ProcessStatusTypes.ArchiveFailure
|
|
};
|
|
var request = new DocumentProcessingInfoStatusRequest()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
ProcessStatus = ProcessStatusTypes.Reprocessing,
|
|
ReasonMessage = Guid.NewGuid().ToString(),
|
|
Username = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfo);
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.Update(It.IsAny<DocumentProcessingInfo>())).Throws(new Exception("Error"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateDocumentProcessingInfoStatus(request));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Exactly(2));
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Once);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentProcessingInfoStatus_RejectedStatus_Failure()
|
|
{
|
|
var documentProcessingInfoId = DateTime.Now.Millisecond;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
StatusType = ProcessStatusTypes.Completed
|
|
};
|
|
var request = new DocumentProcessingInfoStatusRequest()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
ProcessStatus = ProcessStatusTypes.Reprocessing,
|
|
ReasonMessage = Guid.NewGuid().ToString(),
|
|
Username = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfo);
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateDocumentProcessingInfoStatus(request));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocumentProcessingInfoStatus_SameStatus_Failure()
|
|
{
|
|
var documentProcessingInfoId = DateTime.Now.Millisecond;
|
|
var documentProcessingInfo = new DocumentProcessingInfo()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
StatusType = ProcessStatusTypes.Reprocessing
|
|
};
|
|
var request = new DocumentProcessingInfoStatusRequest()
|
|
{
|
|
DocumentProcessingInfoId = documentProcessingInfoId,
|
|
ProcessStatus = ProcessStatusTypes.Reprocessing,
|
|
ReasonMessage = Guid.NewGuid().ToString(),
|
|
Username = Guid.NewGuid().ToString()
|
|
};
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfo);
|
|
|
|
Assert.ThrowsAsync<ServiceException>(async () => await _documentProcessingInfoService.UpdateDocumentProcessingInfoStatus(request));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.Update(It.IsAny<DocumentProcessingInfo>()), Times.Never);
|
|
_mockProcessingLogService.Verify(x => x.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByDocumentIdsAsync_RepositoryReturnsInfoForId_InfoAtIdKey()
|
|
{
|
|
var ids = Enumerable.Repeat(Guid.NewGuid, 5)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
var info = new DocumentProcessingInfo
|
|
{
|
|
DocumentId = ids[2]
|
|
};
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(dpir => dpir.FindByDocumentIdsAsync(ids))
|
|
.ReturnsAsync(new[] { info });
|
|
|
|
var infoById = await _documentProcessingInfoService.GetByDocumentIdsAsync(ids);
|
|
|
|
Assert.AreSame(infoById[info.DocumentId.Value], info);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByDocumentIdsAsync_RepositoryDoesNotReturnInfoForId_NullAtIdKey()
|
|
{
|
|
var ids = Enumerable.Repeat(Guid.NewGuid, 5)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
var info = new DocumentProcessingInfo
|
|
{
|
|
DocumentId = ids[2]
|
|
};
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(dpir => dpir.FindByDocumentIdsAsync(ids))
|
|
.ReturnsAsync(Array.Empty<DocumentProcessingInfo>());
|
|
|
|
var infoById = await _documentProcessingInfoService.GetByDocumentIdsAsync(ids);
|
|
|
|
Assert.IsNull(infoById[info.DocumentId.Value]);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByDocumentIdsAsync_RepositoryThrowsException_ThrowsServiceException()
|
|
{
|
|
var ids = Enumerable.Repeat(Guid.NewGuid, 5)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(dpir => dpir.FindByDocumentIdsAsync(ids))
|
|
.ThrowsAsync(new Exception());
|
|
|
|
Assert.ThrowsAsync<ServiceException>(() => _documentProcessingInfoService.GetByDocumentIdsAsync(ids));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByDocumentIdsAsync_AllCases_AllInputIdsInDictionaryKeys()
|
|
{
|
|
var ids = Enumerable.Repeat(Guid.NewGuid, 5)
|
|
.Select(f => f())
|
|
.ToArray();
|
|
var info = new DocumentProcessingInfo
|
|
{
|
|
DocumentId = ids[2]
|
|
};
|
|
var otherInfo = new DocumentProcessingInfo
|
|
{
|
|
DocumentId = ids[4]
|
|
};
|
|
_mockDocumentProcessingInfoRepository
|
|
.Setup(dpir => dpir.FindByDocumentIdsAsync(ids))
|
|
.ReturnsAsync(new[] { info, otherInfo });
|
|
|
|
var infoById = await _documentProcessingInfoService.GetByDocumentIdsAsync(ids);
|
|
|
|
CollectionAssert.AreEquivalent(ids, infoById.Keys);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetByProcessStatusTypeAsync_Success()
|
|
{
|
|
var processStatus = ProcessStatusTypes.Processing;
|
|
|
|
var documentProcessingInfos = GenerateDocumentProcessingInfos();
|
|
documentProcessingInfos.ForEach(x => x.StatusType.Equals(processStatus));
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByProcessStatusTypeAsync(It.IsAny<ProcessStatusTypes>(), null))
|
|
.ReturnsAsync(documentProcessingInfos).Verifiable();
|
|
|
|
var result = await _documentProcessingInfoService.GetByProcessStatusTypeAsync(processStatus);
|
|
|
|
Assert.AreSame(result, documentProcessingInfos);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByProcessStatusTypeAsync(It.IsAny<ProcessStatusTypes>(), It.IsAny<bool?>()), Times.Once);
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void GetByProcessStatusType_Failure_Exception()
|
|
{
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindByProcessStatusTypeAsync(It.IsAny<ProcessStatusTypes>(), null))
|
|
.ThrowsAsync(new Exception("Test"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(() =>
|
|
_documentProcessingInfoService.GetByProcessStatusTypeAsync(It.IsAny<ProcessStatusTypes>()));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindByProcessStatusTypeAsync(It.IsAny<ProcessStatusTypes>(), It.IsAny<bool?>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetCompletedFirstPassByIngestorRunInfoIdAsync_Success()
|
|
{
|
|
var ingestorRunInfoId = Guid.NewGuid();
|
|
var documentProcessingInfos = GenerateDocumentProcessingInfos();
|
|
documentProcessingInfos.ForEach(x => x.IngestorRunInfoId = ingestorRunInfoId);
|
|
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindCompletedFirstPassByIngestorRunInfoIdAsync(It.IsAny<Guid>()))
|
|
.ReturnsAsync(documentProcessingInfos).Verifiable();
|
|
|
|
var result = await _documentProcessingInfoService.GetCompletedFirstPassByIngestorRunInfoIdAsync(ingestorRunInfoId);
|
|
|
|
Assert.AreSame(documentProcessingInfos, result);
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindCompletedFirstPassByIngestorRunInfoIdAsync(It.IsAny<Guid>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetCompletedFirstPassByIngestorRunInfoIdAsync_Failure_Exception()
|
|
{
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.FindCompletedFirstPassByIngestorRunInfoIdAsync(It.IsAny<Guid>()))
|
|
.ThrowsAsync(new Exception("Test"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(() =>
|
|
_documentProcessingInfoService.GetCompletedFirstPassByIngestorRunInfoIdAsync(It.IsAny<Guid>()));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.FindCompletedFirstPassByIngestorRunInfoIdAsync(It.IsAny<Guid>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SaveRangeAsync_Success()
|
|
{
|
|
var documentProcessingInfos = GenerateDocumentProcessingInfos().ToArray();
|
|
await _documentProcessingInfoService.SaveRangeAsync(documentProcessingInfos);
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.AddRangeAsync(It.IsAny<DocumentProcessingInfo[]>()), Times.Once());
|
|
_unitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void SaveRangeAsync_Failure_Exception()
|
|
{
|
|
_mockDocumentProcessingInfoRepository.Setup(x => x.AddRangeAsync(It.IsAny<DocumentProcessingInfo[]>()))
|
|
.ThrowsAsync(new Exception("Test"));
|
|
|
|
Assert.ThrowsAsync<ServiceException>(() =>
|
|
_documentProcessingInfoService.SaveRangeAsync(It.IsAny<DocumentProcessingInfo[]>()));
|
|
|
|
_mockDocumentProcessingInfoRepository.Verify(x => x.AddRangeAsync(It.IsAny<DocumentProcessingInfo[]>()), Times.Once);
|
|
_unitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
|
|
}
|
|
|
|
private List<DocumentProcessingInfo> GenerateDocumentProcessingInfos()
|
|
=> new()
|
|
{
|
|
GenerateDocumentProcessingInfo(),
|
|
GenerateDocumentProcessingInfo(),
|
|
GenerateDocumentProcessingInfo()
|
|
};
|
|
|
|
private DocumentProcessingInfo GenerateDocumentProcessingInfo(Guid? documentId = null)
|
|
=> new()
|
|
{
|
|
DocumentId = documentId ?? Guid.NewGuid()
|
|
};
|
|
} |