using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using LCU.API.Internal.Document.Controllers;
using LCU.API.Internal.Document.Services;
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
using LCU.Library.Internal.DocumentModels.Requests;
using LCU.Library.Internal.DocumentModels.Requests.Search;
using LCU.Library.Internal.DocumentModels.Responses;
using LCU.Library.Internal.Exceptions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Cosmos;
using Moq;
using NUnit.Framework;

namespace LCU.API.Internal.DocumentTest.Controllers;

public class DocumentControllerTest
{
    private DocumentController _controller = null!;
    private Mock<IDocumentService> _mockDocumentService = null!;
    private Mock<IDocumentAuditService> _mockDocumentAuditService = null!;

    [SetUp]
    public void Setup()
    {
        _mockDocumentService = new Mock<IDocumentService>();
        _mockDocumentAuditService = new Mock<IDocumentAuditService>();

        _controller = new DocumentController(_mockDocumentService.Object,
                                             _mockDocumentAuditService.Object)
        {
            ControllerContext =
            {
                HttpContext = new DefaultHttpContext()
            }
        };
    }

    [Test]
    public async Task Get_Document_OK()
    {
        var docId = Guid.NewGuid();
        var documentResponse = GenerateDocumentResponse(docId);

        _mockDocumentService.Setup(service => service.GetDocument(docId)).ReturnsAsync(documentResponse).Verifiable();

        var result = await _controller.GetDocumentById(docId);
        Assert.NotNull(result);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentResponse;
        Assert.NotNull(okValue);

        var expectedDocContent = documentResponse.Content;
        var expectedDocInformation = documentResponse.DocumentInformation;
        var returnedDocInformation = okValue!.DocumentInformation;

        Assert.AreEqual(expectedDocContent, okValue.Content);
        Assert.AreEqual(expectedDocInformation.DocumentId, returnedDocInformation.DocumentId);
        Assert.AreEqual(expectedDocInformation.Name, returnedDocInformation.Name);
        Assert.AreEqual(expectedDocInformation.Type, returnedDocInformation.Type);
        Assert.AreEqual(expectedDocInformation.Source, returnedDocInformation.Source);
        Assert.AreEqual(expectedDocInformation.ScanStatus, returnedDocInformation.ScanStatus);
        Assert.AreEqual(expectedDocInformation.UploadDate, returnedDocInformation.UploadDate);
        Assert.AreEqual(expectedDocInformation.LastModifiedDate, returnedDocInformation.LastModifiedDate);
        Assert.AreEqual(expectedDocInformation.Attributes, returnedDocInformation.Attributes);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_Document_Null_NoContent()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocument(docId)).ReturnsAsync((DocumentResponse)null).Verifiable();

        var result = await _controller.GetDocumentById(docId);
        Assert.NotNull(result);

        var noContent = result as NotFoundObjectResult;
        Assert.NotNull(noContent);
        Assert.AreEqual(404, noContent!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_Document_ServiceException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocument(docId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentById(docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_Document_UnexpectedException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocument(docId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentById(docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentByBlobId_Null_NoContent()
    {
        var blobId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentByBlobId(blobId)).ReturnsAsync((byte[]?)null).Verifiable();

        var result = await _controller.GetDocumentByBlobId(blobId);
        Assert.NotNull(result);

        var noContent = result as NotFoundObjectResult;
        Assert.NotNull(noContent);
        Assert.AreEqual(404, noContent!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentByBlobId_ServiceException()
    {
        var blobId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentByBlobId(blobId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentByBlobId(blobId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentByBlobId_UnexpectedException()
    {
        var blobId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentByBlobId(blobId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentByBlobId(blobId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Post_SearchDocumentInformation_Content_Ok()
    {
        var random = new Random(DateTime.Now.Millisecond);
        var searchRequest = new DocumentInformationFilteredSearch
        {
            Filter = new DocumentInformationFilter(),
            Skip = random.Next(),
            Take = random.Next(),
            SortDefinition = new List<SortableField>
            {
                new()
                {
                    Field = "CreatedDate",
                    Position = 0,
                    IsDescending = false
                }
            }
        };
        var docIdOne = Guid.NewGuid();
        var docIdTwo = Guid.NewGuid();
        var documentInformationResponse = new List<DocumentInformationResponse>
        {
            new()
            {
                DocumentId = docIdOne
            },
            new()
            {
                DocumentId = docIdTwo
            }
        };
        _mockDocumentService
            .Setup(x => x.SearchDocumentInformation(searchRequest.Filter, searchRequest.Skip, searchRequest.Take, searchRequest.SortDefinition))
            .ReturnsAsync(documentInformationResponse)
            .Verifiable();

        var result = await _controller.PostDocumentInformationByFilter(searchRequest);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);
        var documentsInformation = okResult.Value as List<DocumentInformationResponse>;
        CollectionAssert.AreEqual(documentInformationResponse, documentsInformation);
    }

    [Test]
    public async Task Post_SearchDocumentInformation_Null_NoContent()
    {
        var documentInformationResponse = new List<DocumentInformationResponse>
        {
            Capacity = 0
        };
        var searchRequest = new DocumentInformationFilteredSearch
        {
            Filter = new DocumentInformationFilter()
        };
        _mockDocumentService
            .Setup(x => x.SearchDocumentInformation(searchRequest.Filter, It.IsAny<int?>(), It.IsAny<int?>(), It.IsAny<List<SortableField>?>()))
            .ReturnsAsync(documentInformationResponse)
            .Verifiable();

        var result = await _controller.PostDocumentInformationByFilter(searchRequest);

        var noContentResult = result as NoContentResult;
        Assert.NotNull(noContentResult);
        Assert.AreEqual(204, noContentResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Post_SearchDocumentInformation_ServiceException()
    {
        var searchRequest = new DocumentInformationFilteredSearch
        {
            Filter = new DocumentInformationFilter()
        };
        _mockDocumentService
            .Setup(x => x.SearchDocumentInformation(searchRequest.Filter, It.IsAny<int?>(), It.IsAny<int?>(), It.IsAny<List<SortableField>?>()))
            .ThrowsAsync(new ServiceException("Thrown from unit test"))
            .Verifiable();

        var result = await _controller.PostDocumentInformationByFilter(searchRequest);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Post_SearchDocumentInformation_UnexpectedException()
    {
        var searchRequest = new DocumentInformationFilteredSearch
        {
            Filter = new DocumentInformationFilter()
        };
        _mockDocumentService
            .Setup(x => x.SearchDocumentInformation(searchRequest.Filter, It.IsAny<int?>(), It.IsAny<int?>(), It.IsAny<List<SortableField>?>()))
            .ThrowsAsync(new Exception("Thrown from unit test"))
            .Verifiable();

        var result = await _controller.PostDocumentInformationByFilter(searchRequest);

        var statusCodeResult = result as StatusCodeResult;
        Assert.NotNull(statusCodeResult);
        Assert.AreEqual(500, statusCodeResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentAudit_Content_Ok()
    {
        var docId = Guid.NewGuid();
        var documentAuditResponse = new List<DocumentAuditResponse>
        {
            new DocumentFieldAuditResponse
            {
                DocumentId = docId,
                Source = "Unit Test",
                Date = DateTime.Parse("2022-04-28T17:32:35.093Z"),
                UserId = "Test",
                Field = "Test",
                PreviousValue = "0",
                CurrentValue = "1"
            },
            new DocumentActionAuditResponse
            {
                DocumentId = docId,
                Source = "Unit Test",
                Date = DateTime.Parse("2022-04-28T17:32:35.093Z"),
                UserId = "Test",
                Action = DocumentAction.Download,
                ActionDescription = "Testing"
            }
        };
        _mockDocumentAuditService
            .Setup(service => service.GetDocumentAudits(docId))
            .ReturnsAsync(documentAuditResponse);

        var result = await _controller.GetDocumentAuditInformationById(docId);

        Assert.NotNull(result);
        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);
        Assert.AreSame(documentAuditResponse, okResult.Value!);
    }

    [Test]
    public async Task Get_DocumentAudit_NoContent_Ok()
    {
        var docId = Guid.NewGuid();
        var documentAuditResponse = new List<DocumentAuditResponse>();
        _mockDocumentAuditService
            .Setup(service => service.GetDocumentAudits(docId))
            .ReturnsAsync(documentAuditResponse);

        var result = await _controller.GetDocumentAuditInformationById(docId);

        Assert.NotNull(result);
        var okResult = result as NoContentResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(204, okResult!.StatusCode);
    }

    [Test]
    public async Task Get_DocumentAudit_ServiceException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentAuditService.Setup(service => service.GetDocumentAudits(docId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentAuditInformationById(docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentAudit_UnexpectedException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentAuditService.Setup(service => service.GetDocumentAudits(docId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentAuditInformationById(docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentAuditService.Verify();
    }

    [Test]
    public async Task GetDocumentAuditInformationByIds_AuditServiceThrowsServiceException_Returns500()
    {
        var documentIds = new[] { Guid.NewGuid(), Guid.NewGuid() };
        _mockDocumentAuditService
            .Setup(s => s.GetDocumentAudits(documentIds))
            .ThrowsAsync(new ServiceException(string.Empty));

        var response = await _controller.GetDocumentAuditInformationByIds(documentIds);

        Assert.IsInstanceOf<ObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((ObjectResult)response).StatusCode);
    }

    [Test]
    public async Task GetDocumentAuditInformationByIds_AuditServiceThrowsException_Returns500()
    {
        var documentIds = new[] { Guid.NewGuid(), Guid.NewGuid() };
        _mockDocumentAuditService
            .Setup(s => s.GetDocumentAudits(documentIds))
            .ThrowsAsync(new Exception());

        var response = await _controller.GetDocumentAuditInformationByIds(documentIds);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task GetDocumentAuditInformationByIds_AuditServiceDoesNotThrow_ReturnsOkWithLogs()
    {
        var documentIds = new[] { Guid.NewGuid(), Guid.NewGuid() };
        var auditLogs = new List<DocumentAuditResponse>
        {
            new DocumentFieldAuditResponse(),
            new DocumentActionAuditResponse()
        };
        _mockDocumentAuditService
            .Setup(s => s.GetDocumentAudits(documentIds))
            .ReturnsAsync(auditLogs);

        var response = await _controller.GetDocumentAuditInformationByIds(documentIds);

        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
        Assert.AreEqual(auditLogs, ((OkObjectResult)response).Value);
    }

    [Test]
    public async Task ExternalActionPerformed_ExternalActionNotAllowed_Returns400()
    {
        var documentId = Guid.NewGuid();
        var request = new DocumentActionNotificationRequest
        {
            Action = (DocumentAction)DateTime.Now.Millisecond,
            Source = Guid.NewGuid().ToString()
        };

        var response = await _controller.ExternalActionPerformed(documentId, request);

        Assert.IsInstanceOf<ObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status400BadRequest, ((ObjectResult)response).StatusCode);
    }

    [Test]
    public async Task ExternalActionPerformed_AuditServiceThrowsException_Returns500()
    {
        var userId = Guid.NewGuid().ToString();
        var documentId = Guid.NewGuid();
        var request = new DocumentActionNotificationRequest
        {
            Action = DocumentAction.Download,
            Source = Guid.NewGuid().ToString()
        };
        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));
        _mockDocumentAuditService
            .Setup(s => s.AuditAction(documentId, userId, request.Source, request.Action))
            .ThrowsAsync(new Exception());
        var response = await _controller.ExternalActionPerformed(documentId, request);
        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task ExternalActionPerformed_AuditServiceDoesNotThrow_ReturnsOk()
    {
        var userId = Guid.NewGuid().ToString();
        var documentId = Guid.NewGuid();
        var request = new DocumentActionNotificationRequest
        {
            Action = DocumentAction.Download,
            Source = Guid.NewGuid().ToString()
        };
        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));
        _mockDocumentAuditService
            .Setup(s => s.AuditAction(documentId, userId, request.Source, request.Action))
            .Verifiable();
        var response = await _controller.ExternalActionPerformed(documentId, request);
        _mockDocumentAuditService.Verify();
        Assert.IsInstanceOf<OkResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((OkResult)response).StatusCode);
    }

    [Test]
    public async Task Upload_Document_OK()
    {
        var docId = Guid.NewGuid();
        var docRequest = GenerateDocumentRequest();

        var docInformation = new DocumentInformationResponse
        {
            DocumentId = docId
        };

        _mockDocumentService.Setup(service => service.UploadDocument(docRequest)).ReturnsAsync(docInformation)
            .Verifiable();

        var result = await _controller.UploadDocument(docRequest);
        Assert.NotNull(result);

        var okResult = result as CreatedAtActionResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(201, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentInformationResponse;
        Assert.NotNull(okValue);

        Assert.AreEqual(docInformation.DocumentId, okValue!.DocumentId);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Upload_Document_ServiceException()
    {
        var docRequest = GenerateDocumentRequest();

        _mockDocumentService.Setup(service => service.UploadDocument(docRequest))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.UploadDocument(docRequest);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Upload_Document_UnexpectedException()
    {
        var docRequest = GenerateDocumentRequest();

        _mockDocumentService.Setup(service => service.UploadDocument(docRequest))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.UploadDocument(docRequest);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_Document_OK()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocRequest = GenerateUpdateDocumentRequest();

        var docInformation = new DocumentInformationResponse
        {
            DocumentId = docId
        };

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocument(updateDocRequest, docId, userId))
            .ReturnsAsync(docInformation).Verifiable();

        var result = await _controller.UpdateDocument(updateDocRequest, docId);
        Assert.NotNull(result);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentInformationResponse;
        Assert.NotNull(okValue);

        Assert.AreEqual(docInformation.DocumentId, okValue!.DocumentId);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_Document_Null_NotFound()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocRequest = GenerateUpdateDocumentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocument(updateDocRequest, docId, userId))
            .ReturnsAsync((DocumentInformationResponse?)null).Verifiable();

        var result = await _controller.UpdateDocument(updateDocRequest, docId);
        Assert.NotNull(result);

        var okResult = result as NotFoundObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(404, okResult!.StatusCode);

        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_Document_ServiceException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocRequest = GenerateUpdateDocumentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocument(updateDocRequest, docId, userId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocument(updateDocRequest, docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_Document_UnexpectedException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocRequest = GenerateUpdateDocumentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocument(updateDocRequest, docId, userId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocument(updateDocRequest, docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentInformation_OK()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocInformationRequest = GenerateUpdateDocumentInformationRequest();

        var docInformation = new DocumentInformationResponse
        {
            DocumentId = docId
        };

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentInformation(updateDocInformationRequest, docId, userId))
            .ReturnsAsync(docInformation).Verifiable();

        var result = await _controller.UpdateDocumentInformation(updateDocInformationRequest, docId);
        Assert.NotNull(result);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentInformationResponse;
        Assert.NotNull(okValue);

        Assert.AreEqual(docInformation.DocumentId, okValue!.DocumentId);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentInformation_Null_NotFound()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocInformationRequest = GenerateUpdateDocumentInformationRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentInformation(updateDocInformationRequest, docId, userId))
            .ReturnsAsync((DocumentInformationResponse?)null).Verifiable();

        var result = await _controller.UpdateDocumentInformation(updateDocInformationRequest, docId);
        Assert.NotNull(result);

        var okResult = result as NotFoundObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(404, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentInformation_ServiceException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocInformationRequest = GenerateUpdateDocumentInformationRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentInformation(updateDocInformationRequest, docId, userId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentInformation(updateDocInformationRequest, docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentInformation_UnexpectedException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocInformationRequest = GenerateUpdateDocumentInformationRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentInformation(updateDocInformationRequest, docId, userId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentInformation(updateDocInformationRequest, docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }
    
    [Test]
    public async Task Get_DocumentInformation_OK()
    {
        var docId = Guid.NewGuid();
        var documentResponse = GenerateDocumentResponse(docId).DocumentInformation;

        _mockDocumentService.Setup(service => service.GetDocumentInformation(docId)).ReturnsAsync(documentResponse).Verifiable();

        var result = await _controller.GetDocumentInformation(docId);
        Assert.NotNull(result);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentInformationResponse;
        Assert.NotNull(okValue);

        var expectedDocInformation = documentResponse;
        var returnedDocInformation = okValue!;

        Assert.AreEqual(expectedDocInformation.DocumentId, returnedDocInformation.DocumentId);
        Assert.AreEqual(expectedDocInformation.Name, returnedDocInformation.Name);
        Assert.AreEqual(expectedDocInformation.Type, returnedDocInformation.Type);
        Assert.AreEqual(expectedDocInformation.Source, returnedDocInformation.Source);
        Assert.AreEqual(expectedDocInformation.ScanStatus, returnedDocInformation.ScanStatus);
        Assert.AreEqual(expectedDocInformation.UploadDate, returnedDocInformation.UploadDate);
        Assert.AreEqual(expectedDocInformation.LastModifiedDate, returnedDocInformation.LastModifiedDate);
        Assert.AreEqual(expectedDocInformation.Attributes, returnedDocInformation.Attributes);
        _mockDocumentService.Verify();
    }
    
    [Test]
    public async Task Get_DocumentInformation_Null_NotFound()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentInformation(docId)).ReturnsAsync((DocumentInformationResponse)null).Verifiable();

        var result = await _controller.GetDocumentInformation(docId);
        Assert.NotNull(result);

        var notFound = result as NotFoundObjectResult;
        Assert.NotNull(notFound);
        Assert.AreEqual(404, notFound!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentInformation_ServiceException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentInformation(docId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentInformation(docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Get_DocumentInformation_UnexpectedException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.GetDocumentInformation(docId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.GetDocumentInformation(docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentSetStatus_OK()
    {
        var userId = Guid.NewGuid().ToString();
        var updateDocumentScanStatusRequest = GenerateUpdateDocumentScanStatusRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentScanStatus(true, updateDocumentScanStatusRequest.DocumentBlobIds, userId))
            .Verifiable();

        var result = await _controller.UpdateDocumentScanStatus(updateDocumentScanStatusRequest);
        Assert.NotNull(result);

        var okResult = result as OkResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentSetStatus_ServiceException()
    {
        var userId = Guid.NewGuid().ToString();
        var updateDocumentScanStatusRequest = GenerateUpdateDocumentScanStatusRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentScanStatus(true, updateDocumentScanStatusRequest.DocumentBlobIds, userId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentScanStatus(updateDocumentScanStatusRequest);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentSetStatus_UnexpectedException()
    {
        var userId = Guid.NewGuid().ToString();
        var updateDocumentScanStatusRequest = GenerateUpdateDocumentScanStatusRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentScanStatus(true, updateDocumentScanStatusRequest.DocumentBlobIds, userId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentScanStatus(updateDocumentScanStatusRequest);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentContent_OK()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocContentRequest = GenerateUpdateDocumentContentRequest();

        var docInformation = new DocumentInformationResponse
        {
            DocumentId = docId
        };

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentContent(updateDocContentRequest, docId, userId))
            .ReturnsAsync(docInformation).Verifiable();

        var result = await _controller.UpdateDocumentContent(updateDocContentRequest, docId);
        Assert.NotNull(result);

        var okResult = result as OkObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(200, okResult!.StatusCode);

        var okValue = okResult.Value as DocumentInformationResponse;
        Assert.NotNull(okValue);

        Assert.AreEqual(docInformation.DocumentId, okValue!.DocumentId);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentContent_Null_NotFound()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocContentRequest = GenerateUpdateDocumentContentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentContent(updateDocContentRequest, docId, userId))
            .ReturnsAsync((DocumentInformationResponse?)null).Verifiable();

        var result = await _controller.UpdateDocumentContent(updateDocContentRequest, docId);
        Assert.NotNull(result);

        var okResult = result as NotFoundObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(404, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentContent_ServiceException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocContentRequest = GenerateUpdateDocumentContentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentContent(updateDocContentRequest, docId, userId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentContent(updateDocContentRequest, docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Update_DocumentContent_UnexpectedException()
    {
        var userId = Guid.NewGuid().ToString();
        var docId = Guid.NewGuid();
        var updateDocContentRequest = GenerateUpdateDocumentContentRequest();

        _controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim("name", userId) }));

        _mockDocumentService.Setup(service => service.UpdateDocumentContent(updateDocContentRequest, docId, userId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.UpdateDocumentContent(updateDocContentRequest, docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_Document_OK()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.DeleteDocument(docId)).Verifiable();

        var result = await _controller.DeleteDocument(docId);
        Assert.NotNull(result);

        var okResult = result as OkResult;
        Assert.AreEqual(200, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_Document_ServiceException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.DeleteDocument(docId))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.DeleteDocument(docId);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_Document_UnexpectedException()
    {
        var docId = Guid.NewGuid();

        _mockDocumentService.Setup(service => service.DeleteDocument(docId))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.DeleteDocument(docId);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_DocumentContent_OK()
    {
        var request = new DeleteDocumentContentRequest()
        {
            DocumentId = Guid.NewGuid(),
            Reason = Guid.NewGuid().ToString()
        };

        _mockDocumentService.Setup(service => service.DeleteDocumentContent(request)).Verifiable();

        var result = await _controller.DeleteDocumentContent(request);
        Assert.NotNull(result);

        var okResult = result as OkResult;
        Assert.AreEqual(200, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_DocumentContent_ServiceException()
    {
        var request = new DeleteDocumentContentRequest()
        {
            DocumentId = Guid.NewGuid(),
            Reason = Guid.NewGuid().ToString()
        };

        _mockDocumentService.Setup(service => service.DeleteDocumentContent(request))
            .ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();

        var result = await _controller.DeleteDocumentContent(request);
        Assert.NotNull(result);

        var okResult = result as ObjectResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }

    [Test]
    public async Task Delete_DocumentContent_UnexpectedException()
    {
        var request = new DeleteDocumentContentRequest()
        {
            DocumentId = Guid.NewGuid(),
            Reason = Guid.NewGuid().ToString()
        };

        _mockDocumentService.Setup(service => service.DeleteDocumentContent(request))
            .ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();

        var result = await _controller.DeleteDocumentContent(request);
        Assert.NotNull(result);

        var okResult = result as StatusCodeResult;
        Assert.NotNull(okResult);
        Assert.AreEqual(500, okResult!.StatusCode);
        _mockDocumentService.Verify();
    }
    
    [Test]
    public async Task CountDocuments_ServiceThrowsServiceException_Returns500()
    {
        var filter = new DocumentInformationFilter();
        _mockDocumentService
            .Setup(d => d.CountDocuments(filter))
            .ThrowsAsync(new ServiceException(string.Empty));

        var response = await _controller.CountDocuments(filter);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task CountDocuments_ServiceThrowsException_Returns500()
    {
        var filter = new DocumentInformationFilter();
        _mockDocumentService
            .Setup(d => d.CountDocuments(filter))
            .ThrowsAsync(new Exception());

        var response = await _controller.CountDocuments(filter);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task CountDocuments_ServiceDoesNotThrow_ReturnsOkAndCount()
    {
        var filter = new DocumentInformationFilter();
        var expectedCount = DateTime.Now.Millisecond;
        _mockDocumentService
            .Setup(d => d.CountDocuments(filter))
            .ReturnsAsync(expectedCount);

        var response = await _controller.CountDocuments(filter);

        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
        Assert.AreEqual(expectedCount, ((OkObjectResult)response).Value);
    }

    [Test]
    public async Task GetMemberDocumentById_DocumentServiceReturnsNull_Returns404()
    {
        var number = DateTime.Now.Millisecond;
        var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocument(number, documentId))
            .ReturnsAsync((DocumentResponse?)null);

        var response = await _controller.GetMemberDocumentById(number, documentId);

        Assert.IsInstanceOf<NotFoundObjectResult>(response);
    }

    [Test]
    public async Task GetMemberDocumentById_DocumentServiceReturnsDocumentResponse_Returns200WithDocumentResponse()
    {
        var number = DateTime.Now.Millisecond;
        var documentId = Guid.NewGuid();
        var document = new DocumentResponse();
        _mockDocumentService
            .Setup(d => d.GetDocument(number, documentId))
            .ReturnsAsync(document);

        var response = await _controller.GetMemberDocumentById(number, documentId);

        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((ObjectResult)response).StatusCode);
        Assert.AreSame(document, ((OkObjectResult)response).Value);
    }

    [Test]
    public async Task GetMemberDocumentById_DocumentServiceThrowsServiceException_Returns500()
    {
        var number = DateTime.Now.Millisecond;
        var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocument(number, documentId))
            .ThrowsAsync(new ServiceException(string.Empty));

        var response = await _controller.GetMemberDocumentById(number, documentId);

        Assert.IsInstanceOf<ObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((ObjectResult)response).StatusCode);
    }

    [Test]
    public async Task GetMemberDocumentById_DocumentServiceThrowsException_Returns500()
    {
        var number = DateTime.Now.Millisecond;
        var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocument(number, documentId))
            .ThrowsAsync(new Exception());

        var response = await _controller.GetMemberDocumentById(number, documentId);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task GetDocumentContentByBlobId_DocumentServiceReturnsNull_Returns404()
    {
        var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(documentId))
            .ReturnsAsync((byte[]?)null);

        var response = await _controller.GetDocumentContentByBlobId(documentId);

        Assert.IsInstanceOf<NotFoundObjectResult>(response);
    }

    [Test]
    public async Task GetDocumentContentByBlobId_DocumentServiceReturnsBytes_Returns200WithBytes()
    {
        var documentId = Guid.NewGuid();
        var bytes = Encoding.Default.GetBytes(Guid.NewGuid().ToString());
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(documentId))
            .ReturnsAsync(bytes);

        var response = await _controller.GetDocumentContentByBlobId(documentId);

        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((ObjectResult)response).StatusCode);
        Assert.AreSame(bytes, ((OkObjectResult)response).Value);
    }

    [Test]
    public async Task GetDocumentContentByBlobId_DocumentServiceThrowsServiceException_Returns500()
    {
        var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(documentId))
            .ThrowsAsync(new ServiceException(string.Empty));

        var response = await _controller.GetDocumentContentByBlobId(documentId);

        Assert.IsInstanceOf<ObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((ObjectResult)response).StatusCode);
    }

    [Test]
    public async Task GetDocumentContentByBlobId_DocumentServiceThrowsException_Returns500()
    {
            var documentId = Guid.NewGuid();
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(documentId))
            .ThrowsAsync(new Exception());

        var response = await _controller.GetDocumentContentByBlobId(documentId);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task GetMemberDocumentContentByBlobId_DocumentServiceReturnsNull_Returns404()
    {
        var documentId = Guid.NewGuid();
        var number = DateTime.Now.Millisecond;
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(number, documentId))
            .ReturnsAsync((byte[]?)null);

        var response = await _controller.GetMemberDocumentContentByBlobId(number, documentId);

        Assert.IsInstanceOf<NotFoundObjectResult>(response);
    }

    [Test]
    public async Task GetMemberDocumentContentByBlobId_DocumentServiceReturnsBytes_Returns200WithBytes()
    {
        var documentId = Guid.NewGuid();
        var number = DateTime.Now.Millisecond;
        var bytes = Encoding.Default.GetBytes(Guid.NewGuid().ToString());
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(number, documentId))
            .ReturnsAsync(bytes);

        var response = await _controller.GetMemberDocumentContentByBlobId(number, documentId);

        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((ObjectResult)response).StatusCode);
        Assert.AreSame(bytes, ((OkObjectResult)response).Value);
    }

    [Test]
    public async Task GetMemberDocumentContentByBlobId_DocumentServiceThrowsServiceException_Returns500()
    {
        var documentId = Guid.NewGuid();
        var number = DateTime.Now.Millisecond;
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(number, documentId))
            .ThrowsAsync(new ServiceException(string.Empty));

        var response = await _controller.GetMemberDocumentContentByBlobId(number, documentId);

        Assert.IsInstanceOf<ObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((ObjectResult)response).StatusCode);
    }

    [Test]
    public async Task GetMemberDocumentContentByBlobId_DocumentServiceThrowsException_Returns500()
    {
        var documentId = Guid.NewGuid();
        var number = DateTime.Now.Millisecond;
        _mockDocumentService
            .Setup(d => d.GetDocumentByBlobId(number, documentId))
            .ThrowsAsync(new Exception());

        var response = await _controller.GetMemberDocumentContentByBlobId(number, documentId);

        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
    }

    [Test]
    public async Task GetDocumentsForCleanup_Success()
    {
        var documents = new List<Guid> { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
        _mockDocumentService.Setup(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
                                                                                .ReturnsAsync(documents).Verifiable();

        var response = await _controller.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>());
        
        Assert.AreSame(((OkObjectResult)response).Value, documents);
        Assert.IsInstanceOf<OkObjectResult>(response);
        Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
        _mockDocumentService.Verify(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()), Times.Once);
    }
    
    [Test]
    public async Task GetDocumentsForCleanup_Success_NoDocumentsFound()
    {
        var documents = new List<Guid>();
        _mockDocumentService.Setup(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
            .ReturnsAsync(documents).Verifiable();

        var response = await _controller.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>());
        
        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status204NoContent, ((StatusCodeResult)response).StatusCode);
        _mockDocumentService.Verify(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()), Times.Once);
    }
    
    [Test]
    public async Task GetDocumentsForCleanup_Failure_Exception()
    {
        _mockDocumentService.Setup(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()))
            .ThrowsAsync(new Exception());

        var response = await _controller.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>());
        
        Assert.IsInstanceOf<StatusCodeResult>(response);
        Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
        _mockDocumentService.Verify(x => x.GetDocumentsForCleanup(It.IsAny<GetDocumentCleanupRequest>()), Times.Once);
    }

    private static DocumentRequest GenerateDocumentRequest()
    {
        return new DocumentRequest
        {
            Name = "TestFile.txt",
            Type = "Test",
            Content = new byte[10],
            Source = "Unit Test",
            Attributes = new Dictionary<string, string>
            {
                { "IsTest", "true" }
            }
        };
    }

    private static UpdateDocumentRequest GenerateUpdateDocumentRequest()
    {
        return new UpdateDocumentRequest
        {
            Content = new byte[10],
            Name = "TestFile.txt",
            Type = "Test",
            UpdateSource = "Unit Test",
            Attributes = new Dictionary<string, string>
            {
                { "IsTest", "true" }
            }
        };
    }

    private static UpdateDocumentInformationRequest GenerateUpdateDocumentInformationRequest()
    {
        return new UpdateDocumentInformationRequest
        {
            Name = "TestFile.txt",
            Type = "Test",
            UpdateSource = "Unit Test",
            Attributes = new Dictionary<string, string>
            {
                { "IsTest", "true" }
            }
        };
    }

    private static UpdateDocumentScanStatusRequest GenerateUpdateDocumentScanStatusRequest()
    {
        return new UpdateDocumentScanStatusRequest
        {
            ScanStatus = true,
            DocumentBlobIds = new List<Guid>()
        };
    }

    private static UpdateDocumentContentRequest GenerateUpdateDocumentContentRequest()
    {
        return new UpdateDocumentContentRequest
        {
            Content = new byte[10],
            UpdateSource = "Unit Test"
        };
    }

    private static DocumentResponse GenerateDocumentResponse(Guid docId)
    {
        return new DocumentResponse
        {
            DocumentInformation = new DocumentInformationResponse
            {
                DocumentId = docId,
                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" }
                }
            }
        };
    }
}