вот теперь точно ready

TwoFromTheCasketContratcs/.idea/.idea.TwoFromTheCasketContratcs/.idea/.gitignore

@@ -0,0 +1,13 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Rider ignored files
+/.idea.TwoFromTheCasketContratcs.iml
+/projectSettingsUpdater.xml
+/modules.xml
+/contentModel.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

TwoFromTheCasketContratcs/.idea/.idea.TwoFromTheCasketContratcs/.idea/encodings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
+</project>

TwoFromTheCasketContratcs/.idea/.idea.TwoFromTheCasketContratcs/.idea/indexLayout.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="UserContentModel">
+    <attachedFolders />
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>

TwoFromTheCasketContratcs/.idea/.idea.TwoFromTheCasketContratcs/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/Implementations/MasterBusinessLogicContract.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.Extensions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketBuisnessLogic.Implementations;
+
+internal class MasterBusinessLogicContract(IMasterStorageContract masterStorageContract, ILogger logger) : IMasterBuisnessLogicContract
+{
+    ILogger _logger = logger;
+    private IMasterStorageContract _masterStorageContract = masterStorageContract;
+    public List<MasterDataModel> GetAllMasters(bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllWorkers params: {onlyActive}", onlyActive);
+        return _masterStorageContract.GetList(onlyActive) ?? throw new
+      NullListException();
+    }
+
+    public List<MasterDataModel> GetAllMastersByPost(string postId, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllWorkers params: {postId}, { onlyActive},", postId, onlyActive); 
+        if (postId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(postId));
+        }
+        if (!postId.IsGuid())
+        {
+            throw new ValidationException("The value in the field postId is not a unique identifier."); 
+        }
+        return _masterStorageContract.GetList(onlyActive, postId) ?? throw new NullListException();
+    }
+
+    public List<MasterDataModel> GetAllMastersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllWorkers params: {onlyActive}, { fromDate}, { toDate}", onlyActive, fromDate, toDate); 
+  if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _masterStorageContract.GetList(onlyActive, fromEmploymentDate:
+      fromDate, toEmploymentDate: toDate) ?? throw new NullListException();
+    }
+
+    public MasterDataModel GetMasterByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _masterStorageContract.GetElementById(data) ?? throw
+         new ElementNotFoundException(data);
+        }
+        return _masterStorageContract.GetElementByFIO(data) ?? throw new
+      ElementNotFoundException(data);
+    }
+
+    public void InsertMaster(MasterDataModel workerDataModel)
+    {
+        _logger.LogInformation("New data: {json}",
+      JsonSerializer.Serialize(workerDataModel));
+        ArgumentNullException.ThrowIfNull(workerDataModel);
+        workerDataModel.Validate();
+        _masterStorageContract.AddElement(workerDataModel);
+    }
+
+    public void UpdateMaster(MasterDataModel workerDataModel)
+    {
+        _logger.LogInformation("Update data: {json}",
+      JsonSerializer.Serialize(workerDataModel));
+        ArgumentNullException.ThrowIfNull(workerDataModel);
+        workerDataModel.Validate();
+        _masterStorageContract.UpdElement(workerDataModel);
+    }
+
+    public void DeleteMaster(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"); 
+        }
+        _masterStorageContract.DelElement(id);
+    }
+
+    public List<MasterDataModel> GetAllMastersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllWorkers params: {onlyActive}, { fromDate}, { toDate}", onlyActive, fromDate, toDate); 
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _masterStorageContract.GetList(onlyActive, fromBirthDate: fromDate, toBirthDate: toDate) ?? throw new NullListException();
+    }
+
+    public List<MasterDataModel> GetAllWorkersByEmploymentDate(DateTime
+   fromDate, DateTime toDate, bool onlyActive = true)
+    {
+        _logger.LogInformation("GetAllMaster params: {onlyActive}, { fromDate}, { toDate}", onlyActive, fromDate, toDate); 
+     if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _masterStorageContract.GetList(onlyActive, fromEmploymentDate:
+      fromDate, toEmploymentDate: toDate) ?? throw new NullListException();
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/Implementations/OrderBusinessLogicContract.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.Extensions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketBuisnessLogic.Implementations;
+
+internal class OrderBusinessLogicContract(IOrderStorageContract orderStorageContract, ILogger logger) : IOrderBuisnessLogicContract
+{
+    private ILogger _logger = logger;
+    private IOrderStorageContract _orderStorageContract = orderStorageContract;
+    public List<OrderDataModel> GetAllOrder()
+    {
+        _logger.LogInformation("GetAllOrders called");
+        var orders = _orderStorageContract.GetList();
+        if (orders == null)
+        {
+            throw new NullListException();
+        }
+        return orders;
+    }
+
+    public OrderDataModel GetOrderByDate(DateTime fromDate)
+    {
+        _logger.LogInformation("GetAllOrdersByDate called with fromDate: {fromDate} to: {toDate}");
+
+        
+        return _orderStorageContract.GetElementByDate(fromDate) ?? throw new NullListException();
+    }
+
+    public OrderDataModel GetOrderByData(string data)
+    {
+        _logger.LogInformation($"GetOrderByData called with data: {data}");
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _orderStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _orderStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertOrder(OrderDataModel orderDataModel)
+    {
+        _logger.LogInformation("InsertOrder called with orderDataModel: {orderDataModel}");
+        ValidateOrder(orderDataModel);
+        _orderStorageContract.AddElement(orderDataModel);
+    }
+
+    public void UpdateOrder(OrderDataModel orderDataModel)
+    {
+        _logger.LogInformation("UpdateOrder called with orderDataModel: {orderDataModel}");
+        ValidateOrder(orderDataModel);
+        _orderStorageContract.UpdElement(orderDataModel);
+    }
+
+    public void DeleteOrder(string id)
+    {
+        _logger.LogInformation($"DeleteOrder called with id: {id}");
+        ValidateId(id);
+        _orderStorageContract.DelElement(id);
+    }
+
+    private void ValidateOrder(OrderDataModel orderDataModel)
+    {
+        if (orderDataModel == null)
+            throw new ArgumentNullException(nameof(orderDataModel));
+
+        orderDataModel.Validate();
+    }
+
+    private void ValidateId(string id)
+    {
+        if (string.IsNullOrEmpty(id))
+            throw new ArgumentNullException(nameof(id));
+
+        if (!Guid.TryParse(id, out _))
+            throw new ValidationException("Id is not a unique identifier");
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/Implementations/PostBusinessLogicContract.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.Extensions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketBuisnessLogic.Implementations;
+
+internal class PostBusinessLogicContract(IPostStorageContract postStorageContract, ILogger logger) : IPostBuisnessLogicContract
+{
+    private IPostStorageContract _postStorageContract = postStorageContract;
+    private ILogger _logger = logger;
+
+    public List<PostDataModel> GetAllPosts()
+    {
+        _logger.LogInformation("GetAllPosts");
+        return _postStorageContract.GetList() ?? throw new
+      NullListException();
+    }
+
+    public List<PostDataModel> GetAllDataOfPost(string postId)
+    {
+        _logger.LogInformation("GetAllDataOfPost for {postId}", postId);
+        if (postId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(postId));
+        }
+        if (!postId.IsGuid())
+        {
+            throw new ValidationException("The value in the field postId is not a unique identifier."); 
+        }
+        return _postStorageContract.GetPostWithHistory(postId) ?? throw new
+      NullListException();
+    }
+
+    public PostDataModel GetPostByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _postStorageContract.GetElementById(data) ?? throw new
+         ElementNotFoundException(data);
+        }
+        return _postStorageContract.GetElementByName(data) ?? throw new
+      ElementNotFoundException(data);
+    }
+
+    public void InsertPost(PostDataModel postDataModel)
+    {
+        _logger.LogInformation("InsertPost called with postDataModel: {postDataModel}");
+
+        if (postDataModel == null)
+            throw new ArgumentNullException(nameof(postDataModel));
+
+        postDataModel.Validate(); // Вызовляем проверку валидности данных
+
+        _postStorageContract.AddElement(postDataModel);
+    }
+
+    public void UpdatePost(PostDataModel postDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(postDataModel));
+        ArgumentNullException.ThrowIfNull(postDataModel);
+        postDataModel.Validate();
+        _postStorageContract.UpdElement(postDataModel);
+    }
+
+    public void DeletePost(string id)
+    {
+        _logger.LogInformation("Delete by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier"); 
+        }
+        _postStorageContract.DelElement(id);
+    }
+
+    public void RestorePost(string id)
+    {
+        _logger.LogInformation("Restore by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier"); 
+        }
+        _postStorageContract.ResElement(id);
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/Implementations/SalaryBuisnessLogicContract.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.StorageContracts;
+using TwoFromTheCasketContratcs.Extensions;
+using TwoFromTheCasketContratcs.Exceptions;
+
+namespace TwoFromTheCasketBuisnessLogic.Implementations
+{
+    internal class SalaryBusinessLogicContract(ISalaryStorageContract
+salaryStorageContract, IPostStorageContract
+postStorageContract, IMasterStorageContract masterStorageContract, ILogger
+logger, IOrderStorageContract orderStorageContract) : ISalaryBuisnessLogicContract
+    {
+        private readonly ILogger _logger = logger;
+        private readonly ISalaryStorageContract _salaryStorageContract = salaryStorageContract;
+        private readonly IPostStorageContract _postStorageContract = postStorageContract;
+        private readonly IMasterStorageContract _masterStorageContract = masterStorageContract;
+        private readonly IOrderStorageContract _orderStorageContract = orderStorageContract;
+
+        
+        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> GetAllSalariesByPeriodByMaster(DateTime fromDate, DateTime toDate, string masterId)
+        {
+            if (fromDate.IsDateNotOlder(toDate))
+            {
+                throw new IncorrectDatesException(fromDate, toDate);
+            }
+
+            if (string.IsNullOrEmpty(masterId))
+            {
+                throw new ArgumentNullException(nameof(masterId));
+            }
+
+            if (!Guid.TryParse(masterId, out _))
+            {
+                throw new ValidationException("The value in the field masterId is not a unique identifier.");
+            }
+
+            _logger.LogInformation("GetAllSalaries params: {fromDate}, {toDate}, {masterId}", fromDate, toDate, masterId);
+            return _salaryStorageContract.GetList(fromDate, toDate, masterId) ?? throw new NullListException();
+        }
+
+        public void CalculateSalaryByMonth(DateTime date)
+        {
+            _logger.LogInformation("CalculateSalaryByMonth: {date}", date);
+
+            var startDate = new DateTime(date.Year, date.Month, 1);
+            var finishDate = new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month));
+
+            var masters = _masterStorageContract.GetList() ?? throw new NullListException();
+
+            foreach (var master in masters)
+            {
+                master.Validate(); 
+
+                var orders = _orderStorageContract.GetList()?.Count(x => x.Id.IsGuid()) ??
+                            throw new NullListException();
+                var post = _postStorageContract.GetElementById(master.PostId) ?? throw new NullListException();
+
+                var baseSalary = post.Salary; 
+                var prize = 500.0; 
+
+                var totalSalary = baseSalary + prize; 
+
+                _logger.LogDebug("The master {master.Id} was paid a salary of {salary}", master.Id, totalSalary);
+
+                _salaryStorageContract.AddElement(new SalaryDataModel(master.Id, finishDate, totalSalary, prize));
+            }
+        }
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/Implementations/ServiceBusinessLogicContract.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.Extensions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketBuisnessLogic.Implementations;
+
+internal class ServiceBusinessLogicContract(IServiceStorageContract serviceStorageContract, ILogger logger) : IServiceBuisnessLogicContract
+{
+    ILogger _logger = logger;
+    private IServiceStorageContract _serviceStorageContract = serviceStorageContract;
+    public List<ServiceDataModel> GetAllServices(bool onlyActive)
+    {
+        _logger.LogInformation("GetAllService called");
+        var services = _serviceStorageContract.GetList();
+        if(services == null)
+        {
+            throw new NullListException();
+        }
+        return services;
+    }
+
+    public List<ServiceDataModel> GetServicesByMasterId(string masterId, bool onlyActive)
+    {
+        _logger.LogInformation("GetAllServicesByMasterId called");
+        if (masterId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(masterId));
+        }
+        if (!masterId.IsGuid())
+        {
+            throw new ValidationException("The value in the field masterId is not a unique identifier.");
+        }
+        return _serviceStorageContract.GetElementByMasterId(masterId) ?? throw new NullListException();
+    }
+
+    public List<ServiceDataModel> GetServicesByServiceType(ServiceType serviceType, bool onlyActive)
+    {
+        _logger.LogInformation($"GetServicesByServiceType called for {serviceType} (onlyActive: {onlyActive})");
+
+        
+        var allServices = _serviceStorageContract.GetList() ?? new List<ServiceDataModel>();
+
+        
+        var filteredByType = allServices.Where(s => s.ServiceType == serviceType);
+
+        
+        if (onlyActive)
+        {
+            filteredByType = filteredByType.Where(s => s.IsDeleted!);
+        }
+
+        return filteredByType.ToList();
+    }
+
+    public void InsertService(ServiceDataModel serviceDataModel)
+    {
+        _logger.LogInformation("New data: {json}",
+      JsonSerializer.Serialize(serviceDataModel));
+        ArgumentNullException.ThrowIfNull(serviceDataModel);
+        serviceDataModel.Validate();
+        _serviceStorageContract.AddElement(serviceDataModel);
+
+    }
+
+    public void UpdateService(ServiceDataModel serviceDataModel)
+    {
+        _logger.LogInformation("Update data: {json}",
+      JsonSerializer.Serialize(serviceDataModel));
+        ArgumentNullException.ThrowIfNull(serviceDataModel);
+        serviceDataModel.Validate();
+        _serviceStorageContract.UpdElement(serviceDataModel);
+    }
+    public void DeleteService(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");
+        }
+        _serviceStorageContract.DelElement(id);
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketBuisnessLogic/TwoFromTheCasketBuisnessLogic.csproj

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

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs.sln

@@ -7,6 +7,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TwoFromTheCasketContratcs",
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TwoFromTheCasketTest", "TwoFromTheCasketTest\TwoFromTheCasketTest.csproj", "{71E6B2F8-F494-4500-A887-481047D885DF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TwoFromTheCasketBuisnessLogic", "TwoFromTheCasketBuisnessLogic\TwoFromTheCasketBuisnessLogic.csproj", "{371435E4-6D04-4302-86C8-23F063FBE57A}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{71E6B2F8-F494-4500-A887-481047D885DF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{71E6B2F8-F494-4500-A887-481047D885DF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{71E6B2F8-F494-4500-A887-481047D885DF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{371435E4-6D04-4302-86C8-23F063FBE57A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{371435E4-6D04-4302-86C8-23F063FBE57A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{371435E4-6D04-4302-86C8-23F063FBE57A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{371435E4-6D04-4302-86C8-23F063FBE57A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/BuisnessLogicsContracts/IMasterBuisnessLogicContract.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+
+public interface IMasterBuisnessLogicContract
+{
+    List<MasterDataModel> GetAllMasters(bool onlyActive = true);
+
+    List<MasterDataModel> GetAllMastersByPost(string postId, bool onlyActive = true);
+    List<MasterDataModel> GetAllMastersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true);
+
+    List<MasterDataModel> GetAllMastersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true);
+
+    MasterDataModel GetMasterByData(string data);
+
+    void InsertMaster(MasterDataModel masterDataModel);
+
+    void UpdateMaster(MasterDataModel masterDataModel);
+
+    void DeleteMaster(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/BuisnessLogicsContracts/IOrderBuisnessLogicContract.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+
+public interface IOrderBuisnessLogicContract
+{
+    List<OrderDataModel> GetAllOrder();
+
+    OrderDataModel GetOrderByDate(DateTime fromDate);
+
+    OrderDataModel GetOrderByData(string data);
+
+    void InsertOrder(OrderDataModel orderDataModel);
+
+    void UpdateOrder(OrderDataModel orderDataModel);
+
+    void DeleteOrder(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/BuisnessLogicsContracts/IPostBuisnessLogicContract.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+
+public interface IPostBuisnessLogicContract
+{
+    List<PostDataModel> GetAllPosts();
+
+    List<PostDataModel> GetAllDataOfPost(string postId);
+
+    PostDataModel GetPostByData(string data);
+
+    void InsertPost(PostDataModel postDataModel);
+
+    void UpdatePost(PostDataModel postDataModel);
+
+    void DeletePost(string id);
+
+    void RestorePost(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/BuisnessLogicsContracts/ISalaryBuisnessLogicContract.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+
+public interface ISalaryBuisnessLogicContract
+{
+    List<SalaryDataModel> GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate); 
+ 
+    List<SalaryDataModel> GetAllSalariesByPeriodByMaster(DateTime fromDate, DateTime toDate, string masterId);
+
+    void CalculateSalaryByMonth(DateTime date);
+} 
+

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/BuisnessLogicsContracts/IServiceBuisnessLogicContract.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+
+namespace TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+
+public interface IServiceBuisnessLogicContract
+{
+    List<ServiceDataModel> GetAllServices(bool onlyActive);
+
+    List<ServiceDataModel> GetServicesByServiceType(ServiceType serviceType, bool onlyActive);
+
+    List<ServiceDataModel> GetServicesByMasterId(string masterId, bool onlyActive);
+
+    void InsertService(ServiceDataModel serviceDataModel);
+
+    void UpdateService(ServiceDataModel serviceDataModel);
+
+    void DeleteService(string id);
+
+
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/DataModels/PostDataModel.cs

@@ -11,24 +11,19 @@ using TwoFromTheCasketContratcs.Infrastructure;
 
 namespace TwoFromTheCasketContratcs.DataModels;
 
-public class PostDataModel(string id, string postId, string postName, PostType
-postType, double salary, bool isActual, DateTime changeDate) : IValidation
+public class PostDataModel(string id, string postName, PostType
+postType, double salary) : IValidation
 {
     public string Id { get; private set; } = id;
 
-    public string PostId { get; private set; } = postId;
-
     public string PostName { get; private set; } = postName;
 
     public PostType PostType { get; private set; } = postType;
 
     public double Salary { get; private set; } = salary;
 
-    public bool IsActual { get; private set; } = isActual;
-
-    public DateTime ChangeDate { get; private set; } = changeDate;
-
-    public void Validate()
+    
+public void Validate()
     {
         if (Id.IsEmpty())
             throw new ValidationException("Field Id is empty");
@@ -36,11 +31,6 @@ postType, double salary, bool isActual, DateTime changeDate) : IValidation
         if (!Id.IsGuid())
             throw new ValidationException("The value in the field Id is not a unique identifier"); 
         
-        if (PostId.IsEmpty())
-            throw new ValidationException("Field PostId is empty");
-
-        if (!PostId.IsGuid())
-            throw new ValidationException("The value in the field PostId is not a unique identifier"); 
    
         if (PostName.IsEmpty())
             throw new ValidationException("Field PostName is empty");

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Exceptions/ElementExistsException.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketContratcs.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 alredy an element with value {paramValue} of parameter {paramName}")
+    {
+        ParamName = paramName;
+        ParamValue = paramValue;
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Exceptions/ElementNotFoundException.cs

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

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Exceptions/IncorrectDatesException.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+
+namespace TwoFromTheCasketContratcs.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}") { } 
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Exceptions/NullListException.cs

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

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Exceptions/StorageException.cs

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

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/Extensions/DateTimeExtensions.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketContratcs.Extensions;
+
+public static class DateTimeExtensions
+{
+    public static bool IsDateNotOlder(this DateTime date, DateTime olderDate)
+    {
+        return date >= olderDate;
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/StorageContracts/IMasterStorageContract.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.StorageContracts;
+
+public interface IMasterStorageContract
+{
+    List<MasterDataModel> GetList(bool onlyActive = true, string? postId =
+null, DateTime? fromBirthDate = null, DateTime? toBirthDate = null, DateTime?
+fromEmploymentDate = null, DateTime? toEmploymentDate = null);
+
+    MasterDataModel? GetElementById(string id);
+
+    MasterDataModel? GetElementByFIO(string name);
+
+    MasterDataModel? GetElementByPostId(string postId);
+
+    void AddElement(MasterDataModel masterDataModel);
+
+    void UpdElement(MasterDataModel masterDataModel);
+
+    void DelElement(string id);
+
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/StorageContracts/IOrderStorageContract.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+
+namespace TwoFromTheCasketContratcs.StorageContracts;
+
+public interface IOrderStorageContract
+{
+    List<OrderDataModel> GetList();
+
+    OrderDataModel? GetElementById(string id);
+
+    OrderDataModel? GetElementByDate(DateTime date);
+
+    OrderDataModel? GetElementByStatus(StatusType status);
+
+    void AddElement(OrderDataModel orderDataModel);
+
+    void UpdElement(OrderDataModel orderDataModel);
+
+    void DelElement(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/StorageContracts/IPostStorageContract.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+
+namespace TwoFromTheCasketContratcs.StorageContracts;
+
+public interface IPostStorageContract
+{
+    List<PostDataModel> GetList();
+
+    List<PostDataModel> GetPostWithHistory(string postId);
+
+    PostDataModel? GetElementById(string id);
+
+    PostDataModel? GetElementByName(string name);
+
+    void AddElement(PostDataModel postDataModel);
+
+    void UpdElement(PostDataModel postDataModel);
+
+    void DelElement(string id);
+
+    void ResElement(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/StorageContracts/ISalaryStorageContract.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+
+namespace TwoFromTheCasketContratcs.StorageContracts;
+
+public interface ISalaryStorageContract
+{
+    List<SalaryDataModel> GetList(DateTime startDate, DateTime endDate, string?
+workerId = null);
+
+    SalaryDataModel? GetElementByMasterId(string masterId);
+
+    SalaryDataModel? GetElementBySalaryDate(DateTime salaryDate);
+
+    void AddElement(SalaryDataModel salaryDataModel);
+
+    void UpdElement(SalaryDataModel salaryDataModel);
+
+    void DelElement(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketContratcs/StorageContracts/IServiceStorageContract.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+
+namespace TwoFromTheCasketContratcs.StorageContracts;
+
+public interface IServiceStorageContract
+{
+    List<ServiceDataModel> GetList();
+
+    List<ServiceHistoryDataModel> GetHistoryByServiceId(string serviceId);
+    ServiceDataModel? GetElementById(string id);
+
+    List<ServiceDataModel>? GetElementByServiceName(string name);
+
+    List<ServiceDataModel>? GetElementByMasterId(string masterId);
+    void AddElement(ServiceDataModel serviceDataModel);
+
+    void UpdElement(ServiceDataModel serviceDataModel);
+
+    void DelElement(string id);
+}

TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/MasterBuisnessLogicContractTests.cs

@@ -0,0 +1,602 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using TwoFromTheCasketBuisnessLogic.Implementations;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketTest.BuisnessLogicContractTests;
+
+
+[TestFixture]
+internal class MasterBusinessLogicContractTests
+{
+    private MasterBusinessLogicContract _masterBusinessLogicContract;
+    private Mock<IMasterStorageContract> _masterStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _masterStorageContract = new Mock<IMasterStorageContract>();
+        _masterBusinessLogicContract = new MasterBusinessLogicContract(_masterStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _masterStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllMasters_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var listOriginal = new List<MasterDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMasters(true);
+        var list = _masterBusinessLogicContract.GetAllMasters(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, null, null, null, null, null), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMasters_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMasters(true);
+        var list = _masterBusinessLogicContract.GetAllMasters(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), null, null, null, null, null), Times.Exactly(2));
+    }
+
+    [Test]
+    public void GetAllMasters_ReturnNull_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMasters(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _masterStorageContract.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 GetAllMasters_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.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(() => _masterBusinessLogicContract.GetAllMasters(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _masterStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), null, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByPost_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var postId = Guid.NewGuid().ToString();
+        var listOriginal = new List<MasterDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByPost(postId, true);
+        var list = _masterBusinessLogicContract.GetAllMastersByPost(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, postId, null, null, null, null), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, postId, null, null, null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByPost_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByPost(Guid.NewGuid().ToString(), true);
+        var list = _masterBusinessLogicContract.GetAllMastersByPost(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));
+        });
+        _masterStorageContract.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 GetAllMastersByPost_PostIdIsNullOrEmpty_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByPost(null, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByPost(string.Empty, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
+        _masterStorageContract.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 GetAllMastersByPost_PostIdIsNotGuid_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByPost("postId", It.IsAny<bool>()), Throws.TypeOf<ValidationException>());
+        _masterStorageContract.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 GetAllMastersByPost_ReturnNull_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByPost(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _masterStorageContract.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 GetAllMastersByPost_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.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(() => _masterBusinessLogicContract.GetAllMastersByPost(Guid.NewGuid().ToString(), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _masterStorageContract.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 GetAllMastersByBirthDate_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<MasterDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByBirthDate(date, date.AddDays(1), true);
+        var list = _masterBusinessLogicContract.GetAllMastersByBirthDate(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, null, date, date.AddDays(1), null, null), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, null, date, date.AddDays(1), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByBirthDate_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), true);
+        var list = _masterBusinessLogicContract.GetAllMasters(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), null, null), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), null, null), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByBirthDate_IncorrectDates_ThrowException_Test()
+    {
+        // Arrange
+        var date = DateTime.UtcNow;
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByBirthDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByBirthDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        _masterStorageContract.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 GetAllMastersByBirthDate_ReturnNull_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _masterStorageContract.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 GetAllMastersByBirthDate_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.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(() => _masterBusinessLogicContract.GetAllMastersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _masterStorageContract.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 GetAllMastersByEmploymentDate_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var date = DateTime.UtcNow;
+        var listOriginal = new List<MasterDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+            new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, true),
+            new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false),
+        };
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByEmploymentDate(date, date.AddDays(1), true);
+        var list = _masterBusinessLogicContract.GetAllMastersByEmploymentDate(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, null, null, null, date, date.AddDays(1)), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, null, null, null, date, date.AddDays(1)), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByEmploymentDate_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _masterStorageContract.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 = _masterBusinessLogicContract.GetAllMastersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), true);
+        var list = _masterBusinessLogicContract.GetAllMastersByEmploymentDate(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));
+        });
+        _masterStorageContract.Verify(x => x.GetList(true, null, null, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+        _masterStorageContract.Verify(x => x.GetList(false, null, null, null, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllMastersByEmploymentDate_IncorrectDates_ThrowException_Test()
+    {
+        // Arrange
+        var date = DateTime.UtcNow;
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByEmploymentDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByEmploymentDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
+        _masterStorageContract.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 GetAllMastersByEmploymentDate_ReturnNull_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetAllMastersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+        _masterStorageContract.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 GetAllMastersByEmploymentDate_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.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(() => _masterBusinessLogicContract.GetAllMastersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+        _masterStorageContract.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 GetMasterByData_GetById_ReturnRecord_Test()
+    {
+        // Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new MasterDataModel(id, "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _masterStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+
+        // Act
+        var element = _masterBusinessLogicContract.GetMasterByData(id);
+
+        // Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _masterStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetMasterByData_GetByFio_ReturnRecord_Test()
+    {
+        // Arrange
+        var fio = "fio";
+        var record = new MasterDataModel(Guid.NewGuid().ToString(), fio, Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _masterStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record);
+
+        // Act
+        var element = _masterBusinessLogicContract.GetMasterByData(fio);
+
+        // Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.FIO, Is.EqualTo(fio));
+        _masterStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetMasterByData_EmptyData_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _masterStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _masterStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetMasterByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _masterStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _masterStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetMasterByData_GetByFio_NotFoundRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData("fio"), Throws.TypeOf<ElementNotFoundException>());
+        _masterStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _masterStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetMasterByData_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _masterStorageContract.Setup(x => x.GetElementByFIO(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _masterBusinessLogicContract.GetMasterByData("fio"), Throws.TypeOf<StorageException>());
+        _masterStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _masterStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertMaster_CorrectRecord_Test()
+    {
+        // Arrange
+        var flag = false;
+        var record = new MasterDataModel(Guid.NewGuid().ToString(), "Иван Иванов Иванович", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _masterStorageContract.Setup(x => x.AddElement(It.IsAny<MasterDataModel>()))
+            .Callback((MasterDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate &&
+                       x.EmploymentDate == record.EmploymentDate && x.IsDeleted == record.IsDeleted;
+            });
+
+        // Act
+        _masterBusinessLogicContract.InsertMaster(record);
+
+        // Assert
+        _masterStorageContract.Verify(x => x.AddElement(It.IsAny<MasterDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertMaster_RecordWithExistsData_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.AddElement(It.IsAny<MasterDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.InsertMaster(new(Guid.NewGuid().ToString(), "Иван Иван Иван", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ElementExistsException>());
+        _masterStorageContract.Verify(x => x.AddElement(It.IsAny<MasterDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertMaster_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.InsertMaster(null), Throws.TypeOf<ArgumentNullException>());
+        _masterStorageContract.Verify(x => x.AddElement(It.IsAny<MasterDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertMaster_InvalidRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.InsertMaster(new MasterDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ValidationException>());
+        _masterStorageContract.Verify(x => x.AddElement(It.IsAny<MasterDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertMaster_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.AddElement(It.IsAny<MasterDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.InsertMaster(new(Guid.NewGuid().ToString(), "Иван Иван Ивна", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<StorageException>());
+        _masterStorageContract.Verify(x => x.AddElement(It.IsAny<MasterDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateMaster_CorrectRecord_Test()
+    {
+        // Arrange
+        var flag = false;
+        var record = new MasterDataModel(Guid.NewGuid().ToString(), "Иван Иван Иван", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false);
+        _masterStorageContract.Setup(x => x.UpdElement(It.IsAny<MasterDataModel>()))
+            .Callback((MasterDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate &&
+                       x.EmploymentDate == record.EmploymentDate && x.IsDeleted == record.IsDeleted;
+            });
+
+        // Act
+        _masterBusinessLogicContract.UpdateMaster(record);
+
+        // Assert
+        _masterStorageContract.Verify(x => x.UpdElement(It.IsAny<MasterDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateMaster_RecordWithIncorrectData_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.UpdElement(It.IsAny<MasterDataModel>())).Throws(new ElementNotFoundException(""));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.UpdateMaster(new(Guid.NewGuid().ToString(), "Иван Иван Иван", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ElementNotFoundException>());
+        _masterStorageContract.Verify(x => x.UpdElement(It.IsAny<MasterDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateMaster_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.UpdateMaster(null), Throws.TypeOf<ArgumentNullException>());
+        _masterStorageContract.Verify(x => x.UpdElement(It.IsAny<MasterDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateMaster_InvalidRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.UpdateMaster(new MasterDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<ValidationException>());
+        _masterStorageContract.Verify(x => x.UpdElement(It.IsAny<MasterDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateMaster_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.UpdElement(It.IsAny<MasterDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.UpdateMaster(new(Guid.NewGuid().ToString(), "Иван Иван Иван", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now, false)), Throws.TypeOf<StorageException>());
+        _masterStorageContract.Verify(x => x.UpdElement(It.IsAny<MasterDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteMaster_CorrectRecord_Test()
+    {
+        // Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _masterStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+
+        // Act
+        _masterBusinessLogicContract.DeleteMaster(id);
+
+        // Assert
+        _masterStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteMaster_RecordWithIncorrectId_ThrowException_Test()
+    {
+        // Arrange
+        var id = Guid.NewGuid().ToString();
+        _masterStorageContract.Setup(x => x.DelElement(It.Is((string x) => x != id))).Throws(new ElementNotFoundException(id));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.DeleteMaster(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _masterStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteMaster_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.DeleteMaster(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _masterBusinessLogicContract.DeleteMaster(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _masterStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteMaster_IdIsNotGuid_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.DeleteMaster("id"), Throws.TypeOf<ValidationException>());
+        _masterStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteMaster_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _masterStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _masterBusinessLogicContract.DeleteMaster(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _masterStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/OrderBuisnessLogicContractTests.cs

@@ -0,0 +1,258 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using TwoFromTheCasketBuisnessLogic.Implementations;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketTest.BuisnessLogicContractTests;
+
+[TestFixture]
+internal class OrderBusinessLogicContractTests
+{
+    private OrderBusinessLogicContract _orderBusinessLogicContract;
+    private Mock<IOrderStorageContract> _orderStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _orderStorageContract = new Mock<IOrderStorageContract>();
+        _orderBusinessLogicContract = new OrderBusinessLogicContract(_orderStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _orderStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllOrder_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var listOriginal = new List<OrderDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.InProcess, RoomType.Industrial),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.InProcess, RoomType.Social),
+        };
+        _orderStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+
+        // Act
+        var list = _orderBusinessLogicContract.GetAllOrder();
+
+        // Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _orderStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllOrder_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _orderStorageContract.Setup(x => x.GetList()).Returns([]);
+
+        // Act
+        var list = _orderBusinessLogicContract.GetAllOrder();
+
+        // Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+    }
+
+    [Test]
+    public void GetAllOrder_ReturnNull_ThrowException_Test()
+    {
+        // Arrange
+        _orderStorageContract.Setup(x => x.GetList()).Returns((List<OrderDataModel>)null!);
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.GetAllOrder(), Throws.TypeOf<NullListException>());
+        _orderStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllOrder_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _orderStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.GetAllOrder(), Throws.TypeOf<StorageException>());
+        _orderStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllOrderByDate_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var fromDate = DateTime.UtcNow.AddDays(-7);
+        var listOriginal = new List<OrderDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-5), StatusType.NotStarted, RoomType.Social),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-3), StatusType.Ready, RoomType.Industrial),
+        };
+        _orderStorageContract.Setup(x => x.GetElementByDate(fromDate)).Returns(listOriginal[0]);
+
+        // Act
+        var list = _orderBusinessLogicContract.GetOrderByDate(fromDate);
+
+        // Assert
+        Assert.That(list, Is.Not.Null);
+        _orderStorageContract.Verify(x => x.GetElementByDate(fromDate), Times.Once);
+    }
+
+    [Test]
+    public void GetOrderByDate_ThrowsNullListException_WhenNoData_Test()
+    {
+        // Arrange
+        var fromDate = DateTime.UtcNow.AddDays(-7);
+        _orderStorageContract.Setup(x => x.GetElementByDate(It.IsAny<DateTime>()))
+            .Returns((OrderDataModel)null);
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.GetOrderByDate(fromDate),
+            Throws.TypeOf<NullListException>());
+
+        _orderStorageContract.Verify(x => x.GetElementByDate(It.IsAny<DateTime>()), Times.Once);
+    }
+
+
+
+
+    [Test]
+    public void GetOrderByData_ReturnRecord_Test()
+    {
+        // Arrange
+        var orderId = Guid.NewGuid().ToString();
+        var record = new OrderDataModel(orderId, DateTime.UtcNow, StatusType.NotStarted, RoomType.Social);
+        _orderStorageContract.Setup(x => x.GetElementById(orderId)).Returns(record);
+
+        // Act
+        var result = _orderBusinessLogicContract.GetOrderByData(orderId);
+
+        // Assert
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result.Id, Is.EqualTo(orderId));
+        _orderStorageContract.Verify(x => x.GetElementById(orderId), Times.Once);
+    }
+
+    [Test]
+    public void GetOrderByData_ReturnNull_ThrowException_Test()
+    {
+        // Arrange
+        _orderStorageContract.Setup(x => x.GetElementById(null));
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.GetOrderByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _orderStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertOrder_CorrectRecord_Test()
+    {
+        // Arrange
+        var record = new OrderDataModel(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.Ready, RoomType.Residential);
+        _orderStorageContract.Setup(x => x.AddElement(It.IsAny<OrderDataModel>()));
+
+        // Act
+        _orderBusinessLogicContract.InsertOrder(record);
+
+        // Assert
+        _orderStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertOrder_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.InsertOrder(null), Throws.TypeOf<ArgumentNullException>());
+        _orderStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertOrder_InvalidRecord_ThrowException_Test()
+    {
+        // Arrange
+        var invalidRecord = new OrderDataModel("invalid-id", default, StatusType.None, RoomType.None);
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.InsertOrder(invalidRecord), Throws.TypeOf<ValidationException>());
+        _orderStorageContract.Verify(x => x.AddElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateOrder_CorrectRecord_Test()
+    {
+        // Arrange
+        var record = new OrderDataModel(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.InProcess, RoomType.Industrial);
+        _orderStorageContract.Setup(x => x.UpdElement(It.IsAny<OrderDataModel>()));
+
+        // Act
+        _orderBusinessLogicContract.UpdateOrder(record);
+
+        // Assert
+        _orderStorageContract.Verify(x => x.UpdElement(It.IsAny<OrderDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateOrder_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.UpdateOrder(null), Throws.TypeOf<ArgumentNullException>());
+        _orderStorageContract.Verify(x => x.UpdElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateOrder_InvalidRecord_ThrowException_Test()
+    {
+        // Arrange
+        var invalidRecord = new OrderDataModel("invalid-id", default, StatusType.None, RoomType.None);
+
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.UpdateOrder(invalidRecord), Throws.TypeOf<ValidationException>());
+        _orderStorageContract.Verify(x => x.UpdElement(It.IsAny<OrderDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteOrder_CorrectRecord_Test()
+    {
+        // Arrange
+        var orderId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.DelElement(It.IsAny<string>()));
+
+        // Act
+        _orderBusinessLogicContract.DeleteOrder(orderId);
+
+        // Assert
+        _orderStorageContract.Verify(x => x.DelElement(orderId), Times.Once);
+    }
+
+    [Test]
+    public void DeleteOrder_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.DeleteOrder(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _orderBusinessLogicContract.DeleteOrder(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _orderStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteOrder_IdIsNotGuid_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _orderBusinessLogicContract.DeleteOrder("invalid-id"), Throws.TypeOf<ValidationException>());
+        _orderStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/PostBusinessLogicContractTests.cs

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

TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/SalaryBusinessLogicContractTests.cs

@@ -0,0 +1,432 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using TwoFromTheCasketBuisnessLogic.Implementations;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketTest.BuisnessLogicContractTests;
+
+[TestFixture]
+[TestFixture]
+internal class SalaryBusinessLogicContractTests
+{
+    
+    private SalaryBusinessLogicContract _salaryBusinessLogicContract;
+    private Mock<ISalaryStorageContract> _salaryStorageContract;
+    private Mock<IOrderStorageContract> _orderStorageContract;
+    private Mock<IPostStorageContract> _postStorageContract;
+    private Mock<IMasterStorageContract> _masterStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _salaryStorageContract = new Mock<ISalaryStorageContract>();
+        _orderStorageContract = new Mock<IOrderStorageContract>();
+        _postStorageContract = new Mock<IPostStorageContract>();
+        _masterStorageContract = new Mock<IMasterStorageContract>();
+        _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object,
+            _postStorageContract.Object, _masterStorageContract.Object,
+            new Mock<ILogger>().Object, _orderStorageContract.Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _salaryStorageContract.Reset();
+        _orderStorageContract.Reset();
+        _postStorageContract.Reset();
+        _masterStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllSalaries_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var startDate = DateTime.UtcNow;
+        var endDate = DateTime.UtcNow.AddDays(1);
+        var listOriginal = new List<SalaryDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10, 10),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14, 10),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30, 10),
+        };
+        _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 GetAllSalariesByMaster_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var startDate = DateTime.UtcNow;
+        var endDate = DateTime.UtcNow.AddDays(1);
+        var masterId = Guid.NewGuid().ToString();
+        var listOriginal = new List<SalaryDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10, 10),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14, 10),
+            new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30, 10),
+        };
+        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
+            .Returns(listOriginal);
+        //Act
+        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(startDate, endDate, masterId);
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+        _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, masterId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllSalariesByMaster_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
+            .Returns([]);
+        //Act
+        var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(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 GetAllSalariesByMaster_IncorrectDates_ThrowException_Test()
+    {
+        //Arrange
+        var dateTime = DateTime.UtcNow;
+        //Act&Assert
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(dateTime, dateTime,
+                Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(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 GetAllSalariesByMaster_MasterIdIsNUllOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
+                DateTime.UtcNow.AddDays(1), null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(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 GetAllSalariesByMaster_MasterIdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(DateTime.UtcNow,
+                DateTime.UtcNow.AddDays(1), "masterId"), Throws.TypeOf<ValidationException>());
+        _salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()),
+            Times.Never);
+    }
+
+    [Test]
+    public void GetAllSalariesByMaster_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(
+            () => _salaryBusinessLogicContract.GetAllSalariesByPeriodByMaster(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 GetAllSalariesByMaster_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.GetAllSalariesByPeriodByMaster(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 masterId = Guid.NewGuid().ToString();
+        var orderSum = 200.0;
+        var postSalary = 2000.0;
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, postSalary));
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        var sum = 0.0;
+        var expectedSum = postSalary + 500;
+        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+            .Callback((SalaryDataModel x) => { sum = x.Salary; });
+        //Act
+        _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
+        //Assert
+        Assert.That(sum, Is.EqualTo(expectedSum));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_WithSeveralMasters_Test()
+    {
+        //Arrange
+        var master1Id = Guid.NewGuid().ToString();
+        var master2Id = Guid.NewGuid().ToString();
+        var master3Id = Guid.NewGuid().ToString();
+        var list = new List<MasterDataModel>()
+        {
+            new MasterDataModel(master1Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                false),
+            new MasterDataModel(master2Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                false),
+            new MasterDataModel(master3Id, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                false)
+        };
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial),
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000));
+        _masterStorageContract.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.CalculateSalaryByMonth(DateTime.UtcNow);
+        //Assert
+        _salaryStorageContract.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Exactly(list.Count));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_WithoitOrdersByMaster_Test()
+    {
+        //Arrange
+        var postSalary = 2000.0;
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, postSalary));
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        var sum = 0.0;
+        var expectedSum = postSalary + 500;
+        _salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+            .Callback((SalaryDataModel x) => { sum = x.Salary; });
+        //Act
+        _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
+        //Assert
+        Assert.That(sum, Is.EqualTo(expectedSum));
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_OrderStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000));
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_PostStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_MasterStorageReturnNull_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000));
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<NullListException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_OrderStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Throws(new StorageException(new InvalidOperationException()));
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000));
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<StorageException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_PostStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Throws(new StorageException(new InvalidOperationException()));
+        _masterStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(),
+                It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+            .Returns([
+                new MasterDataModel(masterId, "А А А", Guid.NewGuid().ToString(), DateTime.UtcNow.AddYears(-19), DateTime.UtcNow,
+                    false)
+            ]);
+        //Act&Assert
+        Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<StorageException>());
+    }
+
+    [Test]
+    public void CalculateSalaryByMounth_MasterStorageThrowException_ThrowException_Test()
+    {
+        //Arrange
+        var masterId = Guid.NewGuid().ToString();
+        _orderStorageContract.Setup(x => x.GetList())
+            .Returns([
+                new OrderDataModel(Guid.NewGuid().ToString(), DateTime.Now, StatusType.Ready, RoomType.Industrial)
+            ]);
+        _postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+            .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Plasterer, 2000));
+        _masterStorageContract.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.CalculateSalaryByMonth(DateTime.UtcNow),
+            Throws.TypeOf<StorageException>());
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketTest/BuisnessLogicContractTests/ServiceBusinessLogicContractTests.cs

@@ -0,0 +1,263 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using TwoFromTheCasketBuisnessLogic.Implementations;
+using TwoFromTheCasketContratcs.BuisnessLogicsContracts;
+using TwoFromTheCasketContratcs.DataModels;
+using TwoFromTheCasketContratcs.Enums;
+using TwoFromTheCasketContratcs.Exceptions;
+using TwoFromTheCasketContratcs.StorageContracts;
+
+namespace TwoFromTheCasketTest.BuisnessLogicContractTests;
+
+[TestFixture]
+internal class ServiceBusinessLogicContractTests
+{
+    private ServiceBusinessLogicContract _serviceBusinessLogicContract;
+    private Mock<IServiceStorageContract> _serviceStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _serviceStorageContract = new Mock<IServiceStorageContract>();
+        _serviceBusinessLogicContract = new ServiceBusinessLogicContract(_serviceStorageContract.Object,new Mock<ILogger>().Object);
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _serviceStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllServices_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var listOriginal = new List<ServiceDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "Service 1", ServiceType.Painting, Guid.NewGuid().ToString(), 100, false),
+            new(Guid.NewGuid().ToString(), "Service 2", ServiceType.Carpentry, Guid.NewGuid().ToString(), 200, false),
+        };
+        _serviceStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+
+        // Act
+        var list = _serviceBusinessLogicContract.GetAllServices(onlyActive: true);
+
+        // Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Is.EquivalentTo(listOriginal));
+        });
+        _serviceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllServices_ReturnEmptyList_Test()
+    {
+        // Arrange
+        _serviceStorageContract.Setup(x => x.GetList()).Returns([]);
+
+        // Act
+        var list = _serviceBusinessLogicContract.GetAllServices(onlyActive: true);
+
+        // Assert
+        Assert.Multiple(() =>
+        {
+            Assert.That(list, Is.Not.Null);
+            Assert.That(list, Has.Count.EqualTo(0));
+        });
+    }
+
+    [Test]
+    public void GetAllServices_ReturnNull_ThrowException_Test()
+    {
+        // Arrange
+        _serviceStorageContract.Setup(x => x.GetList()).Returns((List<ServiceDataModel>)null!);
+
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.GetAllServices(onlyActive: true), Throws.TypeOf<NullListException>());
+        _serviceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllServices_StorageThrowError_ThrowException_Test()
+    {
+        // Arrange
+        _serviceStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.GetAllServices(onlyActive: true), Throws.TypeOf<StorageException>());
+        _serviceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllServicesByMasterId_ReturnAllServices_WhenOnlyActiveFalse()
+    {
+        // Arrange
+        var masterId = Guid.NewGuid().ToString();
+        var listOriginal = new List<ServiceDataModel>()
+    {
+        new(Guid.NewGuid().ToString(), "Service 1", ServiceType.Plastering, masterId, 100, false),
+        new(Guid.NewGuid().ToString(), "Service 2", ServiceType.Carpentry, masterId, 200, false),
+    };
+
+        _serviceStorageContract
+            .Setup(x => x.GetElementByMasterId(masterId))
+            .Returns(listOriginal);
+
+        // Act
+        var list = _serviceBusinessLogicContract.GetServicesByMasterId(masterId, onlyActive: false);
+
+        // Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2)); 
+        _serviceStorageContract.Verify(x => x.GetElementByMasterId(masterId), Times.Once);
+    }
+
+    [Test]
+    public void GetAllServicesByMasterId_ThrowsNullListException_WhenNoServicesFound()
+    {
+        // Arrange
+        _serviceStorageContract
+            .Setup(x => x.GetElementByMasterId(It.IsAny<string>()))
+            .Returns((List<ServiceDataModel>)null!);
+
+        // Act & Assert
+        Assert.That(
+            () => _serviceBusinessLogicContract.GetServicesByMasterId(Guid.NewGuid().ToString(), onlyActive: true),
+            Throws.TypeOf<NullListException>()
+        );
+
+        _serviceStorageContract.Verify(x => x.GetElementByMasterId(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetAllServicesByMasterId_MasterIdIsNullOrEmpty_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.GetServicesByMasterId(null, onlyActive: true), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _serviceBusinessLogicContract.GetServicesByMasterId(string.Empty, onlyActive: true), Throws.TypeOf<ArgumentNullException>());
+        _serviceStorageContract.Verify(x => x.GetElementByMasterId(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetAllServicesByServiceType_ReturnListOfRecords_Test()
+    {
+        // Arrange
+        var serviceType = ServiceType.Carpentry;
+        var listOriginal = new List<ServiceDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "Service 1", serviceType, Guid.NewGuid().ToString(), 100, false),
+            new(Guid.NewGuid().ToString(), "Service 2", serviceType, Guid.NewGuid().ToString(), 200, false),
+        };
+        _serviceStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+
+        // Act
+        var list = _serviceBusinessLogicContract.GetServicesByServiceType(serviceType, onlyActive: true);
+
+        // Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _serviceStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+    
+    [Test]
+    public void InsertService_CorrectRecord_Test()
+    {
+        // Arrange
+        var record = new ServiceDataModel(Guid.NewGuid().ToString(), "Service 1", ServiceType.Plastering, Guid.NewGuid().ToString(), 100, false);
+        _serviceStorageContract.Setup(x => x.AddElement(It.IsAny<ServiceDataModel>()));
+
+        // Act
+        _serviceBusinessLogicContract.InsertService(record);
+
+        // Assert
+        _serviceStorageContract.Verify(x => x.AddElement(It.IsAny<ServiceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertService_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.InsertService(null), Throws.TypeOf<ArgumentNullException>());
+        _serviceStorageContract.Verify(x => x.AddElement(It.IsAny<ServiceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertService_InvalidRecord_ThrowException_Test()
+    {
+        // Arrange
+        var invalidRecord = new ServiceDataModel("invalid-id", "", ServiceType.None, "invalid-master-id", -100, false);
+
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.InsertService(invalidRecord), Throws.TypeOf<ValidationException>());
+        _serviceStorageContract.Verify(x => x.AddElement(It.IsAny<ServiceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateService_CorrectRecord_Test()
+    {
+        // Arrange
+        var record = new ServiceDataModel(Guid.NewGuid().ToString(), "Service 1", ServiceType.Painting, Guid.NewGuid().ToString(), 100, false);
+        _serviceStorageContract.Setup(x => x.UpdElement(It.IsAny<ServiceDataModel>()));
+
+        // Act
+        _serviceBusinessLogicContract.UpdateService(record);
+
+        // Assert
+        _serviceStorageContract.Verify(x => x.UpdElement(It.IsAny<ServiceDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateService_NullRecord_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.UpdateService(null), Throws.TypeOf<ArgumentNullException>());
+        _serviceStorageContract.Verify(x => x.UpdElement(It.IsAny<ServiceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateService_InvalidRecord_ThrowException_Test()
+    {
+        // Arrange
+        var invalidRecord = new ServiceDataModel("invalid-id", "", ServiceType.None, "invalid-master-id", -100, false);
+
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.UpdateService(invalidRecord), Throws.TypeOf<ValidationException>());
+        _serviceStorageContract.Verify(x => x.UpdElement(It.IsAny<ServiceDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteService_CorrectRecord_Test()
+    {
+        // Arrange
+        var id = Guid.NewGuid().ToString();
+        _serviceStorageContract.Setup(x => x.DelElement(It.IsAny<string>()));
+
+        // Act
+        _serviceBusinessLogicContract.DeleteService(id);
+
+        // Assert
+        _serviceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteService_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.DeleteService(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _serviceBusinessLogicContract.DeleteService(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _serviceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteService_IdIsNotGuid_ThrowException_Test()
+    {
+        // Act & Assert
+        Assert.That(() => _serviceBusinessLogicContract.DeleteService("invalid-id"), Throws.TypeOf<ValidationException>());
+        _serviceStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+}

TwoFromTheCasketContratcs/TwoFromTheCasketTest/DataModelsTest/PostDataModelTests.cs

@@ -15,52 +15,40 @@ public class PostDataModelTests
     [Test]
     public void IdIsNullOrEmptyTest()
     {
-        var post = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, 50000, true, DateTime.Now);
+        var post = CreateDataModel(string.Empty, "Manager", PostType.Plasterer, 50000);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
     }
 
     [Test]
     public void IdIsNotGuidTest()
     {
-        var post = CreateDataModel("invalid-guid", Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, 50000, true, DateTime.Now);
+        var post = CreateDataModel("invalid-guid", "Manager", PostType.Plasterer, 50000);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
     }
 
-    [Test]
-    public void PostIdIsNullOrEmptyTest()
-    {
-        var post = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, "Manager", PostType.Plasterer, 50000, true, DateTime.Now);
-        Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
-    }
-
-    [Test]
-    public void PostIdIsNotGuidTest()
-    {
-        var post = CreateDataModel(Guid.NewGuid().ToString(), "invalid-guid", "Manager", PostType.Plasterer, 50000, true, DateTime.Now);
-        Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
-    }
+    
 
     [Test]
     public void PostNameIsNullOrEmptyTest()
     {
-        var post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), string.Empty, PostType.Plasterer, 50000, true, DateTime.Now);
+        var post = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, PostType.Plasterer, 50000);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
     }
 
     [Test]
     public void PostTypeIsNoneTest()
     {
-        var post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Manager", PostType.None, 50000, true, DateTime.Now);
+        var post = CreateDataModel(Guid.NewGuid().ToString(), "Manager", PostType.None, 50000);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
     }
 
     [Test]
     public void SalaryIsLessOrEqualToZeroTest()
     {
-        var post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, 0, true, DateTime.Now);
+        var post = CreateDataModel(Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, 0);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
 
-        post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, -1000, true, DateTime.Now);
+        post = CreateDataModel(Guid.NewGuid().ToString(), "Manager", PostType.Plasterer, -1000);
         Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
     }
 
@@ -68,31 +56,28 @@ public class PostDataModelTests
     public void AllFieldsAreCorrectTest()
     {
         var id = Guid.NewGuid().ToString();
-        var postId = Guid.NewGuid().ToString();
         var postName = "Manager";
         var postType = PostType.Plasterer;
         var salary = 50000.0;
         var isActual = true;
         var changeDate = DateTime.Now;
 
-        var post = CreateDataModel(id, postId, postName, postType, salary, isActual, changeDate);
+        var post = CreateDataModel(id,  postName, postType, salary);
 
         Assert.That(() => post.Validate(), Throws.Nothing);
 
         Assert.Multiple(() =>
         {
             Assert.That(post.Id, Is.EqualTo(id));
-            Assert.That(post.PostId, Is.EqualTo(postId));
             Assert.That(post.PostName, Is.EqualTo(postName));
             Assert.That(post.PostType, Is.EqualTo(postType));
             Assert.That(post.Salary, Is.EqualTo(salary));
-            Assert.That(post.IsActual, Is.EqualTo(isActual));
-            Assert.That(post.ChangeDate, Is.EqualTo(changeDate));
+            
         });
     }
 
-    private static PostDataModel CreateDataModel(string id, string postId, string postName, PostType postType, double salary, bool isActual, DateTime changeDate)
+    private static PostDataModel CreateDataModel(string id,  string postName, PostType postType, double salary)
     {
-        return new PostDataModel(id, postId, postName, postType, salary, isActual, changeDate);
+        return new PostDataModel(id, postName, postType, salary);
     }
 }

TwoFromTheCasketContratcs/TwoFromTheCasketTest/DataModelsTest/SalaryDataModelTests.cs

@@ -9,7 +9,7 @@ using TwoFromTheCasketContratcs.Exceptions;
 namespace TwoFromTheCasketTest.DataModelsTest;
 
 [TestFixture]
-public class SalaryDataModellTests
+public class SalaryDataModelTests
 {
     [Test]
     public void MasterIdIsNullOrEmptyTest()

TwoFromTheCasketContratcs/TwoFromTheCasketTest/TwoFromTheCasketTest.csproj

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