Тесты

TheSoftBedProject/SoftBedBusinessLogic/Implementations/CollectBusinessLogicContract.cs

@@ -0,0 +1,82 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+using System.Text.Json;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class CollectBusinessLogicContract(ICollectStorageContract collectStorageContract, ILogger logger) : ICollectBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly ICollectStorageContract _collectStorageContract = collectStorageContract;
+    public List<CollectDataModel> GetAllCollectsByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllCollects params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _collectStorageContract.GetList(fromDate, toDate) ?? throw new NullListException();
+    }
+
+    public List<CollectDataModel> GetAllCollectsByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllCollects params: {workerId}, {fromDate}, {toDate}", workerId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (workerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(workerId));
+        }
+        if (!workerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field workerId is not a unique identifier.");
+        }
+        return _collectStorageContract.GetList(fromDate, toDate, workerId: workerId) ?? throw new NullListException();
+    }
+
+    public List<CollectDataModel> GetAllCollectsByFurnitureByPeriod(string furnitureId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllCollects params: {buyerId}, {fromDate}, {toDate}", furnitureId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (furnitureId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(furnitureId));
+        }
+        if (!furnitureId.IsGuid())
+        {
+            throw new ValidationException("The value in the field buyerId is not a unique identifier.");
+        }
+        return _collectStorageContract.GetList(fromDate, toDate, furnitureId: furnitureId) ?? throw new NullListException();
+    }
+
+    public CollectDataModel GetCollectByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (!data.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        return _collectStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertCollect(CollectDataModel collectDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(collectDataModel));
+        ArgumentNullException.ThrowIfNull(collectDataModel);
+        collectDataModel.Validate();
+        _collectStorageContract.AddElement(collectDataModel);
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/Implementations/FurnitureBusinessLogicContract.cs

@@ -0,0 +1,91 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+using System.Text.Json;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class FurnitureBusinessLogicContract(IFurnitureStorageContract furnitureStorageContract, ILogger logger) : IFurnitureBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IFurnitureStorageContract _furnitureStorageContract = furnitureStorageContract;
+
+    public List<FurnitureDataModel> GetAllFurniture(bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllFurniture params: {onlyActive}", onlyActive);
+        return _furnitureStorageContract.GetList(onlyActive) ?? throw new NullListException();
+    }
+    public List<FurnitureDataModel> GetAllFurnitureByWorkPieces(string workPiecesId, bool onlyActive = true) 
+    {
+        _logger.LogInformation("GetAllSales params: {workPiecesId}", workPiecesId);
+        if (workPiecesId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(workPiecesId));
+        }
+        if (!workPiecesId.IsGuid())
+        {
+            throw new ValidationException("The value in the field workPiecesId is not a unique identifier.");
+        }
+        return _furnitureStorageContract.GetList(onlyActive, workPiecesId) ?? throw new NullListException();
+    }
+    public List<FurnitureHistoryDataModel> GetFurnitureHistoryByFurniture(string furnitureId)
+    {
+        _logger.LogInformation("GetFurnitureHistoryByFurniture for {furnitureId}", furnitureId);
+        if (furnitureId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(furnitureId));
+        }
+        if (!furnitureId.IsGuid())
+        {
+            throw new ValidationException("The value in the field furnitureId is not a unique identifier.");
+        }
+        return _furnitureStorageContract.GetHistoryByFurnitureId(furnitureId) ?? throw new NullListException();
+    }
+    
+    public FurnitureDataModel GetFurnitureByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _furnitureStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _furnitureStorageContract.GetElementByName(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertFurniture(FurnitureDataModel furnitureDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(furnitureDataModel));
+        ArgumentNullException.ThrowIfNull(furnitureDataModel);
+        furnitureDataModel.Validate();
+        _furnitureStorageContract.AddElement(furnitureDataModel);
+    }
+
+    public void UpdateFurniture(FurnitureDataModel furnitureDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(furnitureDataModel));
+        ArgumentNullException.ThrowIfNull(furnitureDataModel);
+        furnitureDataModel.Validate();
+        _furnitureStorageContract.UpdElement(furnitureDataModel);
+    }
+    public void DeleteFurniture(string id)
+    {
+        _logger.LogInformation("Delete by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _furnitureStorageContract.DelElement(id);
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/Implementations/PostBusinessLogicContract.cs

@@ -0,0 +1,93 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+using System.Text.Json;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class PostBusinessLogicContract(IPostStorageContract postStorageContract, ILogger logger) : IPostBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IPostStorageContract _postStorageContract = postStorageContract;
+
+    public List<PostDataModel> GetAllPosts(bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllPosts params: {onlyActive}", onlyActive);
+        return _postStorageContract.GetList(onlyActive) ?? throw new NullListException();
+    }
+
+    public List<PostDataModel> GetAllDataOfPost(string postId)
+    {
+        _logger.LogInformation("GetAllDataOfPost for {postId}", postId);
+        if (postId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(postId));
+        }
+        if (!postId.IsGuid())
+        {
+            throw new ValidationException("The value in the field postId is not a unique identifier.");
+        }
+        return _postStorageContract.GetPostWithHistory(postId) ?? throw new NullListException();
+    }
+
+    public PostDataModel GetPostByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _postStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _postStorageContract.GetElementByName(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertPost(PostDataModel postDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(postDataModel));
+        ArgumentNullException.ThrowIfNull(postDataModel);
+        postDataModel.Validate();
+        _postStorageContract.AddElement(postDataModel);
+    }
+
+    public void UpdatePost(PostDataModel postDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(postDataModel));
+        ArgumentNullException.ThrowIfNull(postDataModel);
+        postDataModel.Validate();
+        _postStorageContract.UpdElement(postDataModel);
+    }
+
+    public void DeletePost(string id)
+    {
+        _logger.LogInformation("Delete by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _postStorageContract.DelElement(id);
+    }
+
+    public void RestorePost(string id)
+    {
+        _logger.LogInformation("Restore by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _postStorageContract.ResElement(id);
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/Implementations/SalaryBusinessLogicContract.cs

@@ -0,0 +1,64 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class SalaryBusinessLogicContract(ISalaryStorageContract salaryStorageContract,
+    ICollectStorageContract collectStorageContract, IPostStorageContract postStorageContract, IWorkerStorageContract workerStorageContract, ILogger logger) : ISalaryBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly ISalaryStorageContract _salaryStorageContract = salaryStorageContract;
+    private readonly ICollectStorageContract _collectStorageContract = collectStorageContract;
+    private readonly IPostStorageContract _postStorageContract = postStorageContract;
+    private readonly IWorkerStorageContract _workerStorageContract = workerStorageContract;
+
+    public List<SalaryDataModel> GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSalaries params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _salaryStorageContract.GetList(fromDate, toDate) ?? throw new NullListException();
+    }
+
+    public List<SalaryDataModel> GetAllSalariesByPeriodByWorker(DateTime fromDate, DateTime toDate, string workerId)
+    {
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (workerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(workerId));
+        }
+        if (!workerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field workerId is not a unique identifier.");
+        }
+        _logger.LogInformation("GetAllSalaries params: {fromDate}, {toDate}, {workerId}", fromDate, toDate, workerId);
+        return _salaryStorageContract.GetList(fromDate, toDate, workerId) ?? throw new NullListException();
+    }
+
+    public void CalculateSalaryByMonth(DateTime date)
+    {
+        _logger.LogInformation("CalculateSalaryByMonth: {date}", date);
+        var startDate = new DateTime(date.Year, date.Month, 1);
+        var finishDate = new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month));
+        var workers = _workerStorageContract.GetList() ?? throw new NullListException();
+        foreach (var worker in workers)
+        {
+            var collects = _collectStorageContract.GetList(startDate, finishDate, workerId: worker.Id)?.Sum(x => x.Sum) ??
+                throw new NullListException();
+            var post = _postStorageContract.GetElementById(worker.PostId) ??
+                throw new NullListException();
+            var salary = post.Salary + collects * 0.1;
+            _logger.LogDebug("The employee {workerId} was paid a salary of {salary}", worker.Id, salary);
+            _salaryStorageContract.AddElement(new SalaryDataModel(worker.Id, finishDate, salary));
+        }
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/Implementations/WorkPieceBusinessLogicContract.cs

@@ -0,0 +1,69 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class WorkPieceBusinessLogicContract(IWorkPieceStorageContract workPieceStorageContract, ILogger logger) : IWorkPieceBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private IWorkPieceStorageContract _workPieceStorageContract = workPieceStorageContract;
+
+    public List<WorkPieceDataModel> GetAllWorkPieces()
+    {
+        _logger.LogInformation("GetAllWorkPieces");
+        return _workPieceStorageContract.GetList() ?? throw new NullListException();
+    }
+
+    public WorkPieceDataModel GetWorkPiecesByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _workPieceStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        if (Regex.IsMatch(data, @"^\d+x\d+$"))
+        {
+            return _workPieceStorageContract.GetElementBySize(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _workPieceStorageContract.GetElementBySize(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertWorkPiece(WorkPieceDataModel workPieceDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(workPieceDataModel));
+        ArgumentNullException.ThrowIfNull(workPieceDataModel);
+        workPieceDataModel.Validate();
+        _workPieceStorageContract.AddElement(workPieceDataModel);
+    }
+
+    public void UpdateWorkPiece(WorkPieceDataModel workPieceDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(workPieceDataModel));
+        ArgumentNullException.ThrowIfNull(workPieceDataModel);
+        workPieceDataModel.Validate();
+        _workPieceStorageContract.UpdElement(workPieceDataModel);
+    }
+    public void DeleteWorkPiece(string id)
+    {
+        _logger.LogInformation("Delete by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _workPieceStorageContract.DelElement(id);
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/Implementations/WorkerBusinessLogicContract.cs

@@ -0,0 +1,99 @@
+using Microsoft.Extensions.Logging;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.Extensions;
+using SoftBedContracts.StoragesContracts;
+using System.Text.Json;
+
+namespace SoftBedBusinessLogic.Implementations;
+
+internal class WorkerBusinessLogicContract(IWorkerStorageContract workerStorageContract, ILogger logger) : IWorkerBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IWorkerStorageContract _workerStorageContract = workerStorageContract;
+
+    public List<WorkerDataModel> GetAllWorkers()
+    {
+        _logger.LogInformation("GetAllWorkers");
+        return _workerStorageContract.GetList() ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllWorkersByPost(string postId)
+    {
+        _logger.LogInformation("GetAllWorkers params: {postId},", postId);
+        if (postId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(postId));
+        }
+        if (!postId.IsGuid())
+        {
+            throw new ValidationException("The value in the field postId is not a unique identifier.");
+        }
+        return _workerStorageContract.GetList(postId) ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllWorkersByBirthDate(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllWorkers params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _workerStorageContract.GetList(fromBirthDate: fromDate, toBirthDate: toDate) ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllWorkersByEmploymentDate(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllWorkers params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _workerStorageContract.GetList(fromEmploymentDate: fromDate, toEmploymentDate: toDate) ?? throw new NullListException();
+    }
+
+    public WorkerDataModel GetWorkerByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _workerStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _workerStorageContract.GetElementByFIO(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertWorker(WorkerDataModel workerDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(workerDataModel));
+        ArgumentNullException.ThrowIfNull(workerDataModel);
+        workerDataModel.Validate();
+        _workerStorageContract.AddElement(workerDataModel);
+    }
+
+    public void UpdateWorker(WorkerDataModel workerDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(workerDataModel));
+        ArgumentNullException.ThrowIfNull(workerDataModel);
+        workerDataModel.Validate();
+        _workerStorageContract.UpdElement(workerDataModel);
+    }
+
+    public void DeleteWorker(string id)
+    {
+        _logger.LogInformation("Delete by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _workerStorageContract.DelElement(id);
+    }
+}

TheSoftBedProject/SoftBedBusinessLogic/SoftBedBusinessLogic.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+	<ItemGroup>
+		<InternalsVisibleTo Include="SoftBedTests" />
+		<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.2" />
+	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SoftBedContracts\SoftBedContracts.csproj" />
+  </ItemGroup>
+
+</Project>

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/ICollectBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface ICollectBusinessLogicContract
+{
+    List<CollectDataModel> GetAllCollectsByPeriod(DateTime fromDate, DateTime toDate);
+
+    List<CollectDataModel> GetAllCollectsByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate);
+
+    List<CollectDataModel> GetAllCollectsByFurnitureByPeriod(string furnitureId, DateTime fromDate, DateTime toDate);
+
+    CollectDataModel GetCollectByData(string data);
+
+    void InsertCollect(CollectDataModel collectDataModel);
+}

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/IFurnitureBusinessLogicContract.cs

@@ -0,0 +1,20 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface IFurnitureBusinessLogicContract
+{
+    List<FurnitureDataModel> GetAllFurniture(bool onlyActive = true);
+
+    List<FurnitureDataModel> GetAllFurnitureByWorkPieces(string workPiecesId, bool onlyActive = true);
+
+    List<FurnitureHistoryDataModel> GetFurnitureHistoryByFurniture(string furnitureId);
+
+    FurnitureDataModel GetFurnitureByData(string data);
+
+    void InsertFurniture(FurnitureDataModel furnitureDataModel);
+
+    void UpdateFurniture(FurnitureDataModel furnitureDataModel);
+
+    void DeleteFurniture(string id);
+}

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/IPostBusinessLogicContract.cs

@@ -0,0 +1,20 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface IPostBusinessLogicContract
+{
+    List<PostDataModel> GetAllPosts(bool onlyActive);
+
+    List<PostDataModel> GetAllDataOfPost(string postId);
+
+    PostDataModel GetPostByData(string data);
+
+    void InsertPost(PostDataModel postDataModel);
+
+    void UpdatePost(PostDataModel postDataModel);
+
+    void DeletePost(string id);
+
+    void RestorePost(string id);
+}

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs

@@ -0,0 +1,12 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface ISalaryBusinessLogicContract
+{
+    List<SalaryDataModel> GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate);
+
+    List<SalaryDataModel> GetAllSalariesByPeriodByWorker(DateTime fromDate, DateTime toDate, string workerId);
+
+    void CalculateSalaryByMonth(DateTime date);
+}

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/IWorkPieceBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface IWorkPieceBusinessLogicContract
+{
+    List<WorkPieceDataModel> GetAllWorkPieces();
+
+    WorkPieceDataModel GetWorkPiecesByData(string data);
+
+    void InsertWorkPiece(WorkPieceDataModel workPieceDataModel);
+
+    void UpdateWorkPiece(WorkPieceDataModel workPieceDataModel);
+
+    void DeleteWorkPiece(string id);
+}

TheSoftBedProject/SoftBedContracts/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs

@@ -0,0 +1,22 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.BusinessLogicsContracts;
+
+public interface IWorkerBusinessLogicContract
+{
+    List<WorkerDataModel> GetAllWorkers();
+
+    List<WorkerDataModel> GetAllWorkersByPost(string postId);
+
+    List<WorkerDataModel> GetAllWorkersByBirthDate(DateTime fromDate, DateTime toDate);
+
+    List<WorkerDataModel> GetAllWorkersByEmploymentDate(DateTime fromDate, DateTime toDate);
+
+    WorkerDataModel GetWorkerByData(string data);
+
+    void InsertWorker(WorkerDataModel workerDataModel);
+
+    void UpdateWorker(WorkerDataModel workerDataModel);
+
+    void DeleteWorker(string id);
+}

TheSoftBedProject/SoftBedContracts/Exceptions/ElementExistsException.cs

@@ -0,0 +1,14 @@
+namespace SoftBedContracts.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;
+    }
+}

TheSoftBedProject/SoftBedContracts/Exceptions/ElementNotFoundException.cs

@@ -0,0 +1,11 @@
+namespace SoftBedContracts.Exceptions;
+
+public class ElementNotFoundException : Exception
+{
+    public string Value { get; private set; }
+
+    public ElementNotFoundException(string value) : base($"Element not found at value = {value}")
+    {
+        Value = value;
+    }
+}

TheSoftBedProject/SoftBedContracts/Exceptions/IncorrectDatesException.cs

@@ -0,0 +1,6 @@
+namespace SoftBedContracts.Exceptions;
+
+public class IncorrectDatesException : Exception
+{
+    public IncorrectDatesException(DateTime start, DateTime end) : base($"The end date must be later than the start date.. StartDate: {start:dd.MM.YYYY}. EndDate: {end:dd.MM.YYYY}") { }
+}

TheSoftBedProject/SoftBedContracts/Exceptions/NullListException.cs

@@ -0,0 +1,6 @@
+namespace SoftBedContracts.Exceptions;
+
+public class NullListException : Exception
+{
+    public NullListException() : base("The returned list is null") { }
+}

TheSoftBedProject/SoftBedContracts/Exceptions/StorageException.cs

@@ -0,0 +1,6 @@
+namespace SoftBedContracts.Exceptions;
+
+public class StorageException : Exception
+{
+    public StorageException(Exception ex) : base($"Error while working in storage: {ex.Message}", ex) { }
+}

TheSoftBedProject/SoftBedContracts/Extensions/DateTimeExtensions.cs

@@ -0,0 +1,9 @@
+namespace SoftBedContracts.Extensions;
+
+public static class DateTimeExtensions
+{
+    public static bool IsDateNotOlder(this DateTime date, DateTime olderDate)
+    {
+        return date >= olderDate;
+    }
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/ICollectStorageContract.cs

@@ -0,0 +1,14 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface ICollectStorageContract
+{
+    List<CollectDataModel> GetList(DateTime? startDate = null, DateTime? endDate = null, string? workerId = null, string? furnitureId = null);
+
+    CollectDataModel? GetElementById(string id);
+
+    void AddElement(CollectDataModel collectDataModel);
+
+    void DelElement(string id);
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/IFurnitureStorageContract.cs

@@ -0,0 +1,20 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface IFurnitureStorageContract
+{
+    List<FurnitureDataModel> GetList(bool onlyActive = true, string workPieceId = null);
+
+    List<FurnitureHistoryDataModel> GetHistoryByFurnitureId(string furnitureId);
+
+    FurnitureDataModel? GetElementById(string id);
+
+    FurnitureDataModel? GetElementByName(string name);
+
+    void AddElement(FurnitureDataModel furnitureDataModel);
+
+    void UpdElement(FurnitureDataModel furnitureDataModel);
+
+    void DelElement(string id);
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/IPostStorageContarct.cs

@@ -0,0 +1,22 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface IPostStorageContract
+{
+    List<PostDataModel> GetList(bool onlyActual = true);
+
+    List<PostDataModel> GetPostWithHistory(string postId);
+
+    PostDataModel? GetElementById(string id);
+
+    PostDataModel? GetElementByName(string name);
+
+    void AddElement(PostDataModel postDataModel);
+
+    void UpdElement(PostDataModel postDataModel);
+
+    void DelElement(string id);
+
+    void ResElement(string id);
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/ISalaryStorageContract.cs

@@ -0,0 +1,10 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface ISalaryStorageContract
+{
+    List<SalaryDataModel> GetList(DateTime startDate, DateTime endDate, string? workerId = null);
+
+    void AddElement(SalaryDataModel salaryDataModel);
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/IWorkPieceStorageContract.cs

@@ -0,0 +1,18 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface IWorkPieceStorageContract
+{
+    List<WorkPieceDataModel> GetList();
+
+    WorkPieceDataModel? GetElementById(string id);
+
+    WorkPieceDataModel? GetElementBySize(string size);
+
+    void AddElement(WorkPieceDataModel workPieceDataModel);
+
+    void UpdElement(WorkPieceDataModel workPieceDataModel);
+
+    void DelElement(string id);
+}

TheSoftBedProject/SoftBedContracts/StoragesContracts/IWorkerStorageContract.cs

@@ -0,0 +1,18 @@
+using SoftBedContracts.DataModels;
+
+namespace SoftBedContracts.StoragesContracts;
+
+public interface IWorkerStorageContract
+{
+    List<WorkerDataModel> GetList(string? postId = null, DateTime? fromBirthDate = null, DateTime? toBirthDate = null, DateTime? fromEmploymentDate = null, DateTime? toEmploymentDate = null);
+
+    WorkerDataModel? GetElementById(string id);
+
+    WorkerDataModel? GetElementByFIO(string fio);
+
+    void AddElement(WorkerDataModel workerDataModel);
+
+    void UpdElement(WorkerDataModel workerDataModel);
+
+    void DelElement(string id);
+}

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/CollectBusinessLogicContractTests.cs

@@ -0,0 +1,353 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class CollectBusinessLogicContractTests
+{
+    private CollectBusinessLogicContract _collectBusinessLogicContract;
+    private Mock<ICollectStorageContract> _collectStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _collectStorageContract = new Mock<ICollectStorageContract>();
+        _collectBusinessLogicContract = new CollectBusinessLogicContract(_collectStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _collectStorageContract.Reset();
+    }
+    [Test]
+    public void GetAllCollectsByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<CollectDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20),
+        };
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var workerId = Guid.NewGuid().ToString();
+        var listOriginal = new List<CollectDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20),
+        };
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(workerId, date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), workerId, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod("workerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByWorkerByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var furnitureId = Guid.NewGuid().ToString();
+        var listOriginal = new List<CollectDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20),
+        };
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(furnitureId, date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, furnitureId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_FurnitureIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_FurnitureIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod("furnitureId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllCollectsByFurnitureByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _collectStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void GetCollectByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new CollectDataModel(id, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10);
+        _collectStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _collectBusinessLogicContract.GetCollectByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _collectStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetCollectByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetCollectByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _collectBusinessLogicContract.GetCollectByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _collectStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetCollectByData_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetCollectByData("collectId"), Throws.TypeOf<ValidationException>());
+        _collectStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetCollectByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetCollectByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _collectStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetCollectByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.GetCollectByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _collectStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void InsertCollect_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new CollectDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10);
+        _collectStorageContract.Setup(x => x.AddElement(It.IsAny<CollectDataModel>()))
+            .Callback((CollectDataModel x) =>
+            {
+                flag = x.Id == record.Id && 
+                       x.WorkerId == record.WorkerId && 
+                       x.FurnitureId == record.FurnitureId &&
+                       x.Sum == record.Sum;
+            });
+        //Act
+        _collectBusinessLogicContract.InsertCollect(record);
+        //Assert
+        _collectStorageContract.Verify(x => x.AddElement(It.IsAny<CollectDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertCollect_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.AddElement(It.IsAny<CollectDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.InsertCollect(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf<ElementExistsException>());
+        _collectStorageContract.Verify(x => x.AddElement(It.IsAny<CollectDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertCollect_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.InsertCollect(null), Throws.TypeOf<ArgumentNullException>());
+        _collectStorageContract.Verify(x => x.AddElement(It.IsAny<CollectDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertCollect_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.InsertCollect(new CollectDataModel("id", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf<ValidationException>());
+        _collectStorageContract.Verify(x => x.AddElement(It.IsAny<CollectDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertCollect_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _collectStorageContract.Setup(x => x.AddElement(It.IsAny<CollectDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _collectBusinessLogicContract.InsertCollect(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf<StorageException>());
+        _collectStorageContract.Verify(x => x.AddElement(It.IsAny<CollectDataModel>()), Times.Once);
+    }
+}

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/FurnitureBusinessLogicContractTests.cs

@@ -0,0 +1,498 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+using static NUnit.Framework.Internal.OSPlatform;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class FurnitureBusinessLogicContractTests
+{
+    private FurnitureBusinessLogicContract _furnitureBusinessLogicContract;
+    private Mock<IFurnitureStorageContract> _furnitureStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _furnitureStorageContract = new Mock<IFurnitureStorageContract>();
+        _furnitureBusinessLogicContract = new FurnitureBusinessLogicContract(_furnitureStorageContract.Object, new Mock<ILogger>().Object);
+    }
+    [SetUp]
+    public void SetUp()
+    {
+        _furnitureStorageContract.Reset();
+    }
+    [Test]
+    public void GetAllFurniture_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<FurnitureDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "name 1", FurnitureType.CabinetFurniture, 10, false,
+                [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),5)]),
+            new(Guid.NewGuid().ToString(), "name 2", FurnitureType.CabinetFurniture, 10, false, []),
+            new(Guid.NewGuid().ToString(), "name 3", FurnitureType.CabinetFurniture, 10, false, []),
+        };
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurniture(true);
+        var list = _furnitureBusinessLogicContract.GetAllFurniture(false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(list, Is.Not.Null);
+            Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _furnitureStorageContract.Verify(x => x.GetList(true, null), Times.Once);
+        _furnitureStorageContract.Verify(x => x.GetList(false, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllFurniture_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurniture(true);
+        var list = _furnitureBusinessLogicContract.GetAllFurniture(false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(list, Is.Not.Null);
+            Assert.That(listOnlyActive, Has.Count.EqualTo(0));
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), null), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllFurniture_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurniture(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllFurniture_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurniture(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllFurnitureByWorkPieces_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var workPieceId = Guid.NewGuid().ToString();
+        var listOriginal = new List<FurnitureDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "name 1", FurnitureType.CabinetFurniture, 10, false,
+                [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),5)]),
+            new(Guid.NewGuid().ToString(), "name 2", FurnitureType.CabinetFurniture, 10, false, []),
+            new(Guid.NewGuid().ToString(), "name 3", FurnitureType.CabinetFurniture, 10, false, []),
+        };
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, true);
+        var list = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(list, Is.Not.Null);
+            Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _furnitureStorageContract.Verify(x => x.GetList(true, workPieceId), Times.Once);
+        _furnitureStorageContract.Verify(x => x.GetList(false, workPieceId), Times.Once);
+    }
+    [Test]
+    public void GetAllFurnitureByWorkPieces_ReturnEmptyList_Test()
+    {
+        //Arrange
+        var workPieceId = Guid.NewGuid().ToString();
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, true);
+        var list = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(list, Is.Not.Null);
+            Assert.That(listOnlyActive, Has.Count.EqualTo(0));
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), workPieceId), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllFurnitureByWorkPieces_WorkPieceIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(null, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(string.Empty, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllFurnitureByWorkPieces_WorkPieceIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces("workPieceId", It.IsAny<bool>()), Throws.TypeOf<ValidationException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllFurnitureByWorkPieces_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllFurnitureByWorkPieces_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void GetFurnitureHistoryByFurniture_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var furnitureId = Guid.NewGuid().ToString();
+        var listOriginal = new List<FurnitureHistoryDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), 10),
+            new(Guid.NewGuid().ToString(), 15),
+            new(Guid.NewGuid().ToString(), 10),
+        };
+        _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(furnitureId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(furnitureId), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureHistoryByFurniture_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString());
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureHistoryByFurniture_FurnitureIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetFurnitureHistoryByFurniture_FurnitureIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture("furnitureId"), Throws.TypeOf<ValidationException>());
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetFurnitureHistoryByFurniture_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureHistoryByFurniture_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void GetFurnitureByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new FurnitureDataModel(id, "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+        _furnitureStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _furnitureBusinessLogicContract.GetFurnitureByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureByData_GetByName_ReturnRecord_Test()
+    {
+        //Arrange
+        var name = "name";
+        var record = new FurnitureDataModel(Guid.NewGuid().ToString(), name, FurnitureType.CabinetFurniture, 10, false, []);
+        _furnitureStorageContract.Setup(x => x.GetElementByName(name)).Returns(record);
+        //Act
+        var element = _furnitureBusinessLogicContract.GetFurnitureByData(name);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.FurnitureName, Is.EqualTo(name));
+        _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+        _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetFurnitureByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData("name"), Throws.TypeOf<ElementNotFoundException>());
+        _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetFurnitureByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _furnitureStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData("name"), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void InsertFurniture_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new FurnitureDataModel(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+        _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny<FurnitureDataModel>()))
+            .Callback((FurnitureDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FurnitureName == record.FurnitureName && x.FurnitureType == record.FurnitureType 
+                && x.Price == record.Price && x.IsDeleted == record.IsDeleted &&
+                x.WorkPieces.Count == record.WorkPieces.Count &&
+                x.WorkPieces.First().FurnitureId == record.WorkPieces.First().FurnitureId &&
+                x.WorkPieces.First().WorkPieceId == record.WorkPieces.First().WorkPieceId &&
+                x.WorkPieces.First().Count == record.WorkPieces.First().Count; ;
+            });
+        //Act
+        _furnitureBusinessLogicContract.InsertFurniture(record);
+        //Assert
+        _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertFurniture_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny<FurnitureDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
+        _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertFurniture_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(null), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny<FurnitureDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertFurniture_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new FurnitureDataModel("id", "name", FurnitureType.CabinetFurniture, 10, false,
+            [])), Throws.TypeOf<ValidationException>());
+        _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny<FurnitureDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertFurniture_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny<FurnitureDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateFurniture_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new FurnitureDataModel(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+        _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny<FurnitureDataModel>()))
+            .Callback((FurnitureDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FurnitureName == record.FurnitureName && x.FurnitureType == record.FurnitureType
+                && x.Price == record.Price && x.IsDeleted == record.IsDeleted &&
+                x.WorkPieces.Count == record.WorkPieces.Count &&
+                x.WorkPieces.First().FurnitureId == record.WorkPieces.First().FurnitureId &&
+                x.WorkPieces.First().WorkPieceId == record.WorkPieces.First().WorkPieceId &&
+                x.WorkPieces.First().Count == record.WorkPieces.First().Count; ;
+            });
+        //Act
+        _furnitureBusinessLogicContract.UpdateFurniture(record);
+        //Assert
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateFurniture_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny<FurnitureDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementNotFoundException>());
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateFurniture_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny<FurnitureDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateFurniture_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(null), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateFurniture_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new FurnitureDataModel("id", "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ValidationException>());
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateFurniture_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny<FurnitureDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false,
+            [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny<FurnitureDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteFurniture_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _furnitureStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _furnitureBusinessLogicContract.DeleteFurniture(id);
+        //Assert
+        _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteFurniture_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _furnitureStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteFurniture_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteFurniture_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture("id"), Throws.TypeOf<ValidationException>());
+        _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteFurniture_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _furnitureStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs

@@ -0,0 +1,454 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class PostBusinessLogicContractTests
+{
+    private PostBusinessLogicContract _postBusinessLogicContract;
+    private Mock<IPostStorageContract> _postStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _postStorageContract = new Mock<IPostStorageContract>();
+        _postBusinessLogicContract = new PostBusinessLogicContract(_postStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _postStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllPosts_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<PostDataModel>()
+        {
+            new(Guid.NewGuid().ToString(),"name 1", PostType.Loader, 10, true, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), "name 2", PostType.Loader, 10, false, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), "name 3", PostType.Loader, 10, true, DateTime.UtcNow),
+        };
+        _postStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _postBusinessLogicContract.GetAllPosts(true);
+        var listAll = _postBusinessLogicContract.GetAllPosts(false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(listAll, Is.Not.Null);
+            Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
+            Assert.That(listAll, Is.EquivalentTo(listOriginal));
+        });
+        _postStorageContract.Verify(x => x.GetList(true), Times.Once);
+        _postStorageContract.Verify(x => x.GetList(false), Times.Once);
+    }
+
+    [Test]
+    public void GetAllPosts_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns([]);
+        //Act
+        var listOnlyActive = _postBusinessLogicContract.GetAllPosts(true);
+        var listAll = _postBusinessLogicContract.GetAllPosts(false);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(listOnlyActive, Is.Not.Null);
+            Assert.That(listAll, Is.Not.Null);
+            Assert.That(listOnlyActive, Has.Count.EqualTo(0));
+            Assert.That(listAll, Has.Count.EqualTo(0));
+        });
+        _postStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllPosts_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _postStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllPosts_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var postId = Guid.NewGuid().ToString();
+        var listOriginal = new List<PostDataModel>()
+        {
+            new(postId, "name 1", PostType.Loader, 10, true, DateTime.UtcNow),
+            new(postId, "name 2", PostType.Loader, 10, false, DateTime.UtcNow)
+        };
+        _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _postBusinessLogicContract.GetAllDataOfPost(postId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        _postStorageContract.Verify(x => x.GetPostWithHistory(postId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString());
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_PostIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_PostIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost("id"), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+        _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetPostByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new PostDataModel(id, "name", PostType.Loader, 10, true, DateTime.UtcNow);
+        _postStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _postBusinessLogicContract.GetPostByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetPostByData_GetByName_ReturnRecord_Test()
+    {
+        //Arrange
+        var postName = "name";
+        var record = new PostDataModel(Guid.NewGuid().ToString(), postName, PostType.Loader, 10, true, DateTime.UtcNow);
+        _postStorageContract.Setup(x => x.GetElementByName(postName)).Returns(record);
+        //Act
+        var element = _postBusinessLogicContract.GetPostByData(postName);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.PostName, Is.EqualTo(postName));
+        _postStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetPostByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetPostByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.GetPostByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _postStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetPostByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _postStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetPostByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _postStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetPostByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _postStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _postStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertPost_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow.AddDays(-1));
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<PostDataModel>()))
+            .Callback((PostDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.PostName == record.PostName && x.PostType == record.PostType && x.Salary == record.Salary &&
+                    x.ChangeDate == record.ChangeDate;
+            });
+        //Act
+        _postBusinessLogicContract.InsertPost(record);
+        //Assert
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<PostDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertPost_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<PostDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<ElementExistsException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<PostDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertPost_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertPost(null), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<PostDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertPost_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertPost(new PostDataModel("id", "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<PostDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertPost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<PostDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<PostDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow.AddDays(-1));
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<PostDataModel>()))
+            .Callback((PostDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.PostName == record.PostName && x.PostType == record.PostType && x.Salary == record.Salary &&
+                    x.ChangeDate == record.ChangeDate;
+            });
+        //Act
+        _postBusinessLogicContract.UpdatePost(record);
+        //Assert
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdatePost_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<PostDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<PostDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "anme", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<ElementExistsException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdatePost(null), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdatePost_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdatePost(new PostDataModel("id", "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdatePost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<PostDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<PostDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeletePost_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _postStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _postBusinessLogicContract.DeletePost(id);
+        //Assert
+        _postStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeletePost_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _postStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeletePost_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.DeletePost(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.DeletePost(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeletePost_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.DeletePost("id"), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeletePost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void RestorePost_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _postStorageContract.Setup(x => x.ResElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _postBusinessLogicContract.RestorePost(id);
+        //Assert
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void RestorePost_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _postStorageContract.Setup(x => x.ResElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void RestorePost_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.RestorePost(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.RestorePost(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void RestorePost_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.RestorePost("id"), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void RestorePost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.ResElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Once);
+    }
+}

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs

@@ -0,0 +1,346 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class SalaryBusinessLogicContractTests
+{
+    private SalaryBusinessLogicContract _salaryBusinessLogicContract;
+    private Mock<ISalaryStorageContract> _salaryStorageContract;
+    private Mock<ICollectStorageContract> _collectStorageContract;
+    private Mock<IPostStorageContract> _postStorageContract;
+    private Mock<IWorkerStorageContract> _workerStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _salaryStorageContract = new Mock<ISalaryStorageContract>();
+        _collectStorageContract = new Mock<ICollectStorageContract>();
+        _postStorageContract = new Mock<IPostStorageContract>();
+        _workerStorageContract = new Mock<IWorkerStorageContract>();
+        _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object,
+            _collectStorageContract.Object, _postStorageContract.Object, _workerStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _salaryStorageContract.Reset();
+        _collectStorageContract.Reset();
+        _postStorageContract.Reset();
+        _workerStorageContract.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),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30),
+        };
+        _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 GetAllSalariesByWorker_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var startDate = DateTime.UtcNow;
+        var endDate = DateTime.UtcNow.AddDays(1);
+        var workerId = Guid.NewGuid().ToString();
+        var listOriginal = new List<SalaryDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30),
+        };
+        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(startDate, endDate, workerId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, workerId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalariesByWorker_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(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 GetAllSalariesByWorker_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var dateTime = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime, Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(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 GetAllSalariesByWorker_WorkerIdIsNUllOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(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 GetAllSalariesByWorker_WorkerIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), "workerId"), Throws.TypeOf<ValidationException>());
+        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalariesByWorker_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(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 GetAllSalariesByWorker_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.GetAllSalariesByPeriodByWorker(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 CalculateSalaryByMonth_CalculateSalary_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        var collectSum = 300.0;
+        var postSalary = 3000.0;
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 300)]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, postSalary, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        var sum = 0.0;
+        var expectedSum = postSalary + collectSum * 0.1;
+        _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 CalculateSalaryByMonth_WithSeveralWorkers_Test()
+    {
+        //Arrange
+        var worker1Id = Guid.NewGuid().ToString();
+        var worker2Id = Guid.NewGuid().ToString();
+        var worker3Id = Guid.NewGuid().ToString();
+        var list = new List<WorkerDataModel>() {
+            new(worker1Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow),
+            new(worker2Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow),
+            new(worker3Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)
+        };
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), worker1Id, Guid.NewGuid().ToString(), 10),
+            new CollectDataModel(Guid.NewGuid().ToString(), worker1Id, Guid.NewGuid().ToString(), 10),
+            new CollectDataModel(Guid.NewGuid().ToString(), worker2Id, Guid.NewGuid().ToString(), 10),
+            new CollectDataModel(Guid.NewGuid().ToString(), worker3Id, Guid.NewGuid().ToString(), 10),
+            new CollectDataModel(Guid.NewGuid().ToString(), worker3Id, Guid.NewGuid().ToString(), 10)]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(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 CalculateSalaryByMonth_WithoutCollectsByWorker_Test()
+    {
+        //Arrange
+        var postSalary = 3000.0;
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, postSalary, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        var sum = 0.0;
+        var expectedSum = postSalary;
+        _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 CalculateSalaryByMonth_CollectStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMonth_PostStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]);
+        _workerStorageContract.Setup(x => x.GetList( It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMonth_WorkerStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow));
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMonth_CollectStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Throws(new StorageException(new InvalidOperationException()));
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMonth_PostStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Throws(new StorageException(new InvalidOperationException()));
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMonth_WorkerStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _collectStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow));
+        _workerStorageContract.Setup(x => x.GetList(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>());
+    }
+}

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkPieceBusinessLogicContractTests.cs

@@ -0,0 +1,311 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.BusinessLogicsContracts;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class WorkPieceBusinessLogicContractTests
+{
+    private IWorkPieceBusinessLogicContract _workPieceBusinessLogicContract;
+    private Mock<IWorkPieceStorageContract> _workPieceStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _workPieceStorageContract = new Mock<IWorkPieceStorageContract>();
+        _workPieceBusinessLogicContract = new WorkPieceBusinessLogicContract(_workPieceStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _workPieceStorageContract.Reset();
+    }
+    [Test]
+    public void GetAllWorkPieces_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var listOriginal = new List<WorkPieceDataModel>()
+        {
+            new(Guid.NewGuid().ToString(),"100x100",100),
+            new(Guid.NewGuid().ToString(),"20x20",20),
+            new(Guid.NewGuid().ToString(),"30x100",30),
+        };
+        _workPieceStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+        // Act
+        var list = _workPieceBusinessLogicContract.GetAllWorkPieces();
+        // Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+    }
+    [Test]
+    public void GetAllWorkPieces_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _workPieceStorageContract.Setup(x => x.GetList()).Returns([]);
+        // Act
+        var list = _workPieceBusinessLogicContract.GetAllWorkPieces();
+        // Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _workPieceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+    [Test]
+    public void GetAllWorkPieces_ReturnNull_ThrowException_Test()
+    {
+        // Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetAllWorkPieces(), Throws.TypeOf<NullListException>());
+        _workPieceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+    [Test]
+    public void GetAllWorkPieces_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _workPieceStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+        // Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetAllWorkPieces(), Throws.TypeOf<StorageException>());
+        _workPieceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+    [Test]
+    public void GetWorkPieceByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new WorkPieceDataModel(id, "100x100", 100);
+        _workPieceStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _workPieceBusinessLogicContract.GetWorkPiecesByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkPieceByData_GetBySize_ReturnRecord_Test()
+    {
+        //Arrange
+        var size = "100x100";
+        var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), size, 0);
+        _workPieceStorageContract.Setup(x => x.GetElementBySize(size)).Returns(record);
+        //Act
+        var element = _workPieceBusinessLogicContract.GetWorkPiecesByData(size);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Size, Is.EqualTo(size));
+        _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkPieceByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetWorkPieceByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetWorkPieceByData_GetBySize_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData("100x100"), Throws.TypeOf<ElementNotFoundException>());
+        _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny<string>()), Times.Once);
+    }
+    [Test]
+    public void GetWorkPieceByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _workPieceStorageContract.Setup(x => x.GetElementBySize(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData("100x100"), Throws.TypeOf<StorageException>());
+        _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertWorkPiece_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), "100x100", 10);
+        _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny<WorkPieceDataModel>()))
+            .Callback((WorkPieceDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Size == record.Size && x.Weight == record.Weight;
+            });
+        //Act
+        _workPieceBusinessLogicContract.InsertWorkPiece(record);
+        //Assert
+        _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+    [Test]
+    public void InsertWorkPiece_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny<WorkPieceDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf<ElementExistsException>());
+        _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertWorkPiece_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(null), Throws.TypeOf<ArgumentNullException>());
+        _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny<WorkPieceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertWorkPiece_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new WorkPieceDataModel("id", "100x100", 10)), Throws.TypeOf<ValidationException>());
+        _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny<WorkPieceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertWorkPiece_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny<WorkPieceDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf<StorageException>());
+        _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+    }
+    [Test]
+    public void UpdateWorkPiece_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), "100x100", 100);
+        _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()))
+            .Callback((WorkPieceDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Size == record.Size;
+            });
+        //Act
+        _workPieceBusinessLogicContract.UpdateWorkPiece(record);
+        //Assert
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateWorkPiece_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkPieceDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf<ElementNotFoundException>());
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateWorkPiece_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkPieceDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf<ElementExistsException>());
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateWorkPiece_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(null), Throws.TypeOf<ArgumentNullException>());
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateWorkPiece_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new WorkPieceDataModel("id", "100x100", 10)), Throws.TypeOf<ValidationException>());
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateWorkPiece_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkPieceDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf<StorageException>());
+        _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkPieceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteWorkPiece_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _workPieceStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _workPieceBusinessLogicContract.DeleteWorkPiece(id);
+        //Assert
+        _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteWorkPiece_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteWorkPiece_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteWorkPiece_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece("id"), Throws.TypeOf<ValidationException>());
+        _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteWorkPiece_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workPieceStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}
+

TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs

@@ -0,0 +1,531 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using SoftBedBusinessLogic.Implementations;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SoftBedTests.BusinessLogicsContractsTests;
+
+internal class WorkerBusinessLogicContractTests
+{
+    private WorkerBusinessLogicContract _workerBusinessLogicContract;
+    private Mock<IWorkerStorageContract> _workerStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _workerStorageContract = new Mock<IWorkerStorageContract>();
+        _workerBusinessLogicContract = new WorkerBusinessLogicContract(_workerStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _workerStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllWorkers_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkers();
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkers_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkers();
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkers_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkers_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var postId = Guid.NewGuid().ToString();
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkersByPost(postId);
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _workerStorageContract.Verify(x => x.GetList(postId, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString());
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_PostIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_PostIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost("postId"), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByPost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByBirthDate_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date.AddDays(1));
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, date, date.AddDays(1), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByBirthDate_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkers();
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByBirthDate_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllWorkersByBirthDate_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByBirthDate_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByEmploymentDate_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date.AddDays(1));
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, null, null, date, date.AddDays(1)), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByEmploymentDate_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var list = _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+        _workerStorageContract.Verify(x => x.GetList(null, null, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByEmploymentDate_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllWorkersByEmploymentDate_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllWorkersByEmploymentDate_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkerByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new WorkerDataModel(id, "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now);
+        _workerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _workerBusinessLogicContract.GetWorkerByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkerByData_GetByFio_ReturnRecord_Test()
+    {
+        //Arrange
+        var fio = "fio";
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), fio, Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now);
+        _workerStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record);
+        //Act
+        var element = _workerBusinessLogicContract.GetWorkerByData(fio);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.FIO, Is.EqualTo(fio));
+        _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkerByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetWorkerByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetWorkerByData_GetByFio_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetWorkerByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _workerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertWorker_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now);
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>()))
+            .Callback((WorkerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate &&
+                    x.EmploymentDate == record.EmploymentDate;
+            });
+        //Act
+        _workerBusinessLogicContract.InsertWorker(record);
+        //Assert
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertWorker_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.InsertWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<ElementExistsException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertWorker_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.InsertWorker(null), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertWorker_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.InsertWorker(new WorkerDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertWorker_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.InsertWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateWorker_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now);
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>()))
+            .Callback((WorkerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate &&
+                    x.EmploymentDate == record.EmploymentDate;
+            });
+        //Act
+        _workerBusinessLogicContract.UpdateWorker(record);
+        //Assert
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateWorker_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateWorker_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.UpdateWorker(null), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateWorker_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new WorkerDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateWorker_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteWorker_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _workerBusinessLogicContract.DeleteWorker(id);
+        //Assert
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteWorker_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x != id))).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteWorker_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.DeleteWorker(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _workerBusinessLogicContract.DeleteWorker(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteWorker_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.DeleteWorker("id"), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteWorker_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

TheSoftBedProject/SoftBedTests/SoftBedTests.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="..\SoftBedBusinessLogic\SoftBedBusinessLogic.csproj" />
     <ProjectReference Include="..\SoftBedContracts\SoftBedContracts.csproj" />
   </ItemGroup>
 

TheSoftBedProject/TheSoftBedProject.sln

@@ -5,7 +5,9 @@ VisualStudioVersion = 17.9.34728.123
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SoftBedContracts", "SoftBedContracts\SoftBedContracts.csproj", "{B0AF813F-CC99-4892-AA65-4CDB225B7AA3}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SoftBedTests", "SoftBedTests\SoftBedTests.csproj", "{0E56A9DB-177A-4114-B437-DE0F6C9711F4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SoftBedTests", "SoftBedTests\SoftBedTests.csproj", "{0E56A9DB-177A-4114-B437-DE0F6C9711F4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SoftBedBusinessLogic", "SoftBedBusinessLogic\SoftBedBusinessLogic.csproj", "{C64D5EFE-D645-459C-8E48-F42ED08261C4}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -21,6 +23,10 @@ Global
 		{0E56A9DB-177A-4114-B437-DE0F6C9711F4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0E56A9DB-177A-4114-B437-DE0F6C9711F4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0E56A9DB-177A-4114-B437-DE0F6C9711F4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C64D5EFE-D645-459C-8E48-F42ED08261C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C64D5EFE-D645-459C-8E48-F42ED08261C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C64D5EFE-D645-459C-8E48-F42ED08261C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C64D5EFE-D645-459C-8E48-F42ED08261C4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE