persistence/DD.Persistence.Test/ChangeLogTest.cs

using DD.Persistence.API.Services;
using DD.Persistence.Models;
using DD.Persistence.Models.Common;
using DD.Persistence.Models.Requests;
using DD.Persistence.Repositories;
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 expectedCommitId = Uuid7.Guid();
        var comment = "Добавление нескольких значений";
        var commitRequest = new CreateChangeLogCommitRequest(Uuid7.Guid(), comment);
        var commit = new ChangeLogCommitDto(expectedCommitId, commitRequest);
        var dtos = GenerateChangeLogValuesDto(2);

        changeLogCommitRepository.Add(Arg.Any<CreateChangeLogCommitRequest>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .AddRange(
                Arg.Any<Guid>(),
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

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

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

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

        var dtos = GenerateChangeLogValuesDto(2);

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

        changeLogRepository
            .UpdateRange(
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(),
                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 expectedCommitId = Uuid7.Guid();
        var comment = "Удаление нескольких значений";
        var commitRequest = new CreateChangeLogCommitRequest(Uuid7.Guid(), comment);
        var commit = new ChangeLogCommitDto(expectedCommitId, commitRequest);
        var dtos = GenerateChangeLogValuesDto(2);
        var dtoIds = dtos.Select(d => d.Id);

        changeLogCommitRepository.Add(Arg.Any<CreateChangeLogCommitRequest>(), Arg.Any<CancellationToken>()).Returns(expectedCommitId);
        changeLogRepository
            .MarkAsDeleted(
                Arg.Any<Guid>(),
                Arg.Any<IEnumerable<Guid>>(),
                Arg.Any<DateTimeOffset>(),
                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(commit.Id, dtoIds, Arg.Any<DateTimeOffset>(), CancellationToken.None);
    }

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

        changeLogCommitRepository.Add(Arg.Any<CreateChangeLogCommitRequest>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .ClearAndAddRange(
                Arg.Any<Guid>(),
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

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

        //assert
        await changeLogCommitRepository.Received(1).Add(commitRequest, CancellationToken.None);
        await changeLogRepository.Received(2).ClearAndAddRange(discriminatorId, 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<ChangeLogValuesDto>()
        {
            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;

        changeLogRepository
           .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 changeLogRepository.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 };

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

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

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

    }


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

                Id = Uuid7.Guid(),
                Value = 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(),
            });
        }
        return items;
    }
}