PIbd-23_Kadyshev_M.I_TwoFromTheCasket/TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/SalaryBusinessLogicContractTests.cs

using System;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using TwoFromTheCasketBuisnessLogic.Implementations;
using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
using TwoFromTheCasketContratcs.DataModels;
using TwoFromTheCasketContratcs.Enums;
using TwoFromTheCasketContratcs.Exceptions;
using TwoFromTheCasketContratcs.StorageContracts;

namespace TwoFromTheCasketTest.BuisnessLogicContractTests;

[TestFixture]
[TestFixture]
internal class SalaryBusinessLogicContractTests
{
   
    private SalaryBusinessLogicContract _salaryBusinessLogicContract;
    private Mock<ISalaryStorageContract> _salaryStorageContract;
    private Mock<IOrderStorageContract> _orderStorageContract;
    private Mock<IPostStorageContract> _postStorageContract;
    private Mock<IMasterStorageContract> _masterStorageContract;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        _salaryStorageContract = new Mock<ISalaryStorageContract>();
        _orderStorageContract = new Mock<IOrderStorageContract>();
        _postStorageContract = new Mock<IPostStorageContract>();
        _masterStorageContract = new Mock<IMasterStorageContract>();
        _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object,
            _postStorageContract.Object, _masterStorageContract.Object,
            new Mock<ILogger>().Object, _orderStorageContract.Object);
    }

    [SetUp]
    public void SetUp()
    {
        _salaryStorageContract.Reset();
        _orderStorageContract.Reset();
        _postStorageContract.Reset();
        _masterStorageContract.Reset();
    }

    [Test]
    public void GetAllSalaries_ReturnListOfRecords_Test()
    {
        //Arrange
        var startDate = DateTime.UtcNow;
        var endDate = DateTime.UtcNow.AddDays(1);
        var listOriginal = new List<SalaryDataModel>()
        {
            new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10, 10),
            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14, 10),
            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30, 10),
        };
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Returns(listOriginal);
        //Act
        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(startDate, endDate);
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.EquivalentTo(listOriginal));
        _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, null), Times.Once);
    }

    [Test]
    public void GetAllSalaries_ReturnEmptyList_Test()
    {
        //Arrange
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Returns([]);
        //Act
        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void GetAllSalaries_IncorrectDates_ThrowException_Test()
    {
        //Arrange
        var dateTime = DateTime.UtcNow;
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime),
            Throws.TypeOf<IncorrectDatesException>());
        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime.AddSeconds(-1)),
            Throws.TypeOf<IncorrectDatesException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Never);
    }

    [Test]
    public void GetAllSalaries_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)),
            Throws.TypeOf<NullListException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void GetAllSalaries_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)),
            Throws.TypeOf<StorageException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void GetAllSalariesByMaster_ReturnListOfRecords_Test()
    {
        //Arrange
        var startDate = DateTime.UtcNow;
        var endDate = DateTime.UtcNow.AddDays(1);
        var masterId = Guid.NewGuid().ToString();
        var listOriginal = new List<SalaryDataModel>()
        {
            new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10, 10),
            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14, 10),
            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30, 10),
        };
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Returns(listOriginal);
        //Act
        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(startDate, endDate, masterId);
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.EquivalentTo(listOriginal));
        _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, masterId), Times.Once);
    }

    [Test]
    public void GetAllSalariesByMaster_ReturnEmptyList_Test()
    {
        //Arrange
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Returns([]);
        //Act
        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
            DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString());
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void GetAllSalariesByMaster_IncorrectDates_ThrowException_Test()
    {
        //Arrange
        var dateTime = DateTime.UtcNow;
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(dateTime, dateTime,
                Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(dateTime, dateTime.AddSeconds(-1),
                Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Never);
    }

    [Test]
    public void GetAllSalariesByMaster_MasterIdIsNUllOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
                DateTime.UtcNow.AddDays(1), null), Throws.TypeOf<ArgumentNullException>());
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
                DateTime.UtcNow.AddDays(1), string.Empty), Throws.TypeOf<ArgumentNullException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Never);
    }

    [Test]
    public void GetAllSalariesByMaster_MasterIdIsNotGuid_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
                DateTime.UtcNow.AddDays(1), "masterId"), Throws.TypeOf<ValidationException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Never);
    }

    [Test]
    public void GetAllSalariesByMaster_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
                DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void GetAllSalariesByMaster_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
            .Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(
            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
                DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
            Times.Once);
    }

    [Test]
    public void CalculateSalaryByMounth_CalculateSalary_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        var orderSum = 200.0;
        var postSalary = 2000.0;
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, postSalary, true,default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        var sum = 0.0;
        var expectedSum = postSalary + 500;
        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
            .Callback((SalaryDataModel x) => { sum = x.Salary; });
        //Act
        _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
        //Assert
        Assert.That(sum, Is.EqualTo(expectedSum));
    }

    [Test]
    public void CalculateSalaryByMounth_WithSeveralMasters_Test()
    {
        //Arrange
        var master1Id = Guid.NewGuid().ToString();
        var master2Id = Guid.NewGuid().ToString();
        var master3Id = Guid.NewGuid().ToString();
        var list = new List<MasterDataModel>()
        {
            new MasterDataModel(master1Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                false),
            new MasterDataModel(master2Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                false),
            new MasterDataModel(master3Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                false)
        };
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000, true, default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns(list);
        //Act
        _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
        //Assert
        _salaryStorageContract.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Exactly(list.Count));
    }

    [Test]
    public void CalculateSalaryByMounth_WithoitOrdersByMaster_Test()
    {
        //Arrange
        var postSalary = 2000.0;
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, postSalary, true, default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        var sum = 0.0;
        var expectedSum = postSalary + 500;
        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
            .Callback((SalaryDataModel x) => { sum = x.Salary; });
        //Act
        _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
        //Assert
        Assert.That(sum, Is.EqualTo(expectedSum));
    }

    [Test]
    public void CalculateSalaryByMounth_OrderStorageReturnNull_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000, true, default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<NullListException>());
    }

    [Test]
    public void CalculateSalaryByMounth_PostStorageReturnNull_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<NullListException>());
    }

    [Test]
    public void CalculateSalaryByMounth_MasterStorageReturnNull_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000, true, default));
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<NullListException>());
    }

    [Test]
    public void CalculateSalaryByMounth_OrderStorageThrowException_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Throws(new StorageException(new InvalidOperationException()));
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000, true, default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<StorageException>());
    }

    [Test]
    public void CalculateSalaryByMounth_PostStorageThrowException_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Throws(new StorageException(new InvalidOperationException()));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Returns([
                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
                    false)
            ]);
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<StorageException>());
    }

    [Test]
    public void CalculateSalaryByMounth_MasterStorageThrowException_ThrowException_Test()
    {
        //Arrange
        var masterId = Guid.NewGuid().ToString();
        _orderStorageContract.Setup(x => x.GetList())
            .Returns([
                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
            ]);
        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000, true, default));
        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
            .Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
            Throws.TypeOf<StorageException>());
    }
}