Красная зона на тестах по заготовкам

PapaCarloProject/PapaCarloBusinessLogic/Implementations/BlankBusinessLogicContract.cs

@@ -1,5 +1,6 @@
 using PapaCarloContracts.BusinessLogicContracts;
 using PapaCarloContracts.DataModels;
+using PapaCarloContracts.StoragesContracts;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -8,8 +9,9 @@ using System.Threading.Tasks;
 
 namespace PapaCarloBusinessLogic.Implementations
 {
-    internal class BlankBusinessLogicContract : IBlankBusinessLogicContract
+    internal class BlankBusinessLogicContract(IBlankStorageContract storageContract) : IBlankBusinessLogicContract
     {
+        private IBlankStorageContract _storageContract = storageContract;
         public void DeleteBlank(string id)
         {
         }

PapaCarloProject/PapaCarloBusinessLogic/PapaCarloBusinessLogic.csproj

@@ -5,6 +5,11 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+    
+<ItemGroup>
+    <InternalsVisibleTo Include="PapaCarloTests" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+</ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\PapaCarloContracts\PapaCarloContracts.csproj" />

PapaCarloProject/PapaCarloContracts/Exceptions/ElementExistsException.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PapaCarloContracts.Exceptions;
+
+public class ElementExistsException : Exception
+{
+    public string ParamName { get; private set; }
+
+    public string ParamValue { get; private set; }
+
+    public ElementExistsException(string paramName, string paramValue) : base($"There is already an element with value{paramValue} of parameter {paramName}")
+    {
+        ParamName = paramName;
+        ParamValue = paramValue;
+    }
+}

PapaCarloProject/PapaCarloContracts/Exceptions/ElementNotFoundException.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PapaCarloContracts.Exceptions;
+
+public class ElementNotFoundException : Exception
+{
+    public string Value { get; private set; }
+
+    public ElementNotFoundException(string value) : base($"Element not found at value = {value}")
+    {
+        Value = value;
+    }
+}

PapaCarloProject/PapaCarloContracts/Exceptions/NullListException.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PapaCarloContracts.Exceptions;
+
+public class NullListException : Exception
+{
+    public NullListException() : base("The returned list is null") { }
+}

PapaCarloProject/PapaCarloContracts/Exceptions/StorageException.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PapaCarloContracts.Exceptions;
+
+public class StorageException : Exception
+{
+    public StorageException(Exception ex) : base($"Error while working in storage: {ex.Message}", ex) { }
+}

PapaCarloProject/PapaCarloContracts/StoragesContracts/IBlankStorageContract.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PapaCarloContracts.StoragesContracts;
 
-public interface IManufacturerStorageContract
+public interface IBlankStorageContract
 {
     List<BlankDataModel> GetList();
     BlankDataModel? GetElementById(string id);

PapaCarloProject/PapaCarloTests/BusinessLogicsContracts/BlankBusinessLogicContractTests.cs

@@ -0,0 +1,284 @@
+using Moq;
+using NUnit.Framework;
+using PapaCarloBusinessLogic.Implementations;
+using PapaCarloContracts.BusinessLogicContracts;
+using PapaCarloContracts.DataModels;
+using PapaCarloContracts.Exceptions;
+using PapaCarloContracts.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PapaCarloTests.BusinessLogicsContracts;
+
+[TestFixture]
+internal class BlankBusinessLogicContractTests
+{
+    private IBlankBusinessLogicContract _blankBusinessLogicContract;
+    private Mock<IBlankStorageContract> _blankStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _blankStorageContract = new Mock<IBlankStorageContract>();
+        _blankBusinessLogicContract = new BlankBusinessLogicContract(_blankStorageContract.Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _blankStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllBlanks_ReturnListOfRecords_Test()
+    {
+        var listOriginal = new List<BlankDataModel>()
+        {
+            new(Guid.NewGuid().ToString(),"Mahogany","",""),
+             new(Guid.NewGuid().ToString(),"Birch","",""),
+              new(Guid.NewGuid().ToString(),"Spruce","","")
+        };
+
+        _blankStorageContract.Setup(x=> x.GetList()).Returns(listOriginal);
+
+        var list = _blankBusinessLogicContract.GetAllBlanks();
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+    }
+
+    [Test]
+    public void GetAllBlanks_ReturnEmptyList_Test()
+    {
+        
+
+        _blankStorageContract.Setup(x => x.GetList()).Returns([]);
+
+        var list = _blankBusinessLogicContract.GetAllBlanks();
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _blankStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllBlanks_ReturnNull_ThrowException_Test()
+    { 
+        Assert.That(() => _blankBusinessLogicContract.GetAllBlanks(), Throws.TypeOf<NullListException>());
+        _blankStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllBlanks_StorageThrowError_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+
+        Assert.That(() => _blankBusinessLogicContract.GetAllBlanks(), Throws.TypeOf<StorageException>());
+        _blankStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetBlankByData_GetById_ReturnRecord_Test()
+    {
+        var id = Guid.NewGuid().ToString();
+        var record = new BlankDataModel(id, "Spruce", "", "");
+        _blankStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+
+        var element = _blankBusinessLogicContract.GetBlankByData(id);
+
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _blankStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBlankByData_GetByName_ReturnRecord_Test()
+    {
+        var name = "Spruce";
+        var record = new BlankDataModel(Guid.NewGuid().ToString(), name, "", "");
+        _blankStorageContract.Setup(x => x.GetElementByName(name)).Returns(record);
+
+        var element = _blankBusinessLogicContract.GetBlankByData(name);
+
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.BlankName, Is.EqualTo(name));
+        _blankStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    public void GetBlankByData_GetByOldName_ReturnRecord_Test()
+    {
+        var oldName = "Spruce";
+        var record = new BlankDataModel(Guid.NewGuid().ToString(), "Birch", oldName, "");
+        _blankStorageContract.Setup(x => x.GetElementByOldName(oldName)).Returns(record);
+
+        var element = _blankBusinessLogicContract.GetBlankByData(oldName);
+
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.PrevBlankName, Is.EqualTo(oldName));
+        _blankStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBlankByData_EmptyData_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData(String.Empty), Throws.TypeOf<ArgumentNullException>());
+
+        _blankStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _blankStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+        _blankStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetBlankByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _blankStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _blankStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+        _blankStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetBlankByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData("Name"), Throws.TypeOf<ElementNotFoundException>());
+        _blankStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _blankStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+        _blankStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+    }
+    [Test]
+    public void GetBlankByData_StorageThrowError_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _blankStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _blankBusinessLogicContract.GetBlankByData("Name"), Throws.TypeOf<StorageException>());
+
+        _blankStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _blankStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertBlank_CorrectRecord_Test()
+    {
+        var flag = false;
+        var record = new BlankDataModel(Guid.NewGuid().ToString(), "Spruce", "", "");
+        _blankStorageContract.Setup(x => x.AddElement(It.IsAny<BlankDataModel>()))
+            .Callback((BlankDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.BlankName == record.BlankName;
+            });
+        _blankBusinessLogicContract.InsertBlank(record);
+
+        _blankStorageContract.Verify(x => x.AddElement(It.IsAny<BlankDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertBlank_RecordWithExistData_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.AddElement(It.IsAny<BlankDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+
+        Assert.That(() => _blankBusinessLogicContract.InsertBlank(new(Guid.NewGuid().ToString(), "Spruce", "", "")), Throws.TypeOf<ElementExistsException>());
+        _blankStorageContract.Verify(x => x.AddElement(It.IsAny<BlankDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertBlank_NullRecord_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.InsertBlank(null), Throws.TypeOf<ArgumentNullException>());
+        _blankStorageContract.Verify(x => x.AddElement(It.IsAny<BlankDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertBlank_InvalidRecord_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.InsertBlank(new BlankDataModel("id", "name", "", "")), Throws.TypeOf<ValidationException>());
+        _blankStorageContract.Verify(x => x.AddElement(It.IsAny<BlankDataModel>()), Times.Never);
+    }
+    [Test]
+    public void InsertBlank_StorageThrowError_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.AddElement(It.IsAny<BlankDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+
+        Assert.That(() => _blankBusinessLogicContract.InsertBlank(new(Guid.NewGuid().ToString(), "Spruce", "", "")), Throws.TypeOf<StorageException>());
+        _blankStorageContract.Verify(x => x.AddElement(It.IsAny<BlankDataModel>()), Times.Once);
+    }
+    [Test]
+    public void UpdateBlank_RecordWithIncorrectData_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.UpdElement(It.IsAny<BlankDataModel>())).Throws(new ElementNotFoundException(""));
+
+        Assert.That(() => _blankBusinessLogicContract.UpdateBlank(new(Guid.NewGuid().ToString(), "Spruce", "", "")), Throws.TypeOf<ElementNotFoundException>());
+        _blankStorageContract.Verify(x => x.UpdElement(It.IsAny<BlankDataModel>()), Times.Once);
+    }
+    [Test]
+    public void UpdateBlank_RecordWithExistData_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.UpdElement(It.IsAny<BlankDataModel>())).Throws(new ElementExistsException("Data","Data"));
+
+        Assert.That(() => _blankBusinessLogicContract.UpdateBlank(new(Guid.NewGuid().ToString(), "Spruce", "", "")), Throws.TypeOf<ElementNotFoundException>());
+        _blankStorageContract.Verify(x => x.UpdElement(It.IsAny<BlankDataModel>()), Times.Once);
+    }
+    [Test]
+    public void UpdateBlank_NullRecord_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.UpdateBlank(null), Throws.TypeOf<ArgumentNullException>());
+        _blankStorageContract.Verify(x => x.UpdElement(It.IsAny<BlankDataModel>()), Times.Never);
+    }
+    [Test]
+    public void UpdateBlank_InvalidRecord_ThrowException_Test()
+    {
+
+        Assert.That(() => _blankBusinessLogicContract.UpdateBlank(new("id", "Spruce", "", "")), Throws.TypeOf<ValidationException>());
+        _blankStorageContract.Verify(x => x.UpdElement(It.IsAny<BlankDataModel>()), Times.Never);
+    }
+    [Test]
+    public void DeleteBlank_CorrectRecord_Test()
+    {
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _blankStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+
+        _blankBusinessLogicContract.DeleteBlank(id);
+
+        _blankStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+    [Test]
+    public void DeleteBlank_RecordWithIncorrectId_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(""));
+
+        Assert.That(() => _blankBusinessLogicContract.DeleteBlank(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _blankStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void DeleteBlank_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.DeleteBlank(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _blankBusinessLogicContract.DeleteBlank(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _blankStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+    [Test]
+    public void DeleteBlank_IdIsNotGuid_ThrowException_Test()
+    {
+        Assert.That(() => _blankBusinessLogicContract.DeleteBlank("id"), Throws.TypeOf<ValidationException>());
+        _blankStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+    [Test]
+    public void DeleteBlank_StorageThrowError_ThrowException_Test()
+    {
+        _blankStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+
+        Assert.That(() => _blankBusinessLogicContract.DeleteBlank(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _blankStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+
+
+}

PapaCarloProject/PapaCarloTests/PapaCarloTests.csproj

@@ -11,12 +11,14 @@
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="NUnit" Version="4.2.2" />
     <PackageReference Include="NUnit.Analyzers" Version="4.3.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\PapaCarloBusinessLogic\PapaCarloBusinessLogic.csproj" />
     <ProjectReference Include="..\PapaCarloContracts\PapaCarloContracts.csproj" />
   </ItemGroup>