456 lines
17 KiB
C#
456 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.Document.Configurations;
|
|
using LCU.API.Internal.Document.Exceptions;
|
|
using LCU.API.Internal.Document.Services;
|
|
using LCU.API.Internal.DocumentLib.Containers;
|
|
using LCU.API.Internal.DocumentLib.Repositories;
|
|
using LCU.Library.Internal.DocumentModels.Requests.Search;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
|
|
namespace LCU.API.Internal.DocumentTest.Services;
|
|
|
|
public class DocumentInformationServiceTest
|
|
{
|
|
private DocumentInformationService _documentInformationService;
|
|
private Mock<IDocumentInformationRepository> _mockDocumentRepository;
|
|
private ApiConfiguration _apiConfiguration;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_mockDocumentRepository = new Mock<IDocumentInformationRepository>();
|
|
_apiConfiguration = new ApiConfiguration() { FileUploadCutoffHours = -2 };
|
|
_documentInformationService = new DocumentInformationService(_mockDocumentRepository.Object,
|
|
_apiConfiguration);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentInformation_Success()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docBlobId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
docInformation.UploadDate = DateTime.UtcNow.AddDays(-1);
|
|
docInformation.ScanStatus = true;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
var returnedDocInfo = await _documentInformationService.GetDocumentInformation(docId);
|
|
|
|
Assert.NotNull(returnedDocInfo);
|
|
|
|
Assert.AreEqual(docInformation.DocumentId, returnedDocInfo?.DocumentId);
|
|
Assert.AreEqual(docInformation.Name, returnedDocInfo?.Name);
|
|
Assert.AreEqual(docInformation.Type, returnedDocInfo?.Type);
|
|
Assert.AreEqual(docInformation.Source, returnedDocInfo?.Source);
|
|
Assert.AreEqual(docInformation.ScanStatus, returnedDocInfo?.ScanStatus);
|
|
Assert.AreEqual(docInformation.UploadDate, returnedDocInfo?.UploadDate);
|
|
Assert.AreEqual(docInformation.LastModifiedDate, returnedDocInfo?.LastModifiedDate);
|
|
Assert.AreEqual(docInformation.PersonNumbers, returnedDocInfo?.PersonNumbers);
|
|
Assert.AreEqual(docInformation.OrganizationNumbers, returnedDocInfo?.OrganizationNumbers);
|
|
Assert.AreEqual(docInformation.AccountNumber, returnedDocInfo?.AccountNumber);
|
|
Assert.AreEqual(docInformation.Attributes, returnedDocInfo?.Attributes);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocument_NoInformationPresent_Null()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(null as DocumentInformation)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.GetDocumentInformation(docId);
|
|
|
|
Assert.Null(result);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocument_ScanStatusIsFalse_DocumentIsNull()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.ScanStatus = false;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.GetDocumentInformation(docId);
|
|
|
|
Assert.IsNull(result);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void GetDocument_ExceptionThrown_ThrowDocumentInformationServiceException()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId))
|
|
.ThrowsAsync(new Exception("Thrown from unit test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async () => await _documentInformationService.GetDocumentInformation(docId));
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentInformationByBlobId_Success()
|
|
{
|
|
var docBlobId = Guid.NewGuid();
|
|
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
docInformation.ScanStatus = true;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformationByBlobId(docBlobId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
var returnedDocInfo = await _documentInformationService.GetDocumentInformationByBlobId(docBlobId);
|
|
|
|
Assert.NotNull(returnedDocInfo);
|
|
|
|
Assert.AreEqual(docInformation.DocumentId, returnedDocInfo?.DocumentId);
|
|
Assert.AreEqual(docInformation.Name, returnedDocInfo?.Name);
|
|
Assert.AreEqual(docInformation.Type, returnedDocInfo?.Type);
|
|
Assert.AreEqual(docInformation.Source, returnedDocInfo?.Source);
|
|
Assert.AreEqual(docInformation.ScanStatus, returnedDocInfo?.ScanStatus);
|
|
Assert.AreEqual(docInformation.UploadDate, returnedDocInfo?.UploadDate);
|
|
Assert.AreEqual(docInformation.LastModifiedDate, returnedDocInfo?.LastModifiedDate);
|
|
Assert.AreEqual(docInformation.PersonNumbers, returnedDocInfo?.PersonNumbers);
|
|
Assert.AreEqual(docInformation.OrganizationNumbers, returnedDocInfo?.OrganizationNumbers);
|
|
Assert.AreEqual(docInformation.AccountNumber, returnedDocInfo?.AccountNumber);
|
|
Assert.AreEqual(docInformation.Attributes, returnedDocInfo?.Attributes);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentByBlobId_NoInformationPresent_Null()
|
|
{
|
|
var docBlobId = Guid.NewGuid();
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformationByBlobId(docBlobId)).ReturnsAsync(null as DocumentInformation)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.GetDocumentInformationByBlobId(docBlobId);
|
|
|
|
Assert.Null(result);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void GetDocumentByBlobId_ExceptionThrown_ThrowDocumentInformationServiceException()
|
|
{
|
|
var docBlobId = Guid.NewGuid();
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformationByBlobId(docBlobId))
|
|
.ThrowsAsync(new Exception("Thrown from unit test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async () => await _documentInformationService.GetDocumentInformationByBlobId(docBlobId));
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeleteDocument_Success()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docBlobId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
_mockDocumentRepository
|
|
.Setup(x => x.RemoveDocumentInformation(docId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
await _documentInformationService.DeleteDocumentInformation(docId);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeleteDocument_NoInformationPresent_Null()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docBlobId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(null as DocumentInformation)
|
|
.Verifiable();
|
|
|
|
await _documentInformationService.DeleteDocumentInformation(docId);
|
|
|
|
_mockDocumentRepository.Verify(x => x.RemoveDocumentInformation(It.IsAny<Guid>()), Times.Never);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void DeleteDocument_RemoveDocumentInfoThrowsException_ThrowDocumentInformationServiceException()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docBlobId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
_mockDocumentRepository.Setup(x => x.RemoveDocumentInformation(docId))
|
|
.ThrowsAsync(new Exception("thrown from unit test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async () => await _documentInformationService.DeleteDocumentInformation(docId));
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task UploadDocument_Success()
|
|
{
|
|
var docBlobId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.SaveDocumentInformation(It.Is<DocumentInformation>(info =>
|
|
info.DocumentBlobId == docBlobId)))
|
|
.ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.UploadDocumentInformation(docInformation);
|
|
|
|
Assert.AreEqual(docInformation, result);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void UploadDocument_ExceptionThrown_ThrowDocumentInformation()
|
|
{
|
|
var docInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentRepository.Setup(x => x.SaveDocumentInformation(It.IsAny<DocumentInformation>()))
|
|
.ThrowsAsync(new Exception("Error thrown from unit test.")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async () => await _documentInformationService.UploadDocumentInformation(docInformation));
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocument_Success()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentId = docId;
|
|
|
|
_mockDocumentRepository.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(docInformation).Verifiable();
|
|
_mockDocumentRepository
|
|
.Setup(x => x.UpdateDocumentInformation(docId, It.Is<DocumentInformation>(info =>
|
|
info.DocumentId == docId))).ReturnsAsync(docInformation)
|
|
.Verifiable();
|
|
|
|
await _documentInformationService.UpdateDocumentInformation(docId, docInformation);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task UpdateDocument_NoInformation_Null()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
var docInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentRepository
|
|
.Setup(x => x.GetDocumentInformation(docId)).ReturnsAsync(null as DocumentInformation)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.UpdateDocumentInformation(docId, docInformation);
|
|
|
|
Assert.Null(result);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void UpdateDocument_ExceptionThrown_ThrowDocumentInformationServiceException()
|
|
{
|
|
var docBlobId = Guid.NewGuid();
|
|
var docId = Guid.NewGuid();
|
|
|
|
var docInformation = GenerateDocumentInformation();
|
|
docInformation.DocumentId = docId;
|
|
docInformation.DocumentBlobId = docBlobId;
|
|
|
|
_mockDocumentRepository.Setup(x => x.GetDocumentInformation(docId)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async () => await _documentInformationService.UpdateDocumentInformation(docId, docInformation));
|
|
|
|
_mockDocumentRepository.Verify(
|
|
x => x.UpdateDocumentInformation(It.IsAny<Guid>(), It.IsAny<DocumentInformation>()), Times.Never);
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_Success()
|
|
{
|
|
var searchFilter = GenerateDocumentInformationFilter();
|
|
var random = new Random(DateTime.Now.Millisecond);
|
|
var skip = random.Next();
|
|
var take = random.Next();
|
|
var docInformation = new List<DocumentInformation> { GenerateDocumentInformation() };
|
|
_mockDocumentRepository
|
|
.Setup(x => x.SearchDocumentInformation(searchFilter, skip, take, null))
|
|
.ReturnsAsync(docInformation);
|
|
|
|
var result = await _documentInformationService.SearchDocumentInformation(searchFilter, skip, take);
|
|
|
|
Assert.AreEqual(docInformation, result);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SearchDocumentInformation_NoneFound_EmptyList()
|
|
{
|
|
var searchFilter = GenerateDocumentInformationFilter();
|
|
_mockDocumentRepository
|
|
.Setup(x => x.SearchDocumentInformation(searchFilter, It.IsAny<int?>(), It.IsAny<int?>(), null))
|
|
.ReturnsAsync((List<DocumentInformation>)null)
|
|
.Verifiable();
|
|
|
|
var result = await _documentInformationService.SearchDocumentInformation(searchFilter);
|
|
|
|
_mockDocumentRepository.Verify();
|
|
Assert.IsEmpty(result);
|
|
}
|
|
|
|
[Test]
|
|
public void SearchDocumentInformation_ThrowsException_DocumentInformationServiceException()
|
|
{
|
|
var searchFilter = GenerateDocumentInformationFilter();
|
|
_mockDocumentRepository
|
|
.Setup(x => x.SearchDocumentInformation(searchFilter, It.IsAny<int?>(), It.IsAny<int?>(), null))
|
|
.ThrowsAsync(new Exception("Thrown from unit test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(async() => await _documentInformationService.SearchDocumentInformation(searchFilter));
|
|
|
|
_mockDocumentRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CountDocuments_RepositoryCountThrows_ThrowsDocumentInformationServiceException()
|
|
{
|
|
var filter = new DocumentInformationFilter();
|
|
_mockDocumentRepository
|
|
.Setup(r => r.CountDocuments(filter))
|
|
.ThrowsAsync(new Exception());
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(() => _documentInformationService.CountDocuments(filter));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CountDocuments_RepositoryReturnsCount_ReturnsCount()
|
|
{
|
|
var filter = new DocumentInformationFilter();
|
|
var expectedCount = DateTime.Now.Millisecond;
|
|
_mockDocumentRepository
|
|
.Setup(r => r.CountDocuments(filter))
|
|
.ReturnsAsync(expectedCount);
|
|
|
|
var count = await _documentInformationService.CountDocuments(filter);
|
|
|
|
Assert.AreEqual(expectedCount, count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentsForCleanup_Success()
|
|
{
|
|
var documents = new List<Guid> { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
|
|
_mockDocumentRepository.Setup(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
|
|
.ReturnsAsync(documents).Verifiable();
|
|
|
|
var result = await _documentInformationService.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>());
|
|
|
|
Assert.NotNull(result);
|
|
Assert.IsNotEmpty(result);
|
|
Assert.AreSame(documents, result);
|
|
_mockDocumentRepository.Verify(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentsForCleanup_Success_NoDocumentsFound()
|
|
{
|
|
var documents = new List<Guid>();
|
|
_mockDocumentRepository.Setup(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
|
|
.ReturnsAsync(documents).Verifiable();
|
|
|
|
var result = await _documentInformationService.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>());
|
|
|
|
Assert.NotNull(result);
|
|
Assert.IsEmpty(result);
|
|
Assert.AreSame(documents, result);
|
|
_mockDocumentRepository.Verify(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public void GetDocumentsForCleanup_ThrowsDocumentInformationServiceException()
|
|
{
|
|
_mockDocumentRepository
|
|
.Setup(r => r.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
|
|
.ThrowsAsync(new Exception());
|
|
|
|
Assert.ThrowsAsync<DocumentInformationServiceException>(() =>
|
|
_documentInformationService.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()));
|
|
}
|
|
|
|
private static DocumentInformationFilter GenerateDocumentInformationFilter()
|
|
{
|
|
return new DocumentInformationFilter
|
|
{
|
|
Name = "TestSearch"
|
|
};
|
|
}
|
|
|
|
private static DocumentInformation GenerateDocumentInformation()
|
|
{
|
|
return new DocumentInformation
|
|
{
|
|
DocumentId = Guid.NewGuid(),
|
|
Name = "TestFile.txt",
|
|
Type = "Test",
|
|
Source = "Developer's Laptop",
|
|
DataSource = "DNA",
|
|
ScanStatus = null,
|
|
UploadDate = DateTime.Parse("2022-03-25T19:16:12.3665642Z"),
|
|
LastModifiedDate = DateTime.Parse("0001-01-01T00:00:00"),
|
|
PersonNumbers = new string[] { "1", "2" },
|
|
OrganizationNumbers = new string[] { "3", "4" },
|
|
AccountNumber = "5",
|
|
Attributes = new Dictionary<string, string>
|
|
{
|
|
{ "IsTest", "true" },
|
|
{ "Owner", "Me Myself" }
|
|
}
|
|
};
|
|
}
|
|
}
|