hz/monorepo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adding

Browse Source
This commit is contained in:
Zeeshaun
2026-03-24 15:26:03 -05:00
parent 1e5beb292a
commit 9cc87337b8
333 changed files with 17931 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/CleanUpJobSettingServiceTest.cs
+129
View File
@@ -0,0 +1,129 @@
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class CleanUpJobSettingServiceTest
{
private readonly CleanUpJobSettingService _cleanUpJobSettingService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly Mock<ICleanUpJobSettingRepository> _mockCleanUpJobSettingRepository;
public CleanUpJobSettingServiceTest()
{
_mockCleanUpJobSettingRepository = new Mock<ICleanUpJobSettingRepository>();
_mockUnitOfWork = new Mock<IUnitOfWork>();
_cleanUpJobSettingService = new CleanUpJobSettingService(_mockUnitOfWork.Object,
_mockCleanUpJobSettingRepository.Object);
}
[Fact]
public async Task GetAsync_Success()
{
// Arrange
_mockCleanUpJobSettingRepository.Setup(repo => repo.ListAsync()).ReturnsAsync(new List<CleanUpJobSetting>()
{
new CleanUpJobSetting(),
new CleanUpJobSetting(),
new CleanUpJobSetting()
});
// Act
var result = await _cleanUpJobSettingService.GetAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(3, result.Count());
}
[Fact]
public async Task GetByCleanUpJobSettingIdAsync_Success()
{
// Arrange
_mockCleanUpJobSettingRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync(new CleanUpJobSetting());
// Act
var result = await _cleanUpJobSettingService.GetByCleanUpJobSettingIdAsync(100);
// Assert
Assert.NotNull(result);
}
[Fact]
public async Task GetByCleanUpJobSettingIdAsync_Null()
{
// Arrange
_mockCleanUpJobSettingRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync((CleanUpJobSetting)null);
// Act
var result = await _cleanUpJobSettingService.GetByCleanUpJobSettingIdAsync(100);
// Assert
Assert.Null(result);
}
[Fact]
public async Task SaveAsync_Success()
{
// Arrange
_mockCleanUpJobSettingRepository.Setup(repo => repo.AddAsync(It.IsAny<CleanUpJobSetting>())).ReturnsAsync(new CleanUpJobSetting());
// Act
var result = await _cleanUpJobSettingService.SaveAsync(new CleanUpJobSetting());
// Assert
Assert.NotNull(result);
_mockCleanUpJobSettingRepository.Verify(x => x.AddAsync(It.IsAny<CleanUpJobSetting>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async void UpdateAsync_Success()
{
// Arrange
var cleanUpJobSettingToUpdate = new CleanUpJobSetting()
{
CleanUpJobSettingId = 100,
CompletionDaysPast = 15
};
_mockCleanUpJobSettingRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync(cleanUpJobSettingToUpdate);
_mockCleanUpJobSettingRepository.Setup(repo => repo.Update(It.IsAny<CleanUpJobSetting>())).Verifiable();
// Act
var result = await _cleanUpJobSettingService.UpdateAsync(cleanUpJobSettingToUpdate);
// Assert
Assert.NotNull(result);
Assert.Equal(cleanUpJobSettingToUpdate.CleanUpJobSettingId, result.CleanUpJobSettingId);
Assert.Equal(cleanUpJobSettingToUpdate.CompletionDaysPast, result.CompletionDaysPast);
_mockCleanUpJobSettingRepository.VerifyAll();
}
[Fact]
public async Task DeleteAsync_Success()
{
// Arrange
var cleanUpJobSettingReturned = new CleanUpJobSetting()
{
CleanUpJobSettingId = 100,
CompletionDaysPast = 15
};
_mockCleanUpJobSettingRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync(cleanUpJobSettingReturned);
_mockCleanUpJobSettingRepository.Setup(repo => repo.Remove(It.IsAny<CleanUpJobSetting>())).Verifiable();
// Act
var cleanUpJobSettingIdToDelete = 100;
await _cleanUpJobSettingService.DeleteAsync(cleanUpJobSettingIdToDelete); ;
// Assert
_mockCleanUpJobSettingRepository.VerifyAll();
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/CleanUpJobTagServiceTest.cs
+145
View File
@@ -0,0 +1,145 @@
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class CleanUpJobTagServiceTest
{
private readonly CleanUpJobTagService _cleanUpJobTagService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly Mock<ICleanUpJobTagRepository> _mockCleanUpJobTagRepository;
public CleanUpJobTagServiceTest()
{
_mockCleanUpJobTagRepository = new Mock<ICleanUpJobTagRepository>();
_mockUnitOfWork = new Mock<IUnitOfWork>();
_cleanUpJobTagService = new CleanUpJobTagService(_mockCleanUpJobTagRepository.Object,
_mockUnitOfWork.Object);
}
[Fact]
public async Task GetAsync_Success()
{
// Arrange
_mockCleanUpJobTagRepository.Setup(repo => repo.ListAsync()).ReturnsAsync(new List<CleanUpJobTag>()
{
new CleanUpJobTag(),
new CleanUpJobTag(),
new CleanUpJobTag()
});
// Act
var result = await _cleanUpJobTagService.GetAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(3, result.Count());
}
[Fact]
public async Task GetByCleanUpJobTagIdAsync_Success()
{
// Arrange
_mockCleanUpJobTagRepository.Setup(repo => repo.FindByCleanUpJobTagIdAsync(It.IsAny<int>())).ReturnsAsync(new CleanUpJobTag());
// Act
var result = await _cleanUpJobTagService.GetByCleanUpJobTagIdAsync(100);
// Assert
Assert.NotNull(result);
}
[Fact]
public async Task GetByCleanUpJobSettingIdAsync_Success()
{
// Arrange
_mockCleanUpJobTagRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync(new List<CleanUpJobTag>()
{
new CleanUpJobTag(),
new CleanUpJobTag(),
new CleanUpJobTag()
});
// Act
var result = await _cleanUpJobTagService.GetByCleanUpJobSettingIdAsync(100);
// Assert
Assert.NotNull(result);
Assert.Equal(3, result.Count());
}
[Fact]
public async Task SaveAsync_Success()
{
// Arrange
_mockCleanUpJobTagRepository.Setup(repo => repo.AddAsync(It.IsAny<CleanUpJobTag>())).ReturnsAsync(new CleanUpJobTag());
// Act
var result = await _cleanUpJobTagService.SaveAsync(new CleanUpJobTag());
// Assert
Assert.NotNull(result);
_mockCleanUpJobTagRepository.Verify(x => x.AddAsync(It.IsAny<CleanUpJobTag>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async Task DeleteAsync_Success()
{
// Arrange
var cleanUpJobTagReturned = new CleanUpJobTag()
{
CleanUpJobTagId = 100,
CleanUpJobSettingId = 16,
TagId = 10
};
_mockCleanUpJobTagRepository.Setup(repo => repo.FindByCleanUpJobTagIdAsync(It.IsAny<int>())).ReturnsAsync(cleanUpJobTagReturned);
_mockCleanUpJobTagRepository.Setup(repo => repo.Remove(It.IsAny<CleanUpJobTag>())).Verifiable();
// Act
var cleanUpJobSettingIdToDelete = 100;
await _cleanUpJobTagService.DeleteAsync(cleanUpJobSettingIdToDelete); ;
// Assert
_mockCleanUpJobTagRepository.VerifyAll();
}
[Fact]
public async Task DeleteByCleanUpJobSettingIdAsync_Success()
{
// Arrange
var tagOne = new CleanUpJobTag()
{
CleanUpJobTagId = 100,
CleanUpJobSettingId = 16,
TagId = 10
};
var tagTwo = new CleanUpJobTag()
{
CleanUpJobTagId = 101,
CleanUpJobSettingId = 16,
TagId = 12
};
var tagList = new List<CleanUpJobTag>();
tagList.Add(tagOne);
tagList.Add(tagTwo);
_mockCleanUpJobTagRepository.Setup(repo => repo.FindByCleanUpJobSettingIdAsync(It.IsAny<int>())).ReturnsAsync(tagList);
_mockCleanUpJobTagRepository.Setup(repo => repo.Remove(tagOne)).Verifiable();
_mockCleanUpJobTagRepository.Setup(repo => repo.Remove(tagTwo)).Verifiable();
// Act
await _cleanUpJobTagService.DeleteByCleanUpJobSettingIdAsync(16); ;
// Assert
_mockCleanUpJobTagRepository.VerifyAll();
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/BatchErroredJobsServiceTest.cs
+101
View File
@@ -0,0 +1,101 @@
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
using LCU.Api.Internal.Dispatcher.Services.QueueServices;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.DispatcherModels.Models.Requests;
using System.Collections.Generic;
using System.Threading;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests.DispatcherOperationServices;
public class BatchErroredJobsServiceTest
{
private readonly BatchErroredJobsService _service;
private readonly Mock<IJobService> _mockJobService;
private readonly Mock<IQueueSendErroredJobAlertService> _mockQueueSendErroredJobAlertService;
public BatchErroredJobsServiceTest()
{
_mockJobService = new Mock<IJobService>();
_mockQueueSendErroredJobAlertService = new Mock<IQueueSendErroredJobAlertService>();
_service = new BatchErroredJobsService(_mockJobService.Object,
_mockQueueSendErroredJobAlertService.Object);
}
[Fact]
public void Basic_Construct_Test()
{
Assert.NotNull(_service);
}
[Fact]
public async Task PerformBatchErroredJobs_NoJobs_DoesNotQueue()
{
// Arrange
_mockJobService.Setup(x => x.GetErrorMonitoringJobs())
.ReturnsAsync(new List<Job>());
// Act
await _service.PerformBatchErroredJobs(CancellationToken.None);
// Assert
_mockQueueSendErroredJobAlertService.Verify(
x => x.QueueSendErroredJobAlert(It.IsAny<BatchedErroredJobAlertRequest>()),
Times.Never);
}
[Fact]
public async Task PerformBatchErroredJobs_JobsWithFailedWorkItems_QueuesBatch()
{
// Arrange
var failedExecution = new WorkItemExecution
{
Status = StatusType.Failed
};
var workItem = new WorkItem
{
WorkItemId = 1,
WorkItemExecutions = new List<WorkItemExecution> { failedExecution }
};
var job = new Job
{
JobId = 10,
WorkItems = new List<WorkItem> { workItem }
};
_mockJobService.Setup(x => x.GetErrorMonitoringJobs())
.ReturnsAsync(new List<Job> { job });
BatchedErroredJobAlertRequest capturedBatch = null;
_mockQueueSendErroredJobAlertService
.Setup(x => x.QueueSendErroredJobAlert(It.IsAny<BatchedErroredJobAlertRequest>()))
.Callback<BatchedErroredJobAlertRequest>(batch => capturedBatch = batch)
.Returns(Task.CompletedTask);
// Act
await _service.PerformBatchErroredJobs(CancellationToken.None);
// Assert
_mockQueueSendErroredJobAlertService.Verify(
x => x.QueueSendErroredJobAlert(It.IsAny<BatchedErroredJobAlertRequest>()),
Times.Once);
Assert.NotNull(capturedBatch);
Assert.Single(capturedBatch.ErroredJobAlertRequests);
Assert.Equal(job, capturedBatch.ErroredJobAlertRequests[0].CurrentJob);
Assert.Equal(workItem, capturedBatch.ErroredJobAlertRequests[0].CurrentWorkItem);
}
[Fact]
public async Task PerformBatchErroredJobs_Exception_IsHandledAndLogged()
{
// Arrange
_mockJobService.Setup(x => x.GetErrorMonitoringJobs())
.ThrowsAsync(new System.Exception("Test exception"));
// Act & Assert
await _service.PerformBatchErroredJobs(CancellationToken.None);
_mockQueueSendErroredJobAlertService.Verify(
x => x.QueueSendErroredJobAlert(It.IsAny<BatchedErroredJobAlertRequest>()),
Times.Never);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/CleanUpJobsServiceTest.cs
+382
View File
@@ -0,0 +1,382 @@
using LCU.Api.Internal.Dispatcher.Configurations;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
using LCU.Api.Internal.DispatcherLib.Repositories;
using LCU.Library.Internal.DispatcherModels.Models.Results;
using System.Collections.Generic;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests.DispatcherOperationServices;
public class CleanUpJobsServiceTest
{
private readonly Mock<IJobService> _mockJobService;
private readonly Mock<ICleanUpJobSettingService> _mockCleanUpJobSettingService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly CleanUpJobsService _cleanUpJobsService;
public CleanUpJobsServiceTest()
{
var apiConfiguration = new ApiConfiguration()
{
CleanUpJobsDaysToDelete = -20
};
_mockJobService = new Mock<IJobService>();
_mockCleanUpJobSettingService = new Mock<ICleanUpJobSettingService>();
_mockUnitOfWork = new Mock<IUnitOfWork>();
_cleanUpJobsService = new CleanUpJobsService(_mockJobService.Object,
_mockCleanUpJobSettingService.Object,
_mockUnitOfWork.Object,
apiConfiguration);
}
[Fact]
public void Basic_Construct_Test()
{
Assert.NotNull(_cleanUpJobsService);
}
[Fact]
public void ShouldSoftDeleteByDate_True()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CompletionDaysPast = -15
};
var execution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
WorkItemId = 2,
CompletedTimestamp = DateTime.Now.AddDays(-30),
StartedTimestamp = DateTime.Now.AddDays(-30).AddMinutes(-1)
};
var workItem = new WorkItem()
{
JobId = 1,
WorkItemId = 2,
WorkItemExecutions = new List<WorkItemExecution>()
{
execution
},
Order = 1
};
var job = new Job()
{
JobId = 1,
WorkItems = new List<WorkItem>()
{
workItem
},
};
var result = new CleanUpJobBatchResult();
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByDate(setting, job, result);
// Assert
Assert.True(shouldDelete);
}
[Fact]
public void ShouldSoftDeleteByDate_False()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CompletionDaysPast = -45
};
var execution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
WorkItemId = 2,
CompletedTimestamp = DateTime.Now.AddDays(-30),
StartedTimestamp = DateTime.Now.AddDays(-30).AddMinutes(-1)
};
var workItem = new WorkItem()
{
JobId = 1,
WorkItemId = 2,
WorkItemExecutions = new List<WorkItemExecution>()
{
execution
},
Order = 1
};
var job = new Job()
{
JobId = 1,
WorkItems = new List<WorkItem>()
{
workItem
},
};
var result = new CleanUpJobBatchResult();
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByDate(setting, job, result);
// Assert
Assert.False(shouldDelete);
}
[Fact]
public void ShouldSoftDeleteByDate_NoWorkItemExecutions_False()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CompletionDaysPast = -45
};
var workItem = new WorkItem()
{
JobId = 1,
WorkItemId = 2,
WorkItemExecutions = new List<WorkItemExecution>(),
Order = 1
};
var job = new Job()
{
JobId = 1,
WorkItems = new List<WorkItem>()
{
workItem
},
};
var result = new CleanUpJobBatchResult();
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByDate(setting, job, result);
// Assert
Assert.False(shouldDelete);
Assert.Equal(1, result.FailureCount);
}
[Fact]
public void ShouldSoftDeleteByDate_NoWorkItems_False()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CompletionDaysPast = -45
};
var job = new Job()
{
JobId = 1,
WorkItems = new List<WorkItem>(),
};
var result = new CleanUpJobBatchResult();
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByDate(setting, job, result);
// Assert
Assert.False(shouldDelete);
Assert.Equal(1, result.FailureCount);
}
[Fact]
public void ShouldSoftDeleteByTag_Okay()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CleanUpJobTags = new List<CleanUpJobTag>()
{
new CleanUpJobTag()
{
TagId = 1
},
new CleanUpJobTag()
{
TagId = 3
},
new CleanUpJobTag()
{
TagId = 5
}
}
};
var job = new Job()
{
JobTags = new List<JobTag>()
{
new JobTag()
{
TagId = 1
},
new JobTag()
{
TagId = 3
},
new JobTag()
{
TagId = 5
}
}
};
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByTag(setting, job);
// Assert
Assert.True(shouldDelete);
}
[Fact]
public void ShouldSoftDeleteByTag_Okay_UnorderedTagId()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CleanUpJobTags = new List<CleanUpJobTag>()
{
new CleanUpJobTag()
{
TagId = 1
},
new CleanUpJobTag()
{
TagId = 3
},
new CleanUpJobTag()
{
TagId = 5
}
}
};
var job = new Job()
{
JobTags = new List<JobTag>()
{
new JobTag()
{
TagId = 3
},
new JobTag()
{
TagId = 5
},
new JobTag()
{
TagId = 1
}
}
};
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByTag(setting, job);
// Assert
Assert.True(shouldDelete);
}
[Fact]
public void ShouldSoftDeleteByTag_False_NumberOfTags()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CleanUpJobTags = new List<CleanUpJobTag>()
{
new CleanUpJobTag()
{
TagId = 1
},
new CleanUpJobTag()
{
TagId = 3
},
new CleanUpJobTag()
{
TagId = 5
}
}
};
var job = new Job()
{
JobTags = new List<JobTag>()
{
new JobTag()
{
TagId = 3
},
new JobTag()
{
TagId = 5
}
}
};
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByTag(setting, job);
// Assert
Assert.False(shouldDelete);
}
[Fact]
public void ShouldSoftDeleteByTag_False_DifferentTags()
{
// Arrange
var setting = new CleanUpJobSetting()
{
CleanUpJobTags = new List<CleanUpJobTag>()
{
new CleanUpJobTag()
{
TagId = 1
},
new CleanUpJobTag()
{
TagId = 3
},
new CleanUpJobTag()
{
TagId = 5
}
}
};
var job = new Job()
{
JobTags = new List<JobTag>()
{
new JobTag()
{
TagId = 3
},
new JobTag()
{
TagId = 5
},
new JobTag()
{
TagId = 100
}
}
};
// Act
var shouldDelete = _cleanUpJobsService.ShouldSoftDeleteByTag(setting, job);
// Assert
Assert.False(shouldDelete);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/CompletionServiceTest.cs
+210
View File
@@ -0,0 +1,210 @@
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);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/ExecutionServiceTest.cs
+127
View File
@@ -0,0 +1,127 @@
using System.Collections.Generic;
using System.Net.Http;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using LCU.Api.Internal.Dispatcher.Services.QueueServices;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests.DispatcherOperationServices;
public class ExecutionServiceTest
{
private readonly ExecutionService _executionService;
private readonly Mock<IPostRequest> _mockPostRequest;
private readonly Mock<IWorkItemService> _mockWorkItemService;
private readonly Mock<IJobService> _mockJobService;
private readonly Mock<IQueueCompletionService> _mockQueueCompletionService;
public ExecutionServiceTest()
{
_mockPostRequest = new Mock<IPostRequest>();
_mockWorkItemService = new Mock<IWorkItemService>();
_mockJobService = new Mock<IJobService>();
_mockQueueCompletionService = new Mock<IQueueCompletionService>();
_executionService = new ExecutionService(_mockPostRequest.Object,
_mockWorkItemService.Object,
_mockJobService.Object,
_mockQueueCompletionService.Object);
}
[Fact]
public async Task HandleExecutionRequest_Execution_Successful()
{
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
};
var httpRequestMessage = new HttpRequestMessage();
var httpResponseMessage = new HttpResponseMessage
{
StatusCode = System.Net.HttpStatusCode.OK
};
_mockWorkItemService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(workItem);
_mockPostRequest.Setup(x => x.AsyncWithNewtonSerializedNoThrow(It.IsAny<Uri>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()))
.ReturnsAsync(() => httpResponseMessage);
_mockJobService.Setup(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>())).ReturnsAsync(job);
_mockJobService.Setup(x => x.SaveAsync(It.IsAny<Job>())).ReturnsAsync(job);
_mockQueueCompletionService.Setup(x => x.QueueCompletion(It.IsAny<DispatcherReturnResponse>(), It.IsAny<List<string>>(), It.IsAny<bool>())).Verifiable();
await _executionService.HandleExecutionRequest(workItemExecution);
_mockWorkItemService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
_mockPostRequest.Verify(x => x.AsyncWithNewtonSerializedNoThrow(It.IsAny<Uri>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once);
_mockJobService.Verify(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>()), Times.Once);
_mockJobService.Verify(x => x.UpdateAsync(It.IsAny<Job>()), Times.Once);
_mockQueueCompletionService.Verify(x => x.QueueCompletion(It.IsAny<DispatcherReturnResponse>(), It.IsAny<List<string>>(), It.IsAny<bool>()), Times.Never);
}
[Fact]
public async Task HandleExecutionRequest_Execution_NOT_Successful()
{
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
};
var httpRequestMessage = new HttpRequestMessage();
var httpResponseMessage = new HttpResponseMessage
{
StatusCode = System.Net.HttpStatusCode.BadRequest
};
_mockWorkItemService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(workItem);
_mockPostRequest.Setup(x => x.AsyncWithNewtonSerializedNoThrow(It.IsAny<Uri>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()))
.ReturnsAsync(() => httpResponseMessage);
_mockJobService.Setup(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>())).ReturnsAsync(job);
_mockJobService.Setup(x => x.SaveAsync(It.IsAny<Job>())).ReturnsAsync(job);
_mockQueueCompletionService.Setup(x => x.QueueCompletion(It.IsAny<DispatcherReturnResponse>(), It.IsAny<List<string>>(), It.IsAny<bool>())).Verifiable();
await _executionService.HandleExecutionRequest(workItemExecution);
_mockWorkItemService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Once);
_mockPostRequest.Verify(x => x.AsyncWithNewtonSerializedNoThrow(It.IsAny<Uri>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once);
_mockJobService.Verify(x => x.GetByWorkItemIdExcludingWorkItemsAsync(It.IsAny<int>()), Times.Once);
_mockJobService.Verify(x => x.UpdateAsync(It.IsAny<Job>()), Times.Once);
_mockQueueCompletionService.Verify(x => x.QueueCompletion(It.IsAny<DispatcherReturnResponse>(), It.IsAny<List<string>>(), It.IsAny<bool>()), Times.Once);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/DispatcherOperationServices/IngestionServiceTest.cs
+643
View File
@@ -0,0 +1,643 @@
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 = "[email protected]"
// },
// new JobErrorRecipient
// {
// JobErrorRecipientId = 4,
// Recipient = "[email protected]"
// }
// },
// 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 = "[email protected]"
// }
// },
// 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 = "[email protected]"
// }
// },
// 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 = "[email protected]"
// },
// new JobErrorRecipient
// {
// JobErrorRecipientId = 4,
// Recipient = "[email protected]"
// }
// },
// 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 = "[email protected]"
// },
// new JobErrorRecipient
// {
// JobErrorRecipientId = 4,
// Recipient = "[email protected]"
// },
// new JobErrorRecipient
// {
// JobErrorRecipientId = 5,
// Recipient = "[email protected]"
// }
// },
// 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 = "[email protected]"
// },
// new JobErrorRecipient
// {
// JobErrorRecipientId = 4,
// Recipient = "[email protected]"
// },
// new JobErrorRecipient
// {
// Recipient = "[email protected]"
// }
// },
// 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);
//}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/JobServiceTest.cs
+990
View File
@@ -0,0 +1,990 @@
using LCU.Api.Internal.Dispatcher.Configurations;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
using LCU.Api.Internal.DispatcherSharedLib.Utilities;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.DispatcherModels.Models.Requests;
using LCU.Library.Internal.DispatcherModels.Models.Results;
using NCrontab;
using System.Collections.Generic;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class JobServiceTest
{
private readonly JobService _jobService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly Mock<IJobRepository> _mockJobRepository;
private readonly Mock<IWorkItemService> _mockWorkItemService;
private readonly Mock<IWorkItemExecutionService> _mockWorkItemExecutionService;
private readonly ApiConfiguration _apiConfiguration;
public JobServiceTest()
{
_mockJobRepository = new Mock<IJobRepository>();
_mockWorkItemService = new Mock<IWorkItemService>();
_mockWorkItemExecutionService = new Mock<IWorkItemExecutionService>();
_mockUnitOfWork = new Mock<IUnitOfWork>();
_apiConfiguration = new ApiConfiguration()
{
NumberOfWorkItemExecutions = 10,
NumberOfExecutionMessages = 20,
ProcessingLimitInMinutes = 30,
JobStatusesToMonitorByTimeLimit = new List<JobStatus>() { JobStatus.Processing }
};
_jobService = new JobService(_mockUnitOfWork.Object,
_mockJobRepository.Object,
_mockWorkItemService.Object,
_mockWorkItemExecutionService.Object,
_apiConfiguration);
}
[Fact]
public async Task GetListAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.ListAsync(10, 20)).ReturnsAsync(new List<Job>()
{
new Job(),
new Job()
});
// Act
var result = await _jobService.GetAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async Task GetByIdAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>(), 10, 20)).ReturnsAsync(new Job());
// Act
var result = await _jobService.GetByIdAsync(1);
// Assert
Assert.NotNull(result);
}
[Fact]
public async Task SaveAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.AddAsync(It.IsAny<Job>())).ReturnsAsync(new Job());
// Act
var result = await _jobService.SaveAsync(new Job());
// Assert
Assert.NotNull(result);
_mockJobRepository.Verify(x => x.AddAsync(It.IsAny<Job>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async Task UpdateAsync_Success()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
RequestingApplication = "App"
};
_mockJobRepository.Setup(repo => repo.Update(It.IsAny<Job>())).ReturnsAsync(jobToUpdate).Verifiable();
// Act
var result = await _jobService.UpdateAsync(jobToUpdate);
// Assert
Assert.NotNull(result);
Assert.Equal(jobToUpdate.JobId, result.JobId);
Assert.Equal(jobToUpdate.RequestingApplication, result.RequestingApplication);
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(), 10, 20), Times.Never);
_mockJobRepository.Verify(x => x.Update(It.IsAny<Job>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async Task CompleteJobAndWorkItem_Success_NoReschedule()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
RequestingApplication = "App",
NextRunTime = Convert.ToDateTime("1/1/2022")
};
_mockJobRepository.Setup(repo => repo.FindByIdExcludingWorkItemsAsync(1)).ReturnsAsync(jobToUpdate);
var updatedJob = new Job()
{
JobId = 1,
RequestingApplication = "App",
NextRunTime = null
};
_mockJobRepository.Setup(repo => repo.Update(It.IsAny<Job>())).ReturnsAsync(updatedJob).Verifiable();
var updatedWorkitemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
Status = StatusType.Completed
};
_mockWorkItemExecutionService.Setup(repo => repo.UpdateCompleteWorkItemExecutionWithoutSave(It.IsAny<WorkItemExecution>(), StatusType.Completed)).ReturnsAsync(updatedWorkitemExecution);
_mockUnitOfWork.Setup(uow => uow.CompleteAsync()).Returns(Task.CompletedTask);
// Act
await _jobService.CompleteJobAndWorkItem(jobToUpdate, new WorkItemExecution(100), StatusType.Completed);
// Assert
_mockJobRepository.Verify(x => x.FindByIdExcludingWorkItemsAsync(1), Times.Never);
_mockJobRepository.Verify(x => x.Update(It.IsAny<Job>()), Times.Once);
_mockWorkItemExecutionService.Verify(x => x.UpdateCompleteWorkItemExecutionWithoutSave(It.IsAny<WorkItemExecution>(), It.IsAny<StatusType>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async Task CompleteJobAndWorkItem_Success_Reschedule()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
RequestingApplication = "App",
NextRunTime = Convert.ToDateTime("1/1/2022"),
CronSchedule = "5 * * * *"
};
_mockJobRepository.Setup(repo => repo.FindByIdExcludingWorkItemsAsync(1)).ReturnsAsync(jobToUpdate);
var updatedJob = new Job()
{
JobId = 1,
RequestingApplication = "App",
NextRunTime = DateTime.Now.AddSeconds(5)
};
_mockJobRepository.Setup(repo => repo.Update(It.IsAny<Job>())).ReturnsAsync(updatedJob).Verifiable();
var updatedWorkitemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
Status = StatusType.Completed
};
_mockWorkItemExecutionService.Setup(repo => repo.UpdateCompleteWorkItemExecutionWithoutSave(It.IsAny<WorkItemExecution>(), It.IsAny<StatusType>())).ReturnsAsync(updatedWorkitemExecution);
_mockUnitOfWork.Setup(uow => uow.CompleteAsync()).Returns(Task.CompletedTask);
// Act
await _jobService.CompleteJobAndWorkItem(jobToUpdate, new WorkItemExecution(100), StatusType.Completed);
// Assert
_mockJobRepository.Verify(x => x.FindByIdExcludingWorkItemsAsync(1), Times.Never);
_mockJobRepository.Verify(x => x.Update(It.IsAny<Job>()), Times.Once);
_mockWorkItemExecutionService.Verify(x => x.UpdateCompleteWorkItemExecutionWithoutSave(It.IsAny<WorkItemExecution>(), It.IsAny<StatusType>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public void HolidayHelper_Success_SkipMemorialDayHolidayNextOccurrence()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
SkipHolidays = true,
RequestingApplication = "App",
CronSchedule = "0 0 1-30 5 *"
};
CrontabSchedule schedule = CrontabSchedule.Parse(jobToUpdate.CronSchedule);
var nextRunTime = schedule.GetNextOccurrence(DateTime.Now);
var memorialDay = HolidayHelpers.GetMemorialDay(nextRunTime.Year); //stage next possible holiday date, reset cron
jobToUpdate.NextRunTime = memorialDay;
jobToUpdate.CronSchedule = $"0 0 {memorialDay.Day} {memorialDay.Month} *";
// Assert
Assert.NotNull(jobToUpdate);
Assert.Equal(memorialDay, jobToUpdate.NextRunTime);
}
[Fact]
public void HolidayHelper_Success_SkipThanksGivingHolidayNextOccurrence()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
SkipHolidays = true,
RequestingApplication = "App",
CronSchedule = "0 0 22-30 11 *"
};
CrontabSchedule schedule = CrontabSchedule.Parse(jobToUpdate.CronSchedule);
var nextRunTime = schedule.GetNextOccurrence(DateTime.Now);
var thanksgivingDay = HolidayHelpers.GetThanksgivingDay(nextRunTime.Year); //stage next possible holiday date, reset cron
jobToUpdate.NextRunTime = thanksgivingDay;
jobToUpdate.CronSchedule = $"0 0 {thanksgivingDay.Day} {thanksgivingDay.Month} *";
// Assert
Assert.NotNull(jobToUpdate);
Assert.Equal(thanksgivingDay, jobToUpdate.NextRunTime);
}
[Fact]
public void HolidayHelper_Success_SkipIndependenceDayHolidayNextOccurrence()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
SkipHolidays = true,
RequestingApplication = "App",
CronSchedule = "0 0 4-31 7 *"
};
CrontabSchedule schedule = CrontabSchedule.Parse(jobToUpdate.CronSchedule);
var nextRunTime = schedule.GetNextOccurrence(DateTime.Now);
CronHelpers.SetNextScheduledRunTime(ref jobToUpdate);
var nextRunTimeAfterHoliday = HolidayHelpers.HandleHolidays(nextRunTime);
// Assert
Assert.NotNull(jobToUpdate);
Assert.Equal(nextRunTimeAfterHoliday, jobToUpdate.NextRunTime);
}
[Fact]
public void HolidayHelper_Success_SkipLaborDayHolidayNextOccurrence()
{
// Arrange
var jobToUpdate = new Job()
{
JobId = 1,
SkipHolidays = true,
RequestingApplication = "App",
CronSchedule = "0 0 1-30 9 *"
};
CrontabSchedule schedule = CrontabSchedule.Parse(jobToUpdate.CronSchedule);
var nextRunTime = schedule.GetNextOccurrence(DateTime.Now);
var laborDay = HolidayHelpers.GetLaborDay(nextRunTime.Year); //stage next possible holiday date, reset cron
jobToUpdate.NextRunTime = laborDay;
jobToUpdate.CronSchedule = $"0 0 {laborDay.Day} {laborDay.Month} *";
var nextRunTimeAfterHoliday = HolidayHelpers.GetLaborDay(nextRunTime.Year);
// Assert
Assert.NotNull(jobToUpdate);
Assert.Equal(nextRunTimeAfterHoliday, jobToUpdate.NextRunTime);
}
[Fact]
public void GetJobsProcessingLongerThanTime_Return_OneProcessingJob_LongerThen_30minutes()
{
// Arrange
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Process Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-31)
}
}
}
},
JobStatus = JobStatus.Processing
}
};
// Act
var result = _jobService.GetJobsInStatusLongerThanTimeLimit(jobs, 30);
// Assert
Assert.NotNull(result);
Assert.Single(result);
}
[Fact]
public void GetJobsProcessingLongerThanTime_Return_NoneProcessingJob_NotLongerThen_30minutes()
{
// Arrange
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Failed Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.Failed,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = DateTime.Now.AddMinutes(-10)
}
}
}
}
},
new Job()
{
Name = "Test Process Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.Processing,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-29)
}
}
}
}
}
};
// Act
var result = _jobService.GetJobsInStatusLongerThanTimeLimit(jobs, 30);
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
[Fact]
public void GetJobsProcessingLongerThanTime_Return_NoneProcessingJob_NoneAreProcessing()
{
// Arrange
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Failed Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.Failed,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = DateTime.Now.AddMinutes(-5)
}
}
}
}
},
new Job()
{
Name = "Test Failed 2 Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.Processing,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed 2 WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = DateTime.Now.AddMinutes(-29)
}
}
}
}
}
};
// Act
var result = _jobService.GetJobsInStatusLongerThanTimeLimit(jobs, 30);
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
[Fact]
public void GetJobsProcessingLongerThanTime_Return_TwoJobs_MultipleStatuses()
{
// Arrange
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Failed Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.DeterminingOperation,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = Convert.ToDateTime("4/1/2021")
}
}
}
}
},
new Job()
{
Name = "Test Failed 2 Job",
NextRunTime = DateTime.Now.AddHours(-1),
JobStatus = JobStatus.Processing,
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed 2 WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = DateTime.Now.AddMinutes(-31)
}
}
}
}
}
};
// Act
var result = _jobService.GetJobsInStatusLongerThanTimeLimit(jobs, 30);
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async Task GetErroredAndProcessingJobs_Return_TwoJobs_OneFailed_OneProcessingLongerThen_30minutes()
{
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Pending Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Pending WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Pending,
StartedTimestamp = Convert.ToDateTime("4/1/2021")
}
}
}
},
JobStatus = JobStatus.Failed
},
new Job()
{
Name = "Test Failed Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = Convert.ToDateTime("4/1/2021")
}
}
}
},
JobStatus = JobStatus.Failed
},
new Job()
{
Name = "Test Process Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-31)
}
}
}
},
JobStatus = JobStatus.Processing
}
};
_mockJobRepository.Setup(repo => repo.FindJobsPastDateByStatuses(It.IsAny<DateTime>(), 10, 20, It.IsAny<List<JobStatus>>())).ReturnsAsync(jobs);
// Act
var result = await _jobService.GetErrorMonitoringJobs();
// Assert
Assert.NotNull(result);
Assert.Equal(3, result.ToList().Count);
Assert.Single(result.Where(r => r.CurrentStatus == StatusType.Failed));
Assert.Single(result.Where(r => r.CurrentStatus == StatusType.Processing));
}
[Fact]
public async Task GetErroredAndProcessingJobs_Return_OneFailedJob()
{
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Pending Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Pending WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Pending,
StartedTimestamp = DateTime.Now.AddMinutes(-5)
}
}
}
},
JobStatus = JobStatus.PendingToRun
},
new Job()
{
Name = "Test Failed Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Failed WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = Convert.ToDateTime("4/1/2021")
}
}
}
},
JobStatus = JobStatus.Failed
},
new Job()
{
Name = "Test Process Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-5)
}
}
}
},
JobStatus = JobStatus.Inactive
}
};
_mockJobRepository.Setup(repo => repo.FindJobsPastDateByStatuses(It.IsAny<DateTime>(), 10, 20, It.IsAny<List<JobStatus>>())).ReturnsAsync(jobs);
// Act
var result = await _jobService.GetErrorMonitoringJobs();
// Assert
Assert.NotNull(result);
Assert.Single(result);
Assert.Single(result.Where(r => r.CurrentStatus == StatusType.Failed));
Assert.Empty(result.Where(r => r.CurrentStatus == StatusType.Processing));
}
[Fact]
public async Task GetErroredAndProcessingJobs_Return_Empty()
{
var jobs = new List<Job>()
{
new Job()
{
Name = "Test Pending Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Pending WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Pending,
StartedTimestamp = DateTime.Now.AddMinutes(-12)
}
}
}
}
},
new Job()
{
Name = "Test Process 1 Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process 1 WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-2)
}
}
}
}
},
new Job()
{
Name = "Test Process 2 Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
new WorkItem()
{
Name = "Test Process 2 WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Processing,
StartedTimestamp = DateTime.Now.AddMinutes(-5)
}
}
}
}
}
};
_mockJobRepository.Setup(repo => repo.FindJobsPastDateByStatuses(It.IsAny<DateTime>(), 10, 20, It.IsAny<List<JobStatus>>())).ReturnsAsync(jobs);
// Act
var result = await _jobService.GetErrorMonitoringJobs();
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
[Fact]
public async Task FilterPaged_Ok()
{
var pagedJobResult = new PagedResult<Job>();
var filter = new Filter()
{
Page = 1,
Limit = 2,
StatusFilters = null,
SortableFields = null,
TagIdFilters = new List<int> { 1 }
};
_mockJobRepository.Setup(repo => repo.FilteredListAsync(filter, _apiConfiguration.NumberOfWorkItemExecutions, _apiConfiguration.NumberOfExecutionMessages))
.ReturnsAsync(pagedJobResult).Verifiable();
// Act
var result = await _jobService.GetFilteredJobs(filter);
// Assert
Assert.NotNull(result);
Assert.Equal(pagedJobResult, result);
}
[Fact]
public async Task DeleteAsync_Success()
{
var jobReturned = new Job
{
JobId = 1,
WorkItems = new List<WorkItem>
{
new WorkItem
{
WorkItemId = 1
},
new WorkItem
{
WorkItemId = 2
}
}
};
_mockJobRepository.Setup(repo => repo.FindByIdAsync(1, 10, 20)).ReturnsAsync(jobReturned);
// Act
var jobIdToDelete = 1;
await _jobService.DeleteAsync(jobIdToDelete);
// Assert
_mockJobRepository.Verify(service => service.FindByIdAsync(It.Is<int>(x => x == 1), It.Is<int>(x => x == 10), It.Is<int>(x => x == 20)), Times.Once);
_mockWorkItemService.Verify(service => service.DeleteList(It.Is<List<WorkItem>>(workItems => workItems.Count == 2)), Times.Never);
}
[Fact]
public async Task GetJobsReadyToBeScheduled_Return_Empty()
{
var jobs = new List<Job>();
_mockJobRepository.Setup(repo => repo.FindJobsReadyToBeScheduled(It.IsAny<DateTime>())).ReturnsAsync(jobs);
// Act
var result = await _jobService.GetJobsReadyToBeScheduled();
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
[Fact]
public async Task GetJobsReadyToBeScheduled_Returns_One()
{
var jobs = new List<Job>
{
new Job
{
JobId = 1,
}
};
_mockJobRepository.Setup(repo => repo.FindJobsReadyToBeScheduled(It.IsAny<DateTime>())).ReturnsAsync(jobs);
// Act
var result = await _jobService.GetJobsReadyToBeScheduled();
// Assert
Assert.NotNull(result);
Assert.Single(result);
}
[Fact]
public async Task GetInactiveAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.ListInactiveAsync(10, 20)).ReturnsAsync(new List<Job>()
{
new Job(),
new Job()
});
// Act
var result = await _jobService.GetInactiveAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async Task GetSoftDeletedAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.ListSoftDeletedTrackedAsync(10, 20, It.IsAny<DateTime>())).ReturnsAsync(new List<Job>()
{
new Job(),
new Job()
});
// Act
var result = await _jobService.GetSoftDeletedTrackedAsync(DateTime.Now.AddDays(-1));
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async Task RemoveSoftDeleteById_Success()
{
// Arrange
var existingJob = new Job()
{
JobId = 100,
SoftDeleteDate = DateTime.Now,
};
_mockJobRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>(), 10, 20)).ReturnsAsync(existingJob);
_mockJobRepository.Setup(repo => repo.Update(It.IsAny<Job>())).Verifiable();
// Act
var result = await _jobService.RemoveSoftDeleteById(100);
// Assert
Assert.NotNull(result);
Assert.Equal(existingJob.JobId, result.JobId);
Assert.Null(result.SoftDeleteDate);
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(), 10, 20), Times.Once);
_mockJobRepository.Verify(x => x.Update(It.IsAny<Job>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public void RemoveSoftDeleteById_Throws()
{
// Arrange
_mockJobRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>(), 10, 20)).ReturnsAsync((Job)null);
// Act/Assert
var result = Assert.ThrowsAsync<ArgumentNullException>(async () => await _jobService.RemoveSoftDeleteById(100));
}
[Fact]
public async Task GetInactiveExcludeSoftDeletedAsync_Success()
{
// Arrange
_mockJobRepository.Setup(repo => repo.ListInactiveExcludeSoftDeletedTrackedAsync(10, 20)).ReturnsAsync(new List<Job>()
{
new Job(),
new Job()
});
// Act
var result = await _jobService.GetInactiveExcludeSoftDeletedTrackedAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async void CopyJobAsync_Success_KeepEnvironment()
{
var job = new Job
{
JobId = DateTime.Now.Millisecond,
CronSchedule = new Guid().ToString(),
NextRunTime = DateTime.Now.AddHours(1)
};
var request = new CopyJobRequest
{
JobId = job.JobId,
ChangeEnvironment = false
};
var newJob = new Job
{
JobId = DateTime.Now.Millisecond + 1
};
_mockJobRepository.Setup(x => x.FindByIdAsync(job.JobId, 10, 20))
.ReturnsAsync(job).Verifiable();
_mockJobRepository.Setup(x => x.AddAsync(It.IsAny<Job>()))
.ReturnsAsync(newJob).Verifiable();
var result = await _jobService.CopyJobAsync(request);
Assert.NotNull(result);
Assert.Null(result.CronSchedule);
Assert.Null(result.NextRunTime);
Assert.NotEqual(request.JobId, result.JobId);
Assert.Equal(newJob.JobId, result.JobId);
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(),
It.IsAny<int>(),
It.IsAny<int>()), Times.Once());
_mockJobRepository.Verify(x => x.AddAsync(It.IsAny<Job>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async void CopyJobAsync_Success_ChangeEnvironment()
{
var job = new Job
{
JobId = DateTime.Now.Millisecond,
CronSchedule = new Guid().ToString(),
NextRunTime = DateTime.Now.AddHours(1)
};
var request = new CopyJobRequest
{
JobId = job.JobId,
ChangeEnvironment = true
};
_mockJobRepository.Setup(x => x.FindByIdAsync(job.JobId, 10, 20))
.ReturnsAsync(job).Verifiable();
var result = await _jobService.CopyJobAsync(request);
Assert.NotNull(result);
Assert.Null(result.CronSchedule);
Assert.Null(result.NextRunTime);
Assert.Equal(0, result.JobId);
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(),
It.IsAny<int>(),
It.IsAny<int>()), Times.Once());
_mockJobRepository.Verify(x => x.AddAsync(It.IsAny<Job>()), Times.Never);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
}
[Fact]
public void CopyJobAsync_Failure_NotFound()
{
var request = new CopyJobRequest
{
JobId = DateTime.Now.Millisecond
};
Job? jobReturned = null;
_mockJobRepository.Setup(x => x.FindByIdAsync(request.JobId, 10, 20))
.ReturnsAsync(jobReturned).Verifiable();
Assert.ThrowsAsync<ServiceException>(async () => await _jobService.CopyJobAsync(request));
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
}
[Fact]
public void CopyJobAsync_Failure_Exception()
{
_mockJobRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>()))
.ThrowsAsync(new Exception("Test")).Verifiable();
Assert.ThrowsAsync<ServiceException>(async () =>
await _jobService.CopyJobAsync(It.IsAny<CopyJobRequest>()));
_mockJobRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>()), Times.Never);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/JobTagServiceTest.cs
+70
View File
@@ -0,0 +1,70 @@
using System.Collections.Generic;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class JobTagServiceTest
{
private readonly JobTagService _jobTagService;
private readonly Mock<IJobTagRepository> _mockJobTagRepository;
public JobTagServiceTest()
{
_mockJobTagRepository = new Mock<IJobTagRepository>();
var mockUnitOfWork = new Mock<IUnitOfWork>();
_jobTagService = new JobTagService(mockUnitOfWork.Object,
_mockJobTagRepository.Object);
}
[Fact]
public async void GetListAsync_Success()
{
// Arrange
_mockJobTagRepository.Setup(jobTagRepository => jobTagRepository.ListAsync()).ReturnsAsync(
new List<JobTag>()
{
new JobTag(),
new JobTag()
});
// Act
var result = await _jobTagService.GetAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async void GetJobTagsByTagIdAsync_Success()
{
// Arrange
_mockJobTagRepository.Setup(jobTagRepository => jobTagRepository.FindByTagIdAsync(2)).ReturnsAsync(
new List<JobTag>()
{
new JobTag {JobId = 1, TagId = 2},
new JobTag {JobId = 3, TagId = 2 }
});
// Act
var result = await _jobTagService.GetByTagIdAsync(2);
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async void SaveAsync_Success()
{
// Arrange
_mockJobTagRepository.Setup(jobTagRepository => jobTagRepository.AddAsync(It.IsAny<JobTag>())).ReturnsAsync(new JobTag());
// Act
var result = await _jobTagService.SaveAsync(new JobTag());
// Assert
Assert.NotNull(result);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/SendErroredJobAlertServiceTests.cs
+389
View File
@@ -0,0 +1,389 @@
using LCU.Api.Internal.Dispatcher.Configurations;
using LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
using LCU.Api.Internal.Dispatcher.Services;
using System.Collections.Generic;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.DispatcherModels.Models.Requests;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests
{
public class SendErroredJobAlertServiceTests
{
private readonly Mock<INotificationService> _mockNotificationService;
private readonly ApiConfiguration _apiConfigiguration;
private readonly SendErroredJobAlertService _sendErroredJobAlertService;
public SendErroredJobAlertServiceTests()
{
_mockNotificationService = new Mock<INotificationService>();
_apiConfigiguration = new ApiConfiguration
{
DefaultErrorRecipient = "[email protected]",
BatchErroredJobsTemplate = "./TemplatesTest/Test_BatchErroredJobsTemplate.html",
ErrorRowTemplate = "./TemplatesTest/Test_ErrorRowTemplate.html"
};
_sendErroredJobAlertService = new SendErroredJobAlertService(_apiConfigiguration, _mockNotificationService.Object);
}
[Fact]
public void GroupJobsByRecipients_Returns_OnlyDefault()
{
var job = new Job()
{
JobId = 1
};
var erroredJobAlertRequests = new List<ErroredJobAlertRequest>
{
new ErroredJobAlertRequest
{
CurrentJob = job,
CurrentWorkItem = new WorkItem()
}
};
var result = _sendErroredJobAlertService.GroupJobsByRecipients(erroredJobAlertRequests);
Assert.NotNull(result);
Assert.Single(result);
var resultErroredJobAlertRequest = result["[email protected]"].FirstOrDefault();
Assert.Equal(job, resultErroredJobAlertRequest.CurrentJob);
}
[Fact]
public void GroupJobsByRecipients_Returns_FourRecipients_And_Default()
{
var job1 = new Job()
{
JobId = 1
};
var job2 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "Test_Recipient_1",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
}
}
};
var job3 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_3",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_4",
}
}
};
var erroredJobAlertRequests = new List<ErroredJobAlertRequest>
{
new ErroredJobAlertRequest
{
CurrentJob = job1,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job2,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job3,
CurrentWorkItem = new WorkItem()
}
};
var result = _sendErroredJobAlertService.GroupJobsByRecipients(erroredJobAlertRequests);
Assert.NotNull(result);
Assert.Equal(job1, result["[email protected]"].FirstOrDefault().CurrentJob);
Assert.Equal(job2, result["test_recipient_1"].FirstOrDefault().CurrentJob);
Assert.Equal(job3, result["test_recipient_4"].FirstOrDefault().CurrentJob);
}
[Fact]
public void GroupJobsByRecipients_Returns_FourRecipients_And_DefaultAsTwoJobs()
{
var job1 = new Job()
{
JobId = 1
};
var job2 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "[email protected]",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_1",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
}
}
};
var job3 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_3",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_4",
}
}
};
var erroredJobAlertRequests = new List<ErroredJobAlertRequest>
{
new ErroredJobAlertRequest
{
CurrentJob = job1,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job2,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job3,
CurrentWorkItem = new WorkItem()
}
};
var result = _sendErroredJobAlertService.GroupJobsByRecipients(erroredJobAlertRequests);
Assert.NotNull(result);
Assert.Equal(2, result["[email protected]"].Count);
Assert.Equal(job2, result["test_recipient_1"].FirstOrDefault().CurrentJob);
Assert.Equal(job3, result["test_recipient_4"].FirstOrDefault().CurrentJob);
}
[Fact]
public void GroupJobsByRecipients_Returns_FourRecipients_And_DefaultWithLower_DefaultAsTwoJobs()
{
var job1 = new Job()
{
JobId = 1
};
var job2 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "[email protected]",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_1",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
}
}
};
var job3 = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_3",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_4",
}
}
};
var erroredJobAlertRequests = new List<ErroredJobAlertRequest>
{
new ErroredJobAlertRequest
{
CurrentJob = job1,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job2,
CurrentWorkItem = new WorkItem()
},
new ErroredJobAlertRequest
{
CurrentJob = job3,
CurrentWorkItem = new WorkItem()
}
};
var result = _sendErroredJobAlertService.GroupJobsByRecipients(erroredJobAlertRequests);
Assert.NotNull(result);
Assert.Equal(2, result["[email protected]"].Count);
Assert.Equal(job2, result["test_recipient_1"].FirstOrDefault().CurrentJob);
Assert.Equal(job3, result["test_recipient_4"].FirstOrDefault().CurrentJob);
}
[Fact]
public void AddRecipients_Returns_AddsThree_Groups()
{
var job = new Job()
{
JobErrorRecipients = new List<JobErrorRecipient>()
{
new JobErrorRecipient()
{
Recipient = "Test_Recipient_2",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_3",
},
new JobErrorRecipient()
{
Recipient = "Test_Recipient_4",
}
}
};
var groupedRecipients = new Dictionary<string, List<ErroredJobAlertRequest>>();
var erroredJobAlertRequest = new ErroredJobAlertRequest
{
CurrentJob = job,
CurrentWorkItem = new WorkItem()
};
_sendErroredJobAlertService.AddRecipients(erroredJobAlertRequest, groupedRecipients);
Assert.NotNull(groupedRecipients);
Assert.Equal(3, groupedRecipients.Count);
Assert.NotNull(groupedRecipients["test_recipient_2"]);
Assert.NotNull(groupedRecipients["test_recipient_3"]);
Assert.NotNull(groupedRecipients["test_recipient_4"]);
}
[Fact]
public void SetUpJobErrorDetails_NoWorkItem_ErroredOrProcessing_Throws()
{
var erroredJobAlertRequest = new ErroredJobAlertRequest
{
CurrentJob = new Job()
};
Assert.ThrowsAsync<ArgumentNullException>(async () => _sendErroredJobAlertService.SetUpJobErrorDetails(erroredJobAlertRequest));
}
[Fact]
public void SetUpJobErrorDetails_NoWorkItem_ErroredOrProcessing_Return_JobErrorDetail()
{
var workItem = new WorkItem()
{
Name = "Test WorkItem",
WorkItemExecutions = new List<WorkItemExecution>(){
new WorkItemExecution()
{
Status = StatusType.Failed,
StartedTimestamp = Convert.ToDateTime("4/1/2021")
}
}
};
var job = new Job()
{
Name = "Test Job",
NextRunTime = DateTime.Now.AddHours(-1),
WorkItems = new List<WorkItem>() {
workItem
},
JobStatus = JobStatus.Failed
};
var erroredJobAlertRequest = new ErroredJobAlertRequest
{
CurrentJob = job,
CurrentWorkItem = workItem
};
var result = _sendErroredJobAlertService.SetUpJobErrorDetails(erroredJobAlertRequest);
Assert.NotNull(result);
Assert.Equal("Test Job", result.JobName);
Assert.Equal("Test WorkItem", result.WorkItemName);
Assert.Equal("Failed", result.JobStatus);
Assert.Equal(Convert.ToDateTime("4/1/2021").ToString(), result.StartTime);
}
[Fact]
public void CreateErrorRow_Return_Filled_Test_ErrorRowTemplate()
{
var jobErrorDetails = new JobErrorDetail()
{
JobName = "Test Job",
WorkItemName = "Test WorkItem",
JobStatus = "Failed",
StartTime = Convert.ToDateTime("4/1/2021").ToString()
};
var result = _sendErroredJobAlertService.CreateErrorRow(jobErrorDetails);
Assert.Contains("Test Job", result);
Assert.Contains("Test WorkItem", result);
Assert.Contains("Failed", result);
Assert.Contains(Convert.ToDateTime("4/1/2021").ToString(), result);
}
[Fact]
public void CreateBatchErroredJobsEmail_Return_Filled_Test_ErrorRowTemplate()
{
var stringHtmlErrors = "<div><div>Test Job</div><div>Test WorkItem</div><div>Failed</div><div>4/1/2021 12:00:00 AM</div></div>";
var result = _sendErroredJobAlertService.CreateBatchErroredJobsEmail(stringHtmlErrors);
Assert.Contains("Test Job", result);
Assert.Contains("Test WorkItem", result);
Assert.Contains("Failed", result);
Assert.Contains(Convert.ToDateTime("4/1/2021").ToString(), result);
}
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/TagServiceTest.cs
+116
View File
@@ -0,0 +1,116 @@
using System.Collections.Generic;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class TagServiceTest
{
private readonly TagService _tagService;
private readonly Mock<IJobTagService> _mockJobTagService;
private readonly Mock<ITagRepository> _mockTagRepository;
public TagServiceTest()
{
_mockTagRepository = new Mock<ITagRepository>();
var mockUnitOfWork = new Mock<IUnitOfWork>();
_mockJobTagService = new Mock<IJobTagService>();
_tagService = new TagService(mockUnitOfWork.Object,
_mockTagRepository.Object,
_mockJobTagService.Object);
}
[Fact]
public async void GetListAsync_Success()
{
// Arrange
_mockTagRepository.Setup(tagRepository => tagRepository.ListAsync()).ReturnsAsync(
new List<Tag>()
{
new Tag(),
new Tag()
});
// Act
var result = await _tagService.GetAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count());
}
[Fact]
public async void GetByIdAsync_Success()
{
// Arrange
_mockTagRepository.Setup(tagRepository => tagRepository.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(new Tag());
// Act
var result = await _tagService.GetByIdAsync(1);
// Assert
Assert.NotNull(result);
}
[Fact]
public async void SaveAsync_Success()
{
// Arrange
_mockTagRepository.Setup(tagRepository => tagRepository.AddAsync(It.IsAny<Tag>())).ReturnsAsync(new Tag());
// Act
var result = await _tagService.SaveAsync(new Tag());
// Assert
Assert.NotNull(result);
}
[Fact]
public async void UpdateAsync_Success()
{
// Arrange
var jobTagToUpdate = new Tag()
{
TagId = 1,
TagName = "Test"
};
_mockTagRepository.Setup(tagRepository => tagRepository.Update(It.IsAny<Tag>())).Verifiable();
// Act
var result = await _tagService.UpdateAsync(jobTagToUpdate);
// Assert
Assert.NotNull(result);
Assert.Equal(jobTagToUpdate.TagId, result.TagId);
Assert.Equal(jobTagToUpdate.TagName, result.TagName);
_mockTagRepository.VerifyAll();
}
[Fact]
public void DeleteAsync_Success()
{
// Arrange
var jobTagToDelete = new JobTag()
{
TagId = 1,
JobTagId = 2
};
var tagToDelete = new Tag()
{
TagId = 1,
TagName = "Test"
};
_mockTagRepository.Setup(tagRepository => tagRepository.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(tagToDelete);
_mockTagRepository.Setup(tagRepository => tagRepository.Remove(It.IsAny<Tag>())).Verifiable();
// Act
_tagService.DeleteAsync(tagToDelete.TagId);
// Assert
Assert.True(true);
_mockTagRepository.VerifyAll();
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/WorkItemExecutionServiceTest.cs
+102
View File
@@ -0,0 +1,102 @@
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
using LCU.Library.Internal.DispatcherModels.Enums;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class WorkItemExecutionServiceTest
{
private readonly WorkItemExecutionService _workItemExecutionService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly Mock<IWorkItemExecutionRepository> _workItemExecutionRepository;
public WorkItemExecutionServiceTest()
{
_mockUnitOfWork = new Mock<IUnitOfWork>();
_workItemExecutionRepository = new Mock<IWorkItemExecutionRepository>();
_workItemExecutionService = new WorkItemExecutionService(_mockUnitOfWork.Object,
_workItemExecutionRepository.Object);
}
[Fact]
public async void GetByIdAsync_Success()
{
// Arrange
var workItemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1
};
_workItemExecutionRepository.Setup(repo => repo.FindByIdAsync(1)).ReturnsAsync(workItemExecution);
// Act
var result = await _workItemExecutionService.GetByIdAsync(1);
// Assert
Assert.NotNull(result);
Assert.Equal(1, result.WorkItemExecutionId);
_workItemExecutionRepository.Verify(x => x.FindByIdAsync(1), Times.Once);
}
[Fact]
public void GetAsync_Exception()
{
_workItemExecutionRepository.Setup(x => x.FindByIdAsync(1)).ThrowsAsync(new Exception("Error"));
Assert.ThrowsAsync<ServiceException>(async () => await _workItemExecutionService.GetByIdAsync(1));
_workItemExecutionRepository.Verify(x => x.FindByIdAsync(1), Times.Once);
}
[Fact]
public async void UpdateCompleteWorkItemExecutionWithoutSave_Success()
{
// Arrange
var workItemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1
};
var updatingWorkItemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
Status = StatusType.Completed
};
_workItemExecutionRepository.Setup(repo => repo.Update(updatingWorkItemExecution));
// Act
var result = await _workItemExecutionService.UpdateCompleteWorkItemExecutionWithoutSave(workItemExecution, StatusType.Completed);
// Assert
Assert.NotNull(result);
Assert.Equal(StatusType.Completed, result.Status);
_workItemExecutionRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
_workItemExecutionRepository.Verify(x => x.Update(It.IsAny<WorkItemExecution>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
}
[Fact]
public async void UpdateCompleteWorkItemExecution_Success()
{
// Arrange
var workItemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1
};
var updatingWorkItemExecution = new WorkItemExecution()
{
WorkItemExecutionId = 1,
Status = StatusType.Completed
};
_workItemExecutionRepository.Setup(repo => repo.Update(updatingWorkItemExecution));
// Act
var result = await _workItemExecutionService.UpdateCompleteWorkItemExecution(workItemExecution, StatusType.Completed);
// Assert
Assert.NotNull(result);
Assert.Equal(StatusType.Completed, result.Status);
_workItemExecutionRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
_workItemExecutionRepository.Verify(x => x.Update(It.IsAny<WorkItemExecution>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
}
LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/ServiceTests/WorkItemServiceTest.cs
+226
View File
@@ -0,0 +1,226 @@
using System.Collections.Generic;
using LCU.Library.Internal.LcuMassTransitModels;
using LCU.Api.Internal.Dispatcher.Services;
using LCU.Api.Internal.DispatcherLib.Repositories;
using LCU.Api.Internal.Dispatcher.Configurations;
using LCU.Api.Internal.DispatcherSharedLib.BuilderServices;
namespace LCU.Api.Internal.DispatcherTests.ServiceTests;
public class WorkItemServiceTest
{
private readonly WorkItemService _workItemService;
private readonly Mock<IUnitOfWork> _mockUnitOfWork;
private readonly Mock<IWorkItemRepository> _mockWorkItemRepository;
private readonly Mock<IWorkItemExecutionService> _mockWorkItemExecutionService;
private readonly Mock<IActionBuilderService> _mockActionBuilderService;
private readonly ConnectionConfiguration _connectionConfiguration;
private readonly ReceiveEndpointConfigurations _receiveEndpointConfigurations;
private readonly ApiConfiguration _apiConfiguration;
public WorkItemServiceTest()
{
_mockUnitOfWork = new Mock<IUnitOfWork>();
_mockWorkItemRepository = new Mock<IWorkItemRepository>();
_mockWorkItemExecutionService = new Mock<IWorkItemExecutionService>();
_mockActionBuilderService = new Mock<IActionBuilderService>();
_connectionConfiguration = new ConnectionConfiguration();
_apiConfiguration = new ApiConfiguration()
{
NumberOfExecutionMessages = 20,
NumberOfWorkItemExecutions = 10
};
_receiveEndpointConfigurations = new ReceiveEndpointConfigurations
{
CompletionReceiveEndpoint = new ReceiveEndpointConfiguration()
};
_workItemService = new WorkItemService(_mockUnitOfWork.Object,
_mockWorkItemRepository.Object,
_mockWorkItemExecutionService.Object,
_mockActionBuilderService.Object,
_connectionConfiguration,
_receiveEndpointConfigurations,
_apiConfiguration);
}
[Fact]
public async Task GetByIdAsync_Success()
{
// Arrange
var workItem = new WorkItem()
{
WorkItemId = 1
};
_mockWorkItemRepository.Setup(repo => repo.FindByIdAsync(1)).ReturnsAsync(workItem);
// Act
var result = await _workItemService.GetByIdAsync(1);
// Assert
Assert.NotNull(result);
Assert.Equal(1, result.WorkItemId);
_mockWorkItemRepository.Verify(x => x.FindByIdAsync(1), Times.Once);
}
[Fact]
public void GetAsync_Exception()
{
_mockWorkItemRepository.Setup(x => x.FindByIdAsync(1)).ThrowsAsync(new Exception("Error"));
Assert.ThrowsAsync<ServiceException>(async () => await _workItemService.GetByIdAsync(1));
_mockWorkItemRepository.Verify(x => x.FindByIdAsync(1), Times.Once);
}
[Fact]
public async Task GetByJobIdAsync_Success()
{
// Arrange
var workItems = new List<WorkItem>()
{
new WorkItem()
{
WorkItemId = 1
}
};
_mockWorkItemRepository.Setup(repo => repo.FindByJobIdAsync(1)).ReturnsAsync(workItems);
// Act
var result = await _workItemService.GetByJobIdAsync(1);
// Assert
Assert.NotNull(result);
Assert.Equal(1, result.FirstOrDefault().WorkItemId);
_mockWorkItemRepository.Verify(x => x.FindByJobIdAsync(1), Times.Once);
}
[Fact]
public void GetByJobIdAsync_Exception()
{
_mockWorkItemRepository.Setup(x => x.FindByJobIdAsync(1)).ThrowsAsync(new Exception("Error"));
Assert.ThrowsAsync<ServiceException>(async () => await _workItemService.GetByJobIdAsync(1));
_mockWorkItemRepository.Verify(x => x.FindByJobIdAsync(1), Times.Once);
}
[Fact]
public async Task UpdateAsync_Success()
{
// Arrange
var workItem = new WorkItem()
{
WorkItemId = 1
};
var updatingWorkItem = new WorkItem()
{
WorkItemId = 1,
Name = "Test"
};
_mockWorkItemRepository.Setup(repo => repo.Update(updatingWorkItem));
// Act
var result = await _workItemService.UpdateAsync(updatingWorkItem);
// Assert
Assert.NotNull(result);
Assert.Equal("Test", result.Name);
_mockWorkItemRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
_mockWorkItemRepository.Verify(x => x.Update(It.IsAny<WorkItem>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
[Fact]
public async Task DeleteList_Success()
{
// Arrange
var workItem1Executions = new List<WorkItemExecution>()
{
new WorkItemExecution
{
WorkItemId = 1,
WorkItemExecutionId = 1
},
new WorkItemExecution
{
WorkItemId = 1,
WorkItemExecutionId = 2
}
};
_mockWorkItemExecutionService.Setup(service => service.GetAllByWorkItemId(1)).ReturnsAsync(workItem1Executions);
var workItem2Executions = new List<WorkItemExecution>()
{
new WorkItemExecution
{
WorkItemId = 2,
WorkItemExecutionId = 3
},
new WorkItemExecution
{
WorkItemId = 2,
WorkItemExecutionId = 4
}
};
_mockWorkItemExecutionService.Setup(service => service.GetAllByWorkItemId(2)).ReturnsAsync(workItem2Executions);
var deletingWorkItems = new List<WorkItem>
{
new WorkItem
{
WorkItemId = 1,
WorkItemExecutions = new List<WorkItemExecution>
{
new WorkItemExecution
{
WorkItemId = 1,
WorkItemExecutionId = 1
},
new WorkItemExecution
{
WorkItemId = 1,
WorkItemExecutionId = 2
}
}
},
new WorkItem
{
WorkItemId = 2,
WorkItemExecutions = new List<WorkItemExecution>
{
new WorkItemExecution
{
WorkItemId = 2,
WorkItemExecutionId = 3
},
new WorkItemExecution
{
WorkItemId = 2,
WorkItemExecutionId = 4
}
}
}
};
_mockWorkItemRepository.Setup(repo => repo.RemoveList(deletingWorkItems));
var startingDeletingWorkItems = new List<WorkItem>
{
new WorkItem
{
WorkItemId = 1
},
new WorkItem
{
WorkItemId = 2
}
};
// Act
await _workItemService.DeleteList(startingDeletingWorkItems);
// Assert
_mockWorkItemExecutionService.Verify(x => x.GetAllByWorkItemId(It.Is<int>(x => x == 1)), Times.Once);
_mockWorkItemExecutionService.Verify(x => x.GetAllByWorkItemId(It.Is<int>(x => x == 2)), Times.Once);
_mockWorkItemRepository.Verify(x => x.RemoveList(It.IsAny<List<WorkItem>>()), Times.Once);
_mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
}
}