557 lines
22 KiB
C#
557 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using FluentAssertions;
|
|
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;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
|
|
namespace LCU.API.Internal.DocumentTest.Services;
|
|
|
|
public class DocumentAuditServiceTest
|
|
{
|
|
private DocumentAuditService _documentAuditService;
|
|
private Mock<IDocumentAuditRepository> _mockDocumentAuditRepository;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_mockDocumentAuditRepository = new Mock<IDocumentAuditRepository>();
|
|
_documentAuditService = new DocumentAuditService(_mockDocumentAuditRepository.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentAudits_RepositoryReturnsActionAudits_ReturnsAuditsTransformedToResponse()
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var actionAudits = new List<DocumentAudit>
|
|
{
|
|
new DocumentActionAudit
|
|
(
|
|
documentId,
|
|
Guid.NewGuid().ToString(),
|
|
DateTime.Now,
|
|
Guid.NewGuid().ToString(),
|
|
Valid<DocumentAction>(),
|
|
Guid.NewGuid().ToString()
|
|
)
|
|
};
|
|
_mockDocumentAuditRepository
|
|
.Setup(r => r.GetDocumentAudits(documentId))
|
|
.ReturnsAsync(actionAudits);
|
|
|
|
var audits = await _documentAuditService.GetDocumentAudits(documentId);
|
|
|
|
actionAudits.Should().HaveSameCount(audits);
|
|
actionAudits.Should().AllSatisfy(a => audits.Should().ContainEquivalentOf(a));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentAudits_RepositoryReturnsFieldAudits_ReturnsAuditsTransformedToResponse()
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var actionAudits = new List<DocumentAudit>
|
|
{
|
|
new DocumentFieldAudit
|
|
(
|
|
documentId,
|
|
Guid.NewGuid().ToString(),
|
|
DateTime.Now,
|
|
Guid.NewGuid().ToString(),
|
|
Guid.NewGuid().ToString(),
|
|
Guid.NewGuid(),
|
|
Guid.NewGuid()
|
|
)
|
|
};
|
|
_mockDocumentAuditRepository
|
|
.Setup(r => r.GetDocumentAudits(documentId))
|
|
.ReturnsAsync(actionAudits);
|
|
|
|
var audits = await _documentAuditService.GetDocumentAudits(documentId);
|
|
|
|
actionAudits.Should().HaveSameCount(audits);
|
|
actionAudits.Should().AllSatisfy(a => audits.Should().ContainEquivalentOf(a));
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetDocumentAudits_RepositoryReturnsAnyAuditsOfUnknownType_ThrowsDocumentAuditServiceException()
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var actionAudits = new List<DocumentAudit>
|
|
{
|
|
new UnknownAuditType
|
|
(
|
|
documentId,
|
|
Guid.NewGuid().ToString(),
|
|
DateTime.Now,
|
|
Guid.NewGuid().ToString()
|
|
)
|
|
};
|
|
_mockDocumentAuditRepository
|
|
.Setup(r => r.GetDocumentAudits(documentId))
|
|
.ReturnsAsync(actionAudits);
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.GetDocumentAudits(documentId));
|
|
}
|
|
|
|
[Test]
|
|
public void GetDocumentAudits_DocumentAuditRepositoryThrowsException_ThrowsDocumentAuditServiceExceptionThrown()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.GetDocumentAudits(docId))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(async () => await _documentAuditService.GetDocumentAudits(docId));
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void GetDocumentAudits_Exception_DocumentAuditServiceExceptionThrown()
|
|
{
|
|
var docId = Guid.NewGuid();
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.GetDocumentAudits(docId))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(async () => await _documentAuditService.GetDocumentAudits(docId));
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentUploadedAudit_Success()
|
|
{
|
|
var uploadDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
var audits = new DocumentAudit[]
|
|
{
|
|
new DocumentActionAudit
|
|
(
|
|
documentInformation.DocumentId,
|
|
"System",
|
|
uploadDate,
|
|
"System",
|
|
DocumentAction.Upload,
|
|
"Document Uploaded"
|
|
)
|
|
};
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list =>
|
|
list.Length == 1
|
|
&& list.All(a => a is DocumentActionAudit)
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Action == DocumentAction.Upload
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).UserId == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Source == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).ActionDescription == "Document Uploaded")))
|
|
.ReturnsAsync(audits)
|
|
.Verifiable();
|
|
|
|
var result = await _documentAuditService.CreateDocumentUploadedAudit(documentInformation.DocumentId, uploadDate);
|
|
var resultArray = result.ToArray();
|
|
|
|
Assert.NotNull(result);
|
|
audits.Should().HaveSameCount(resultArray);
|
|
audits.Should().AllSatisfy(a => resultArray.Should().ContainEquivalentOf(a));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentUploadedAudit_DocumentAuditRepositoryThrowsException_ThrowsNewDocumentAuditServiceExceptionThrown()
|
|
{
|
|
var uploadDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new DocumentAuditServiceException("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentUploadedAudit(documentInformation.DocumentId, uploadDate));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentUploadedAudit_Exception_DocumentAuditServiceExceptionThrown()
|
|
{
|
|
var uploadDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentUploadedAudit(documentInformation.DocumentId, uploadDate));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentDeletedAudit_Success()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
var audits = new DocumentAudit[]
|
|
{
|
|
new DocumentActionAudit
|
|
(
|
|
documentInformation.DocumentId,
|
|
"System",
|
|
deleteDate,
|
|
"System",
|
|
DocumentAction.Delete,
|
|
"Document Deleted"
|
|
)
|
|
};
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list =>
|
|
list.Length == 1
|
|
&& list.All(a => a is DocumentActionAudit)
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Action == DocumentAction.Delete
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).UserId == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Source == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).ActionDescription == "Document Deleted")))
|
|
.ReturnsAsync(audits)
|
|
.Verifiable();
|
|
|
|
var result = await _documentAuditService.CreateDocumentDeletedAudit(documentInformation.DocumentId, deleteDate);
|
|
var resultArray = result.ToArray();
|
|
|
|
Assert.NotNull(result);
|
|
audits.Should().HaveSameCount(resultArray);
|
|
audits.Should().AllSatisfy(a => resultArray.Should().ContainEquivalentOf(a));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentDeletedAudit_DocumentAuditRepositoryThrowsException_ThrowsNewDocumentAuditServiceExceptionThrown()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new DocumentAuditServiceException("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentDeletedAudit(documentInformation.DocumentId, deleteDate));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentDeletedAudit_Exception_DocumentAuditServiceExceptionThrown()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentDeletedAudit(documentInformation.DocumentId, deleteDate));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentContentDeletedAudit_Success()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
var reason = Guid.NewGuid().ToString();
|
|
var reasonFull = $"DocumentContent Deleted. Reason: {reason}";
|
|
|
|
var audits = new DocumentAudit[]
|
|
{
|
|
new DocumentActionAudit
|
|
(
|
|
documentInformation.DocumentId,
|
|
"System",
|
|
deleteDate,
|
|
"System",
|
|
DocumentAction.DeleteContent,
|
|
reasonFull
|
|
)
|
|
};
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list =>
|
|
list.Length == 1
|
|
&& list.All(a => a is DocumentActionAudit)
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Action == DocumentAction.DeleteContent
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).UserId == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).Source == "System"
|
|
&& ((DocumentActionAudit)list.FirstOrDefault()!).ActionDescription == reasonFull)))
|
|
.ReturnsAsync(audits)
|
|
.Verifiable();
|
|
|
|
var result = await _documentAuditService.CreateDocumentContentDeletedAudit(documentInformation.DocumentId, deleteDate, reason);
|
|
var resultArray = result.ToArray();
|
|
|
|
Assert.NotNull(result);
|
|
audits.Should().HaveSameCount(resultArray);
|
|
audits.Should().AllSatisfy(a => resultArray.Should().ContainEquivalentOf(a));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentContentDeletedAudit_DocumentAuditRepositoryThrowsException_ThrowsNewDocumentAuditServiceExceptionThrown()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
var reason = Guid.NewGuid().ToString();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new DocumentAuditServiceException("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentContentDeletedAudit(documentInformation.DocumentId, deleteDate, reason));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentContentDeletedAudit_Exception_DocumentAuditServiceExceptionThrown()
|
|
{
|
|
var deleteDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var documentInformation = GenerateDocumentInformation();
|
|
var reason = Guid.NewGuid().ToString();
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentContentDeletedAudit(documentInformation.DocumentId, deleteDate, reason));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentAudits_No_Differences_Success()
|
|
{
|
|
var updateDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var docInformationOld = GenerateDocumentInformation();
|
|
var docInformationNew = GenerateDocumentInformation();
|
|
|
|
var result = await _documentAuditService.CreateDocumentAudits(docInformationOld, docInformationNew, false, updateDate, "testUser");
|
|
|
|
Assert.NotNull(result);
|
|
Assert.IsEmpty(result);
|
|
_mockDocumentAuditRepository.Verify(x => x.SaveDocumentAudits(It.IsAny<DocumentAudit[]>()), Times.Never);
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentAudits_No_Differences_ContentChange_Success()
|
|
{
|
|
var updateDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var userId = Guid.NewGuid().ToString();
|
|
var docInformationOld = GenerateDocumentInformation();
|
|
var docInformationNew = GenerateDocumentInformation();
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list =>
|
|
list.Length == 1
|
|
&& list.All(a => a is DocumentFieldAudit)
|
|
&& ((DocumentFieldAudit)list.FirstOrDefault()!).Field == "Content"
|
|
&& list.All(audit => string.Equals(userId, ((DocumentFieldAudit)audit).UserId)))))
|
|
.ReturnsAsync(new List<DocumentAudit>())
|
|
.Verifiable();
|
|
|
|
await _documentAuditService.CreateDocumentAudits(docInformationOld, docInformationNew, true, updateDate, userId);
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDocumentAudits_All_Differences_Success()
|
|
{
|
|
var updateDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var docInformationOld = GenerateDocumentInformation();
|
|
var docInformationEverythingChanges = GenerateDocumentInformation();
|
|
var userId = Guid.NewGuid().ToString();
|
|
docInformationEverythingChanges.Name = "BrandNewName";
|
|
docInformationEverythingChanges.Type = "BrandNewType";
|
|
docInformationEverythingChanges.ScanStatus = true;
|
|
docInformationEverythingChanges.DataSource = "NEW SOURCE";
|
|
docInformationEverythingChanges.Attributes = new Dictionary<string, string>
|
|
{
|
|
{ "NEW_FIELD", "NEW_VALUE" }
|
|
};
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list =>
|
|
list.Length == 4
|
|
&& list.All(a => a is DocumentFieldAudit)
|
|
&& list.Any(audit => string.Equals("Name", ((DocumentFieldAudit)audit).Field))
|
|
&& list.Any(audit => string.Equals("Type", ((DocumentFieldAudit)audit).Field))
|
|
&& list.Any(audit => string.Equals("ScanStatus", ((DocumentFieldAudit)audit).Field))
|
|
&& list.Any(audit => string.Equals("Attributes", ((DocumentFieldAudit)audit).Field))
|
|
&& list.All(audit => string.Equals(userId, ((DocumentFieldAudit)audit).UserId)))))
|
|
.ReturnsAsync(new List<DocumentAudit>())
|
|
.Verifiable();
|
|
|
|
await _documentAuditService.CreateDocumentAudits(docInformationOld, docInformationEverythingChanges, false, updateDate, userId);
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentAudits_DocumentAuditRepositoryThrowsException_ThrowsNewDocumentAuditServiceExceptionThrown()
|
|
{
|
|
var updateDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var docInformationOld = GenerateDocumentInformation();
|
|
var docInformationNew = GenerateDocumentInformation();
|
|
var userId = Guid.NewGuid().ToString();
|
|
docInformationNew.Name = "NewName.txt";
|
|
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new DocumentAuditServiceException("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentAudits(docInformationOld, docInformationNew, false, updateDate, userId));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDocumentAudits_Exception_DocumentAuditServiceExceptionThrown()
|
|
{
|
|
|
|
var updateDate = DateTime.Parse("2022-04-28T17:32:35.093Z");
|
|
var docInformationOld = GenerateDocumentInformation();
|
|
var docInformationNew = GenerateDocumentInformation();
|
|
var userId = Guid.NewGuid().ToString();
|
|
docInformationNew.Name = "NewName.txt";
|
|
_mockDocumentAuditRepository
|
|
.Setup(x => x.SaveDocumentAudits(It.Is<DocumentAudit[]>(list => list.Any())))
|
|
.ThrowsAsync(new Exception("Thrown From Unit Test"))
|
|
.Verifiable();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.CreateDocumentAudits(docInformationOld, docInformationNew, false, updateDate, userId));
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public void AuditAction_RepositoryThrowsException_ThrowsDocumentAuditServiceException()
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var userId = Guid.NewGuid().ToString();
|
|
var source = Guid.NewGuid().ToString();
|
|
var action = Valid<DocumentAction>();
|
|
_mockDocumentAuditRepository
|
|
.Setup(r => r.SaveDocumentAudits(It.Is<DocumentActionAudit>(a =>
|
|
a.DocumentId == documentId
|
|
&& a.UserId == userId
|
|
&& a.Source == source
|
|
&& a.Action == action)))
|
|
.ThrowsAsync(new Exception());
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.AuditAction(documentId, userId, source, action));
|
|
}
|
|
|
|
[Test]
|
|
public void AuditAction_UnknownActionType_ThrowsDocumentAuditServiceException()
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var userId = Guid.NewGuid().ToString();
|
|
var source = Guid.NewGuid().ToString();
|
|
var action = Invalid<DocumentAction>();
|
|
|
|
Assert.ThrowsAsync<DocumentAuditServiceException>(() => _documentAuditService.AuditAction(documentId, userId, source, action));
|
|
}
|
|
|
|
private static DocumentAction[] AllDocumentActions => AllValid<DocumentAction>();
|
|
|
|
[TestCaseSource(nameof(AllDocumentActions))]
|
|
public async Task AuditAction_ValidAction_SavesActionAudit(DocumentAction action)
|
|
{
|
|
var documentId = Guid.NewGuid();
|
|
var userId = Guid.NewGuid().ToString();
|
|
var source = Guid.NewGuid().ToString();
|
|
_mockDocumentAuditRepository
|
|
.Setup(r => r.SaveDocumentAudits(It.Is<DocumentActionAudit>(a =>
|
|
a.DocumentId == documentId
|
|
&& a.UserId == userId
|
|
&& a.Source == source
|
|
&& a.Action == action)))
|
|
.Verifiable();
|
|
|
|
await _documentAuditService.AuditAction(documentId, userId, source, action);
|
|
|
|
_mockDocumentAuditRepository.Verify();
|
|
}
|
|
|
|
private static List<DocumentAudit> GenerateDocumentAudits()
|
|
{
|
|
return new List<DocumentAudit>
|
|
{
|
|
new DocumentFieldAudit(Guid.NewGuid(), "UnitTest", DateTime.Parse("2022-04-28T17:32:35.093Z"), "Test", "Test", "0", "1")
|
|
};
|
|
}
|
|
|
|
private static DocumentInformation GenerateDocumentInformation()
|
|
{
|
|
return new DocumentInformation
|
|
{
|
|
DocumentId = Guid.NewGuid(),
|
|
Name = "TestFile.txt",
|
|
Type = "Test",
|
|
Source = "Developer's Laptop",
|
|
ScanStatus = null,
|
|
UploadDate = DateTime.Parse("2022-03-25T19:16:12.3665642Z"),
|
|
LastModifiedDate = DateTime.Parse("0001-01-01T00:00:00"),
|
|
Attributes = new Dictionary<string, string>
|
|
{
|
|
{ "IsTest", "true" },
|
|
{ "Owner", "Me Myself" }
|
|
}
|
|
};
|
|
}
|
|
|
|
private static T[] AllValid<T>()
|
|
where T : struct, Enum
|
|
{
|
|
return Enum.GetValues<T>();
|
|
}
|
|
|
|
private static T Valid<T>()
|
|
where T : struct, Enum
|
|
{
|
|
var values = Enum.GetValues<T>();
|
|
|
|
return values[DateTime.Now.Millisecond % values.Length];
|
|
}
|
|
|
|
private static T Invalid<T>()
|
|
where T : struct, Enum
|
|
{
|
|
return (T)Convert.ChangeType(Enum.GetValues<T>().Length + 1, typeof(int));
|
|
}
|
|
|
|
private class UnknownAuditType : DocumentAudit
|
|
{
|
|
public UnknownAuditType(Guid documentId, string source, DateTime date, string userId)
|
|
: base(documentId, source, date, userId)
|
|
{
|
|
}
|
|
}
|
|
} |