persistence/DD.Persistence.Test/ChangeLogTest.cs

using DD.Persistence.Database.Repositories;
using DD.Persistence.Models.ChangeLog;
using DD.Persistence.Models.Common;
using DD.Persistence.Models.Requests;
using DD.Persistence.Repositories;
using DD.Persistence.Services;
using Microsoft.Extensions.Caching.Memory;
using NSubstitute;
using UuidExtensions;

namespace DD.Persistence.Test;
public class ChangeLogTest
{
    private readonly IChangeLogCommitRepository changeLogCommitRepository = Substitute.For<IChangeLogCommitRepository>();
    private readonly IChangeLogRepository changeLogRepository = Substitute.For<IChangeLogRepository>();
    private ChangeLogService service;

    public ChangeLogTest()
    {
        var memoryCache = new MemoryCache(new MemoryCacheOptions());
        service = new ChangeLogService(memoryCache, changeLogCommitRepository, changeLogRepository);
    }
    [Fact]
    public async Task AddRange()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var commitRequest = new ChangeLogCommitCreateRequest(discriminatorId, Uuid7.Guid(), "Добавление нескольких значений");
        var commit = new ChangeLogCommitDto() {
            IdAuthor = commitRequest.IdAuthor, 
            Comment = commitRequest.Comment

        };
        commit.Id = Uuid7.Guid();
        var dtos = GenerateChangeLogRequests(2);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitCreateRequest>(), Arg.Any<CancellationToken>()).Returns(commit);
        changeLogRepository
            .AddRange(
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<IDictionary<string, object>>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        //act
        var addRangeResult = await service
            .AddRange(commitRequest, dtos, CancellationToken.None);
        addRangeResult = await service
            .AddRange(commitRequest, dtos, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).Add(commitRequest, CancellationToken.None);
        await changeLogRepository.Received(2).AddRange(Arg.Any<ChangeLogCommitDto>(), dtos, CancellationToken.None);
    }

    [Fact]
    public async Task UpdateRange()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var commitRequest = new ChangeLogCommitCreateRequest(discriminatorId, Uuid7.Guid(), "Изменение нескольких значений");
        var commit = new ChangeLogCommitDto() {
            IdAuthor = commitRequest.IdAuthor, 
            Comment = commitRequest.Comment
        };
        commit.Id = Uuid7.Guid();

        var dtos = GenerateChangeLogValuesDto(2);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitCreateRequest>(), Arg.Any<CancellationToken>()).Returns(commit);

        changeLogRepository
            .UpdateRange(
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogBaseDto>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        //act
        var updateRangeResult = await service
            .UpdateRange(commitRequest, dtos, CancellationToken.None);

        updateRangeResult = await service
            .UpdateRange(commitRequest, dtos, CancellationToken.None);

        updateRangeResult = await service
           .UpdateRange(commitRequest, dtos, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).Add(commitRequest, CancellationToken.None);
        await changeLogRepository.Received(3).UpdateRange(Arg.Any<ChangeLogCommitDto>(), dtos, CancellationToken.None);
    }

    [Fact]
    public async Task MarkAsDeleted()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var commitRequest = new ChangeLogCommitCreateRequest(discriminatorId, Uuid7.Guid(), "Удаление нескольких значений");
        var commit = new ChangeLogCommitDto()
        {
            IdAuthor = commitRequest.IdAuthor,
            Comment = commitRequest.Comment
        };
        commit.Id = Uuid7.Guid();
        var dtos = GenerateChangeLogValuesDto(2);
        var dtoIds = dtos.Select(d => d.Id);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitCreateRequest>(), Arg.Any<CancellationToken>()).Returns(commit);
        changeLogRepository
            .MarkAsDeleted(
                Arg.Any<IEnumerable<Guid>>(),
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        //act
        var markAsDeletedResult = await service
            .MarkAsDeleted(dtoIds, commitRequest, CancellationToken.None);
        markAsDeletedResult = await service
            .MarkAsDeleted(dtoIds, commitRequest, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).Add(commitRequest, CancellationToken.None);
        await changeLogRepository.Received(2).MarkAsDeleted(dtoIds, commit, CancellationToken.None);
    }

    [Fact]
    public async Task ClearAndAddRange()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var commitRequest = new ChangeLogCommitCreateRequest(discriminatorId, Uuid7.Guid(), "Удаление и добавление нескольких значений");
        var commit = new ChangeLogCommitDto() {
            IdAuthor = commitRequest.IdAuthor,
            Comment = commitRequest.Comment
        };
        commit.Id = Uuid7.Guid();
        var dtos = GenerateChangeLogRequests(2);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitCreateRequest>(), Arg.Any<CancellationToken>()).Returns(commit);
        changeLogRepository
            .ClearAndAddRange(
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<IDictionary<string, object>>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        //act
        var clearAndAddResult = await service
            .ClearAndAddRange(commitRequest, dtos, CancellationToken.None);
        clearAndAddResult = await service
            .ClearAndAddRange(commitRequest, dtos, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).Add(commitRequest, CancellationToken.None);
        await changeLogRepository.Received(2).ClearAndAddRange(Arg.Any<ChangeLogCommitDto>(), dtos, CancellationToken.None);
    }

    [Fact]
    public async Task GetByDate()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var paginationRequest = new PaginationRequest()
        {
            Skip = 0,
            Take = 1000
        };
        var dtos = GenerateChangeLogValuesDto(5);
        var items = new PaginationContainer<ChangeLogBaseDto>()
        {
            Take = paginationRequest.Take,
            Skip = paginationRequest.Skip,
            Items = dtos,
            Count = 10
        };
        var momentDate = DateTime.UtcNow;

        changeLogRepository
           .GetByDate(
               Arg.Any<Guid>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<PaginationRequest>(),
               Arg.Any<CancellationToken>())
           .Returns(items);

        //act
        var actualItems = await service
            .GetByDate(discriminatorId, momentDate, paginationRequest, CancellationToken.None);

        //assert
        await changeLogRepository.Received(1).GetByDate(discriminatorId, momentDate, paginationRequest, CancellationToken.None);

    }

    [Fact]
    public async Task GetChangeLogForInterval()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();
        var dtos = GenerateChangeLogDto(5);

        var dateBegin = DateTimeOffset.UtcNow.AddDays(-5);
        var dateEnd = DateTimeOffset.UtcNow;

        changeLogCommitRepository
           .GetChangeLogForInterval(
               Arg.Any<Guid>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<CancellationToken>())
           .Returns(dtos);

        //act
        var actualItems = await service
            .GetChangeLogForInterval(discriminatorId, dateBegin, dateEnd, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).GetChangeLogForInterval(discriminatorId, dateBegin, dateEnd, CancellationToken.None);

    }

    [Fact]
    public async Task GetDatesChange()
    {
        //arrange
        var discriminatorId = Uuid7.Guid();

        var dateBegin = DateTimeOffset.UtcNow.AddDays(-5);
        var dateEnd = DateTimeOffset.UtcNow;

        var dateOnlyBegin = new DateOnly(dateBegin.Year, dateBegin.Month, dateBegin.Day);
        var dateOnlyEnd = new DateOnly(dateEnd.Year, dateEnd.Month, dateEnd.Day);

        var dtos = new List<DateOnly>() { dateOnlyBegin, dateOnlyEnd };

        changeLogCommitRepository
           .GetDatesChange(
               Arg.Any<Guid>(),
               Arg.Any<CancellationToken>())
           .Returns(dtos);

        //act
        var actualItems = await service
            .GetDatesChange(discriminatorId, CancellationToken.None);

        //assert
        await changeLogCommitRepository.Received(1).GetDatesChange(discriminatorId, CancellationToken.None);

    }


    private IEnumerable<ChangeLogBaseDto> GenerateChangeLogValuesDto(int count)
    {
        var items = new List<ChangeLogBaseDto>();
        for (int i = 0; i < count; i++)
        {
            items.Add(new ChangeLogBaseDto()
            {

                Id = Uuid7.Guid(),
                Value = new Dictionary<string, object>
                {
                    { "1", 1 },
                    { "2", 2 }
                }

            });
        }
        return items;
    }

    private IEnumerable<IDictionary<string, object>> GenerateChangeLogRequests(int count)
    {
        var items = new List<IDictionary<string, object>>();
        for (int i = 0; i < count; i++)
        {
            items.Add(new Dictionary<string, object>
                {
                    { "1", 1 },
                    { "2", 2 }
                });
        }
        return items;
    }

    private IEnumerable<ChangeLogDto> GenerateChangeLogDto(int count)
    {
        var items = new List<ChangeLogDto>();
        for (int i = 0; i < count; i++)
        {
            items.Add(new ChangeLogDto()
            {
                Id = Uuid7.Guid(),
                Value = new Dictionary<string, object>
                {
                    { "1", 1 },
                    { "2", 2 }
                }
            });
        }
        return items;
    }
}