Check/MagicCarpetProject/MagicCarpetTests/BusinessLogicContractsTests/ReportContractTests.cs

using MagicCarpetBusinessLogic.Implementations;
using MagicCarpetBusinessLogic.OfficePackage;
using MagicCarpetContracts.DataModels;
using MagicCarpetContracts.Enums;
using MagicCarpetContracts.Exceptions;
using MagicCarpetContracts.StoragesContracts;
using Microsoft.Extensions.Logging;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MagicCarpetTests.BusinessLogicContractsTests;

[TestFixture]
internal class ReportContractTests
{
    private ReportContract _reportContract;
    private Mock<ISaleStorageContract> _saleStorageContract;
    private Mock<ITourStorageContract> _tourStorageContract;
    private Mock<ISalaryStorageContract> _salaryStorageContract;
    private Mock<BaseWordBuilder> _baseWordBuilder;
    private Mock<BaseExcelBuilder> _baseExcelBuilder;
    private Mock<BasePdfBuilder> _basePdfBuilder;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        _saleStorageContract = new Mock<ISaleStorageContract>();
        _tourStorageContract = new Mock<ITourStorageContract>();
        _salaryStorageContract = new Mock<ISalaryStorageContract>();
        _baseWordBuilder = new Mock<BaseWordBuilder>();
        _baseExcelBuilder = new Mock<BaseExcelBuilder>();
        _basePdfBuilder = new Mock<BasePdfBuilder>();
        _reportContract = new ReportContract(_tourStorageContract.Object, _salaryStorageContract.Object, _saleStorageContract.Object,
            _baseWordBuilder.Object, _baseExcelBuilder.Object, _basePdfBuilder.Object, new Mock<ILogger>().Object);
    }
    [SetUp]
    public void SetUp()
    {
        _saleStorageContract.Reset();
        _salaryStorageContract.Reset();
        _tourStorageContract.Reset();
    }

    [Test]
    public async Task GetDataHistoriesByTour_ShouldSuccess_Test()
    {
        //Arrange
        var TourId1 = Guid.NewGuid().ToString();
        var TourId2 = Guid.NewGuid().ToString();

        var Tour1 = new TourDataModel(TourId1, "name1","test1", 10.5, TourType.Beach);
        var Tour2 = new TourDataModel(TourId1, "name2", "test1", 10.5, TourType.Beach);

        _tourStorageContract.Setup(x => x.GetHistoriesListAsync(It.IsAny<CancellationToken>()))
            .Returns(Task.FromResult(new List<TourHistoryDataModel>()
            {
            new(TourId1, 22, DateTime.UtcNow, Tour1),
            new(TourId2, 21, DateTime.UtcNow, Tour2),
            new(TourId1, 33, DateTime.UtcNow, Tour1),
            new(TourId1, 32, DateTime.UtcNow, Tour1),
            new(TourId2, 65, DateTime.UtcNow, Tour2)
            }));

        //Act
        var data = await _reportContract.GetDataToursHistoryAsync(CancellationToken.None);

        //Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(2));
        Assert.Multiple(() =>
        {
            Assert.That(data.First(x => x.TourName == Tour1.TourName).Histories, Has.Count.EqualTo(3));
            Assert.That(data.First(x => x.TourName == Tour2.TourName).Histories, Has.Count.EqualTo(2));
        });
        _tourStorageContract.Verify(x => x.GetHistoriesListAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public async Task GetDataHistoriesByTour_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        _tourStorageContract.Setup(x =>
            x.GetHistoriesListAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TourHistoryDataModel>());

        //Act
        var data = await _reportContract.GetDataToursHistoryAsync(CancellationToken.None);

        //Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
        _tourStorageContract.Verify(x =>
            x.GetHistoriesListAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public void GetDataHistoriesByTour_WhenStorageThrowError_ShouldFail_Test()
    {
        //Arrange
        _tourStorageContract.Setup(x =>
            x.GetHistoriesListAsync(It.IsAny<CancellationToken>()))
            .ThrowsAsync(new StorageException(new InvalidOperationException()));

        //Act & Assert
        Assert.That(async () => await
            _reportContract.GetDataToursHistoryAsync(CancellationToken.None),
            Throws.TypeOf<StorageException>());

        _tourStorageContract.Verify(x =>
            x.GetHistoriesListAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public async Task CreateDocumentHistoriesByTour_ShouldSuccess_Test()
    {
        // Arrange
        var TourId1 = Guid.NewGuid().ToString();
        var TourId2 = Guid.NewGuid().ToString();

        var Tour1 = new TourDataModel(TourId1, "name1","test1", 10.5, TourType.Beach);
        var Tour2 = new TourDataModel(TourId1, "name2","test1", 10.5, TourType.Beach);

        var histories = new List<TourHistoryDataModel>()
    {
        new(TourId1, 22, DateTime.UtcNow, Tour1),
        new(TourId1, 33, DateTime.UtcNow, Tour1),
        new(TourId1, 32, DateTime.UtcNow, Tour1),
        new(TourId2, 21, DateTime.UtcNow, Tour2),
        new(TourId2, 65, DateTime.UtcNow, Tour2)
    };

        _tourStorageContract.Setup(x => x.GetHistoriesListAsync(It.IsAny<CancellationToken>()))
            .Returns(Task.FromResult(histories));

        _baseWordBuilder.Setup(x => x.AddHeader(It.IsAny<string>())).Returns(_baseWordBuilder.Object);
        _baseWordBuilder.Setup(x => x.AddParagraph(It.IsAny<string>())).Returns(_baseWordBuilder.Object);

        var countRows = 0;
        string[] firstRow = [];
        string[] secondRow = [];

        _baseWordBuilder.Setup(x => x.AddTable(It.IsAny<int[]>(),
            It.IsAny<List<string[]>>()))
            .Callback((int[] widths, List<string[]> data) =>
            {
                countRows = data.Count;
                if (data.Count > 0) firstRow = data[0];
                if (data.Count > 1) secondRow = data[1];
            })
            .Returns(_baseWordBuilder.Object);

        // Act
        var data = await _reportContract.CreateDocumentToursHistoryAsync(CancellationToken.None);

        // Assert
        _tourStorageContract.Verify(x => x.GetHistoriesListAsync(It.IsAny<CancellationToken>()), Times.Once);
        _baseWordBuilder.Verify(x => x.AddHeader(It.IsAny<string>()), Times.Once);
        _baseWordBuilder.Verify(x => x.AddParagraph(It.IsAny<string>()), Times.Once);
        _baseWordBuilder.Verify(x => x.AddTable(It.IsAny<int[]>(), It.IsAny<List<string[]>>()), Times.Once);
        _baseWordBuilder.Verify(x => x.Build(), Times.Once);

        Assert.Multiple(() =>
        {
            // 1 заголовок + 2 тура (name1 и name2) + 5 записей истории
            Assert.That(countRows, Is.EqualTo(8));

            Assert.That(firstRow, Has.Length.EqualTo(3));
            Assert.That(secondRow, Has.Length.EqualTo(3));

            Assert.That(firstRow[0], Is.EqualTo("Название тура"));
            Assert.That(firstRow[1], Is.EqualTo("Старая цена"));

            Assert.That(secondRow[0], Is.EqualTo("name1"));
            Assert.That(secondRow[1], Is.EqualTo(""));
        });
    }

    [Test]
    public async Task GetDataBySalesByPeriod_ShouldSuccess_Test()
    {
        //Arrange
        _saleStorageContract.Setup(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(new
            List<SaleDataModel>()
        {
            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DiscountType.None, false, [new SaleTourDataModel("",
            Guid.NewGuid().ToString(), 10, 10)]),
            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DiscountType.None, false, [new SaleTourDataModel("",
            Guid.NewGuid().ToString(), 10, 10)]),
        }));

        //Act
        var data = await _reportContract.GetDataBySalesAsync(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, CancellationToken.None);

        //Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(2));
        _saleStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public async Task GetDataBySalesByPeriod_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        _saleStorageContract.Setup(x => x.GetListAsync(It.IsAny<DateTime>(),
        It.IsAny<DateTime>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(new List<SaleDataModel>()));
        //Act
        var data = await
        _reportContract.GetDataBySalesAsync(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, CancellationToken.None);
        //Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
        _saleStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public void GetDataBySalesByPeriod_WhenIncorrectDates_ShouldFail_Test()
    {
        //Arrange
        var date = DateTime.UtcNow;
        //Act&Assert
        Assert.That(async () => await
        _reportContract.GetDataBySalesAsync(date, date, CancellationToken.None),
        Throws.TypeOf<IncorrectDatesException>());
        Assert.That(async () => await
        _reportContract.GetDataBySalesAsync(date, DateTime.UtcNow.AddDays(-1),
        CancellationToken.None), Throws.TypeOf<IncorrectDatesException>());
    }

    [Test]
    public void GetDataBySalesByPeriod_WhenStorageThrowError_ShouldFail_Test()
    {
        //Arrange
        _saleStorageContract.Setup(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
            .Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(async () => await _reportContract.GetDataBySalesAsync(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, CancellationToken.None),
            Throws.TypeOf<StorageException>());
        _saleStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(),
        It.IsAny<DateTime>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public async Task CreateDocumentSalesByPeriod_ShouldeSuccess_Test()
    {
        var Tour1 = new TourDataModel(Guid.NewGuid().ToString(), "name 1","test1", 10.5, TourType.Beach);
        var Tour2 = new TourDataModel(Guid.NewGuid().ToString(), "name 2","test1", 10.5, TourType.Beach);
        _saleStorageContract.Setup(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(new List<SaleDataModel>()
        {
            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, DiscountType.RegularCustomer, false, [new SaleTourDataModel("", Tour1.Id, 10, 10, Tour1), new SaleTourDataModel("", Tour2.Id, 10, 10, Tour2)]),
            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, DiscountType.RegularCustomer, false, [new SaleTourDataModel("", Tour2.Id, 10, 10, Tour2)])
        }));
        _baseExcelBuilder.Setup(x => x.AddHeader(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>())).Returns(_baseExcelBuilder.Object);
        _baseExcelBuilder.Setup(x => x.AddParagraph(It.IsAny<string>(), It.IsAny<int>())).Returns(_baseExcelBuilder.Object);
        var countRows = 0;
        string[] firstRow = [];
        string[] secondRow = [];
        string[] thirdRow = [];
        _baseExcelBuilder.Setup(x => x.AddTable(It.IsAny<int[]>(), It.IsAny<List<string[]>>()))
            .Callback((int[] widths, List<string[]> data) =>
            {
                countRows = data.Count;
                firstRow = data[0];
                secondRow = data[1];
                thirdRow = data[2];
            })
            .Returns(_baseExcelBuilder.Object);
        //Act
        var data = await _reportContract.CreateDocumentSalesByPeriodAsync(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, CancellationToken.None);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(countRows, Is.EqualTo(7));
            Assert.That(firstRow, Is.Not.EqualTo(default));
            Assert.That(secondRow, Is.Not.EqualTo(default));
        });
        Assert.Multiple(() =>
        {
            Assert.That(firstRow[0], Is.EqualTo("Сотрудник"));
            Assert.That(firstRow[1], Is.EqualTo("Дата"));
            Assert.That(firstRow[2], Is.EqualTo("Сумма"));
            Assert.That(firstRow[3], Is.EqualTo("Скидка"));
            Assert.That(firstRow[4], Is.EqualTo("Товар"));
            Assert.That(firstRow[5], Is.EqualTo("Кол-во"));
        });
        Assert.Multiple(() =>
        {
            Assert.That(secondRow[0], Is.Empty);
            Assert.That(secondRow[1], Is.Not.Empty);
            Assert.That(secondRow[2], Is.EqualTo(200.ToString("N2")));
            Assert.That(secondRow[3], Is.EqualTo(100.ToString("N2")));
            Assert.That(secondRow[4], Is.Empty);
            Assert.That(secondRow[5], Is.Empty);
        });
        Assert.Multiple(() =>
        {
            Assert.That(thirdRow[0], Is.Empty);
            Assert.That(thirdRow[1], Is.Empty);
            Assert.That(thirdRow[2], Is.Empty);
            Assert.That(thirdRow[3], Is.Empty);
            Assert.That(thirdRow[4], Is.EqualTo(Tour1.TourName));
            Assert.That(thirdRow[5], Is.EqualTo(10.ToString("N2")));
        });
        _saleStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()), Times.Once);
        _baseExcelBuilder.Verify(x => x.AddHeader(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once);
        _baseExcelBuilder.Verify(x => x.AddParagraph(It.IsAny<string>(), It.IsAny<int>()), Times.Once);
        _baseExcelBuilder.Verify(x => x.AddTable(It.IsAny<int[]>(), It.IsAny<List<string[]>>()), Times.Once);
        _baseExcelBuilder.Verify(x => x.Build(), Times.Once);
    }

    [Test]
    public async Task GetDataSalaryByPeriod_ShouldSuccess_Test()
    {
        // Arrange
        var startDate = DateTime.UtcNow.AddDays(-20);
        var endDate = DateTime.UtcNow.AddDays(5);

        var employee1 = new EmployeeDataModel(
            Guid.NewGuid().ToString(),
            "fio 1",
            "abc@gmail.com",
            Guid.NewGuid().ToString(),
            DateTime.UtcNow.AddYears(-20),
            DateTime.UtcNow.AddDays(-3));

        var employee2 = new EmployeeDataModel(
            Guid.NewGuid().ToString(),
            "fio 2",
            "abc@gmail.com",
            Guid.NewGuid().ToString(),
            DateTime.UtcNow.AddYears(-20),
            DateTime.UtcNow.AddDays(-3));

        _salaryStorageContract.Setup(x =>
            x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<SalaryDataModel>()
            {
                new(employee1.Id, DateTime.UtcNow.AddDays(-10), 100),
                new(employee1.Id, endDate, 1000),
                new(employee1.Id, startDate, 1000),
                new(employee2.Id, DateTime.UtcNow.AddDays(-10), 100),
                new(employee2.Id, DateTime.UtcNow.AddDays(-5), 200)
            });

        // Act
        var data = await _reportContract.GetDataSalaryByPeriodAsync(
            DateTime.UtcNow.AddDays(-1),
            DateTime.UtcNow,
            CancellationToken.None);

        // Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(2));

        var totalSalary = data.First();

        Assert.Multiple(() =>
        {
            Assert.That(totalSalary, Is.Not.Null);
            Assert.That(totalSalary.TotalSalary, Is.EqualTo(2100));
        });

        _salaryStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(),
            It.IsAny<CancellationToken>()), Times.Once);
    }

    [Test]
    public async Task GetDataSalaryByPeriod_WhenNoRecords_ShouldSuccess_Test()
    {
        // Arrange
        _salaryStorageContract.Setup(x =>
            x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<SalaryDataModel>());

        // Act
        var data = await _reportContract.GetDataSalaryByPeriodAsync(
            DateTime.UtcNow.AddDays(-1),
            DateTime.UtcNow,
            CancellationToken.None);

        // Assert
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));

        _salaryStorageContract.Verify(x =>
            x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()),
            Times.Once);
    }

    [Test]
    public void GetDataSalaryByPeriod_WhenIncorrectDates_ShouldFail_Test()
    {
        // Arrange
        var date = DateTime.UtcNow;

        // Act & Assert
        Assert.That(async () => await _reportContract.GetDataSalaryByPeriodAsync(
            date, date, CancellationToken.None),
            Throws.TypeOf<IncorrectDatesException>());

        Assert.That(async () => await _reportContract.GetDataSalaryByPeriodAsync(
            date, DateTime.UtcNow.AddDays(-1), CancellationToken.None),
            Throws.TypeOf<IncorrectDatesException>());
    }

    [Test]
    public void GetDataBySalaryByPeriod_WhenStorageThrowError_ShouldFail_Test()
    {
        // Arrange
        _salaryStorageContract.Setup(x =>
            x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
            .ThrowsAsync(new StorageException(new InvalidOperationException()));

        // Act & Assert
        Assert.That(async () => await _reportContract.GetDataSalaryByPeriodAsync(
            DateTime.UtcNow.AddDays(-1),
            DateTime.UtcNow,
            CancellationToken.None),
            Throws.TypeOf<StorageException>());

        _salaryStorageContract.Verify(x =>
            x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()),
            Times.Once);
    }

    [Test]
    public async Task CreateDocumentSalaryByPeriod_ShouldeSuccess_Test()
    {
        //Arrange
        var startDate = DateTime.UtcNow.AddDays(-20);
        var endDate = DateTime.UtcNow.AddDays(5);
        var employee1 = new EmployeeDataModel(Guid.NewGuid().ToString(), "fio 1", "abc@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-20), DateTime.UtcNow.AddDays(-3));
        var employee2 = new EmployeeDataModel(Guid.NewGuid().ToString(), "fio 2", "abc@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-20), DateTime.UtcNow.AddDays(-3));
        _salaryStorageContract.Setup(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(new List<SalaryDataModel>()
        {
            new(employee1.Id, DateTime.UtcNow.AddDays(-10), 100, employee1),
            new(employee1.Id, endDate, 1000, employee1),
            new(employee1.Id, startDate, 1000, employee1),
            new(employee2.Id, DateTime.UtcNow.AddDays(-10), 100, employee2),
            new(employee2.Id, DateTime.UtcNow.AddDays(-5), 200, employee2)
        }));
        _basePdfBuilder.Setup(x => x.AddHeader(It.IsAny<string>())).Returns(_basePdfBuilder.Object);
        _basePdfBuilder.Setup(x => x.AddParagraph(It.IsAny<string>())).Returns(_basePdfBuilder.Object);
        var countRows = 0;
        (string, double) firstRow = default;
        (string, double) secondRow = default;
        _basePdfBuilder.Setup(x => x.AddPieChart(It.IsAny<string>(), It.IsAny<List<(string, double)>>()))
            .Callback((string header, List<(string, double)> data) =>
            {
                countRows = data.Count;
                firstRow = data[0];
                secondRow = data[1];
            })
            .Returns(_basePdfBuilder.Object);
        //Act
        var data = await _reportContract.CreateDocumentSalaryByPeriodAsync(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow, CancellationToken.None);
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(countRows, Is.EqualTo(2));
            Assert.That(firstRow, Is.Not.EqualTo(default));
            Assert.That(secondRow, Is.Not.EqualTo(default));
        });
        Assert.Multiple(() =>
        {
            Assert.That(firstRow.Item1, Is.EqualTo(employee1.FIO));
            Assert.That(firstRow.Item2, Is.EqualTo(2100));
            Assert.That(secondRow.Item1, Is.EqualTo(employee2.FIO));
            Assert.That(secondRow.Item2, Is.EqualTo(300));
        });
        _salaryStorageContract.Verify(x => x.GetListAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()), Times.Once);
        _basePdfBuilder.Verify(x => x.AddHeader(It.IsAny<string>()), Times.Once);
        _basePdfBuilder.Verify(x => x.AddParagraph(It.IsAny<string>()), Times.Once);
        _basePdfBuilder.Verify(x => x.AddPieChart(It.IsAny<string>(), It.IsAny<List<(string, double)>>()), Times.Once);
        _basePdfBuilder.Verify(x => x.Build(), Times.Once);
    }
}