monorepo/LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/CompletionServiceTest.cs

using System.Collections.Generic;
using Newtonsoft.Json;
using LCU.Library.Internal.ApiResponse.Models;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
using LCU.Api.Internal.Dispatcher.Services.QueueServices;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests.DispatcherOperationServices;

public class CompletionServiceTest
{
    private readonly CompletionService _completionService;
    private readonly Mock<IJobService> _mockJobService;
    private readonly Mock<IWorkItemService> _mockWorkItemService;
    private readonly Mock<IExecutionMessageService> _mockExecutionMessageService;
    private readonly Mock<IQueueJobFailureService> _mockQueueJobFailureService;
    private readonly Mock<IQueueDetermineOperationService> _mockQueueDetermineOperationService;

    public CompletionServiceTest()
    {
        _mockJobService = new Mock<IJobService>();
        _mockWorkItemService = new Mock<IWorkItemService>();
        _mockExecutionMessageService = new Mock<IExecutionMessageService>();
        _mockQueueJobFailureService = new Mock<IQueueJobFailureService>();
        _mockQueueDetermineOperationService = new Mock<IQueueDetermineOperationService>();
        _completionService = new CompletionService(_mockJobService.Object,
                                                   _mockWorkItemService.Object,
                                                   _mockExecutionMessageService.Object,
                                                   _mockQueueJobFailureService.Object,
                                                   _mockQueueDetermineOperationService.Object);
    }

    [Fact]
    public async Task HandleCompletionRequest_CurrentWorkItemExecution_Null()
    {
        var dispatcherReturnResponse = new DispatcherReturnResponse
        {
            WorkItemId = 1
        };
        var response = new Response
        {
            ResponsePayload = JsonConvert.SerializeObject(dispatcherReturnResponse),
            Successful = true
        };
        var workItem = new WorkItem
        {
            WorkItemExecutions = new List<WorkItemExecution>
            {
                new WorkItemExecution
                {
                    WorkItemId = 1,
                    WorkItemExecutionId = 1,
                    CompletedTimestamp = Convert.ToDateTime("1/1/2022")
                }
            }
        };
        var job = new Job()
        {
            JobId = 1,
            Name = "JobOne"
        };
        _mockJobService.Setup(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>())).ReturnsAsync(job);
        _mockWorkItemService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(workItem);

        await _completionService.HandleCompletionRequest(response);

        _mockJobService.Verify(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>()), Times.Once);
        _mockQueueJobFailureService.Verify(x => x.QueueJobFailure(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<List<string>>()), Times.Never);
        _mockWorkItemService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
        _mockExecutionMessageService.Verify(x => x.SaveExecutionMessages(It.IsAny<int>(), It.IsAny<List<string>>()), Times.Never);
        _mockWorkItemService.Verify(x => x.ResetCanceledJobCounter(It.IsAny<WorkItem>()), Times.Never);
        _mockJobService.Verify(x => x.UpdateAsync(It.IsAny<Job>()), Times.Never);
        _mockQueueDetermineOperationService.Verify(x => x.QueueDetermineOperation(It.IsAny<Job>(), It.IsAny<WorkItem>(), It.IsAny<DetermineOperationType>()), Times.Never);
    }

    [Fact]
    public async Task HandleCompletionRequest_Successful_False()
    {
        var dispatcherReturnResponse = new DispatcherReturnResponse
        {
            WorkItemId = 1
        };
        var response = new Response
        {
            ResponsePayload = JsonConvert.SerializeObject(dispatcherReturnResponse),
            Successful = false
        };
        var workItemExecution = new WorkItemExecution
        {
            WorkItemExecutionId = 1,
            WorkItemId = 1,
            CompletedTimestamp = null,
            Status = StatusType.Processing
        };
        var workItem = new WorkItem
        {
            WorkItemId = 1,
            CancelJobOnFailure = false,
            Url = "http://testing.com",
            SerializedPayload = "{\"Test\":\"Test\"}",
            HttpMethod = HttpMethodType.Post,
            WorkItemExecutions = new List<WorkItemExecution>
            {
                workItemExecution
            }
        };
        var job = new Job
        {
            JobId = 1
        };

        _mockJobService.Setup(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>())).ReturnsAsync(job);
        _mockWorkItemService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(workItem);
        _mockExecutionMessageService.Setup(x => x.SaveExecutionMessages(It.IsAny<int>(), It.IsAny<List<string>>())).Verifiable();
        _mockQueueJobFailureService.Setup(x => x.QueueJobFailure(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<List<string>>())).Verifiable();
        _mockQueueDetermineOperationService.Setup(x => x.QueueDetermineOperation(It.IsAny<Job>(), It.IsAny<WorkItem>(), It.IsAny<DetermineOperationType>())).Verifiable();

        await _completionService.HandleCompletionRequest(response);

        _mockJobService.Verify(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>()), Times.Once);
        _mockQueueJobFailureService.Verify(x => x.QueueJobFailure(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<List<string>>()), Times.Once);
        _mockWorkItemService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
        _mockExecutionMessageService.Verify(x => x.SaveExecutionMessages(It.IsAny<int>(), It.IsAny<List<string>>()), Times.Never);
        _mockWorkItemService.Verify(x => x.ResetCanceledJobCounter(It.IsAny<WorkItem>()), Times.Never);
        _mockJobService.Verify(x => x.UpdateAsync(It.IsAny<Job>()), Times.Never);
        _mockQueueDetermineOperationService.Verify(x => x.QueueDetermineOperation(It.IsAny<Job>(), It.IsAny<WorkItem>(), It.IsAny<DetermineOperationType>()), Times.Never);
    }

    [Fact]
    public async Task HandleCompletionRequest_Successful_true_ResetCanceledJobCounter_CompleteJob()
    {
        var dispatcherReturnResponse = new DispatcherReturnResponse
        {
            WorkItemId = 1
        };
        var response = new Response
        {
            ResponsePayload = JsonConvert.SerializeObject(dispatcherReturnResponse),
            Successful = true
        };
        var workItemExecution = new WorkItemExecution
        {
            WorkItemExecutionId = 1,
            WorkItemId = 1,
            CompletedTimestamp = null,
            Status = StatusType.Failed
        };
        var workItem = new WorkItem
        {
            WorkItemId = 1,
            CancelJobOnFailure = true,
            CanceledJobCounter = 1,
            CancelJobLimit = 1,
            Url = "http://testing.com",
            SerializedPayload = "{\"Test\":\"Test\"}",
            HttpMethod = HttpMethodType.Post,
            Order = 1,
            WorkItemExecutions = new List<WorkItemExecution>
            {
                workItemExecution
            }
        };
        var job = new Job
        {
            JobId = 1,
            WorkItems = new List<WorkItem>
            {
                workItem
            }
        };

        var updatedWorkItem = new WorkItem
        {
            WorkItemId = 1,
            CancelJobOnFailure = true,
            CanceledJobCounter = 0,
            CancelJobLimit = 1,
            Url = "http://testing.com",
            SerializedPayload = "{\"Test\":\"Test\"}",
            HttpMethod = HttpMethodType.Post,
            Order = 1,
            WorkItemExecutions = new List<WorkItemExecution>
            {
                workItemExecution
            }
        };
        var updatedJob = new Job
        {
            JobId = 1,
            JobStatus = JobStatus.DeterminingOperation
        };

        _mockJobService.Setup(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>())).ReturnsAsync(job);
        _mockWorkItemService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(workItem);
        _mockExecutionMessageService.Setup(x => x.SaveExecutionMessages(It.IsAny<int>(), It.IsAny<List<string>>())).Verifiable();
        _mockQueueJobFailureService.Setup(x => x.QueueJobFailure(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<List<string>>())).Verifiable();
        _mockJobService.Setup(x => x.UpdateAsync(It.IsAny<Job>())).ReturnsAsync(updatedJob);
        _mockQueueDetermineOperationService.Setup(x => x.QueueDetermineOperation(It.IsAny<Job>(), It.IsAny<WorkItem>(), It.IsAny<DetermineOperationType>())).Verifiable();

        await _completionService.HandleCompletionRequest(response);

        _mockJobService.Verify(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>()), Times.Once);
        _mockQueueJobFailureService.Verify(x => x.QueueJobFailure(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<List<string>>()), Times.Never);
        _mockWorkItemService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
        _mockExecutionMessageService.Verify(x => x.SaveExecutionMessages(It.IsAny<int>(), It.IsAny<List<string>>()), Times.Once);
        _mockWorkItemService.Verify(x => x.ResetCanceledJobCounter(It.IsAny<WorkItem>()), Times.Once);
        _mockJobService.Verify(x => x.UpdateAsync(It.IsAny<Job>()), Times.Once);
        _mockQueueDetermineOperationService.Verify(x => x.QueueDetermineOperation(It.IsAny<Job>(), It.IsAny<WorkItem>(), It.IsAny<DetermineOperationType>()), Times.Once);
    }
}