добавление первого теста для бизнес логики

MagicCarpetProject/MagicCarpetContracts/StoragesContracts/IPostStorageContract.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MagicCarpetContracts.StoragesContracts;
 
-public interface IPostStorafeContract
+public interface IPostStorageContract
 {
     List<PostDataModel> GetList(bool onlyActual = true);
     List<PostDataModel> GetPostWithHistory(string postId);

MagicCarpetProject/MagicCarpetTests/BusinessLogicContractsTests/TourBusinessLogicContractTests.cs

@@ -0,0 +1,391 @@
+using MagicCarpetBusinessLogic.Implementations;
+using MagicCarpetContracts.DataModels;
+using MagicCarpetContracts.Enums;
+using MagicCarpetContracts.Exceptions;
+using MagicCarpetContracts.StoragesContracts;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MagicCarpetTests.BusinessLogicContractsTests;
+
+[TestFixture]
+internal class TourBusinessLogicContractTests
+{
+    private TourBusinessLogicContract _tourBusinessLogicContract;
+    private Mock<ITourStorageContract> _tourStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _tourStorageContract = new Mock<ITourStorageContract>();
+        _tourBusinessLogicContract = new TourBusinessLogicContract(_tourStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _tourStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllTours_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<TourDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "name 1", 15.5, TourType.Ski),
+            new(Guid.NewGuid().ToString(), "name 2", 15.5, TourType.Ski),
+            new(Guid.NewGuid().ToString(), "name 3", 15.5, TourType.Ski),
+        };
+        _tourStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+        //Act
+        var list = _tourBusinessLogicContract.GetAllTours();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+    }
+
+    [Test]
+    public void GetAllTours_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.GetList()).Returns([]);
+        //Act
+        var list = _tourBusinessLogicContract.GetAllTours();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _tourStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllTours_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetAllTours(), Throws.TypeOf<NullListException>());
+        _tourStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllTours_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetAllTours(), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var tourId = Guid.NewGuid().ToString();
+        var listOriginal = new List<TourHistoryDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), 10),
+            new(Guid.NewGuid().ToString(), 15),
+            new(Guid.NewGuid().ToString(), 10),
+        };
+        _tourStorageContract.Setup(x => x.GetHistoryByTourId(It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _tourBusinessLogicContract.GetTourHistoryByTour(tourId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(tourId), Times.Once);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.GetHistoryByTourId(It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _tourBusinessLogicContract.GetTourHistoryByTour(Guid.NewGuid().ToString());
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_TourIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourHistoryByTour(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _tourBusinessLogicContract.GetTourHistoryByTour(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_TourIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourHistoryByTour("tourId"), Throws.TypeOf<ValidationException>());
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourHistoryByTour(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourHistoryByTour_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.GetHistoryByTourId(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourHistoryByTour(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.GetHistoryByTourId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new TourDataModel(id, "name", 10, TourType.Ski);
+        _tourStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _tourBusinessLogicContract.GetTourByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _tourStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourByData_GetByName_ReturnRecord_Test()
+    {
+        //Arrange
+        var name = "name";
+        var record = new TourDataModel(Guid.NewGuid().ToString(), name, 10, TourType.Ski);
+        _tourStorageContract.Setup(x => x.GetElementByName(name)).Returns(record);
+        //Act
+        var element = _tourBusinessLogicContract.GetTourByData(name);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.TourName, Is.EqualTo(name));
+        _tourStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _tourStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+        _tourStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetTourByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _tourStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData("name"), Throws.TypeOf<ElementNotFoundException>());
+        _tourStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetTourByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _tourStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _tourBusinessLogicContract.GetTourByData("name"), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _tourStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertTour_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new TourDataModel(Guid.NewGuid().ToString(), "name", 10, TourType.Ski);
+        _tourStorageContract.Setup(x => x.AddElement(It.IsAny<TourDataModel>()))
+            .Callback((TourDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.TourName == record.TourName &&
+                    x.Price == record.Price && x.BaseTour == record.BaseTour;
+            });
+        //Act
+        _tourBusinessLogicContract.InsertTour(record);
+        //Assert
+        _tourStorageContract.Verify(x => x.AddElement(It.IsAny<TourDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertTour_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.AddElement(It.IsAny<TourDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.InsertTour(new(Guid.NewGuid().ToString(), "name", 10, TourType.Ski)), Throws.TypeOf<ElementExistsException>());
+        _tourStorageContract.Verify(x => x.AddElement(It.IsAny<TourDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertTour_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.InsertTour(null), Throws.TypeOf<ArgumentNullException>());
+        _tourStorageContract.Verify(x => x.AddElement(It.IsAny<TourDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertTour_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.InsertTour(new TourDataModel("id", "name", 10, TourType.Ski)), Throws.TypeOf<ValidationException>());
+        _tourStorageContract.Verify(x => x.AddElement(It.IsAny<TourDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertTour_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.AddElement(It.IsAny<TourDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.InsertTour(new(Guid.NewGuid().ToString(), "name", 10, TourType.Ski)), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.AddElement(It.IsAny<TourDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateTour_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new TourDataModel(Guid.NewGuid().ToString(), "name", 10, TourType.Ski);
+        _tourStorageContract.Setup(x => x.UpdElement(It.IsAny<TourDataModel>()))
+            .Callback((TourDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.TourName == record.TourName &&
+                    x.Price == record.Price && x.BaseTour == record.BaseTour;
+            });
+        //Act
+        _tourBusinessLogicContract.UpdateTour(record);
+        //Assert
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateTour_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.UpdElement(It.IsAny<TourDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), "name", 10, TourType.Ski)), Throws.TypeOf<ElementNotFoundException>());
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateTour_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.UpdElement(It.IsAny<TourDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), "name", 10, TourType.Ski)), Throws.TypeOf<ElementExistsException>());
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateTour_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.UpdateTour(null), Throws.TypeOf<ArgumentNullException>());
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateTour_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.UpdateTour(new TourDataModel("id", "name", 10, TourType.Ski)), Throws.TypeOf<ValidationException>());
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateTour_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.UpdElement(It.IsAny<TourDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.UpdateTour(new(Guid.NewGuid().ToString(), "name", 10, TourType.Ski)), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.UpdElement(It.IsAny<TourDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteTour_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _tourStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _tourBusinessLogicContract.DeleteTour(id);
+        //Assert
+        _tourStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteTour_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _tourStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.DeleteTour(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _tourStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteTour_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.DeleteTour(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _tourBusinessLogicContract.DeleteTour(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _tourStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteTour_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.DeleteTour("id"), Throws.TypeOf<ValidationException>());
+        _tourStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteTour_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _tourStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _tourBusinessLogicContract.DeleteTour(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _tourStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

MagicCarpetProject/MagicCarpetTests/MagicCarpetTests.csproj

@@ -12,12 +12,14 @@
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="NUnit" Version="3.14.0" />
     <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\MagicCarpetBusinessLogic\MagicCarpetBusinessLogic.csproj" />
     <ProjectReference Include="..\MagicCarpetContracts\MagicCarpetContracts.csproj" />
   </ItemGroup>