using System.Collections.Generic;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests.DispatcherOperationServices;

public class IngestionServiceTest
{
    private readonly IngestionService _ingestionService;
    private readonly Mock<IJobService> _mockJobService;
    private readonly Mock<IWorkItemService> _mockWorkItemService;
    private readonly Mock<IJobErrorRecipientService> _mockJobErrorRecipientService;
    private readonly Mock<IJobTagService> _mockJobTagService;

    public IngestionServiceTest()
    {
        _mockJobService = new Mock<IJobService>();
        _mockWorkItemService = new Mock<IWorkItemService>();
        _mockJobErrorRecipientService = new Mock<IJobErrorRecipientService>();
        _mockJobTagService = new Mock<IJobTagService>();
        _ingestionService = new IngestionService(_mockJobService.Object,
                                                 _mockWorkItemService.Object,
                                                 _mockJobErrorRecipientService.Object,
                                                 _mockJobTagService.Object);
    }

    //[Fact]
    //public void HandleIngestionRequest_Request_Null()
    //{
    //    Job request = null;
    //    var result = Assert.ThrowsAsync<ArgumentNullException>(async () => await _ingestionService.HandleIngestionRequest(request));

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.IsAny<List<int>>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.IsAny<List<WorkItem>>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public void HandleIngestionRequest_Request_SaveNewJob_SaveReturnedNull()
    //{
    //    Job returnJob = null;
    //    _mockJobService.Setup(x => x.SaveAsync(It.IsAny<Job>())).ReturnsAsync(returnJob);

    //    var request = new Job
    //    {
    //        Name = "Test"
    //    };
    //    var result = Assert.ThrowsAsync<ServiceException>(async () => await _ingestionService.HandleIngestionRequest(request));

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.IsAny<List<int>>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.IsAny<List<WorkItem>>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public void HandleIngestionRequest_Request_SaveNewJob_UpdatedWorkItems_Null()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test"
    //    };
    //    _mockJobService.Setup(x => x.SaveAsync(It.IsAny<Job>())).ReturnsAsync(returnJob);

    //    List<WorkItem> returnWorkItems = null;
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    var request = new Job
    //    {
    //        Name = "Test"
    //    };
    //    var result = Assert.ThrowsAsync<ServiceException>(async () => await _ingestionService.HandleIngestionRequest(request));

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.IsAny<List<int>>()), Times.Never);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.IsAny<List<WorkItem>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public void HandleIngestionRequest_Request_UpdateRequest_PopulateActionFieldsAndUpdateList_ReturnsNull()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test Job",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            }
    //        }
    //    };
    //    _mockJobService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(returnJob);

    //    List<WorkItem> returnWorkItems = null;
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    var request = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        }
    //    };
    //    var result = Assert.ThrowsAsync<ServiceException>(async () => await _ingestionService.HandleIngestionRequest(request));

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);


    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.Is<List<int>>(workItems => workItems.Count == 1)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.Is<List<WorkItem>>(workItems => workItems.Count == 0)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.IsAny<List<JobErrorRecipient>>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public void HandleIngestionRequest_Request_UpdateRequest_UpdateJobReturns_Null()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test Job",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>(),
    //        JobTags = new List<JobTag>()
    //    };
    //    _mockJobService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(returnJob);

    //    var returnWorkItems = new List<WorkItem>
    //    {
    //        new WorkItem
    //        {
    //            WorkItemId = 1,
    //            Name="Test WorkItem 1"
    //        }
    //    };
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    Job returnUpdateJob = null;
    //    _mockJobService.Setup(x => x.UpdateAsync(It.IsAny<Job>())).ReturnsAsync(returnUpdateJob);

    //    var request = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>(),
    //        JobTags = new List<JobTag>()
    //    };
    //    var result = Assert.ThrowsAsync<ServiceException>(async () => await _ingestionService.HandleIngestionRequest(request));

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.Is<List<int>>(workItems => workItems.Count == 1)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.Is<List<WorkItem>>(workItems => workItems.Count == 0)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public async Task HandleIngestionRequest_Request_UpdateRequest_UpdateJobReturns()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test Job",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>(),
    //        JobTags = new List<JobTag>()
    //    };
    //    _mockJobService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(returnJob);

    //    var returnWorkItems = new List<WorkItem>
    //    {
    //        new WorkItem
    //        {
    //            WorkItemId = 1,
    //            Name="Test WorkItem 1"
    //        }
    //    };
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    var returnUpdateJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>(),
    //        JobTags = new List<JobTag>()
    //    };
    //    _mockJobService.Setup(x => x.UpdateAsync(It.IsAny<Job>())).ReturnsAsync(returnUpdateJob);

    //    var request = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>(),
    //        JobTags = new List<JobTag>()
    //    };
    //    await _ingestionService.HandleIngestionRequest(request);

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.Is<List<int>>(workItems => workItems.Count == 1)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.Is<List<WorkItem>>(workItems => workItems.Count == 0)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public async Task HandleIngestionRequest_Request_UpdateRequest_Remove_WorkItems_JobErrorRecipients_JobTags()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test Job",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            },
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 4,
    //                Recipient = "Test2@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            },
    //            new JobTag
    //            {
    //                JobId= 7,
    //                TagId = 8,
    //            }
    //        }
    //    };
    //    _mockJobService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(returnJob);

    //    var returnWorkItems = new List<WorkItem>
    //    {
    //        new WorkItem
    //        {
    //            WorkItemId = 1,
    //            Name="Test WorkItem 1"
    //        }
    //    };
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    var returnUpdateJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            }
    //        }
    //    };
    //    _mockJobService.Setup(x => x.UpdateAsync(It.IsAny<Job>())).ReturnsAsync(returnUpdateJob);

    //    var request = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            }
    //        }
    //    };
    //    await _ingestionService.HandleIngestionRequest(request);

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.Is<List<int>>(workItems => workItems.Count == 1)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.Is<List<WorkItem>>(workItems => workItems.Count == 0)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 1)), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Once);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Never);
    //}

    //[Fact]
    //public async Task HandleIngestionRequest_Request_UpdateRequest_Add_WorkItems_JobErrorRecipients_JobTags()
    //{
    //    var returnJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test Job",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            },
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 4,
    //                Recipient = "Test2@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            },
    //            new JobTag
    //            {
    //                JobId= 7,
    //                TagId = 8,
    //            }
    //        }
    //    };
    //    _mockJobService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(returnJob);

    //    var returnWorkItems = new List<WorkItem>
    //    {
    //        new WorkItem
    //        {
    //            WorkItemId = 1,
    //            Name="Test WorkItem 1"
    //        }
    //    };
    //    _mockWorkItemService.Setup(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>())).ReturnsAsync(returnWorkItems);

    //    var returnUpdateJob = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 3,
    //                Name="Test WorkItem 3"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            },
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 4,
    //                Recipient = "Test2@test.com"
    //            },
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 5,
    //                Recipient = "Test3@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            },
    //            new JobTag
    //            {
    //                JobId= 7,
    //                TagId = 8,
    //            },
    //            new JobTag
    //            {
    //                JobId= 9,
    //                TagId = 10,
    //            }
    //        }
    //    };
    //    _mockJobService.Setup(x => x.UpdateAsync(It.IsAny<Job>())).ReturnsAsync(returnUpdateJob);

    //    var request = new Job
    //    {
    //        JobId = 1,
    //        Name = "Test",
    //        WorkItems = new List<WorkItem>
    //        {
    //            new WorkItem
    //            {
    //                WorkItemId = 1,
    //                Name="Test WorkItem 1"
    //            },
    //            new WorkItem
    //            {
    //                WorkItemId = 2,
    //                Name="Test WorkItem 2"
    //            },
    //            new WorkItem
    //            {
    //                Name="Test WorkItem 3"
    //            }
    //        },
    //        JobErrorRecipients = new List<JobErrorRecipient>
    //        {
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 3,
    //                Recipient = "Test@test.com"
    //            },
    //            new JobErrorRecipient
    //            {
    //                JobErrorRecipientId = 4,
    //                Recipient = "Test2@test.com"
    //            },
    //            new JobErrorRecipient
    //            {

    //                Recipient = "Test3@test.com"
    //            }
    //        },
    //        JobTags = new List<JobTag>
    //        {
    //            new JobTag
    //            {
    //                JobId= 5,
    //                TagId = 6,
    //            },
    //            new JobTag
    //            {
    //                JobId= 7,
    //                TagId = 8,
    //            },
    //            new JobTag
    //            {
    //                JobId= 9,
    //                TagId = 10,
    //            }
    //        }
    //    };
    //    await _ingestionService.HandleIngestionRequest(request);

    //    //Saving New
    //    _mockJobService.Verify(x => x.SaveAsync(It.IsAny<Job>()), Times.Never);

    //    //Updating 
    //    _mockJobService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
    //    _mockWorkItemService.Verify(x => x.DeleteRangeAsync(It.Is<List<int>>(workItems => workItems.Count == 0)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.SaveRangeAsync(It.Is<List<WorkItem>>(workItems => workItems.Count == 1)), Times.Once);
    //    _mockWorkItemService.Verify(x => x.PopulateActionFieldsAndUpdateList(It.IsAny<List<WorkItem>>()), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.DeleteList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 0)), Times.Once);
    //    _mockJobErrorRecipientService.Verify(x => x.SaveList(It.Is<List<JobErrorRecipient>>(jobErrorRecipient => jobErrorRecipient.Count == 1)), Times.Once);
    //    _mockJobTagService.Verify(x => x.Delete(It.IsAny<int>()), Times.Never);
    //    _mockJobTagService.Verify(x => x.SaveAsync(It.IsAny<JobTag>()), Times.Once);
    //}
}