Check/MagicCarpetProject/MagicCarpetTests/BusinessLogicContractsTests/AgnecyBusinessLogicContractTests.cs

using MagicCarpetBusinessLogic.Implementations;
using MagicCarpetContracts.BusinessLogicContracts;
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 AgnecyBusinessLogicContractTests 
{
    private IAgencyBusinessLogicContract _agencyBusinessLogicContract;
    private Mock<IAgencyStorageContract> _agencyStorageContract;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        _agencyStorageContract = new Mock<IAgencyStorageContract>();
        _agencyBusinessLogicContract = new AgencyBusinessLogicContract(_agencyStorageContract.Object, new Mock<ILogger>().Object);
    }

    [TearDown]
    public void TearDown()
    {
        _agencyStorageContract.Reset();
    }

    public void GetAllSupplies_ReturnListOfRecords_Test()
    {
        // Arrange
        var listOriginal = new List<AgencyDataModel>()
        {
            new(Guid.NewGuid().ToString(), TourType.Beach, 1, []),
            new(Guid.NewGuid().ToString(), TourType.Beach, 1, []),
            new(Guid.NewGuid().ToString(), TourType.Beach, 1, []),
        };
        _agencyStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
        // Act
        var list = _agencyBusinessLogicContract.GetAllTours();
        // Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.EquivalentTo(listOriginal));
    }

    [Test]
    public void GetAllSupplies_ReturnEmptyList_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.GetList()).Returns([]);
        // Act
        var list = _agencyBusinessLogicContract.GetAllTours();
        // Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
        _agencyStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetAllSupplies_ReturnNull_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.GetList()).Returns((List<AgencyDataModel>)null);
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.GetAllTours(), Throws.TypeOf<NullListException>());
        _agencyStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetAllSupplies_StorageThrowError_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.GetAllTours(), Throws.TypeOf<StorageException>());
        _agencyStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetSuppliesByData_GetById_ReturnRecord_Test()
    {
        // Arrange
        var id = Guid.NewGuid().ToString();
        var record = new AgencyDataModel(id, TourType.Beach, 1, []);
        _agencyStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
        // Act
        var element = _agencyBusinessLogicContract.GetTourByData(id);
        // Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.Id, Is.EqualTo(id));
        _agencyStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetToursByData_EmptyData_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.GetTourByData(null), Throws.TypeOf<ArgumentNullException>());
        Assert.That(() => _agencyBusinessLogicContract.GetTourByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
        _agencyStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void GetSuppliesByData_GetById_NotFoundRecord_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new ElementNotFoundException(""));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.GetTourByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
        _agencyStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetSuppliesByData_StorageThrowError_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.GetTourByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
        _agencyStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void InsertSupplies_CorrectRecord_Test()
    {
        // Arrange
        var record = new AgencyDataModel(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
        _agencyStorageContract.Setup(x => x.AddElement(It.IsAny<AgencyDataModel>()));
        // Act
        _agencyBusinessLogicContract.InsertTour(record);
        // Assert
        _agencyStorageContract.Verify(x => x.AddElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void InsertSupplies_RecordWithExistsData_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.AddElement(It.IsAny<AgencyDataModel>())).Throws(new ElementExistsException("Data", "Data"));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.InsertTour(new(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
        _agencyStorageContract.Verify(x => x.AddElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void InsertSupplies_NullRecord_ThrowException_Test()
    {
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.InsertTour(null), Throws.TypeOf<ArgumentNullException>());
        _agencyStorageContract.Verify(x => x.AddElement(It.IsAny<AgencyDataModel>()), Times.Never);
    }

    [Test]
    public void InsertTours_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.InsertTour(new AgencyDataModel("id", TourType.Beach, 1, [])), Throws.TypeOf<ValidationException>());
        _agencyStorageContract.Verify(x => x.AddElement(It.IsAny<AgencyDataModel>()), Times.Never);
    }

    [Test]
    public void InsertSupplies_StorageThrowError_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.AddElement(It.IsAny<AgencyDataModel>())).Throws(new StorageException(new InvalidOperationException()));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.InsertTour(new(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
        _agencyStorageContract.Verify(x => x.AddElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateSupplies_CorrectRecord_Test()
    {
        // Arrange
        var record = new AgencyDataModel(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
        _agencyStorageContract.Setup(x => x.UpdElement(It.IsAny<AgencyDataModel>()));
        // Act
        _agencyBusinessLogicContract.UpdateTour(record);
        // Assert
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateSupplies_RecordWithIncorrectData_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.UpdElement(It.IsAny<AgencyDataModel>())).Throws(new ElementNotFoundException(""));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementNotFoundException>());
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateSupplies_RecordWithExistsData_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.UpdElement(It.IsAny<AgencyDataModel>())).Throws(new ElementExistsException("Data", "Data"));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateSupplies_NullRecord_ThrowException_Test()
    {
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.UpdateTour(null), Throws.TypeOf<ArgumentNullException>());
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Never);
    }

    [Test]
    public void UpdateTours_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.UpdateTour(new AgencyDataModel(Guid.NewGuid().ToString(), TourType.Beach, 1, [])), Throws.TypeOf<ValidationException>());
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Never);
    }

    [Test]
    public void UpdateSupplies_StorageThrowError_ThrowException_Test()
    {
        // Arrange
        _agencyStorageContract.Setup(x => x.UpdElement(It.IsAny<AgencyDataModel>())).Throws(new StorageException(new InvalidOperationException()));
        // Act & Assert
        Assert.That(() => _agencyBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), TourType.Beach, 1,
            [new TourAgencyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
        _agencyStorageContract.Verify(x => x.UpdElement(It.IsAny<AgencyDataModel>()), Times.Once);
    }

    [Test]
    public void DeleteTours_CorrectRecord_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        var flag = false;
        _agencyStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
        //Act
        _agencyBusinessLogicContract.DeleteTour(id);
        //Assert
        _agencyStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once); Assert.That(flag);
    }

    [Test]
    public void DeleteTours_RecordWithIncorrectId_ThrowException_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        _agencyStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.DeleteTour(Guid.NewGuid().ToString()),
        Throws.TypeOf<ElementNotFoundException>());
        _agencyStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void DeleteTours_IdIsNullOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.DeleteTour(null), Throws.TypeOf<ArgumentNullException>());
        Assert.That(() => _agencyBusinessLogicContract.DeleteTour(string.Empty), Throws.TypeOf<ArgumentNullException>());
        _agencyStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void DeleteTours_IdIsNotGuid_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.DeleteTour("id"),
        Throws.TypeOf<ValidationException>());
        _agencyStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void DeleteTours_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _agencyStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _agencyBusinessLogicContract.DeleteTour(Guid.NewGuid().ToString()),
        Throws.TypeOf<StorageException>());
        _agencyStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
    }
}