monorepo/LCU.API.Internal.FileOperations/LCU.Api.Internal.FileOperationsTests/Controllers/DirectFileOperationsControllerTest.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;
using LCU.Api.Internal.FileOperations.Controllers;
using LCU.Api.Internal.FileOperations.Services;
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.Exceptions;
namespace LCU.Api.Internal.FileOperationsTests.Controllers;

public class DirectFileOperationsControllerTest
{
    private readonly DirectFileOperationsController _controller;
    private readonly Mock<IDirectFileOperationsService> _mockDirectFileOperationsService;
    private readonly Mock<IActionService<MoveFileRequest>> _mockMoveFileService;
    private readonly Mock<IActionService<WriteFileRequest>> _mockWriteFileService;
    private readonly Mock<IActionService<CreateDirectoryRequest>> _mockCreateDirectoryService;
    private readonly Mock<IActionService<UnzipFileRequest>> _mockUnzipFileService;
    private readonly Mock<IActionService<ZipDirectoryRequest>> _mockZipDirectoryService;
    private readonly Mock<IActionService<DeleteDirectoryRequest>> _mockDeleteDirectoryService;
    private readonly Mock<IActionService<DeleteFileRequest>> _mockDeleteFileService;
    private readonly Mock<IActionService<AppendFileRequest>> _mockAppendFileService;

    public DirectFileOperationsControllerTest()
    {
        _mockDirectFileOperationsService = new Mock<IDirectFileOperationsService>();
        _mockMoveFileService = new Mock<IActionService<MoveFileRequest>>();
        _mockWriteFileService = new Mock<IActionService<WriteFileRequest>>();
        _mockCreateDirectoryService = new Mock<IActionService<CreateDirectoryRequest>>();
        _mockUnzipFileService = new Mock<IActionService<UnzipFileRequest>>();
        _mockZipDirectoryService = new Mock<IActionService<ZipDirectoryRequest>>();
        _mockDeleteDirectoryService = new Mock<IActionService<DeleteDirectoryRequest>>();
        _mockDeleteFileService = new Mock<IActionService<DeleteFileRequest>>();
        _mockAppendFileService = new Mock<IActionService<AppendFileRequest>>();
        _controller = new DirectFileOperationsController(_mockDirectFileOperationsService.Object,
                                                         _mockMoveFileService.Object,
                                                         _mockWriteFileService.Object,
                                                         _mockCreateDirectoryService.Object,
                                                         _mockUnzipFileService.Object,
                                                         _mockZipDirectoryService.Object,
                                                         _mockDeleteDirectoryService.Object,
                                                         _mockDeleteFileService.Object,
                                                         _mockAppendFileService.Object);
    }

    [Fact]
    public async Task WriteBinaryFilePost_Ok()
    {
        var request = new WriteFileRequest
        {
            FileData = Convert.ToBase64String(new byte[] { 0x52, 0x49, 0x46, 0x46 }),
            DestinationPath = "SomePath",
            Extension = ".wav",
            FileName = "FileName"
        };

        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockWriteFileService.Setup(service => service.PreQueueValidation(It.IsAny<WriteFileRequest>())).Returns(validRequestResponse);
        _mockDirectFileOperationsService.Setup(service =>
                                               service.HandleDirectFileOperationsRequest(It.IsAny<WriteFileRequest>(), FileOperationType.WriteFile))
                                        .ReturnsAsync(validRequestResponse)
                                        .Verifiable();

        var result = await _controller.WriteBinaryFile(request);
        var okResult = result as OkObjectResult;

        Assert.NotNull(okResult);
        Assert.Equal(200, okResult.StatusCode);
        _mockWriteFileService.Verify(service => service.PreQueueValidation(It.IsAny<WriteFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
            service.HandleDirectFileOperationsRequest(It.IsAny<WriteFileRequest>(), FileOperationType.WriteFile), Times.Once);
    }

    [Fact]
    public async Task MoveFilePost_OK()
    {
        // arrange
        var request = new MoveFileRequest()
        {
            SourcePath = "",
            SourceFile = "",
            DestinationPath = ""
        };

        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockMoveFileService.Setup(service => service.PreQueueValidation(It.IsAny<MoveFileRequest>())).Returns(validRequestResponse);
        _mockDirectFileOperationsService.Setup(service =>
                                               service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move))
                                        .ReturnsAsync(validRequestResponse)
                                        .Verifiable();

        // act
        var result = await _controller.MoveFile(request);
        Assert.NotNull(result);
        var okResult = result as OkObjectResult;

        // assert
        Assert.NotNull(okResult);
        Assert.Equal(200, okResult.StatusCode);
        _mockMoveFileService.Verify(service =>
                                  service.PreQueueValidation(It.IsAny<MoveFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move), Times.Once);
    }

    [Fact]
    public async Task MoveFilePost_InvalidRequest()
    {
        // arrange
        var request = new MoveFileRequest() { };
        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>() { "Invalid" }, IsSuccessful = false };
        _mockMoveFileService.Setup(service => service.PreQueueValidation(It.IsAny<MoveFileRequest>())).Returns(validRequestResponse);
        // act
        var result = await _controller.MoveFile(request);

        Assert.NotNull(result);
        var badRequest = result as BadRequestObjectResult;
        Assert.Equal(400, badRequest.StatusCode);
        Assert.Equal($"Request is invalid. Response: {String.Join("\n ", validRequestResponse.MessageStack.ToArray())}", badRequest.Value);
        _mockMoveFileService.Verify(service =>
                                  service.PreQueueValidation(It.IsAny<MoveFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move), Times.Never);
    }

    [Fact]
    public async Task MoveFile_Failure_UnexpectedException()
    {
        var request = new MoveFileRequest()
        {
            SourcePath = "",
            SourceFile = "",
            DestinationPath = ""
        };
        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockMoveFileService.Setup(service => service.PreQueueValidation(It.IsAny<MoveFileRequest>())).Returns(validRequestResponse).Verifiable();
        _mockDirectFileOperationsService.Setup(service => 
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move))
                                        .ThrowsAsync(new Exception("Thrown From Unit Test"))
                                        .Verifiable();



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

        var statusResult = result as StatusCodeResult;
        Assert.NotNull(statusResult);
        Assert.Equal(500, statusResult!.StatusCode);
        _mockMoveFileService.Verify(service =>
                                    service.PreQueueValidation(It.IsAny<MoveFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move), Times.Once);
    }

    [Fact]
    public async Task MoveFile_Failure_ServiceException()
    {
        var request = new MoveFileRequest()
        {
            SourcePath = "",
            SourceFile = "",
            DestinationPath = ""
        };
        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockMoveFileService.Setup(service => service.PreQueueValidation(It.IsAny<MoveFileRequest>())).Returns(validRequestResponse).Verifiable();
        _mockDirectFileOperationsService.Setup(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move))
                                        .ThrowsAsync(new ServiceException("Thrown From Unit Test"))
                                        .Verifiable();



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

        var statusResult = result as ObjectResult;
        Assert.NotNull(statusResult);
        Assert.Equal(500, statusResult!.StatusCode);
        _mockMoveFileService.Verify(service =>
                                    service.PreQueueValidation(It.IsAny<MoveFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<MoveFileRequest>(), FileOperationType.Move), Times.Once);
    }

    [Fact]
    public async Task AppendFilePost_Ok()
    {
        var request = new AppendFileRequest()
        {
            FileData = "Text to write",
            DestinationPath = "SomePath",
            Extension = ".txt",
            FileName = "FileName"
        };

        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockAppendFileService.Setup(service => service.PreQueueValidation(It.IsAny<AppendFileRequest>())).Returns(validRequestResponse);
        _mockDirectFileOperationsService.Setup(service =>
                                               service.HandleDirectFileOperationsRequest(It.IsAny<AppendFileRequest>(), FileOperationType.AppendFile))
                                        .ReturnsAsync(validRequestResponse)
                                        .Verifiable();

        // act
        var result = await _controller.AppendFile(request);
        Assert.NotNull(result);
        var okResult = result as OkObjectResult;

        // assert
        Assert.NotNull(okResult);
        Assert.Equal(200, okResult.StatusCode);
        _mockAppendFileService.Verify(service =>
                                  service.PreQueueValidation(It.IsAny<AppendFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<AppendFileRequest>(), FileOperationType.AppendFile), Times.Once);
    }

    [Fact]
    public async Task AppendFilePost_InvalidRequest()
    {
        // arrange
        var request = new AppendFileRequest() { };
        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>() { "Invalid" }, IsSuccessful = false };
        _mockAppendFileService.Setup(service => service.PreQueueValidation(It.IsAny<AppendFileRequest>())).Returns(validRequestResponse);
        // act
        var result = await _controller.AppendFile(request);

        Assert.NotNull(result);
        var badRequest = result as BadRequestObjectResult;
        Assert.Equal(400, badRequest.StatusCode);
        Assert.Equal($"Request is invalid. Response: {String.Join("\n ", validRequestResponse.MessageStack.ToArray())}", badRequest.Value);
        _mockAppendFileService.Verify(service =>
                                  service.PreQueueValidation(It.IsAny<AppendFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<AppendFileRequest>(), FileOperationType.AppendFile), Times.Never);
    }

    [Fact]
    public async Task AppendFile_Failure_ServiceException()
    {
        var request = new AppendFileRequest()
        {
            FileData = "Text to write",
            DestinationPath = "SomePath",
            Extension = ".txt",
            FileName = "FileName"
        };
        var validRequestResponse = new RequestResponse() { MessageStack = new List<string>(), IsSuccessful = true };
        _mockAppendFileService.Setup(service => service.PreQueueValidation(It.IsAny<AppendFileRequest>())).Returns(validRequestResponse).Verifiable();
        _mockDirectFileOperationsService.Setup(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<AppendFileRequest>(), FileOperationType.AppendFile))
                                        .ThrowsAsync(new ServiceException("Thrown From Unit Test"))
                                        .Verifiable();



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

        var statusResult = result as ObjectResult;
        Assert.NotNull(statusResult);
        Assert.Equal(500, statusResult!.StatusCode);
        _mockAppendFileService.Verify(service =>
                                    service.PreQueueValidation(It.IsAny<AppendFileRequest>()), Times.Once);
        _mockDirectFileOperationsService.Verify(service =>
                                                service.HandleDirectFileOperationsRequest(It.IsAny<AppendFileRequest>(), FileOperationType.AppendFile), Times.Once);
    }
}