monorepo/LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherTests/RepositoryTests/JobRepositoryTest.cs

using System.Collections.Generic;
using LCU.Api.Internal.DispatcherLib.Repositories;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.DispatcherModels.Constants;
namespace LCU.Api.Internal.DispatcherTests.RepositoryTests;

public class JobRepositoryTest : DbContextFromJsonTest
{
    private readonly JobRepository _jobRepository;

    public JobRepositoryTest()
    {
        var dbContext = GetContextWithData("RepositoryTests\\job_repo_basic.json");
        _jobRepository = new JobRepository(dbContext);
    }

    [Fact]
    public async void FilteredListAsync_DefaultFilter()
    {
        // Act
        var filter = new Filter();
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(4, resultsBasic.Items.Count());
        var first = resultsBasic.Items.First();
        Assert.Equal(1, first.JobId);
    }

    [Fact]
    public async void FilteredListAsync_OrderbyNextRunTime()
    {
        // Act
        var filter = new Filter()
        {
            StatusFilters = null,
            SortableFields = new List<SortableField>()
            {
                new SortableField()
                {
                    Field = JobSortableFields.NextRunTime,
                    IsDescending = true,
                    Position = 0
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(8, resultsBasic.Items.Count());
        var first = resultsBasic.Items.First();
        Assert.Equal(3, first.JobId);
    }

    [Fact]
    public async void FilteredListAsync_OrderbyName()
    {
        // Act
        var filter = new Filter()
        {

            TagIdFilters = null,
            StatusFilters = null,
            SortableFields = new List<SortableField>()
            {
                new SortableField()
                {
                    Field = JobSortableFields.Name,
                    IsDescending = true,
                    Position = 0
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(8, resultsBasic.Items.Count());
        var first = resultsBasic.Items.First();
        Assert.Equal(1085, first.JobId);
    }

    [Fact]
    public async void FilteredListAsync_OrderbyDescription()
    {
        // Act
        var filter = new Filter()
        {

            TagIdFilters = null,
            StatusFilters = null,
            SortableFields = new List<SortableField>()
            {
                new SortableField()
                {
                    Field = JobSortableFields.Description,
                    IsDescending = true,
                    Position = 0
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(8, resultsBasic.Items.Count());
        var first = resultsBasic.Items.First();
        Assert.Equal(1085, first.JobId);
    }

    [Fact]
    public async void FilteredListAsync_StatusFailed_Return_2()
    {
        // Act
        var filter = new Filter()
        {
            StatusFilters = new List<StatusFilter>()
            {
                new StatusFilter()
                {
                    IsEnabled = true,
                    JobStatus = JobStatus.Failed
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(0, resultsBasic.Items.Count());
    }

    [Fact]
    public async void FilteredListAsync_StatusInactive_Return_2()
    {
        // Act
        var filter = new Filter()
        {
            StatusFilters = new List<StatusFilter>()
            {
                new StatusFilter()
                {
                    IsEnabled = true,
                    JobStatus = JobStatus.Inactive
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(4, resultsBasic.Items.Count());
    }

    [Fact]
    public async void FilteredListWithPagingAsync_StatusInactive_Return_2()
    {
        // Act
        var filter = new Filter()
        {
            Page = 1,
            Limit = 1,
            StatusFilters = new List<StatusFilter>()
            {
                new StatusFilter()
                {
                    IsEnabled = true,
                    JobStatus = JobStatus.Inactive
                }
            }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Single(resultsBasic.Items);
    }

    [Fact]
    public async void FilteredListAsync_NextRunTimeGreaterThenDate_Return_0()
    {
        // Act
        var filter = new Filter()
        {
            NextRuntimeGreaterThanDate = Convert.ToDateTime("8/20/2025")
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Empty(resultsBasic.Items);
    }

    [Fact]
    public async void FilteredListAsync_NextRunTimeGreaterThenDate_Return_2()
    {
        // Act
        var filter = new Filter()
        {
            NextRuntimeGreaterThanDate = Convert.ToDateTime("1/13/2022")
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(2, resultsBasic.Items.Count());
    }

    [Fact]
    public async void FilteredListAsync_TagId2_Return_0()
    {
        // Act
        var filter = new Filter()
        {
            TagIdFilters = new List<int> { 2 }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Empty(resultsBasic.Items);
    }

    [Fact]
    public async void FilteredListAsync_TagId1_Return_2()
    {
        // Act
        var filter = new Filter()
        {
            StatusFilters = null,
            SortableFields = null,
            TagIdFilters = new List<int> { 1 }
        };
        var resultsBasic = await _jobRepository.FilteredListAsync(filter, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(4, resultsBasic.Items.Count());
    }

    [Fact]
    public async void ListAsync_Test()
    {
        // Act
        var resultsBasic = await _jobRepository.ListAsync(10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(9, resultsBasic.Count());
    }

    [Fact]
    public async void FindAsync_Found()
    {
        // Act
        var resultsBasic = await _jobRepository.FindByIdAsync(1, 10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(1, resultsBasic.JobId);
        Assert.NotNull(resultsBasic.WorkItems);
        Assert.Equal(2, resultsBasic.WorkItems.Count);
    }

    [Fact]
    public async void FindAsync_Missing()
    {
        // Act
        var resultsBasic = await _jobRepository.FindByIdAsync(1000, 10, 20);

        // Assert
        Assert.Null(resultsBasic);
    }

    [Fact]
    public async void Update_Test()
    {
        var foundJob = await _jobRepository.FindByIdAsync(1, 10, 20);
        Assert.NotNull(foundJob);
        Assert.Equal("Test.RequestingApplication.1", foundJob.RequestingApplication);

        foundJob.RequestingApplication = "Test.RequestingApplication.3";

        // Act
        _jobRepository.Update(foundJob);

        //Act / Assert
        var updatedJob = await _jobRepository.FindByIdAsync(1, 10, 20);
        Assert.NotNull(updatedJob);
        updatedJob.RequestingApplication = "Test.RequestingApplication.3";
    }

    [Fact]
    public async void Update_Returns_JobErrorRecipients()
    {
        var foundJob = await _jobRepository.FindByIdExcludingWorkItemsAsync(1085);

        Assert.NotNull(foundJob);
        Assert.Empty(foundJob.JobErrorRecipients);

        foundJob.RequestingApplication = "Updated Application";

        var updatedJob = await _jobRepository.Update(foundJob);

        Assert.NotNull(updatedJob);
        Assert.Single(updatedJob.JobErrorRecipients);
        Assert.Equal("[email protected]", updatedJob.JobErrorRecipients.First().Recipient);
    }

    [Fact]
    public async void AddAsync_Test()
    {
        var jobtag = new Tag();
        jobtag.TagId = 1;
        jobtag.TagName = "Reports";
        // Arrange
        var job = new Job()
        {
            JobId = 100,
            JobTags = new List<JobTag>()
            {
                new JobTag()
                {
                    JobId = 100,
                    Tag = jobtag,
                    TagId = 1
                },
            },
  
            RequestingApplication = "Test.RequestingApplication.1",
            WorkItems = new List<WorkItem>()
                {
                    new WorkItem ()
                    {
                      WorkItemId = 100,
                      JobId  = 100,
                      Order =  1,
                      SerializedPayload = "{TEST:null}",
                      Url = "Test.Application.1",
                      HttpMethod = HttpMethodType.Post,
                    },
                    new WorkItem ()
                    {
                      WorkItemId = 200,
                      JobId  = 100,
                      Order =  2,
                      SerializedPayload = "{TEST:null}",
                      Url = "Test.Application.21",
                      HttpMethod = HttpMethodType.Post,
                    }
                  }
        };

        // Act
        var resultsBasic = await _jobRepository.AddAsync(job);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.True(resultsBasic.JobId > 0);
        Assert.True(resultsBasic.JobTags.Count > 0);
        Assert.NotNull(resultsBasic.WorkItems);
        Assert.Equal(100, resultsBasic.WorkItems.First().WorkItemId);
        Assert.Equal(resultsBasic.JobId, resultsBasic.WorkItems.First().JobId);
    }

    [Fact]
    public async void FindJobsReadyToBeScheduled_Return_2()
    {
        // Act
        var date = DateTime.Now;
        var resultsBasic = await _jobRepository.FindJobsReadyToBeScheduled(date);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(2, resultsBasic.Count());
    }

    [Fact]
    public async void ListInactiveAsync_Test()
    {
        // Act
        var resultsBasic = await _jobRepository.ListInactiveAsync(10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(3, resultsBasic.Count());
    }

    [Fact]
    public async void ListSoftDeletedAsync_Test()
    {
        // Act
        var resultsBasic = await _jobRepository.ListSoftDeletedTrackedAsync(10, 20, new DateTime(2023, 04, 01));

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Single(resultsBasic);
    }

    [Fact]
    public async void ListInactiveExcludeSoftDeletedAsync_Test()
    {
        // Act
        var resultsBasic = await _jobRepository.ListInactiveExcludeSoftDeletedTrackedAsync(10, 20);

        // Assert
        Assert.NotNull(resultsBasic);
        Assert.Equal(2, resultsBasic.Count());
    }
}