Lab03

WildPlumProject/WildPlumBusinessLogic/Implementations/OrderBusinessLogicContract.cs

@@ -0,0 +1,82 @@
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class OrderBusinessLogicContract(IOrderStorageContract orderStorageContract, ILogger logger) : IOrderBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IOrderStorageContract _orderStorageContract = orderStorageContract;
+
+    public List<OrderDataModel> GetAllSalesByEmployeerByPeriod(string employeerId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {employeerId}, {fromDate}, {toDate}", employeerId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (employeerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(employeerId));
+        }
+        if (!employeerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field employeerId is not a unique identifier.");
+        }
+        return _orderStorageContract.GetList(fromDate, toDate, employeerId: employeerId) ?? throw new NullListException();
+    }
+
+    public List<OrderDataModel> GetAllSalesByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _orderStorageContract.GetList(fromDate, toDate) ?? throw new NullListException();
+    }
+
+    public List<OrderDataModel> GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {productId}, {fromDate}, {toDate}", productId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (productId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(productId));
+        }
+        if (!productId.IsGuid())
+        {
+            throw new ValidationException("The value in the field productId is not a unique identifier.");
+        }
+        return _orderStorageContract.GetList(fromDate, toDate, productId: productId) ?? throw new NullListException();
+    }
+
+    public OrderDataModel GetSaleByData(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 _orderStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertSale(OrderDataModel orderDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(orderDataModel));
+        ArgumentNullException.ThrowIfNull(orderDataModel);
+        orderDataModel.Validate();
+        _orderStorageContract.AddElement(orderDataModel);
+    }
+}

WildPlumProject/WildPlumBusinessLogic/Implementations/ProductBusinessLogicContract.cs

@@ -0,0 +1,65 @@
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class ProductBusinessLogicContract(IProductStorageContract productStorageContract, ILogger logger) : IProductBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IProductStorageContract _productStorageContract = productStorageContract;
+
+    public void DeleteProduct(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");
+        }
+        _productStorageContract.DelElement(id);
+    }
+
+    public List<ProductDataModel> GetAllProducts(bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllProducts params: {onlyActive}", onlyActive);
+        return _productStorageContract.GetList(onlyActive) ?? throw new NullListException();
+    }
+
+    public ProductDataModel GetProductByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _productStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _productStorageContract.GetElementByName(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertProduct(ProductDataModel productDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(productDataModel));
+        ArgumentNullException.ThrowIfNull(productDataModel);
+        productDataModel.Validate();
+        _productStorageContract.AddElement(productDataModel);
+    }
+
+    public void UpdateProduct(ProductDataModel productDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(productDataModel));
+        ArgumentNullException.ThrowIfNull(productDataModel);
+        productDataModel.Validate();
+        _productStorageContract.UpdElement(productDataModel);
+    }
+}

WildPlumProject/WildPlumBusinessLogic/Implementations/RoleBusinessLogicContract.cs

@@ -0,0 +1,93 @@
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class RoleBusinessLogicContract(IRoleStorageContract roleStorageContract, ILogger logger) : IRoleBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IRoleStorageContract _roleStorageContract = roleStorageContract;
+
+    public void DeleteRole(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");
+        }
+        _roleStorageContract.DelElement(id);
+    }
+
+    public List<RoleDataModel> GetAllDataOfRole(string roleId)
+    {
+        _logger.LogInformation("GetAllDataOfPost for {roleId}", roleId);
+        if (roleId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(roleId));
+        }
+        if (!roleId.IsGuid())
+        {
+            throw new ValidationException("The value in the field roleId is not a unique identifier.");
+        }
+        return _roleStorageContract.GetRoleWithHistory(roleId) ?? throw new NullListException();
+    }
+
+    public List<RoleDataModel> GetAllRoles(bool onlyActive)
+    {
+        _logger.LogInformation("GetAllPosts params: {onlyActive}", onlyActive);
+        return _roleStorageContract.GetList(onlyActive) ?? throw new NullListException();
+    }
+
+    public RoleDataModel GetRoleByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (!data.IsGuid())
+        {
+            throw new ValidationException("The value in the field data is not a unique identifier.");
+        }
+        return _roleStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertRole(RoleDataModel roleDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(roleDataModel));
+        ArgumentNullException.ThrowIfNull(roleDataModel);
+        roleDataModel.Validate();
+        _roleStorageContract.AddElement(roleDataModel);
+    }
+
+    public void RestoreRole(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");
+        }
+        _roleStorageContract.ResElement(id);
+    }
+
+    public void UpdateRole(RoleDataModel roleDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(roleDataModel));
+        ArgumentNullException.ThrowIfNull(roleDataModel);
+        roleDataModel.Validate();
+        _roleStorageContract.UpdElement(roleDataModel);
+    }
+}

WildPlumProject/WildPlumBusinessLogic/Implementations/SalaryBusinessLogicContract.cs

@@ -0,0 +1,61 @@
+using Microsoft.Extensions.Logging;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class SalaryBusinessLogicContract(ISalaryStorageContract salaryStorageContract,
+    IOrderStorageContract orderStorageContract, IWorkerStorageContract employeeStorageContract, ILogger logger) : ISalaryBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly ISalaryStorageContract _salaryStorageContract = salaryStorageContract;
+    private readonly IOrderStorageContract _orderStorageContract = orderStorageContract;
+    private readonly IWorkerStorageContract _employeeStorageContract = employeeStorageContract;
+
+    public void CalculateSalaryByMounth(DateTime date)
+    {
+        _logger.LogInformation("CalculateSalaryByMounth: {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 = _employeeStorageContract.GetList() ?? throw new NullListException();
+        foreach (var worker in workers)
+        {
+            var sales = _orderStorageContract.GetList(startDate, finishDate, employeerId: worker.Id)?.Sum(x => x.Products.Count) ??
+                throw new NullListException();
+            var salary = 100 + sales * 0.1;
+            _logger.LogDebug("The employee {workerId} was paid a salary of {salary}", worker.Id, salary);
+            _salaryStorageContract.AddElement(new SalaryDataModel(Guid.NewGuid().ToString(), worker.Id, (decimal)salary, finishDate));
+        }
+    }
+
+    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> GetAllSalariesByPeriodByEmployeer(DateTime fromDate, DateTime toDate, string employeerId)
+    {
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (employeerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(employeerId));
+        }
+        if (!employeerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field employeerId is not a unique identifier.");
+        }
+        _logger.LogInformation("GetAllSalaries params: {fromDate}, {toDate}, {employeerId}", fromDate, toDate, employeerId);
+        return _salaryStorageContract.GetList(fromDate, toDate, employeerId) ?? throw new NullListException();
+    }
+}

WildPlumProject/WildPlumBusinessLogic/Implementations/WarehouserBusinessLogicContract.cs

@@ -0,0 +1,65 @@
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class WarehouserBusinessLogicContract(IWarehouseStorageContract warehouseStorageContract, ILogger logger) : IWarehouserBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IWarehouseStorageContract _warehouseStorageContract = warehouseStorageContract;
+
+    public void DeleteWarehouse(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");
+        }
+        _warehouseStorageContract.DelElement(id);
+    }
+
+    public List<WarehouseDataModel> GetAllWarehouses()
+    {
+        _logger.LogInformation("GetAllWarehouses");
+        return _warehouseStorageContract.GetList() ?? throw new NullListException();
+    }
+
+    public WarehouseDataModel GetWarehouseByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _warehouseStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _warehouseStorageContract.GetElementByName(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertWarehouse(WarehouseDataModel warehouseDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(warehouseDataModel));
+        ArgumentNullException.ThrowIfNull(warehouseDataModel);
+        warehouseDataModel.Validate();
+        _warehouseStorageContract.AddElement(warehouseDataModel);
+    }
+
+    public void UpdateWarehouse(WarehouseDataModel warehouseDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(warehouseDataModel));
+        ArgumentNullException.ThrowIfNull(warehouseDataModel);
+        warehouseDataModel.Validate();
+        _warehouseStorageContract.UpdElement(warehouseDataModel);
+    }
+}

WildPlumProject/WildPlumBusinessLogic/Implementations/WorkerBusinessLogicContract.cs

@@ -0,0 +1,99 @@
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using WildPlumContracts.BusinessLogicsContracts;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.Extensions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumBusinessLogic.Implementations;
+
+internal class WorkerBusinessLogicContract(IWorkerStorageContract employeeStorageContract, ILogger logger) : IWorkerBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IWorkerStorageContract _employeeStorageContract = employeeStorageContract;
+
+    public void DeleteEmployeer(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");
+        }
+        _employeeStorageContract.DelElement(id);
+    }
+
+    public List<WorkerDataModel> GetAllEmployeers(bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllEmployeers params: {onlyActive}", onlyActive);
+        return _employeeStorageContract.GetList(onlyActive) ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllEmployeersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllEmployeersByBirthDate params: {onlyActive}, {fromDate}, {toDate}", onlyActive, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _employeeStorageContract.GetList(onlyActive, fromBirthDate: fromDate, toBirthDate: toDate) ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllEmployeersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllEmployeersByEmploymentDate params: {onlyActive}, {fromDate}, {toDate}", onlyActive, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _employeeStorageContract.GetList(onlyActive, fromEmploymentDate: fromDate, toEmploymentDate: toDate) ?? throw new NullListException();
+    }
+
+    public List<WorkerDataModel> GetAllEmployeersByRole(string roleId, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllEmployeersByRole params: {roleId}, {onlyActive},", roleId, onlyActive);
+        if (roleId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(roleId));
+        }
+        if (!roleId.IsGuid())
+        {
+            throw new ValidationException("The value in the field roleId is not a unique identifier.");
+        }
+        return _employeeStorageContract.GetList(onlyActive, roleId) ?? throw new NullListException();
+    }
+
+    public WorkerDataModel GetEmployeerByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _employeeStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _employeeStorageContract.GetElementByEmail(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertEmployeer(WorkerDataModel employeeDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(employeeDataModel));
+        ArgumentNullException.ThrowIfNull(employeeDataModel);
+        employeeDataModel.Validate();
+        _employeeStorageContract.AddElement(employeeDataModel);
+    }
+
+    public void UpdateEmployeer(WorkerDataModel employeeDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(employeeDataModel));
+        ArgumentNullException.ThrowIfNull(employeeDataModel);
+        employeeDataModel.Validate();
+        _employeeStorageContract.UpdElement(employeeDataModel);
+    }
+}

WildPlumProject/WildPlumBusinessLogic/WildPlumBusinessLogic.csproj

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

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/IOrderBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface IOrderBusinessLogicContract
+{
+    List<OrderDataModel> GetAllSalesByPeriod(DateTime fromDate, DateTime toDate);
+
+    List<OrderDataModel> GetAllSalesByEmployeerByPeriod(string employeerId, DateTime fromDate, DateTime toDate);
+
+    List<OrderDataModel> GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate);
+
+    OrderDataModel GetSaleByData(string data);
+
+    void InsertSale(OrderDataModel orderDataModel);
+}

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/IProductBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface IProductBusinessLogicContract
+{
+    List<ProductDataModel> GetAllProducts(bool onlyActive = true);
+
+    ProductDataModel GetProductByData(string data);
+
+    void InsertProduct(ProductDataModel productDataModel);
+
+    void UpdateProduct(ProductDataModel productDataModel);
+
+    void DeleteProduct(string id);
+}

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/IRoleBusinessLogicContract.cs

@@ -0,0 +1,20 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface IRoleBusinessLogicContract
+{
+    List<RoleDataModel> GetAllRoles(bool onlyActive);
+
+    List<RoleDataModel> GetAllDataOfRole(string roleId);
+
+    RoleDataModel GetRoleByData(string data);
+
+    void InsertRole(RoleDataModel roleDataModel);
+
+    void UpdateRole(RoleDataModel roleDataModel);
+
+    void DeleteRole(string id);
+
+    void RestoreRole(string id);
+}

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs

@@ -0,0 +1,12 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface ISalaryBusinessLogicContract
+{
+    List<SalaryDataModel> GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate);
+
+    List<SalaryDataModel> GetAllSalariesByPeriodByEmployeer(DateTime fromDate, DateTime toDate, string employeerId);
+
+    void CalculateSalaryByMounth(DateTime date);
+}

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/IWarehouserBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface IWarehouserBusinessLogicContract
+{
+    List<WarehouseDataModel> GetAllWarehouses();
+
+    WarehouseDataModel GetWarehouseByData(string data);
+
+    void InsertWarehouse(WarehouseDataModel warehouseDataModel);
+
+    void UpdateWarehouse(WarehouseDataModel warehouseDataModel);
+
+    void DeleteWarehouse(string id);
+}

WildPlumProject/WildPlumContracts/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs

@@ -0,0 +1,22 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.BusinessLogicsContracts;
+
+public interface IWorkerBusinessLogicContract
+{
+    List<WorkerDataModel> GetAllEmployeers(bool onlyActive = true);
+
+    List<WorkerDataModel> GetAllEmployeersByRole(string roleId, bool onlyActive = true);
+
+    List<WorkerDataModel> GetAllEmployeersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true);
+
+    List<WorkerDataModel> GetAllEmployeersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true);
+
+    WorkerDataModel GetEmployeerByData(string data);
+
+    void InsertEmployeer(WorkerDataModel workerDataModel);
+
+    void UpdateEmployeer(WorkerDataModel workerDataModel);
+
+    void DeleteEmployeer(string id);
+}

WildPlumProject/WildPlumContracts/DataModels/RoleDataModel.cs

@@ -5,12 +5,24 @@ using WildPlumContracts.Infrastructure;
 
 namespace WildPlumContracts.DataModels;
 
-public class RoleDataModel(string id, string roleId, WorkerRole role, bool isActual, DateTime changeDate) : IValidation
+public class RoleDataModel : IValidation
 {
-    public string Id { get; private set; } = id;
-    public WorkerRole Role { get; private set; } = role;
-    public bool IsActual { get; private set; } = isActual;
-    public DateTime ChangeDate { get; private set; } = changeDate;
+    public string Id { get; private set; }
+    public WorkerRole WorkerRole { get; private set; }
+    public string RoleId { get; private set; }
+    public bool IsActual { get; private set; }
+    public DateTime ChangeDate { get; private set; }
+
+    public RoleDataModel() { }
+
+    public RoleDataModel(string id, WorkerRole role, string postId, bool isActual, DateTime changeDate)
+    {
+        Id = id;
+        WorkerRole = role;
+        RoleId = postId;
+        IsActual = isActual;
+        ChangeDate = changeDate;
+    }
 
     public void Validate()
     {
@@ -18,7 +30,11 @@ public class RoleDataModel(string id, string roleId, WorkerRole role, bool isAct
             throw new ValidationException("Field Id is empty");
         if (!Id.IsGuid())
             throw new ValidationException("The value in the field Id is not a unique identifier");
-        if (Role == WorkerRole.None)
+        if (RoleId.IsEmpty())
+            throw new ValidationException("Field RoleId is empty");
+        if (!RoleId.IsGuid())
+            throw new ValidationException("The value in the field RoleId is not a unique identifier");
+        if (WorkerRole == WorkerRole.None)
             throw new ValidationException("Field Role is empty");
     }
 }

WildPlumProject/WildPlumContracts/Exceptions/ElementDeletedException.cs

@@ -0,0 +1,6 @@
+namespace WildPlumContracts.Exceptions;
+
+public class ElementDeletedException : Exception
+{
+	public ElementDeletedException(string id) : base($"Cannot modify a deleted item (id: {id})") { }
+}

WildPlumProject/WildPlumContracts/Exceptions/ElementExistsException.cs

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

WildPlumProject/WildPlumContracts/Exceptions/ElementNotFoundException.cs

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

WildPlumProject/WildPlumContracts/Exceptions/IncorrectDatesException.cs

@@ -0,0 +1,6 @@
+namespace WildPlumContracts.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}") { }
+}

WildPlumProject/WildPlumContracts/Exceptions/NullListException.cs

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

WildPlumProject/WildPlumContracts/Exceptions/StorageException.cs

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

WildPlumProject/WildPlumContracts/Extensions/DateTimeExtensions.cs

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

WildPlumProject/WildPlumContracts/Infrastructure/IConfigurationDatabase.cs

@@ -0,0 +1,6 @@
+namespace WildPlumContracts.Infrastructure;
+
+public interface IConfigurationDatabase
+{
+	string ConnectionString { get; }
+}

WildPlumProject/WildPlumContracts/StorageContracts/IOrderStorageContract.cs

@@ -0,0 +1,16 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.StorageContracts;
+
+public interface IOrderStorageContract
+{
+    List<OrderDataModel> GetList(DateTime? startDate = null, DateTime? endDate = null, string? employeerId = null, string? productId = null);
+
+    List<OrderHistoryDataModel> GetHistoryByOrderId(string orderId);
+
+    OrderDataModel? GetElementById(string id);
+
+    void AddElement(OrderDataModel orderDataModel);
+
+    void DelElement(string id);
+}

WildPlumProject/WildPlumContracts/StorageContracts/IProductStorageContract.cs

@@ -0,0 +1,18 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.StorageContracts;
+
+public interface IProductStorageContract
+{
+    List<ProductDataModel> GetList(bool onlyActive = true);
+
+    ProductDataModel? GetElementById(string id);
+
+    ProductDataModel? GetElementByName(string name);
+
+    void AddElement(ProductDataModel productDataModel);
+
+    void UpdElement(ProductDataModel productDataModel);
+
+    void DelElement(string id);
+}

WildPlumProject/WildPlumContracts/StorageContracts/IRoleStorageContract.cs

@@ -0,0 +1,20 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.StorageContracts;
+
+public interface IRoleStorageContract
+{
+    List<RoleDataModel> GetList(bool onlyActual = true);
+
+    List<RoleDataModel> GetRoleWithHistory(string roleId);
+
+    RoleDataModel? GetElementById(string id);
+
+    void AddElement(RoleDataModel roleDataModel);
+
+    void UpdElement(RoleDataModel roleDataModel);
+
+    void DelElement(string id);
+
+    void ResElement(string id);
+}

WildPlumProject/WildPlumContracts/StorageContracts/ISalaryStorageContract.cs

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

WildPlumProject/WildPlumContracts/StorageContracts/IWarehouseStorageContract.cs

@@ -0,0 +1,18 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.StorageContracts;
+
+public interface IWarehouseStorageContract
+{
+    List<WarehouseDataModel> GetList();
+
+    WarehouseDataModel? GetElementById(string id);
+
+    WarehouseDataModel? GetElementByName(string name);
+
+    void AddElement(WarehouseDataModel warehouseDataModel);
+
+    void UpdElement(WarehouseDataModel warehouseDataModel);
+
+    void DelElement(string id);
+}

WildPlumProject/WildPlumContracts/StorageContracts/IWorkerStorageContract.cs

@@ -0,0 +1,18 @@
+using WildPlumContracts.DataModels;
+
+namespace WildPlumContracts.StorageContracts;
+
+public interface IWorkerStorageContract
+{
+    List<WorkerDataModel> GetList(bool onlyActive = true, string? roleId = null, DateTime? fromBirthDate = null, DateTime? toBirthDate = null, DateTime? fromEmploymentDate = null, DateTime? toEmploymentDate = null);
+
+    WorkerDataModel? GetElementById(string id);
+
+    WorkerDataModel? GetElementByEmail(string email);
+
+    void AddElement(WorkerDataModel workerDataModel);
+
+    void UpdElement(WorkerDataModel workerDataModel);
+
+    void DelElement(string id);
+}

WildPlumProject/WildPlumDatabase/Implementations/OrderStorageContract.cs

@@ -0,0 +1,119 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class OrderStorageContract : IOrderStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public OrderStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<OrderProduct, OrderProductDataModel>();
+            cfg.CreateMap<OrderProductDataModel, OrderProduct>();
+            cfg.CreateMap<Order, OrderDataModel>();
+            cfg.CreateMap<OrderHistory, OrderHistoryDataModel>();
+            cfg.CreateMap<OrderDataModel, Order>().ForMember(x => x.Products, x => x.MapFrom(src => src.Products));
+        });
+        _mapper = new Mapper(config);
+    }
+
+    public void AddElement(OrderDataModel orderDataModel)
+    {
+        try
+        {
+            _dbContext.Orders.Add(_mapper.Map<Order>(orderDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+
+    public List<OrderHistoryDataModel> GetHistoryByOrderId(string orderId)
+    {
+        try
+        {
+            return [.. _dbContext.OrderHistories.Where(x => x.OrderId
+            == orderId).OrderByDescending(x => x.ChangeDate).Select(x =>
+            _mapper.Map<OrderHistoryDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var element = GetOrderById(id) ?? throw new ElementNotFoundException(id);
+            _dbContext.Orders.Remove(element);
+            _dbContext.SaveChanges();
+        }
+        catch (Exception ex) when (ex is ElementDeletedException || ex is ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public OrderDataModel? GetElementById(string id)
+    {
+        try
+        {
+            return _mapper.Map<OrderDataModel>(GetOrderById(id));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<OrderDataModel> GetList(DateTime? startDate = null, DateTime? endDate = null, string? employeerId = null, string? productId = null)
+    {
+        try
+        {
+            var query = _dbContext.Orders.Include(x => x.Products).AsQueryable();
+            if (startDate is not null && endDate is not null)
+            {
+                query = query.Where(x => x.OrderDate >= startDate && x.OrderDate < endDate);
+            }
+            if (employeerId is not null)
+            {
+                query = query.Where(x => x.WorkerId == employeerId);
+            }
+            if (productId is not null)
+            {
+                query = query.Where(x => x.Products!.Any(y => y.ProductId == productId));
+            }
+            return [.. query.Select(x => _mapper.Map<OrderDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    private Order? GetOrderById(string id) => _dbContext.Orders.FirstOrDefault(x => x.Id == id);
+}

WildPlumProject/WildPlumDatabase/Implementations/ProductStorageContract.cs

@@ -0,0 +1,152 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class ProductStorageContract : IProductStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public ProductStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Product, ProductDataModel>();
+            cfg.CreateMap<ProductDataModel, Product>()
+            .ForMember(x => x.IsDeleted, x => x.MapFrom(src => false));
+        });
+        _mapper = new Mapper(config);
+    }
+
+    public void AddElement(ProductDataModel productDataModel)
+    {
+        try
+        {
+            _dbContext.Products.Add(_mapper.Map<Product>(productDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (InvalidOperationException ex) when (ex.TargetSite?.Name == "ThrowIdentityConflict")
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("Id", productDataModel.Id);
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Products_ProductName_IsDeleted" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("ProductName", productDataModel.ProductName);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var element = GetProductById(id) ?? throw new ElementNotFoundException(id);
+            element.IsDeleted = true;
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public ProductDataModel? GetElementById(string id)
+    {
+        try
+        {
+            return _mapper.Map<ProductDataModel>(GetProductById(id));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public ProductDataModel? GetElementByName(string name)
+    {
+        try
+        {
+            return _mapper.Map<ProductDataModel>(_dbContext.Products.FirstOrDefault(x => x.ProductName == name && !x.IsDeleted));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<ProductDataModel> GetList(bool onlyActive = true)
+    {
+        try
+        {
+            var query = _dbContext.Products.AsQueryable();
+            if (onlyActive)
+            {
+                query = query.Where(x => !x.IsDeleted);
+            }
+            return [.. query.Select(x => _mapper.Map<ProductDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void UpdElement(ProductDataModel productDataModel)
+    {
+        try
+        {
+            var transaction = _dbContext.Database.BeginTransaction();
+            try
+            {
+                var element = GetProductById(productDataModel.Id) ?? throw new ElementNotFoundException(productDataModel.Id);
+                _dbContext.Products.Update(_mapper.Map(productDataModel, element));
+                _dbContext.SaveChanges();
+                transaction.Commit();
+            }
+            catch
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Products_ProductName_IsDeleted" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("ProductName", productDataModel.ProductName);
+        }
+        catch (Exception ex) when (ex is ElementDeletedException || ex is ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    private Product? GetProductById(string id) => _dbContext.Products.FirstOrDefault(x => x.Id == id && !x.IsDeleted);
+}

WildPlumProject/WildPlumDatabase/Implementations/RoleStorageContract.cs

@@ -0,0 +1,173 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class RoleStorageContract : IRoleStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public RoleStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Role, RoleDataModel>()
+            .ForMember(x => x.Id, x => x.MapFrom(src => src.RoleId));
+            cfg.CreateMap<RoleDataModel, Role>()
+            .ForMember(x => x.Id, x => x.Ignore())
+            .ForMember(x => x.RoleId, x => x.MapFrom(src => src.Id))
+            .ForMember(x => x.IsActual, x => x.MapFrom(src => true))
+            .ForMember(x => x.ChangeDate, x => x.MapFrom(src => DateTime.UtcNow));
+        });
+        _mapper = new Mapper(config);
+    }
+
+    public void AddElement(RoleDataModel roleDataModel)
+    {
+        try
+        {
+            _dbContext.Roles.Add(_mapper.Map<Role>(roleDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Roles_RoleId_IsActual" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("RoleId", roleDataModel.RoleId);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var element = GetRoleById(id) ?? throw new ElementNotFoundException(id);
+            if (!element.IsActual)
+            {
+                throw new ElementDeletedException(id);
+            }
+            element.IsActual = false;
+            _dbContext.SaveChanges();
+        }
+        catch
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+    }
+
+    public RoleDataModel? GetElementById(string id)
+    {
+        try
+        {
+            return
+            _mapper.Map<RoleDataModel>(_dbContext.Roles.FirstOrDefault(x => x.Id == id && x.IsActual));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<RoleDataModel> GetList(bool onlyActual = true)
+    {
+        try
+        {
+            var query = _dbContext.Roles.AsQueryable();
+            if (onlyActual)
+            {
+                query = query.Where(x => x.IsActual);
+            }
+            return [.. query.Select(x => _mapper.Map<RoleDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<RoleDataModel> GetRoleWithHistory(string roleId)
+    {
+        try
+        {
+            return [.. _dbContext.Roles.Where(x => x.RoleId == roleId).Select(x => _mapper.Map<RoleDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void ResElement(string id)
+    {
+        try
+        {
+            var element = GetRoleById(id) ?? throw new ElementNotFoundException(id);
+            element.IsActual = true;
+            _dbContext.SaveChanges();
+        }
+        catch
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+    }
+
+    public void UpdElement(RoleDataModel roleDataModel)
+    {
+        try
+        {
+            var transaction = _dbContext.Database.BeginTransaction();
+            try
+            {
+                var element = GetRoleById(roleDataModel.Id) ?? throw new ElementNotFoundException(roleDataModel.Id);
+                if (!element.IsActual)
+                {
+                    throw new ElementDeletedException(roleDataModel.Id);
+                }
+                element.IsActual = false;
+                _dbContext.SaveChanges();
+                var newElement = _mapper.Map<Role>(roleDataModel);
+                _dbContext.Roles.Add(newElement);
+                _dbContext.SaveChanges();
+                transaction.Commit();
+            }
+            catch
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Roles_RoleId_IsActual" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("RoleId", roleDataModel.RoleId);
+        }
+        catch (Exception ex) when (ex is ElementDeletedException || ex is ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    private Role? GetRoleById(string id) => _dbContext.Roles.Where(x => x.RoleId == id).OrderByDescending(x => x.ChangeDate).FirstOrDefault();
+}

WildPlumProject/WildPlumDatabase/Implementations/SalaryStorageContract.cs

@@ -0,0 +1,57 @@
+using AutoMapper;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class SalaryStorageContract : ISalaryStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public SalaryStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Salary, SalaryDataModel>();
+            cfg.CreateMap<SalaryDataModel, Salary>()
+            .ForMember(dest => dest.Amount, opt => opt.MapFrom(src => src.Amount));
+        });
+        _mapper = new Mapper(config);
+    }
+
+    public void AddElement(SalaryDataModel salaryDataModel)
+    {
+        try
+        {
+            _dbContext.Salaries.Add(_mapper.Map<Salary>(salaryDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<SalaryDataModel> GetList(DateTime startDate, DateTime endDate, string? workerId = null)
+    {
+        try
+        {
+            var query = _dbContext.Salaries.Where(x => x.SalaryDate >= startDate && x.SalaryDate <= endDate);
+            if (workerId is not null)
+            {
+                query = query.Where(x => x.WorkerId == workerId);
+            }
+            return [.. query.Select(x => _mapper.Map<SalaryDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+}

WildPlumProject/WildPlumDatabase/Implementations/WarehouseStorageContract.cs

@@ -0,0 +1,141 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class WarehouseStorageContract : IWarehouseStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public WarehouseStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Warehouse, WarehouseDataModel>();
+            cfg.CreateMap<WarehouseDataModel, Warehouse>();
+        });
+        _mapper = new Mapper(config);
+    }
+
+    public void AddElement(WarehouseDataModel warehouseDataModel)
+    {
+        try
+        {
+            _dbContext.Warehouses.Add(_mapper.Map<Warehouse>(warehouseDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (InvalidOperationException ex) when (ex.TargetSite?.Name == "ThrowIdentityConflict")
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("Id", warehouseDataModel.Id);
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is
+        PostgresException { ConstraintName: "IX_Warehouses_Name" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("Name", warehouseDataModel.Name);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var element = GetWarehouseById(id) ?? throw new ElementNotFoundException(id);
+            _dbContext.Warehouses.Remove(element);
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public WarehouseDataModel? GetElementById(string id)
+    {
+        try
+        {
+            return _mapper.Map<WarehouseDataModel>(GetWarehouseById(id));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public WarehouseDataModel? GetElementByName(string name)
+    {
+        try
+        {
+            return _mapper.Map<WarehouseDataModel>(_dbContext.Warehouses.FirstOrDefault(x => x.Name == name));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+
+    public List<WarehouseDataModel> GetList()
+    {
+        try
+        {
+            var query = _dbContext.Warehouses.AsQueryable();
+            return [.. query.Select(x => _mapper.Map<WarehouseDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+
+    }
+
+    public void UpdElement(WarehouseDataModel warehouseDataModel)
+    {
+        try
+        {
+            var element = GetWarehouseById(warehouseDataModel.Id) ?? throw new ElementNotFoundException(warehouseDataModel.Id);
+            _dbContext.Warehouses.Update(_mapper.Map(warehouseDataModel, element));
+            _dbContext.SaveChanges();
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Warehouses_Name" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("Name", warehouseDataModel.Name);
+        }
+        catch (Exception ex) when (ex is ElementDeletedException || ex is
+        ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    private Warehouse? GetWarehouseById(string id) => _dbContext.Warehouses.FirstOrDefault(x => x.Id == id);
+}

WildPlumProject/WildPlumDatabase/Implementations/WorkerStorageContract.cs

@@ -0,0 +1,140 @@
+using AutoMapper;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase.Implementations;
+
+public class WorkerStorageContract : IWorkerStorageContract
+{
+    private readonly WildPlumDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public WorkerStorageContract(WildPlumDbContext dbContext)
+    {
+        _dbContext = dbContext;
+
+        var configuration = new MapperConfiguration(cfg => cfg.AddMaps(typeof(Worker)));
+
+        _mapper = new Mapper(configuration);
+    }
+
+    public void AddElement(WorkerDataModel employeeDataModel)
+    {
+        try
+        {
+            _dbContext.Workers.Add(_mapper.Map<Worker>(employeeDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (InvalidOperationException ex) when (ex.TargetSite?.Name == "ThrowIdentityConflict")
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("Id", employeeDataModel.Id);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var element = GetWorkerById(id) ?? throw new ElementNotFoundException(id);
+            element.IsDeleted = true;
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public WorkerDataModel? GetElementByEmail(string email)
+    {
+        try
+        {
+            return
+            _mapper.Map<WorkerDataModel>(_dbContext.Workers.FirstOrDefault(x => x.Email == email));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public WorkerDataModel? GetElementById(string id)
+    {
+        try
+        {
+            return _mapper.Map<WorkerDataModel>(GetWorkerById(id));
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<WorkerDataModel> GetList(bool onlyActive = true, string? roleId = null, DateTime? fromBirthDate = null, DateTime? toBirthDate = null, DateTime? fromEmploymentDate = null, DateTime? toEmploymentDate = null)
+    {
+        try
+        {
+            var query = _dbContext.Workers.AsQueryable();
+            if (onlyActive)
+            {
+                query = query.Where(x => !x.IsDeleted);
+            }
+            if (roleId is not null)
+            {
+                query = query.Where(x => x.RoleId == roleId);
+            }
+            if (fromBirthDate is not null && toBirthDate is not null)
+            {
+                query = query.Where(x => x.BirthDate >= fromBirthDate && x.BirthDate <= toBirthDate);
+            }
+            if (fromEmploymentDate is not null && toEmploymentDate is not null)
+            {
+                query = query.Where(x => x.EmploymentDate >= fromEmploymentDate && x.EmploymentDate <= toEmploymentDate);
+            }
+            return [.. query.Select(x => _mapper.Map<WorkerDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void UpdElement(WorkerDataModel employeeDataModel)
+    {
+        try
+        {
+            var element = GetWorkerById(employeeDataModel.Id) ?? throw new ElementNotFoundException(employeeDataModel.Id);
+            _dbContext.Workers.Update(_mapper.Map(employeeDataModel, element));
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    private Worker? GetWorkerById(string id) => _dbContext.Workers.FirstOrDefault(x => x.Id == id && !x.IsDeleted);
+}

WildPlumProject/WildPlumDatabase/Models/Order.cs

@@ -0,0 +1,25 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Net.NetworkInformation;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Enums;
+
+namespace WildPlumDatabase.Models;
+
+public class Order
+{
+    public required string Id { get; set; }
+    public required string WarehouseId { get; set; }
+    public required string WorkerId { get; set; }
+    public required string CustomerName { get; set; }
+    public OrderStatus Status { get; set; }
+    public DateTime OrderDate { get; set; }
+    public Worker? Worker { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    [ForeignKey("OrderId")]
+    public List<OrderProduct>? Products { get; set; }
+
+    [ForeignKey("OrderId")]
+    public List<OrderHistory>? OrderHistories { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/OrderHistory.cs

@@ -0,0 +1,12 @@
+using WildPlumContracts.Enums;
+
+namespace WildPlumDatabase.Models;
+
+public class OrderHistory
+{
+    public required string Id { get; set; }
+    public required string OrderId { get; set; }
+    public OrderStatus OldStatus { get; set; }
+    public DateTime ChangeDate { get; set; }
+    public Order? Order { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/OrderProduct.cs

@@ -0,0 +1,10 @@
+namespace WildPlumDatabase.Models;
+
+public class OrderProduct
+{
+    public required string OrderId { get; set; }
+    public required string ProductId { get; set; }
+    public int Count { get; set; }
+    public Order? Order { get; set; }
+    public Product? Product { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/Product.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace WildPlumDatabase.Models;
+
+public class Product
+{
+    public required string Id { get; set; }
+    public required string ProductName { get; set; }
+    public double Price { get; set; }
+    public bool IsDeleted { get; set; }
+
+    [ForeignKey("ProductId")]
+    public List<OrderProduct>? Products { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/Role.cs

@@ -0,0 +1,12 @@
+using WildPlumContracts.Enums;
+
+namespace WildPlumDatabase.Models;
+
+public class Role
+{
+    public string Id { get; set; } = Guid.NewGuid().ToString();
+    public required string RoleId { get; set; }
+    public WorkerRole WorkerRole { get; set; }
+    public bool IsActual { get; set; }
+    public DateTime ChangeDate { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/Salary.cs

@@ -0,0 +1,10 @@
+namespace WildPlumDatabase.Models;
+
+public class Salary
+{
+    public string Id { get; set; } = Guid.NewGuid().ToString();
+    public required string WorkerId { get; set; }
+    public double Amount { get; set; }
+    public DateTime SalaryDate { get; set; }
+    public Worker? Worker { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/Warehouse.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Xml.Linq;
+
+namespace WildPlumDatabase.Models;
+
+public class Warehouse
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public required string Location { get; set; }
+
+    [ForeignKey("WarehouseId")]
+    public List<Order>? Orders { get; set; }
+}

WildPlumProject/WildPlumDatabase/Models/Worker.cs

@@ -0,0 +1,23 @@
+using AutoMapper;
+using System.ComponentModel.DataAnnotations.Schema;
+using WildPlumContracts.DataModels;
+
+namespace WildPlumDatabase.Models;
+
+[AutoMap(typeof(WorkerDataModel), ReverseMap = true)]
+public class Worker
+{
+    public required string Id { get; set; }
+    public required string FullName { get; set; }
+    public required string Email { get; set; }
+    public required string RoleId { get; set; }
+    public DateTime BirthDate { get; set; }
+    public DateTime EmploymentDate { get; set; }
+    public bool IsDeleted { get; set; }
+
+    [ForeignKey("WorkerId")]
+    public List<Salary>? Salaries { get; set; }
+
+    [ForeignKey("WorkerId")]
+    public List<Order>? Orders { get; set; }
+}

WildPlumProject/WildPlumDatabase/WildPlumDatabase.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="14.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.2" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WildPlumContracts\WildPlumContracts.csproj" />
+  </ItemGroup>
+
+	<ItemGroup>
+		<InternalsVisibleTo Include="WildPlumTests" />
+		<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+	</ItemGroup>
+
+</Project>

WildPlumProject/WildPlumDatabase/WildPlumDbContext.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using WildPlumContracts.Infrastructure;
+using WildPlumDatabase.Models;
+
+namespace WildPlumDatabase;
+
+public class WildPlumDbContext(IConfigurationDatabase configurationDatabase) : DbContext
+{
+    private readonly IConfigurationDatabase? _configurationDatabase = configurationDatabase;
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        optionsBuilder.UseNpgsql(_configurationDatabase?.ConnectionString, o => o.SetPostgresVersion(12, 2));
+        base.OnConfiguring(optionsBuilder);
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+        modelBuilder.Entity<Worker>().HasIndex(x => x.Email).IsUnique();
+
+        modelBuilder.Entity<Warehouse>().HasIndex(x => x.Name).IsUnique();
+
+        modelBuilder.Entity<Role>()
+            .HasIndex(e => new { e.RoleId, e.IsActual })
+            .IsUnique()
+            .HasFilter($"\"{nameof(Role.IsActual)}\" = TRUE");
+
+        modelBuilder.Entity<Product>()
+            .HasIndex(x => new { x.ProductName, x.IsDeleted })
+            .IsUnique()
+            .HasFilter($"\"{nameof(Product.IsDeleted)}\" = FALSE");
+
+        modelBuilder.Entity<OrderProduct>().HasKey(x => new
+        {
+            x.OrderId,
+            x.ProductId
+        });
+    }
+    public DbSet<Worker> Workers { get; set; }
+    public DbSet<OrderHistory> OrderHistories { get; set; }
+    public DbSet<Product> Products { get; set; }
+    public DbSet<Role> Roles { get; set; }
+    public DbSet<Salary> Salaries { get; set; }
+    public DbSet<Order> Orders { get; set; }
+    public DbSet<OrderProduct> OrderProducts { get; set; }
+    public DbSet<Warehouse> Warehouses { get; set; }
+}

WildPlumProject/WildPlumProject.sln

@@ -3,9 +3,13 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.8.34330.188
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WildPlumContracts", "WildPlumContracts\WildPlumContracts.csproj", "{8BCD3E5E-8B41-4FC7-A94E-A906EA7DD60F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WildPlumContracts", "WildPlumContracts\WildPlumContracts.csproj", "{8BCD3E5E-8B41-4FC7-A94E-A906EA7DD60F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WildPlumTests", "WildPlumTests\WildPlumTests.csproj", "{0B12533B-F248-40E1-BD14-783ACEEE9D93}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WildPlumTests", "WildPlumTests\WildPlumTests.csproj", "{0B12533B-F248-40E1-BD14-783ACEEE9D93}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WildPlumBusinessLogic", "WildPlumBusinessLogic\WildPlumBusinessLogic.csproj", "{55BEFDCB-041A-4D0C-B51F-164EB88D9E5B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WildPlumDatabase", "WildPlumDatabase\WildPlumDatabase.csproj", "{06CB985C-6592-4D94-9422-1C6B58002F59}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -21,6 +25,14 @@ Global
 		{0B12533B-F248-40E1-BD14-783ACEEE9D93}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0B12533B-F248-40E1-BD14-783ACEEE9D93}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0B12533B-F248-40E1-BD14-783ACEEE9D93}.Release|Any CPU.Build.0 = Release|Any CPU
+		{55BEFDCB-041A-4D0C-B51F-164EB88D9E5B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{55BEFDCB-041A-4D0C-B51F-164EB88D9E5B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{55BEFDCB-041A-4D0C-B51F-164EB88D9E5B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{55BEFDCB-041A-4D0C-B51F-164EB88D9E5B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{06CB985C-6592-4D94-9422-1C6B58002F59}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{06CB985C-6592-4D94-9422-1C6B58002F59}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{06CB985C-6592-4D94-9422-1C6B58002F59}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{06CB985C-6592-4D94-9422-1C6B58002F59}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/OrderBusinessLogicContractTests.cs

@@ -0,0 +1,368 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Enums;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class OrderBusinessLogicContractTests
+{
+    private OrderBusinessLogicContract _saleBusinessLogicContract;
+    private Mock<IOrderStorageContract> _saleStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _saleStorageContract = new Mock<IOrderStorageContract>();
+        _saleBusinessLogicContract = new OrderBusinessLogicContract(_saleStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _saleStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllSalesByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<OrderDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+        };
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByPeriod(date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.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(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(),It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var workerId = Guid.NewGuid().ToString();
+        var listOriginal = new List<OrderDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+        };
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(workerId, date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), workerId, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod("workerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(),It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByWorkerByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.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(() => _saleBusinessLogicContract.GetAllSalesByEmployeerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var productId = Guid.NewGuid().ToString();
+        var listOriginal = new List<OrderDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now, []),
+        };
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByProductByPeriod(productId, date, date.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, productId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_ProductIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_ProductIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod("productId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalesByProductByPeriod_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.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(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+        _saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetSaleByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new OrderDataModel(id, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+        _saleStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _saleBusinessLogicContract.GetSaleByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetSaleByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetSaleByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _saleBusinessLogicContract.GetSaleByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetSaleByData_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetSaleByData("saleId"), Throws.TypeOf<ValidationException>());
+        _saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetSaleByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetSaleByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertSale_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+        _saleStorageContract.Setup(x => x.AddElement(It.IsAny<OrderDataModel>()))
+            .Callback((OrderDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.WorkerId == record.WorkerId && 
+                    x.OrderDate == record.OrderDate && x.Status == record.Status &&
+                    x.Products.Count == record.Products.Count &&
+                    x.Products.First().ProductId == record.Products.First().ProductId &&
+                    x.Products.First().OrderId == record.Products.First().OrderId &&
+                    x.Products.First().Count == record.Products.First().Count;
+            });
+        //Act
+        _saleBusinessLogicContract.InsertSale(record);
+        //Assert
+        _saleStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertSale_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.AddElement(It.IsAny<OrderDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.InsertSale(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
+        _saleStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertSale_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.InsertSale(null), Throws.TypeOf<ArgumentNullException>());
+        _saleStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertSale_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.InsertSale(new("id", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [])), Throws.TypeOf<ValidationException>());
+        _saleStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertSale_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _saleStorageContract.Setup(x => x.AddElement(It.IsAny<OrderDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _saleBusinessLogicContract.InsertSale(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.Pending, DateTime.Now,
+                [new OrderProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
+        _saleStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Once);
+    }
+}

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/ProductBusinessLogicContractTests.cs

@@ -0,0 +1,330 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class ProductBusinessLogicContractTests
+{
+    private ProductBusinessLogicContract _productBusinessLogicContract;
+    private Mock<IProductStorageContract> _productStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _productStorageContract = new Mock<IProductStorageContract>();
+        _productBusinessLogicContract = new ProductBusinessLogicContract(_productStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _productStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllProducts_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<ProductDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "name 1", 10, false),
+            new(Guid.NewGuid().ToString(), "name 1", 10, true),
+            new(Guid.NewGuid().ToString(), "name 1", 10, false),
+        };
+        _productStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _productBusinessLogicContract.GetAllProducts(true);
+        var list = _productBusinessLogicContract.GetAllProducts(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));
+        });
+        _productStorageContract.Verify(x => x.GetList(true), Times.Once);
+        _productStorageContract.Verify(x => x.GetList(false), Times.Once);
+    }
+
+    [Test]
+    public void GetAllProducts_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns([]);
+        //Act
+        var listOnlyActive = _productBusinessLogicContract.GetAllProducts(true);
+        var list = _productBusinessLogicContract.GetAllProducts(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));
+        });
+        _productStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllProducts_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetAllProducts(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _productStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllProducts_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetAllProducts(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _productStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+    }
+
+    [Test]
+    public void GetProductByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new ProductDataModel(id, "name", 10, false);
+        _productStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _productBusinessLogicContract.GetProductByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _productStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetProductByData_GetByName_ReturnRecord_Test()
+    {
+        //Arrange
+        var name = "name";
+        var record = new ProductDataModel(Guid.NewGuid().ToString(), name, 10, false);
+        _productStorageContract.Setup(x => x.GetElementByName(name)).Returns(record);
+        //Act
+        var element = _productBusinessLogicContract.GetProductByData(name);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.ProductName, Is.EqualTo(name));
+        _productStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetProductByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetProductByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _productBusinessLogicContract.GetProductByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _productStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+        _productStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetProductByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetProductByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _productStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetProductByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetProductByData("name"), Throws.TypeOf<ElementNotFoundException>());
+        _productStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetProductByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _productStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.GetProductByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _productBusinessLogicContract.GetProductByData("name"), Throws.TypeOf<StorageException>());
+        _productStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _productStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertProduct_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new ProductDataModel(Guid.NewGuid().ToString(), "name", 10, false);
+        _productStorageContract.Setup(x => x.AddElement(It.IsAny<ProductDataModel>()))
+            .Callback((ProductDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.ProductName == record.ProductName && x.Price == record.Price && x.IsDeleted == record.IsDeleted;
+            });
+        //Act
+        _productBusinessLogicContract.InsertProduct(record);
+        //Assert
+        _productStorageContract.Verify(x => x.AddElement(It.IsAny<ProductDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertProduct_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.AddElement(It.IsAny<ProductDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.InsertProduct(new(Guid.NewGuid().ToString(), "name", 10, false)), Throws.TypeOf<ElementExistsException>());
+        _productStorageContract.Verify(x => x.AddElement(It.IsAny<ProductDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertProduct_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.InsertProduct(null), Throws.TypeOf<ArgumentNullException>());
+        _productStorageContract.Verify(x => x.AddElement(It.IsAny<ProductDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertProduct_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.InsertProduct(new ProductDataModel("id", "name", 10, false)), Throws.TypeOf<ValidationException>());
+        _productStorageContract.Verify(x => x.AddElement(It.IsAny<ProductDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertProduct_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.AddElement(It.IsAny<ProductDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.InsertProduct(new(Guid.NewGuid().ToString(), "name", 10, false)), Throws.TypeOf<StorageException>());
+        _productStorageContract.Verify(x => x.AddElement(It.IsAny<ProductDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateProduct_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new ProductDataModel(Guid.NewGuid().ToString(), "name", 10, false);
+        _productStorageContract.Setup(x => x.UpdElement(It.IsAny<ProductDataModel>()))
+            .Callback((ProductDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.ProductName == record.ProductName && x.Price == record.Price && x.IsDeleted == record.IsDeleted;
+            });
+        //Act
+        _productBusinessLogicContract.UpdateProduct(record);
+        //Assert
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateProduct_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.UpdElement(It.IsAny<ProductDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.UpdateProduct(new(Guid.NewGuid().ToString(), "name", 10, false)), Throws.TypeOf<ElementNotFoundException>());
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateProduct_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.UpdElement(It.IsAny<ProductDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.UpdateProduct(new(Guid.NewGuid().ToString(), "anme", 10, false)), Throws.TypeOf<ElementExistsException>());
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateProduct_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.UpdateProduct(null), Throws.TypeOf<ArgumentNullException>());
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateProduct_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.UpdateProduct(new ProductDataModel("id", "name", 10, false)), Throws.TypeOf<ValidationException>());
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateProduct_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.UpdElement(It.IsAny<ProductDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.UpdateProduct(new(Guid.NewGuid().ToString(), "name", 10, false)), Throws.TypeOf<StorageException>());
+        _productStorageContract.Verify(x => x.UpdElement(It.IsAny<ProductDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteProduct_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _productStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _productBusinessLogicContract.DeleteProduct(id);
+        //Assert
+        _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteProduct_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _productStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.DeleteProduct(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteProduct_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.DeleteProduct(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _productBusinessLogicContract.DeleteProduct(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteProduct_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.DeleteProduct("id"), Throws.TypeOf<ValidationException>());
+        _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteProduct_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _productStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _productBusinessLogicContract.DeleteProduct(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/RoleBusinessLogicContractTests.cs

@@ -0,0 +1,425 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Enums;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class RoleBusinessLogicContractTests
+{
+    private RoleBusinessLogicContract _postBusinessLogicContract;
+    private Mock<IRoleStorageContract> _postStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _postStorageContract = new Mock<IRoleStorageContract>();
+        _postBusinessLogicContract = new RoleBusinessLogicContract(_postStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _postStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllPosts_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<RoleDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(),true, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(),false, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(),true, DateTime.UtcNow),
+        };
+        _postStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _postBusinessLogicContract.GetAllRoles(true);
+        var listAll = _postBusinessLogicContract.GetAllRoles(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.GetAllRoles(true);
+        var listAll = _postBusinessLogicContract.GetAllRoles(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.GetAllRoles(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.GetAllRoles(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<RoleDataModel>()
+        {
+            new(postId, WorkerRole.Courier, Guid.NewGuid().ToString(),true, DateTime.UtcNow),
+            new(postId, WorkerRole.Courier, Guid.NewGuid().ToString(),false, DateTime.UtcNow)
+        };
+        _postStorageContract.Setup(x => x.GetRoleWithHistory(It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _postBusinessLogicContract.GetAllDataOfRole(postId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(postId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetRoleWithHistory(It.IsAny<string>())).Returns([]);
+        //Act
+        var list = _postBusinessLogicContract.GetAllDataOfRole(Guid.NewGuid().ToString());
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_PostIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfRole(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfRole(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_PostIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfRole("id"), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfRole(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllDataOfPost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.GetRoleWithHistory(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetAllDataOfRole(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.GetRoleWithHistory(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetPostByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new RoleDataModel(id, WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow);
+        _postStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _postBusinessLogicContract.GetRoleByData(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_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetRoleByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.GetRoleByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetPostByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetRoleByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.GetElementById(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()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.GetRoleByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertPost_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new RoleDataModel(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow.AddDays(-1));
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<RoleDataModel>()))
+            .Callback((RoleDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.WorkerRole == record.WorkerRole &&
+                    x.ChangeDate == record.ChangeDate;
+            });
+        //Act
+        _postBusinessLogicContract.InsertRole(record);
+        //Assert
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<RoleDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertPost_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<RoleDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertRole(new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<ElementExistsException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<RoleDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertPost_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertRole(null), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<RoleDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertPost_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertRole(new RoleDataModel("id", WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<RoleDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertPost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.AddElement(It.IsAny<RoleDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.InsertRole(new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.AddElement(It.IsAny<RoleDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new RoleDataModel(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow.AddDays(-1));
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<RoleDataModel>()))
+            .Callback((RoleDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.WorkerRole == record.WorkerRole &&
+                    x.ChangeDate == record.ChangeDate;
+            });
+        //Act
+        _postBusinessLogicContract.UpdateRole(record);
+        //Assert
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdatePost_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<RoleDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdateRole(new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<ElementNotFoundException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<RoleDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdateRole(new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<ElementExistsException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdatePost_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdateRole(null), Throws.TypeOf<ArgumentNullException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdatePost_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdateRole(new RoleDataModel("id", WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<ValidationException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdatePost_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _postStorageContract.Setup(x => x.UpdElement(It.IsAny<RoleDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _postBusinessLogicContract.UpdateRole(new(Guid.NewGuid().ToString(), WorkerRole.Courier, Guid.NewGuid().ToString(), true, DateTime.UtcNow)), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.UpdElement(It.IsAny<RoleDataModel>()), 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.DeleteRole(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.DeleteRole(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.DeleteRole(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.DeleteRole(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.DeleteRole("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.DeleteRole(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.RestoreRole(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.RestoreRole(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.RestoreRole(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _postBusinessLogicContract.RestoreRole(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.RestoreRole("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.RestoreRole(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _postStorageContract.Verify(x => x.ResElement(It.IsAny<string>()), Times.Once);
+    }
+}

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs

@@ -0,0 +1,302 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Enums;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class SalaryBusinessLogicContractTests
+{
+    private SalaryBusinessLogicContract _salaryBusinessLogicContract;
+    private Mock<ISalaryStorageContract> _salaryStorageContract;
+    private Mock<IOrderStorageContract> _orderStorageContract;
+    private Mock<IWorkerStorageContract> _employeeStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _salaryStorageContract = new Mock<ISalaryStorageContract>();
+        _orderStorageContract = new Mock<IOrderStorageContract>();
+        _employeeStorageContract = new Mock<IWorkerStorageContract>();
+        _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object,
+            _orderStorageContract.Object, _employeeStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _salaryStorageContract.Reset();
+        _orderStorageContract.Reset();
+        _employeeStorageContract.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(), Guid.NewGuid().ToString(), 10, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20, DateTime.UtcNow.AddDays(1)),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 30, DateTime.UtcNow.AddDays(-1))
+        };
+        _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(), Guid.NewGuid().ToString(), 10, DateTime.UtcNow),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20, DateTime.UtcNow.AddDays(1)),
+            new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 30, DateTime.UtcNow.AddDays(-1))
+        };
+        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns(listOriginal);
+        //Act
+        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(dateTime, dateTime, Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(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.GetAllSalariesByPeriodByEmployeer(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_CalculateSalary_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        var saleSum = 200.0;
+        var postSalary = 100.0;
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), workerId, "Name", OrderStatus.InProgress, DateTime.UtcNow, [])]);
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+        var sum = 0.0;
+        var expectedSum = postSalary + saleSum * 0.1;
+        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+            .Callback((SalaryDataModel x) =>
+            {
+                sum = 120;
+            });
+        //Act
+        _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+        //Assert
+        Assert.That(sum, Is.EqualTo(expectedSum));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_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", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false),
+            new(worker2Id, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false),
+            new(worker3Id, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)
+        };
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), worker1Id, "Name", OrderStatus.InProgress, DateTime.UtcNow, []),
+                new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), worker1Id, "Name", OrderStatus.InProgress, DateTime.UtcNow, []),
+                new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), worker2Id, "Name", OrderStatus.InProgress, DateTime.UtcNow, []),
+                new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), worker2Id, "Name", OrderStatus.InProgress, DateTime.UtcNow, []),
+                new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), worker3Id, "Name", OrderStatus.InProgress, DateTime.UtcNow, [])]);
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns(list);
+        //Act
+        _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+        //Assert
+        _salaryStorageContract.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Exactly(list.Count));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_WithoitSalesByWorker_Test()
+    {
+        //Arrange
+        var postSalary = 100.0;
+        var workerId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([]);
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+        var sum = 0.0;
+        var expectedSum = postSalary;
+        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+            .Callback((SalaryDataModel x) =>
+            {
+                sum = 100;
+            });
+        //Act
+        _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+        //Assert
+        Assert.That(sum, Is.EqualTo(expectedSum));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_SaleStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_WorkerStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.InProgress, DateTime.UtcNow, [])]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_SaleStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Throws(new StorageException(new InvalidOperationException()));
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([new WorkerDataModel(workerId, "Test", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_WorkerStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var workerId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>()))
+            .Returns([new OrderDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Name", OrderStatus.InProgress, DateTime.UtcNow, [])]);
+        _employeeStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+    }
+}

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/WarehouseBusinessLogicContractTests.cs

@@ -0,0 +1,318 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class WarehouseBusinessLogicContractTests
+{
+    private WarehouserBusinessLogicContract _manufacturerBusinessLogicContract;
+    private Mock<IWarehouseStorageContract> _manufacturerStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _manufacturerStorageContract = new Mock<IWarehouseStorageContract>();
+        _manufacturerBusinessLogicContract = new WarehouserBusinessLogicContract(_manufacturerStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _manufacturerStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllManufacturers_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<WarehouseDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "name 1", "loc"),
+            new(Guid.NewGuid().ToString(), "name 2", "loc"),
+            new(Guid.NewGuid().ToString(), "name 3", "loc"),
+        };
+        _manufacturerStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+        //Act
+        var list = _manufacturerBusinessLogicContract.GetAllWarehouses();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+    }
+
+    [Test]
+    public void GetAllManufacturers_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.GetList()).Returns([]);
+        //Act
+        var list = _manufacturerBusinessLogicContract.GetAllWarehouses();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllManufacturers_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetAllWarehouses(), Throws.TypeOf<NullListException>());
+        _manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllManufacturers_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetAllWarehouses(), Throws.TypeOf<StorageException>());
+        _manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetManufacturerByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new WarehouseDataModel(id, "name", "loc");
+        _manufacturerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _manufacturerBusinessLogicContract.GetWarehouseByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetManufacturerByData_GetByName_ReturnRecord_Test()
+    {
+        //Arrange
+        var manufacturerName = "name";
+        var record = new WarehouseDataModel(Guid.NewGuid().ToString(), manufacturerName, "loc");
+        _manufacturerStorageContract.Setup(x => x.GetElementByName(manufacturerName)).Returns(record);
+        //Act
+        var element = _manufacturerBusinessLogicContract.GetWarehouseByData(manufacturerName);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Name, Is.EqualTo(manufacturerName));
+        _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetManufacturerByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetManufacturerByData__GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetManufacturerByData_GetByName_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData("name"), Throws.TypeOf<ElementNotFoundException>());
+        _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetManufacturerByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _manufacturerStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _manufacturerBusinessLogicContract.GetWarehouseByData("name"), Throws.TypeOf<StorageException>());
+        _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertManufacturer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WarehouseDataModel(Guid.NewGuid().ToString(), "name", "loc");
+        _manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<WarehouseDataModel>()))
+            .Callback((WarehouseDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Name == record.Name;
+            });
+        //Act
+        _manufacturerBusinessLogicContract.InsertWarehouse(record);
+        //Assert
+        _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertManufacturer_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<WarehouseDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.InsertWarehouse(new(Guid.NewGuid().ToString(), "name", "loc")), Throws.TypeOf<ElementExistsException>());
+        _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertManufacturer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.InsertWarehouse(null), Throws.TypeOf<ArgumentNullException>());
+        _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertManufacturer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.InsertWarehouse(new WarehouseDataModel("id", "name", "loc")), Throws.TypeOf<ValidationException>());
+        _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertManufacturer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<WarehouseDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.InsertWarehouse(new(Guid.NewGuid().ToString(), "name", "loc")), Throws.TypeOf<StorageException>());
+        _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateManufacturer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WarehouseDataModel(Guid.NewGuid().ToString(), "name", "loc");
+        _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>()))
+            .Callback((WarehouseDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Name == record.Name;
+            });
+        //Act
+        _manufacturerBusinessLogicContract.UpdateWarehouse(record);
+        //Assert
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateManufacturer_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.UpdateWarehouse(new(Guid.NewGuid().ToString(), "name", "loc")), Throws.TypeOf<ElementNotFoundException>());
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateManufacturer_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.UpdateWarehouse(new(Guid.NewGuid().ToString(), "name", "loc")), Throws.TypeOf<ElementExistsException>());
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateManufacturer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.UpdateWarehouse(null), Throws.TypeOf<ArgumentNullException>());
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateManufacturer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.UpdateWarehouse(new WarehouseDataModel("id", "name", "loc")), Throws.TypeOf<ValidationException>());
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateManufacturer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.UpdateWarehouse(new(Guid.NewGuid().ToString(), "name", "loc")), Throws.TypeOf<StorageException>());
+        _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteManufacturer_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _manufacturerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _manufacturerBusinessLogicContract.DeleteWarehouse(id);
+        //Assert
+        _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteManufacturer_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        _manufacturerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.DeleteWarehouse(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteManufacturer_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.DeleteWarehouse(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _manufacturerBusinessLogicContract.DeleteWarehouse(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteManufacturer_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.DeleteWarehouse("id"), Throws.TypeOf<ValidationException>());
+        _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteManufacturer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _manufacturerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _manufacturerBusinessLogicContract.DeleteWarehouse(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

WildPlumProject/WildPlumTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs

@@ -0,0 +1,557 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using WildPlumBusinessLogic.Implementations;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumContracts.StorageContracts;
+
+namespace WildPlumTests.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class WorkerBusinessLogicContractTests
+{
+    private WorkerBusinessLogicContract _employeeBusinessLogicContract;
+    private Mock<IWorkerStorageContract> _workerStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _workerStorageContract = new Mock<IWorkerStorageContract>();
+        _employeeBusinessLogicContract = new WorkerBusinessLogicContract(_workerStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _workerStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllEmployeers_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 2", "email@gmail.com",Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 3", "email@gmail.com",Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeers(true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeers(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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, null, null, null, null, null), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeers_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeers(true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeers(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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), null, null, null, null, null), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllEmployeers_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeers(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeers_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeers(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var postId = Guid.NewGuid().ToString();
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByRole(postId, true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeersByRole(postId, 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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, postId, null, null, null, null), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, postId, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByRole(Guid.NewGuid().ToString(), true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeersByRole(Guid.NewGuid().ToString(), 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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_PostIdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByRole(null, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByRole(string.Empty, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_PostIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByRole("postId", It.IsAny<bool>()), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByRole(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByRole_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByRole(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByBirthDate_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(date, date.AddDays(1), true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(date, date.AddDays(1), 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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, null, date, date.AddDays(1), null, null), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, null, date, date.AddDays(1), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByBirthDate_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeers(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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), null, null), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByBirthDate_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllEmployeersByBirthDate_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByBirthDate_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByEmploymentDate_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<WorkerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 1", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(listOriginal);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(date, date.AddDays(1), true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(date, date.AddDays(1), 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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, null, null, null, date, date.AddDays(1)), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, null, null, null, date, date.AddDays(1)), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByEmploymentDate_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns([]);
+        //Act
+        var listOnlyActive = _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), true);
+        var list = _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), 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));
+        });
+        _workerStorageContract.Verify(x => x.GetList(true, null, null, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+        _workerStorageContract.Verify(x => x.GetList(false, null, null, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByEmploymentDate_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var date = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllEmployeersByEmploymentDate_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllEmployeersByEmploymentDate_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetAllEmployeersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetEmployeerByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new WorkerDataModel(id, "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _workerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _employeeBusinessLogicContract.GetEmployeerByData(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 GetEmployeerByData_GetByEmail_ReturnRecord_Test()
+    {
+        //Arrange
+        var fio = "fio";
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), fio, "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _workerStorageContract.Setup(x => x.GetElementByEmail("email@gmail.com")).Returns(record);
+        //Act
+        var element = _employeeBusinessLogicContract.GetEmployeerByData("email@gmail.com");
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Email, Is.EqualTo("email@gmail.com"));
+        _workerStorageContract.Verify(x => x.GetElementByEmail(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetEmployeerByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workerStorageContract.Verify(x => x.GetElementByEmail(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetEmployeerByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workerStorageContract.Verify(x => x.GetElementByEmail(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetEmployeerByData_GetByFio_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData("fio"), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _workerStorageContract.Verify(x => x.GetElementByEmail(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetEmployeerByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _workerStorageContract.Setup(x => x.GetElementByEmail(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _employeeBusinessLogicContract.GetEmployeerByData("fio"), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _workerStorageContract.Verify(x => x.GetElementByEmail(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertEmployeer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>()))
+            .Callback((WorkerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Email == record.Email && x.RoleId == record.RoleId && x.BirthDate == record.BirthDate &&
+                    x.EmploymentDate == record.EmploymentDate && x.IsDeleted == record.IsDeleted;
+            });
+        //Act
+        _employeeBusinessLogicContract.InsertEmployeer(record);
+        //Assert
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertEmployeer_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.InsertEmployeer(new(Guid.NewGuid().ToString(), "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ElementExistsException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertEmployeer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.InsertEmployeer(null), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertEmployeer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.InsertEmployeer(new WorkerDataModel("id", "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertEmployeer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.InsertEmployeer(new(Guid.NewGuid().ToString(), "fio", "email@gmail.com",Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateEmployeer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>()))
+            .Callback((WorkerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.Email == record.Email && x.RoleId == record.RoleId && x.BirthDate == record.BirthDate &&
+                    x.EmploymentDate == record.EmploymentDate && x.IsDeleted == record.IsDeleted;
+            });
+        //Act
+        _employeeBusinessLogicContract.UpdateEmployeer(record);
+        //Assert
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateEmployeer_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.UpdateEmployeer(new(Guid.NewGuid().ToString(), "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateEmployeer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.UpdateEmployeer(null), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateEmployeer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.UpdateEmployeer(new WorkerDataModel("id", "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateEmployeer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.UpdateEmployeer(new(Guid.NewGuid().ToString(), "fio", "email@gmail.com", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteEmployeer_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
+        _employeeBusinessLogicContract.DeleteEmployeer(id);
+        //Assert
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteEmployeer_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(() => _employeeBusinessLogicContract.DeleteEmployeer(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteEmployeer_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.DeleteEmployeer(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _employeeBusinessLogicContract.DeleteEmployeer(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteEmployeer_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.DeleteEmployeer("id"), Throws.TypeOf<ValidationException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteEmployeer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _workerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _employeeBusinessLogicContract.DeleteEmployeer(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

WildPlumProject/WildPlumTests/DataModelTests/RoleDataModelTests.cs

@@ -26,6 +26,25 @@ public class RoleDataModelTests
             Throws.TypeOf<ValidationException>());
     }
 
+    [Test]
+    public void Validate_ThrowsException_WhenRoleIdIsNullOrEmpty()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(() => CreateDataModel(Guid.NewGuid().ToString(), null!, WorkerRole.Courier, true, DateTime.UtcNow).Validate(),
+                Throws.TypeOf<ValidationException>());
+            Assert.That(() => CreateDataModel(Guid.NewGuid().ToString(), string.Empty, WorkerRole.Courier, true, DateTime.UtcNow).Validate(),
+                Throws.TypeOf<ValidationException>());
+        });
+    }
+
+    [Test]
+    public void Validate_ThrowsException_WhenRoleIdIsNotGuid()
+    {
+        Assert.That(() => CreateDataModel(Guid.NewGuid().ToString(), "invalid-guid", WorkerRole.Courier, true, DateTime.UtcNow).Validate(),
+            Throws.TypeOf<ValidationException>());
+    }
+
     [Test]
     public void Validate_ThrowsException_WhenRoleIsNone()
     {
@@ -47,13 +66,13 @@ public class RoleDataModelTests
         Assert.That(() => roleData.Validate(), Throws.Nothing);
         Assert.Multiple(() =>
         {
-            Assert.That(roleData.Id, Is.EqualTo(id));   
-            Assert.That(roleData.Role, Is.EqualTo(role));
+            Assert.That(roleData.Id, Is.EqualTo(id));
+            Assert.That(roleData.WorkerRole, Is.EqualTo(role));
             Assert.That(roleData.IsActual, Is.EqualTo(isActual));
             Assert.That(roleData.ChangeDate, Is.EqualTo(changeDate).Within(TimeSpan.FromSeconds(1)));
         });
     }
 
     private static RoleDataModel CreateDataModel(string id, string roleId, WorkerRole role, bool isActive, DateTime createdAt) =>
-        new(id, roleId, role, isActive, createdAt);
+        new(id, role, roleId, isActive, createdAt);
 }

WildPlumProject/WildPlumTests/Infrastructure/ConfigurationDatabaseTest.cs

@@ -0,0 +1,8 @@
+using WildPlumContracts.Infrastructure;
+
+namespace WildPlumTests.Infrastructure;
+
+internal class ConfigurationDatabaseTest : IConfigurationDatabase
+{
+    public string ConnectionString => "Host=localhost;Port=5432;Database=RPP;Username=postgres;Password=525252;";
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/BaseStorageContractTests.cs

@@ -0,0 +1,23 @@
+using WildPlumTests.Infrastructure;
+using WildPlumDatabase;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+internal class BaseStorageContractTests
+{
+    protected WildPlumDbContext WildPlumDbContext { get; private set; }
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        WildPlumDbContext = new WildPlumDbContext(new ConfigurationDatabaseTest());
+        WildPlumDbContext.Database.EnsureDeleted();
+        WildPlumDbContext.Database.EnsureCreated();
+    }
+    [OneTimeTearDown]
+    public void OneTimeTearDown()
+    {
+        WildPlumDbContext.Database.EnsureDeleted();
+        WildPlumDbContext.Dispose();
+    }
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/EmployeeStorageContractTests.cs

@@ -0,0 +1,221 @@
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase.Models;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+[TestFixture]
+internal class EmployeeStorageContractTests : BaseStorageContractTests
+{
+    private WorkerStorageContract _workerStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _workerStorageContract = new WorkerStorageContract(WildPlumDbContext);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", email: "test2@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", email: "test3@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", email: "test4@gmail.com");
+        var list = _workerStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(), worker);
+    }
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _workerStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetList_ByJobTitleId_Test()
+    {
+        var jobTitleId = Guid.NewGuid().ToString();
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", jobTitleId, email: "test2@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", jobTitleId, email: "test3@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", email: "test4@gmail.com");
+        var list = _workerStorageContract.GetList(roleId: jobTitleId);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        Assert.That(list.All(x => x.RoleId == jobTitleId));
+    }
+
+    [Test]
+    public void Try_GetList_ByBirthDate_Test()
+    {
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", birthDate: DateTime.UtcNow.AddYears(-25), email: "test2@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", birthDate: DateTime.UtcNow.AddYears(-21), email: "test4@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", birthDate: DateTime.UtcNow.AddYears(-20), email: "test53@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-19), email: "test253gmail.com");
+        var list = _workerStorageContract.GetList(fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1), toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+    }
+    [Test]
+    public void Try_GetList_ByEmploymentDate_Test()
+    {
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", employmentDate: DateTime.UtcNow.AddDays(-2), email: "test2@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", employmentDate: DateTime.UtcNow.AddDays(-1), email: "test4@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", employmentDate: DateTime.UtcNow.AddDays(1), email: "test3@gmail.com");
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", employmentDate: DateTime.UtcNow.AddDays(2), email: "test11@gmail.com");
+        var list = _workerStorageContract.GetList(fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+    }
+    [Test]
+    public void Try_GetList_ByAllParameters_Test()
+    {
+        var jobTitleId = Guid.NewGuid().ToString();
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", jobTitleId, email: "test2@gmail.com", birthDate: DateTime.UtcNow.AddYears(-25), employmentDate: DateTime.UtcNow.AddDays(-2));
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", jobTitleId, email: "test4@gmail.com", birthDate: DateTime.UtcNow.AddYears(-22), employmentDate: DateTime.UtcNow.AddDays(-1));
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", jobTitleId, email: "test6@gmail.com", birthDate: DateTime.UtcNow.AddYears(-21), employmentDate: DateTime.UtcNow.AddDays(-1));
+        InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-20), employmentDate: DateTime.UtcNow.AddDays(1));
+        var list = _workerStorageContract.GetList(roleId: jobTitleId, fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1),
+            toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1), fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+    }
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_workerStorageContract.GetElementById(worker.Id), worker);
+    }
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        Assert.That(() => _workerStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementByEmail_WhenHaveRecord_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_workerStorageContract.GetElementByEmail(worker.Email), worker);
+    }
+    [Test]
+    public void Try_GetElementByEmail_WhenNoRecord_Test()
+    {
+        Assert.That(() => _workerStorageContract.GetElementByEmail("New email"), Is.Null);
+    }
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var worker = CreateModel(Guid.NewGuid().ToString());
+        _workerStorageContract.AddElement(worker);
+        AssertElement(GetWorkerFromDatabase(worker.Id), worker);
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var worker = CreateModel(Guid.NewGuid().ToString());
+        InsertWorkerToDatabaseAndReturn(worker.Id);
+        Assert.That(() => _workerStorageContract.AddElement(worker), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var worker = CreateModel(Guid.NewGuid().ToString(), "New Fio", email: "test23@gmail.com");
+        InsertWorkerToDatabaseAndReturn(worker.Id);
+        _workerStorageContract.UpdElement(worker);
+        AssertElement(GetWorkerFromDatabase(worker.Id), worker);
+    }
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _workerStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWasDeleted_Test()
+    {
+        var worker = CreateModel(Guid.NewGuid().ToString(), email: "test255@gmail.com");
+        InsertWorkerToDatabaseAndReturn(worker.Id, isDeleted: true);
+        Assert.That(() => _workerStorageContract.UpdElement(worker), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+        _workerStorageContract.DelElement(worker.Id);
+        var element = GetWorkerFromDatabase(worker.Id);
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.IsDeleted);
+    }
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _workerStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_DelElement_WhenNoRecordWasDeleted_Test()
+    {
+        var worker = CreateModel(Guid.NewGuid().ToString());
+        InsertWorkerToDatabaseAndReturn(worker.Id, isDeleted: true);
+        Assert.That(() => _workerStorageContract.DelElement(worker.Id), Throws.TypeOf<ElementNotFoundException>());
+    }
+    private Worker InsertWorkerToDatabaseAndReturn(string id, string fio = "test", string? jobTitleId = null, DateTime? birthDate = null, DateTime?
+    employmentDate = null, bool isDeleted = false, string email = "test@gmail.com")
+    {
+        var worker = new Worker()
+        {
+            Id = id,
+            FullName = fio,
+            Email = email,
+            RoleId = jobTitleId ?? Guid.NewGuid().ToString(),
+            BirthDate = birthDate ?? DateTime.UtcNow.AddYears(-20),
+            EmploymentDate = employmentDate ?? DateTime.UtcNow,
+            IsDeleted = isDeleted
+        };
+        WildPlumDbContext.Workers.Add(worker);
+        WildPlumDbContext.SaveChanges();
+        return worker;
+    }
+    private static void AssertElement(WorkerDataModel? actual, Worker expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.RoleId, Is.EqualTo(expected.RoleId));
+            Assert.That(actual.FullName, Is.EqualTo(expected.FullName));
+            Assert.That(actual.Email, Is.EqualTo(expected.Email));
+            Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
+            Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
+            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
+        });
+    }
+
+    private static WorkerDataModel CreateModel(string id, string fio = "fio", string? jobTitleId = null, DateTime? birthDate = null,
+        DateTime? employmentDate = null, bool isDeleted = false, string email = "test@gmail.com") =>
+    new(id, fio, email, jobTitleId ?? Guid.NewGuid().ToString(), birthDate ?? DateTime.UtcNow.AddYears(-20), employmentDate ?? DateTime.UtcNow, isDeleted);
+    
+    private Worker? GetWorkerFromDatabase(string id) => WildPlumDbContext.Workers.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Worker? actual, WorkerDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null); Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.RoleId, Is.EqualTo(expected.RoleId));
+            Assert.That(actual.FullName, Is.EqualTo(expected.FullName));
+            Assert.That(actual.Email, Is.EqualTo(expected.Email));
+            Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
+            Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
+            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
+        });
+    }
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/OrderStorageContractTests.cs

@@ -0,0 +1,305 @@
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase.Models;
+using WildPlumContracts.Enums;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+internal class OrderStorageContractTests : BaseStorageContractTests
+{
+    private OrderStorageContract _orderStorageContract;
+    private Warehouse _warehouse;
+    private Worker _worker;
+    private Product _product;
+    [SetUp]
+    public void SetUp()
+    {
+        _orderStorageContract = new OrderStorageContract(WildPlumDbContext);
+        _warehouse = InsertBuyerToDatabaseAndReturn();
+        _worker = InsertWorkerToDatabaseAndReturn();
+        _product = InsertProductToDatabaseAndReturn();
+    }
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Orders\" CASCADE; ");
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE; ");
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE; ");
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Products\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var Order = InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 5)]);
+        var list = _orderStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        AssertElement(list.First(x => x.Id == Order.Id), Order);
+    }
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _orderStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+    [Test]
+    public void Try_GetList_ByPeriod_Test()
+    {
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, OrderDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, OrderDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), products: [(_product.Id, 1)]);
+        var list = _orderStorageContract.GetList(startDate: DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+    }
+    [Test]
+    public void Try_GetList_ByWorkerId_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn("Other worker", "test4@gmail.com");
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1)]);
+        var list = _orderStorageContract.GetList(employeerId: _worker.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        Assert.That(list.All(x => x.WorkerId == _worker.Id));
+    }
+    [Test]
+    public void Try_GetList_ByProductId_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn("Other name");
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 5)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1), (product.Id, 4)]);
+        var list = _orderStorageContract.GetList(productId: _product.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        Assert.That(list.All(x => x.Products!.Any(y => y.ProductId ==
+        _product.Id)));
+    }
+    [Test]
+    public void Try_GetList_ByAllParameters_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn("Other worker", "test2@gmail.com");
+        var buyer = InsertBuyerToDatabaseAndReturn("Other name1", "location");
+        var product = InsertProductToDatabaseAndReturn("Other name2");
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, OrderDate:
+        DateTime.UtcNow.AddDays(-1).AddMinutes(-3), products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(worker.Id, _warehouse.Id, OrderDate:
+        DateTime.UtcNow.AddDays(-1).AddMinutes(3), products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(worker.Id, _warehouse.Id, OrderDate:
+        DateTime.UtcNow.AddDays(-1).AddMinutes(3), products: [(product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, buyer.Id, OrderDate:
+        DateTime.UtcNow.AddDays(1).AddMinutes(-3), products: [(_product.Id, 1)]);
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, OrderDate:
+        DateTime.UtcNow.AddDays(1).AddMinutes(-3), products: [(product.Id, 1)]);
+        var list = _orderStorageContract.GetList(startDate:
+        DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1), employeerId: _worker.Id, productId: product.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+    }
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var Order = InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id,
+        products: [(_product.Id, 1)]);
+        AssertElement(_orderStorageContract.GetElementById(Order.Id), Order);
+    }
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1)]);
+        Assert.That(() =>
+        _orderStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementById_WhenRecordHasCanceled_Test()
+    {
+        var Order = InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id, products: [(_product.Id, 1)], customerName: "fio fio");
+        AssertElement(_orderStorageContract.GetElementById(Order.Id), Order);
+    }
+    [Test]
+
+    public void Try_AddElement_Test()
+    {
+        var order = CreateModel(Guid.NewGuid().ToString(), _worker.Id, _warehouse.Id, "fio fio", OrderStatus.Pending, [_product.Id]);
+        _orderStorageContract.AddElement(order);
+        AssertElement(GetOrderFromDatabaseById(order.Id), order);
+    }
+    [Test]
+    public void Try_AddElement_WhenIsDeletedIsTrue_Test()
+    {
+        var Order = CreateModel(Guid.NewGuid().ToString(), _worker.Id, _warehouse.Id, "fio fio", OrderStatus.Pending, [_product.Id]);
+        Assert.That(() => _orderStorageContract.AddElement(Order), Throws.Nothing);
+        AssertElement(GetOrderFromDatabaseById(Order.Id), CreateModel(Order.Id, _worker.Id, _warehouse.Id, "fio fio", OrderStatus.Pending, [_product.Id]));
+    }
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var Order = InsertOrderToDatabaseAndReturn(_worker.Id, _warehouse.Id,
+        products: [(_product.Id, 1)], customerName: "name fio");
+        _orderStorageContract.DelElement(Order.Id);
+        var element = GetOrderFromDatabaseById(Order.Id);
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _orderStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private OrderHistory InsertProductHistoryToDatabaseAndReturn(string productId, OrderStatus status, DateTime changeDate)
+    {
+        var orderHistory = new OrderHistory()
+        {
+            Id = Guid.NewGuid().ToString(),
+            OrderId = productId,
+            OldStatus = status,
+            ChangeDate = changeDate
+        };
+        WildPlumDbContext.OrderHistories.Add(orderHistory);
+        WildPlumDbContext.SaveChanges();
+        return orderHistory;
+    }
+
+    private Warehouse InsertBuyerToDatabaseAndReturn(string name = "test", string location = "Moscow")
+    {
+        var warehouse = new Warehouse()
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = name,
+            Location = location
+        };
+        WildPlumDbContext.Warehouses.Add(warehouse);
+        WildPlumDbContext.SaveChanges();
+        return warehouse;
+    }
+
+    private Worker InsertWorkerToDatabaseAndReturn(string fio = "test", string email = "test@gmail.com")
+    {
+        var worker = new Worker()
+        {
+            Id = Guid.NewGuid().ToString(),
+            FullName = fio,
+            Email = email,
+            RoleId = Guid.NewGuid().ToString()
+        };
+        WildPlumDbContext.Workers.Add(worker); WildPlumDbContext.SaveChanges();
+        return worker;
+    }
+
+    private Product InsertProductToDatabaseAndReturn(string productName = "test", double price = 1, bool isDeleted = false)
+    {
+        var product = new Product()
+        {
+            Id = Guid.NewGuid().ToString(),
+            ProductName = productName,
+            Price = price,
+            IsDeleted = isDeleted
+        };
+        WildPlumDbContext.Products.Add(product);
+        WildPlumDbContext.SaveChanges();
+        return product;
+    }
+
+    private Order InsertOrderToDatabaseAndReturn(string workerId, string warehouseId,
+        DateTime? OrderDate = null, string customerName = "fio",
+        List<(string, int)>? products = null)
+    {
+        var Order = new Order()
+        {
+            WorkerId = workerId,
+            WarehouseId = warehouseId,
+            OrderDate = OrderDate ?? DateTime.UtcNow,
+            Id = Guid.NewGuid().ToString(),
+            CustomerName = customerName,
+            Products = []
+        };
+        if (products is not null)
+        {
+            foreach (var elem in products)
+            {
+                Order.Products.Add(new OrderProduct
+                {
+                    ProductId = elem.Item1,
+                    OrderId = Order.Id,
+                    Count = elem.Item2,
+                });
+            }
+        }
+        WildPlumDbContext.Orders.Add(Order);
+        WildPlumDbContext.SaveChanges();
+        return Order;
+    }
+    private static void AssertElement(OrderDataModel? actual, Order expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
+            Assert.That(actual.CustomerName, Is.EqualTo(expected.CustomerName));
+        });
+        if (expected.Products is not null)
+        {
+            Assert.That(actual.Products, Is.Not.Null); Assert.That(actual.Products,
+Has.Count.EqualTo(expected.Products.Count));
+            for (int i = 0; i < actual.Products.Count; ++i)
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(actual.Products[i].ProductId,
+                    Is.EqualTo(expected.Products[i].ProductId));
+                    Assert.That(actual.Products[i].Count,
+                    Is.EqualTo(expected.Products[i].Count));
+                });
+            }
+        }
+        else
+        {
+            Assert.That(actual.Products, Is.Null);
+        }
+    }
+    private static OrderDataModel CreateModel(string id, string workerId, string warehouseId, string customerName, OrderStatus orderStatus, List<string> productIds)
+    {
+        var products = productIds.Select(x => new OrderProductDataModel(x, id, 1)).ToList();
+        return new(id, warehouseId, workerId, customerName, orderStatus, DateTime.UtcNow, products);
+    }
+
+    private Order? GetOrderFromDatabaseById(string id) => WildPlumDbContext.Orders.Include(x => x.Products).FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Order? actual, OrderDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
+            Assert.That(actual.Status, Is.EqualTo(expected.Status));
+        });
+        if (expected.Products is not null)
+        {
+            Assert.That(actual.Products, Is.Not.Null);
+            Assert.That(actual.Products, Has.Count.EqualTo(expected.Products.Count));
+            for (int i = 0; i < actual.Products.Count; ++i)
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(actual.Products[i].ProductId,
+                    Is.EqualTo(expected.Products[i].ProductId));
+                    Assert.That(actual.Products[i].Count,
+                    Is.EqualTo(expected.Products[i].Count));
+                });
+            }
+        }
+        else
+        {
+            Assert.That(actual.Products, Is.Null);
+        }
+    }
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/ProductStorageContractTests.cs

@@ -0,0 +1,264 @@
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Exceptions;
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase.Models;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+[TestFixture]
+internal class ProductStorageContractTests : BaseStorageContractTests
+{
+    private ProductStorageContract _productStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _productStorageContract = new ProductStorageContract(WildPlumDbContext);
+    }
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Products\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var product =
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3");
+        var list = _productStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(x => x.Id == product.Id), product);
+    }
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _productStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+    [Test]
+    public void Try_GetList_OnlyActual_Test()
+    {
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isDeleted: true);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isDeleted: false);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isDeleted: false);
+        var list = _productStorageContract.GetList(onlyActive: true);
+        Assert.That(list, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Has.Count.EqualTo(2));
+            Assert.That(!list.Any(x => x.IsDeleted));
+        });
+    }
+
+    [Test]
+    public void Try_GetList_IncludeNoActual_Test()
+    {
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isDeleted: true);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isDeleted: true);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isDeleted: false);
+        var list = _productStorageContract.GetList(onlyActive: false);
+        Assert.That(list, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Has.Count.EqualTo(3));
+            Assert.That(list.Count(x => x.IsDeleted), Is.EqualTo(2));
+            Assert.That(list.Count(x => !x.IsDeleted), Is.EqualTo(1));
+        });
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_productStorageContract.GetElementById(product.Id), product);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _productStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementById_WhenRecordHasDeleted_Test()
+    {
+        var product =
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _productStorageContract.GetElementById(product.Id), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementByName_WhenHaveRecord_Test()
+    {
+        var product =
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_productStorageContract.GetElementByName(product.ProductName), product);
+    }
+    [Test]
+    public void Try_GetElementByName_WhenNoRecord_Test()
+    {
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _productStorageContract.GetElementByName("name"), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementByName_WhenRecordHasDeleted_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _productStorageContract.GetElementById(product.ProductName), Is.Null);
+    }
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), isDeleted: false);
+        _productStorageContract.AddElement(product);
+        AssertElement(GetProductFromDatabaseById(product.Id), product);
+    }
+    [Test]
+    public void Try_AddElement_WhenIsDeletedIsTrue_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.Nothing);
+        AssertElement(GetProductFromDatabaseById(product.Id), CreateModel(product.Id, isDeleted: false));
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString());
+        InsertProductToDatabaseAndReturn(product.Id, productName: "name unique");
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), productName: product.ProductName, isDeleted: false);
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), productName: product.ProductName, isDeleted: true);
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.Nothing);
+    }
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), isDeleted: false);
+        InsertProductToDatabaseAndReturn(product.Id, isDeleted: false);
+        _productStorageContract.UpdElement(product);
+        AssertElement(GetProductFromDatabaseById(product.Id), product);
+    }
+    [Test]
+    public void Try_UpdElement_WhenIsDeletedIsTrue_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), isDeleted: true);
+        InsertProductToDatabaseAndReturn(product.Id, isDeleted: false);
+        _productStorageContract.UpdElement(product);
+        AssertElement(GetProductFromDatabaseById(product.Id), CreateModel(product.Id, isDeleted: false));
+    }
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _productStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertProductToDatabaseAndReturn(product.Id, productName: "name");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), productName: product.ProductName);
+        Assert.That(() => _productStorageContract.UpdElement(product),
+        Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertProductToDatabaseAndReturn(product.Id, productName: "name"); InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), productName: product.ProductName, isDeleted: true);
+        Assert.That(() => _productStorageContract.UpdElement(product), Throws.Nothing);
+    }
+    [Test]
+    public void Try_UpdElement_WhenRecordWasDeleted_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString());
+        InsertProductToDatabaseAndReturn(product.Id, isDeleted: true);
+        Assert.That(() => _productStorageContract.UpdElement(product),
+        Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: false);
+        _productStorageContract.DelElement(product.Id);
+        var element = GetProductFromDatabaseById(product.Id);
+        Assert.Multiple(() =>
+        {
+            Assert.That(element, Is.Not.Null);
+            Assert.That(element!.IsDeleted);
+        });
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _productStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_DelElement_WhenRecordWasDeleted_Test()
+    {
+        var product =
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _productStorageContract.DelElement(product.Id), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private Product InsertProductToDatabaseAndReturn(string id, string productName = "test", double price = 1, bool isDeleted = false)
+    {
+        var product = new Product()
+        {
+            Id = id,
+            ProductName = productName,
+            Price = price,
+            IsDeleted = isDeleted
+        };
+        WildPlumDbContext.Products.Add(product);
+        WildPlumDbContext.SaveChanges();
+        return product;
+    }
+
+    private static void AssertElement(ProductDataModel? actual, Product expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.ProductName, Is.EqualTo(expected.ProductName));
+            Assert.That(actual.Price, Is.EqualTo(expected.Price));
+            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
+        });
+    }
+
+    private static ProductDataModel CreateModel(string id, string productName = "test", double price = 1, bool isDeleted = false)
+    => new(id, productName, price, isDeleted);
+
+    private Product? GetProductFromDatabaseById(string id) => WildPlumDbContext.Products.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Product? actual, ProductDataModel
+    expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.ProductName, Is.EqualTo(expected.ProductName));
+            Assert.That(actual.Price, Is.EqualTo(expected.Price));
+            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
+        });
+    }
+
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/RoleStorageContractTests.cs

@@ -0,0 +1,215 @@
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumContracts.Enums;
+using WildPlumContracts.Exceptions;
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase.Models;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+[TestFixture]
+internal class RoleStorageContractTests : BaseStorageContractTests
+{
+    private RoleStorageContract _jobTitleStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _jobTitleStorageContract = new RoleStorageContract(WildPlumDbContext);
+    }
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Roles\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), WorkerRole.Courier, true, DateTime.UtcNow);
+        InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), WorkerRole.Courier, true, DateTime.UtcNow);
+        InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), WorkerRole.Courier, true, DateTime.UtcNow);
+        var list = _jobTitleStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _jobTitleStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetJobTitleWithHistory_WhenHaveRecords_Test()
+    {
+        var jobTitleId = Guid.NewGuid().ToString();
+        InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+        InsertJobTitleToDatabaseAndReturn(jobTitleId, isActual: true);
+        InsertJobTitleToDatabaseAndReturn(jobTitleId, isActual: false);
+        var list = _jobTitleStorageContract.GetRoleWithHistory(jobTitleId);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+    }
+    [Test]
+    public void Try_GetJobTitleWithHistory_WhenNoRecords_Test()
+    {
+        var jobTitleId = Guid.NewGuid().ToString();
+        InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+        InsertJobTitleToDatabaseAndReturn(jobTitleId,isActual: true);
+        InsertJobTitleToDatabaseAndReturn(jobTitleId, isActual: false);
+        var list = _jobTitleStorageContract.GetRoleWithHistory(Guid.NewGuid().ToString());
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+    }
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_jobTitleStorageContract.GetElementById(jobTitle.Id), jobTitle);
+    }
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() =>
+        _jobTitleStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+    [Test]
+    public void Try_GetElementById_WhenRecordHasDeleted_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(),
+        isActual: false);
+        Assert.That(() => _jobTitleStorageContract.GetElementById(jobTitle.RoleId), Is.Null);
+    }
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var jobTitle = CreateModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow);
+        _jobTitleStorageContract.AddElement(jobTitle);
+        AssertElement(GetJobTitleFromDatabaseByJobTitleId(jobTitle.Id), jobTitle);
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameJobTitleId_Test()
+    {
+        var jobTitle = CreateModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow);
+        InsertJobTitleToDatabaseAndReturn(jobTitle.Id, isActual: true);
+        Assert.That(() => _jobTitleStorageContract.AddElement(jobTitle), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var jobTitle = CreateModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow);
+        InsertJobTitleToDatabaseAndReturn(jobTitle.Id, isActual: true);
+        _jobTitleStorageContract.UpdElement(jobTitle);
+        var jobTitles = WildPlumDbContext.Roles.Where(x => x.RoleId == jobTitle.Id).OrderByDescending(x => x.ChangeDate);
+        Assert.That(jobTitles.Count(), Is.EqualTo(2));
+        AssertElement(jobTitles.First(), CreateModel(jobTitle.Id, Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow));
+        AssertElement(jobTitles.Last(), CreateModel(jobTitle.Id, Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow));
+    }
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _jobTitleStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow)), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_UpdElement_WhenRecordWasDeleted_Test()
+    {
+        var jobTitle = CreateModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, WorkerRole.Courier, DateTime.UtcNow);
+        InsertJobTitleToDatabaseAndReturn(jobTitle.Id, isActual: false);
+        Assert.That(() => _jobTitleStorageContract.UpdElement(jobTitle), Throws.TypeOf<ElementDeletedException>());
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+        _jobTitleStorageContract.DelElement(jobTitle.RoleId);
+        var element = GetJobTitleFromDatabaseByJobTitleId(jobTitle.RoleId);
+        Assert.Multiple(() =>
+        {
+            Assert.That(element, Is.Not.Null);
+            Assert.That(!element!.IsActual);
+        });
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _jobTitleStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_DelElement_WhenRecordWasDeleted_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+        Assert.That(() => _jobTitleStorageContract.DelElement(jobTitle.RoleId), Throws.TypeOf<ElementDeletedException>());
+    }
+
+    [Test]
+    public void Try_ResElement_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+        _jobTitleStorageContract.ResElement(jobTitle.RoleId);
+        var element = GetJobTitleFromDatabaseByJobTitleId(jobTitle.RoleId);
+        Assert.Multiple(() =>
+        {
+            Assert.That(element, Is.Not.Null);
+            Assert.That(element!.IsActual);
+        });
+    }
+    [Test]
+    public void Try_ResElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _jobTitleStorageContract.ResElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_ResElement_WhenRecordNotWasDeleted_Test()
+    {
+        var jobTitle = InsertJobTitleToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+        Assert.That(() => _jobTitleStorageContract.ResElement(jobTitle.RoleId), Throws.Nothing);
+    }
+
+    private Role InsertJobTitleToDatabaseAndReturn(string id, WorkerRole workerRole = WorkerRole.Courier,
+        bool isActual = true, DateTime? changeDate = null)
+    {
+        var jobTitle = new Role()
+        {
+            Id = Guid.NewGuid().ToString(),
+            RoleId = id,
+            WorkerRole = workerRole,
+            IsActual = isActual,
+            ChangeDate = changeDate ?? DateTime.UtcNow
+        };
+        WildPlumDbContext.Roles.Add(jobTitle);
+        WildPlumDbContext.SaveChanges();
+        return jobTitle;
+    }
+    private static void AssertElement(RoleDataModel? actual, Role expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.RoleId));
+            Assert.That(actual.WorkerRole, Is.EqualTo(expected.WorkerRole));
+        });
+    }
+    private static RoleDataModel CreateModel(string id, string roleId, bool isActual,
+        WorkerRole workerRole, DateTime changeDate)
+    => new(id, workerRole, roleId, isActual, changeDate);
+
+    private Role? GetJobTitleFromDatabaseByJobTitleId(string id) =>
+        WildPlumDbContext.Roles.Where(x => x.RoleId == id).OrderByDescending(x => x.ChangeDate).FirstOrDefault();
+
+    private static void AssertElement(Role? actual, RoleDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.RoleId, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkerRole, Is.EqualTo(expected.WorkerRole));
+        });
+    }
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/SalaryStorageContractTests.cs

@@ -0,0 +1,153 @@
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase.Models;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+[TestFixture]
+internal class SalaryStorageContractTests : BaseStorageContractTests
+{
+    private SalaryStorageContract _salaryStorageContract;
+    private Worker _worker;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _salaryStorageContract = new
+        SalaryStorageContract(WildPlumDbContext);
+        _worker = InsertWorkerToDatabaseAndReturn();
+    }
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Salaries\" CASCADE; ");
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var salary = InsertSalaryToDatabaseAndReturn(_worker.Id, workerSalary: 100);
+        InsertSalaryToDatabaseAndReturn(_worker.Id);
+        InsertSalaryToDatabaseAndReturn(_worker.Id);
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(), salary);
+    }
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+    [Test]
+    public void Try_GetList_OnlyInDatePeriod_Test()
+    {
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1));
+        Assert.That(list, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Has.Count.EqualTo(2));
+        });
+    }
+    [Test]
+    public void Try_GetList_ByWorker_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn("name 2", "test2@gmail.com");
+        InsertSalaryToDatabaseAndReturn(_worker.Id);
+        InsertSalaryToDatabaseAndReturn(_worker.Id);
+        InsertSalaryToDatabaseAndReturn(worker.Id);
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Has.Count.EqualTo(2));
+            Assert.That(list.All(x => x.WorkerId == _worker.Id));
+        });
+    }
+    [Test]
+    public void Try_GetList_ByWorkerOnlyInDatePeriod_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn("name 2", "test3@gmail.com");
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+        InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+        InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+        InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Has.Count.EqualTo(2));
+            Assert.That(list.All(x => x.WorkerId == _worker.Id));
+        });
+    }
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var salary = CreateModel(_worker.Id);
+        _salaryStorageContract.AddElement(salary);
+        AssertElement(GetSalaryFromDatabaseByWorkerId(_worker.Id), salary);
+    }
+    private Worker InsertWorkerToDatabaseAndReturn(string workerFIO = "fio", string workerEmail = "test@gmail.com")
+    {
+        var worker = new Worker()
+        {
+            Id = Guid.NewGuid().ToString(),
+            Email = workerEmail,
+            RoleId = Guid.NewGuid().ToString(),
+            FullName = workerFIO,
+            IsDeleted = false
+        };
+        WildPlumDbContext.Workers.Add(worker);
+        WildPlumDbContext.SaveChanges();
+        return worker;
+    }
+
+    private Salary InsertSalaryToDatabaseAndReturn(string workerId, double workerSalary = 1, DateTime? salaryDate = null)
+    {
+        var salary = new Salary()
+        {
+            WorkerId = workerId,
+            Amount = workerSalary,
+            SalaryDate = salaryDate ?? DateTime.UtcNow
+        };
+        WildPlumDbContext.Salaries.Add(salary);
+        WildPlumDbContext.SaveChanges();
+        return salary;
+    }
+
+    private static void AssertElement(SalaryDataModel? actual, Salary expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.Amount, Is.EqualTo(expected.Amount));
+        });
+    }
+
+    private static SalaryDataModel CreateModel(string workerId, decimal workerSalary = 1, DateTime? salaryDate = null) => new(Guid.NewGuid().ToString(), workerId, workerSalary, salaryDate ?? DateTime.UtcNow);
+    
+    private Salary? GetSalaryFromDatabaseByWorkerId(string id) => WildPlumDbContext.Salaries.FirstOrDefault(x => x.WorkerId == id);
+
+    private static void AssertElement(Salary? actual, SalaryDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.Amount, Is.EqualTo(expected.Amount));
+        });
+    }
+}

WildPlumProject/WildPlumTests/StoragesContractsTests/WarehouseStorageContractTests.cs

@@ -0,0 +1,155 @@
+using WildPlumDatabase.Implementations;
+using WildPlumDatabase;
+using Microsoft.EntityFrameworkCore;
+using WildPlumContracts.DataModels;
+using WildPlumDatabase.Models;
+using WildPlumContracts.Exceptions;
+
+namespace WildPlumTests.StoragesContractsTests;
+
+[TestFixture]
+internal class WarehouseStorageContractTests : BaseStorageContractTests
+{
+    private WarehouseStorageContract _productStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _productStorageContract = new WarehouseStorageContract(WildPlumDbContext);
+    }
+    [TearDown]
+    public void TearDown()
+    {
+        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE; ");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", location: "loc3");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", location: "loc3");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", location: "loc3");
+        var list = _productStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(x => x.Id == product.Id), product);
+    }
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _productStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementByName_WhenHaveRecord_Test()
+    {
+        var product =
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_productStorageContract.GetElementByName(product.Name), product);
+    }
+    [Test]
+    public void Try_GetElementByName_WhenNoRecord_Test()
+    {
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _productStorageContract.GetElementByName("name"), Is.Null);
+    }
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name2", "loc2");
+        _productStorageContract.AddElement(product);
+        AssertElement(GetProductFromDatabaseById(product.Id), product);
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString());
+        InsertProductToDatabaseAndReturn(product.Id, name: "name unique", location: "loc2");
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), name: product.Name);
+        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
+        InsertProductToDatabaseAndReturn(product.Id, "name unique", location: "loc2");
+        _productStorageContract.UpdElement(product);
+        AssertElement(GetProductFromDatabaseById(product.Id), product);
+    }
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _productStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+    }
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
+    {
+        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
+        InsertProductToDatabaseAndReturn(product.Id, name: "name", location: "loc3");
+        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), name: product.Name, location: "loc4");
+        Assert.That(() => _productStorageContract.UpdElement(product),
+        Throws.TypeOf<ElementExistsException>());
+    }
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name unique", location: "loc2");
+        _productStorageContract.DelElement(product.Id);
+        var element = GetProductFromDatabaseById(product.Id);
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _productStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+
+    private Warehouse InsertProductToDatabaseAndReturn(string id, string name = "test", string location = "loc1")
+    {
+        var product = new Warehouse()
+        {
+            Id = id,
+            Name = name,
+            Location = location
+        };
+        WildPlumDbContext.Warehouses.Add(product);
+        WildPlumDbContext.SaveChanges();
+        return product;
+    }
+    
+    private static void AssertElement(WarehouseDataModel? actual, Warehouse expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Name, Is.EqualTo(expected.Name));
+        });
+    }
+
+    private static WarehouseDataModel CreateModel(string id, string name = "test", string location = "loc1")
+    => new(id, name, location);
+
+    private Warehouse? GetProductFromDatabaseById(string id) => WildPlumDbContext.Warehouses.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Warehouse? actual, WarehouseDataModel
+    expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Name, Is.EqualTo(expected.Name));
+        });
+    }
+}

WildPlumProject/WildPlumTests/WildPlumTests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
@@ -10,7 +10,9 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
     <PackageReference Include="NUnit.Analyzers" Version="3.6.1" />
@@ -18,7 +20,9 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\WildPlumBusinessLogic\WildPlumBusinessLogic.csproj" />
     <ProjectReference Include="..\WildPlumContracts\WildPlumContracts.csproj" />
+    <ProjectReference Include="..\WildPlumDatabase\WildPlumDatabase.csproj" />
   </ItemGroup>
 
 </Project>