Лабораторная работа 2. Исправлена логика изменения количества компонента на складе, Добавлен тест на успешное добавление компонента в товар, если его хватает на складе

NorthBridge/NorthBridge.sln

@@ -3,7 +3,14 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.10.35013.160
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NorthBridgeContract", "NorthBridgeContract\NorthBridgeContract.csproj", "{28744C88-4DE9-429F-83DA-CA3670CE2D70}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NorthBridgeContract", "NorthBridgeContract\NorthBridgeContract.csproj", "{28744C88-4DE9-429F-83DA-CA3670CE2D70}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NorthBridgeTest", "NorthBridgeTest\NorthBridgeTest.csproj", "{0105777C-5918-452B-9321-ECAEB1767753}"
+	ProjectSection(ProjectDependencies) = postProject
+		{28744C88-4DE9-429F-83DA-CA3670CE2D70} = {28744C88-4DE9-429F-83DA-CA3670CE2D70}
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NorthBridgeBusinessLogic", "NorthBridgeBusinessLogic\NorthBridgeBusinessLogic.csproj", "{4954C88C-EB84-4FA2-879A-20AFA615DB17}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,6 +22,14 @@ Global
 		{28744C88-4DE9-429F-83DA-CA3670CE2D70}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{28744C88-4DE9-429F-83DA-CA3670CE2D70}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{28744C88-4DE9-429F-83DA-CA3670CE2D70}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0105777C-5918-452B-9321-ECAEB1767753}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0105777C-5918-452B-9321-ECAEB1767753}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0105777C-5918-452B-9321-ECAEB1767753}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0105777C-5918-452B-9321-ECAEB1767753}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4954C88C-EB84-4FA2-879A-20AFA615DB17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4954C88C-EB84-4FA2-879A-20AFA615DB17}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4954C88C-EB84-4FA2-879A-20AFA615DB17}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4954C88C-EB84-4FA2-879A-20AFA615DB17}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NorthBridge/NorthBridgeBusinessLogic/Implementations/BuyerBusinessLogicContract.cs

@@ -0,0 +1,70 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace NorthBridgeBusinessLogic.Implementations;
+
+internal class BuyerBusinessLogicContract(IBuyerStorageContract buyerStorageContract, ILogger logger) : IBuyerBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IBuyerStorageContract _buyerStorageContract = buyerStorageContract;
+
+    public List<BuyerDataModel> GetAllBuyers()
+    {
+        _logger.LogInformation("GetAllBuyers");
+        return _buyerStorageContract.GetList() ?? throw new NullListException();
+    }
+
+    public BuyerDataModel GetBuyerByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _buyerStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        if (Regex.IsMatch(data, @"^((8|\+7)[\- ]?)?(\(?\d{3}\)?[\- ]?)?[\d\- ]{7,10}$"))
+        {
+            return _buyerStorageContract.GetElementByPhoneNumber(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _buyerStorageContract.GetElementByFIO(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertBuyer(BuyerDataModel buyerDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(buyerDataModel));
+        ArgumentNullException.ThrowIfNull(buyerDataModel);
+        buyerDataModel.Validate();
+        _buyerStorageContract.AddElement(buyerDataModel);
+    }
+
+    public void UpdateBuyer(BuyerDataModel buyerDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(buyerDataModel));
+        ArgumentNullException.ThrowIfNull(buyerDataModel);
+        buyerDataModel.Validate();
+        _buyerStorageContract.UpdElement(buyerDataModel);
+    }
+
+    public void DeleteBuyer(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");
+        }
+        _buyerStorageContract.DelElement(id);
+    }
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/ComponentBusinessLogicContract.cs

@@ -0,0 +1,136 @@
+using Microsoft.Extensions.Logging;
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.StoragesContracts;
+using System.Text.Json;
+
+namespace NorthBridgeBusinessLogic.Implementations
+{
+    internal class ComponentBusinessLogicContract(IComponentStorageContract componentStorageContract, ILogger logger) : IComponentBusinessLogicContract
+    {
+        private readonly ILogger _logger = logger;
+        private readonly IComponentStorageContract _componentStorageContract = componentStorageContract;
+
+        public List<ComponentDataModel> GetAllComponents(bool onlyActive)
+        {
+            _logger.LogInformation("GetAllComponents, onlyActive: {onlyActive}", onlyActive);
+            return _componentStorageContract.GetList(onlyActive) ?? throw new NullListException();
+        }
+
+        public ComponentDataModel GetComponentById(string id)
+        {
+            _logger.LogInformation("GetComponentById: {id}", id);
+            if (id.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+            if (!id.IsGuid())
+            {
+                throw new ValidationException("Id is not a unique identifier");
+            }
+            return _componentStorageContract.GetElementById(id) ?? throw new ElementNotFoundException(id);
+        }
+
+        public ComponentDataModel GetComponentByName(string name)
+        {
+            _logger.LogInformation("GetComponentByName: {name}", name);
+            if (name.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            return _componentStorageContract.GetElementByName(name) ?? throw new ElementNotFoundException(name);
+        }
+
+        public ComponentDataModel GetComponentByData(string data)
+        {
+            _logger.LogInformation("GetComponentByData: {data}", data);
+            if (data.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(data));
+            }
+            if (data.IsGuid())
+            {
+                return GetComponentById(data);
+            }
+            return GetComponentByName(data);
+        }
+
+        public void InsertComponent(ComponentDataModel componentDataModel)
+        {
+            _logger.LogInformation("InsertComponent: {json}", JsonSerializer.Serialize(componentDataModel));
+            ArgumentNullException.ThrowIfNull(componentDataModel);
+            componentDataModel.Validate();
+            _componentStorageContract.AddElement(componentDataModel);
+        }
+
+        public void UpdateComponent(ComponentDataModel componentDataModel)
+        {
+            _logger.LogInformation("UpdateComponent: {json}", JsonSerializer.Serialize(componentDataModel));
+            ArgumentNullException.ThrowIfNull(componentDataModel);
+            componentDataModel.Validate();
+
+            var existingComponent = _componentStorageContract.GetElementById(componentDataModel.Id);
+            if (existingComponent == null)
+            {
+                throw new ElementNotFoundException(componentDataModel.Id);
+            }
+
+            if (existingComponent.Price != componentDataModel.Price)
+            {
+                var historyEntry = new ComponentHistoryDataModel(existingComponent.Id, existingComponent.Price);
+                historyEntry.Validate();
+                _componentStorageContract.AddComponentHistory(historyEntry);
+            }
+
+            _componentStorageContract.UpdElement(componentDataModel);
+        }
+
+        public void DeleteComponent(string id)
+        {
+            _logger.LogInformation("DeleteComponent by id: {id}", id);
+            if (id.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+            if (!id.IsGuid())
+            {
+                throw new ValidationException("Id is not a unique identifier");
+            }
+            _componentStorageContract.DelElement(id);
+        }
+
+        public void RestoreComponent(string id)
+        {
+            _logger.LogInformation("RestoreComponent by id: {id}", id);
+            if (id.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+            if (!id.IsGuid())
+            {
+                throw new ValidationException("Id is not a unique identifier");
+            }
+            _componentStorageContract.ResElement(id);
+        }
+
+        public List<ComponentHistoryDataModel> GetComponentHistory(string componentId)
+        {
+            _logger.LogInformation("GetComponentHistory for componentId: {componentId}", componentId);
+            if (componentId.IsEmpty())
+            {
+                throw new ArgumentNullException(nameof(componentId));
+            }
+            if (!componentId.IsGuid())
+            {
+                throw new ValidationException("ComponentId is not a unique identifier");
+            }
+            return _componentStorageContract.GetComponentHistory(componentId) ?? [];
+        }
+    }
+
+
+
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/ManufacturerBusinessLogicContract.cs

@@ -0,0 +1,66 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+
+namespace NorthBridgeBusinessLogic.Implementations;
+
+internal class ManufacturerBusinessLogicContract(IManufacturerStorageContract manufacturerStorageContract, ILogger logger) : IManufacturerBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IManufacturerStorageContract _manufacturerStorageContract = manufacturerStorageContract;
+
+    public List<ManufacturerDataModel> GetAllManufacturers()
+    {
+        _logger.LogInformation("GetAllManufacturers");
+        return _manufacturerStorageContract.GetList() ?? throw new NullListException();
+    }
+
+    public ManufacturerDataModel GetManufacturerByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (data.IsGuid())
+        {
+            return _manufacturerStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+        return _manufacturerStorageContract.GetElementByName(data) ?? _manufacturerStorageContract.GetElementByOldName(data) ??
+            throw new ElementNotFoundException(data);
+    }
+
+    public void InsertManufacturer(ManufacturerDataModel manufacturerDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(manufacturerDataModel));
+        ArgumentNullException.ThrowIfNull(manufacturerDataModel);
+        manufacturerDataModel.Validate();
+        _manufacturerStorageContract.AddElement(manufacturerDataModel);
+    }
+
+    public void UpdateManufacturer(ManufacturerDataModel manufacturerDataModel)
+    {
+        _logger.LogInformation("Update data: {json}", JsonSerializer.Serialize(manufacturerDataModel));
+        ArgumentNullException.ThrowIfNull(manufacturerDataModel);
+        manufacturerDataModel.Validate();
+        _manufacturerStorageContract.UpdElement(manufacturerDataModel);
+    }
+
+    public void DeleteManufacturer(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");
+        }
+        _manufacturerStorageContract.DelElement(id);
+    }
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/PostBusinessLogicContract.cs

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

NorthBridge/NorthBridgeBusinessLogic/Implementations/ProductBusinessLogicContract.cs

@@ -0,0 +1,130 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using NorthBridgeContract.BusinessLogicContracts;
+namespace NorthBridgeBusinessLogic.Implementations;
+
+internal class ProductBusinessLogicContract(
+    IProductStorageContract productStorageContract,
+    IComponentStorageContract componentStorageContract,
+    ILogger logger) : IProductBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly IProductStorageContract _productStorageContract = productStorageContract;
+    private readonly IComponentStorageContract _componentStorageContract = componentStorageContract;
+
+    public List<ProductDataModel> GetAllProducts(bool onlyActive)
+    {
+        _logger.LogInformation("Getting all products (onlyActive: {onlyActive})", onlyActive);
+        var products = _productStorageContract.GetList(onlyActive);
+        return products ?? throw new NullListException();
+    }
+
+    public List<ProductDataModel> GetAllProductsByManufacturer(string manufacturerId, bool onlyActive = true)
+    {
+        _logger.LogInformation("Getting all products for manufacturer {manufacturerId} (onlyActive: {onlyActive})", manufacturerId, onlyActive);
+        if (manufacturerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(manufacturerId));
+        }
+        var products = _productStorageContract.GetListByManufacturer(manufacturerId, onlyActive);
+        return products ?? throw new NullListException();
+    }
+
+    public ProductDataModel GetProductByData(string data)
+    {
+        _logger.LogInformation("Getting product by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+
+        if (data.IsGuid())
+        {
+            return _productStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+        }
+
+        return _productStorageContract.GetElementByName(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertProduct(ProductDataModel productDataModel)
+    {
+        _logger.LogInformation("Inserting new product: {json}", JsonSerializer.Serialize(productDataModel));
+        ArgumentNullException.ThrowIfNull(productDataModel);
+        productDataModel.Validate();
+        _productStorageContract.AddElement(productDataModel);
+    }
+
+    public void UpdateProduct(ProductDataModel productDataModel)
+    {
+        _logger.LogInformation("Updating product: {json}", JsonSerializer.Serialize(productDataModel));
+        ArgumentNullException.ThrowIfNull(productDataModel);
+        productDataModel.Validate();
+
+        var existingProduct = _productStorageContract.GetElementById(productDataModel.Id);
+        if (existingProduct == null)
+        {
+            throw new ValidationException("Product not found");
+        }
+
+        _productStorageContract.UpdElement(productDataModel);
+    }
+
+    public void DeleteProduct(string id)
+    {
+        _logger.LogInformation("Deleting product with id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a valid GUID");
+        }
+        _productStorageContract.DelElement(id);
+    }
+
+    public List<ComponentDataModel> GetComponentsByProductId(string productId)
+    {
+        _logger.LogInformation("Getting components for product {productId}", productId);
+        if (productId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(productId));
+        }
+
+        var components = _productStorageContract.GetComponentsByProductId(productId);
+        return components ?? throw new NullListException();
+    }
+
+    public void AddComponentToProduct(ComponentOnStorageDataModel componentOnStorage, string productId)
+    {
+        _logger.LogInformation("Adding component to product: {json}", JsonSerializer.Serialize(componentOnStorage));
+        ArgumentNullException.ThrowIfNull(componentOnStorage);
+        componentOnStorage.Validate();
+
+        ComponentDataModel component = _componentStorageContract.GetElementById(componentOnStorage.ComponentId)!;
+        if (component == null) 
+            throw new ArgumentNullException($"Component {componentOnStorage.ComponentId} not found");
+
+        if (componentOnStorage.Count <= 0)
+            throw new OutOfStockException(component.ComponentName);
+
+        ComponentInProductDataModel componentInProduct = new ComponentInProductDataModel(component.Id, productId);
+
+        _productStorageContract.AddComponentToProduct(componentInProduct);
+    }
+
+    public void RemoveComponentFromProduct(string componentId, string productId)
+    {
+        _logger.LogInformation("Removing component {componentId} from product {productId}", componentId, productId);
+        if (componentId.IsEmpty() || productId.IsEmpty())
+        {
+            throw new ArgumentNullException("ComponentId or ProductId cannot be null or empty");
+        }
+        _productStorageContract.RemoveComponentFromProduct(componentId, productId);
+    }
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/SalaryBusinessLogicContract.cs

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

NorthBridge/NorthBridgeBusinessLogic/Implementations/SaleBusinessLogicContract.cs

@@ -0,0 +1,113 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+
+internal class SaleBusinessLogicContract(ISaleStorageContract saleStorageContract, ILogger logger) : ISaleBusinessLogicContract
+{
+    private readonly ILogger _logger = logger;
+    private readonly ISaleStorageContract _saleStorageContract = saleStorageContract;
+
+    public List<SaleDataModel> GetAllSalesByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {fromDate}, {toDate}", fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        return _saleStorageContract.GetList(fromDate, toDate) ?? throw new NullListException();
+    }
+
+    public List<SaleDataModel> GetAllSalesByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {workerId}, {fromDate}, {toDate}", workerId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (workerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(workerId));
+        }
+        if (!workerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field workerId is not a unique identifier.");
+        }
+        return _saleStorageContract.GetList(fromDate, toDate, workerId: workerId) ?? throw new NullListException();
+    }
+
+    public List<SaleDataModel> GetAllSalesByBuyerByPeriod(string buyerId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {buyerId}, {fromDate}, {toDate}", buyerId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (buyerId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(buyerId));
+        }
+        if (!buyerId.IsGuid())
+        {
+            throw new ValidationException("The value in the field buyerId is not a unique identifier.");
+        }
+        return _saleStorageContract.GetList(fromDate, toDate, buyerId: buyerId) ?? throw new NullListException();
+    }
+
+    public List<SaleDataModel> GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate)
+    {
+        _logger.LogInformation("GetAllSales params: {productId}, {fromDate}, {toDate}", productId, fromDate, toDate);
+        if (fromDate.IsDateNotOlder(toDate))
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+        if (productId.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(productId));
+        }
+        if (!productId.IsGuid())
+        {
+            throw new ValidationException("The value in the field productId is not a unique identifier.");
+        }
+        return _saleStorageContract.GetList(fromDate, toDate, productId: productId) ?? throw new NullListException();
+    }
+
+    public SaleDataModel GetSaleByData(string data)
+    {
+        _logger.LogInformation("Get element by data: {data}", data);
+        if (data.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+        if (!data.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        return _saleStorageContract.GetElementById(data) ?? throw new ElementNotFoundException(data);
+    }
+
+    public void InsertSale(SaleDataModel saleDataModel)
+    {
+        _logger.LogInformation("New data: {json}", JsonSerializer.Serialize(saleDataModel));
+        ArgumentNullException.ThrowIfNull(saleDataModel);
+        saleDataModel.Validate();
+        _saleStorageContract.AddElement(saleDataModel);
+    }
+
+    public void CancelSale(string id)
+    {
+        _logger.LogInformation("Cancel by id: {id}", id);
+        if (id.IsEmpty())
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+        if (!id.IsGuid())
+        {
+            throw new ValidationException("Id is not a unique identifier");
+        }
+        _saleStorageContract.DelElement(id);
+    }
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/StorageBusinessLogicContract .cs

@@ -0,0 +1,116 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeBusinessLogic.Implementations
+{
+    public class StorageBusinessLogicContract : IStorageBusinessLogicContract
+    {
+        private readonly IStorageContract _storageContract;
+
+        public StorageBusinessLogicContract(IStorageContract storageContract)
+        {
+            _storageContract = storageContract;
+        }
+
+        public void CreateStorage(string id, string address, bool isOpen, List<ComponentOnStorageDataModel> components)
+        {
+            if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(address))
+            {
+                throw new ArgumentException("Invalid storage parameters");
+            }
+
+            var storage = new StorageDataModel(id, address, isOpen, components);
+
+            _storageContract.AddStorage(storage);
+        }
+
+        public void CloseStorage(string storageId)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+
+            _storageContract.CloseStorage(storageId);
+        }
+
+        public void AddComponentToStorage(string storageId, ComponentOnStorageDataModel component)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+
+            if (component == null)
+            {
+                throw new ArgumentNullException("Component cannot be null");
+            }
+
+            _storageContract.AddOrUpdateComponentOnStorage(component);
+        }
+
+        public void UpdateComponentCount(string storageId, string componentId, int newCount)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+
+            if (newCount < 0)
+            {
+                throw new ArgumentException("Count cannot be negative");
+            }
+
+            _storageContract.UpdateComponentCount(storageId, componentId, newCount);
+        }
+
+        public int GetComponentCountFromStorage(string componentId, string storageId)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            var component = _storageContract.GetComponentOnStorage(storageId, componentId);
+
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+            if (component == null)
+            {
+                throw new ArgumentNullException("Component not found");
+            }
+
+            return component.Count;
+        }
+
+        public List<ComponentOnStorageDataModel> GetComponentsFromStorage(string storageId)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+
+            return _storageContract.GetComponentsOnStorage(storageId);
+        }
+
+        public StorageDataModel GetStorageById(string storageId)
+        {
+            var storage = _storageContract.GetStorageById(storageId);
+            if (storage == null)
+            {
+                throw new ArgumentNullException("Storage not found");
+            }
+
+            return storage;
+        }
+    }
+
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/SupplyBusinessLogicContract.cs

@@ -0,0 +1,63 @@
+using NorthBridgeContract.BusinessLogicsContracts;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeBusinessLogic.Implementations
+{
+    public class SupplyBusinessLogicContract : ISupplyBusinessLogicContract
+    {
+        private readonly ISupplyStorageContract _supplyStorageContract;
+
+        public SupplyBusinessLogicContract(ISupplyStorageContract supplyStorageContract)
+        {
+            _supplyStorageContract = supplyStorageContract;
+        }
+
+        public void CreateSupply(SupplyDataModel supply)
+        {
+            supply.Validate();
+            _supplyStorageContract.AddSupply(supply);
+        }
+
+        public SupplyDataModel GetSupplyById(string supplyId)
+        {
+            var supply = _supplyStorageContract.GetSupplyById(supplyId);
+            if (supply == null)
+            {
+                throw new ArgumentException($"Supply with ID {supplyId} not found.");
+            }
+            return supply;
+        }
+
+        public List<SupplyDataModel> GetSuppliesByStorageId(string storageId)
+        {
+            return _supplyStorageContract.GetSuppliesByStorageId(storageId);
+        }
+
+        public void AddOrUpdateComponentInSupply(ComponentInSupplyDataModel componentInSupply)
+        {
+            componentInSupply.Validate();
+            _supplyStorageContract.AddOrUpdateComponentInSupply(componentInSupply);
+        }
+
+        public void UpdateComponentCountInSupply(string supplyId, string componentId, int newCount)
+        {
+            if (newCount <= 0)
+            {
+                throw new ArgumentException("Component count must be greater than zero.");
+            }
+            _supplyStorageContract.UpdateComponentCountInSupply(supplyId, componentId, newCount);
+        }
+
+        public void RemoveComponentFromSupply(string supplyId, string componentId)
+        {
+            _supplyStorageContract.RemoveComponentFromSupply(supplyId, componentId);
+        }
+    }
+
+}

NorthBridge/NorthBridgeBusinessLogic/Implementations/WorkerBusinessLogicContract.cs

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

NorthBridge/NorthBridgeBusinessLogic/NorthBridgeBusinessLogic.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+    <PackageReference Include="System.Text.Json" Version="8.0.5" />
+    <PackageReference Include="System.Text.RegularExpressions" Version="4.3.1" />
+  </ItemGroup>
+	<ItemGroup>
+		<InternalsVisibleTo Include="NorthBridgeTest" />
+		<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+	</ItemGroup>
+
+	<ItemGroup>
+    <ProjectReference Include="..\NorthBridgeContract\NorthBridgeContract.csproj" />
+  </ItemGroup>
+
+</Project>

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IBuyerBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.BusinessLogicsContracts;
+
+public interface IBuyerBusinessLogicContract
+{
+	List<BuyerDataModel> GetAllBuyers();
+
+	BuyerDataModel GetBuyerByData(string data);
+
+	void InsertBuyer(BuyerDataModel buyerDataModel);
+
+	void UpdateBuyer(BuyerDataModel buyerDataModel);
+
+	void DeleteBuyer(string id);
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IComponentBusinessLogicContract.cs

@@ -0,0 +1,31 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.BusinessLogicsContracts
+{
+    public interface IComponentBusinessLogicContract
+    {
+        List<ComponentDataModel> GetAllComponents(bool onlyActive);
+
+        ComponentDataModel GetComponentByData(string data);
+
+        ComponentDataModel? GetComponentById(string id);
+
+        ComponentDataModel? GetComponentByName(string name);
+
+        void InsertComponent(ComponentDataModel componentDataModel);
+
+        void UpdateComponent(ComponentDataModel componentDataModel);
+
+        void DeleteComponent(string id);
+
+        void RestoreComponent(string id);
+
+        List<ComponentHistoryDataModel> GetComponentHistory(string componentId);
+    }
+
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IManufacturerBusinessLogicContract.cs

@@ -0,0 +1,16 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.BusinessLogicsContracts;
+
+public interface IManufacturerBusinessLogicContract
+{
+	List<ManufacturerDataModel> GetAllManufacturers();
+
+	ManufacturerDataModel GetManufacturerByData(string data);
+
+	void InsertManufacturer(ManufacturerDataModel manufacturerDataModel);
+
+	void UpdateManufacturer(ManufacturerDataModel manufacturerDataModel);
+
+	void DeleteManufacturer(string id);
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IPostBusinessLogicContract.cs

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

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IProductBusinessLogicContract.cs

@@ -0,0 +1,25 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.BusinessLogicContracts
+{
+    public interface IProductBusinessLogicContract
+    {
+        List<ProductDataModel> GetAllProducts(bool onlyActive = true);
+
+        List<ProductDataModel> GetAllProductsByManufacturer(string manufacturerId, bool onlyActive = true);
+
+        ProductDataModel? GetProductByData(string data);
+
+        void InsertProduct(ProductDataModel productDataModel);
+
+        void UpdateProduct(ProductDataModel productDataModel);
+
+        void DeleteProduct(string id);
+
+        List<ComponentDataModel> GetComponentsByProductId(string productId);
+
+        void AddComponentToProduct(ComponentOnStorageDataModel componentOnStorage, string productId);
+
+        void RemoveComponentFromProduct(string componentId, string productId);
+    }
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs

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

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISaleBusinessLogicContract.cs

@@ -0,0 +1,20 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.BusinessLogicsContracts;
+
+public interface ISaleBusinessLogicContract
+{
+	List<SaleDataModel> GetAllSalesByPeriod(DateTime fromDate, DateTime toDate);
+
+	List<SaleDataModel> GetAllSalesByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate);
+
+	List<SaleDataModel> GetAllSalesByBuyerByPeriod(string buyerId, DateTime fromDate, DateTime toDate);
+
+	List<SaleDataModel> GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate);
+
+	SaleDataModel GetSaleByData(string data);
+
+	void InsertSale(SaleDataModel saleDataModel);
+
+	void CancelSale(string id);
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IStorageBusinessLogicContract.cs

@@ -0,0 +1,27 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.BusinessLogicsContracts
+{
+    public interface IStorageBusinessLogicContract
+    {
+        void CreateStorage(string id, string address, bool isOpen, List<ComponentOnStorageDataModel> components);
+
+        void CloseStorage(string storageId);
+
+        void AddComponentToStorage(string storageId, ComponentOnStorageDataModel component);
+
+        void UpdateComponentCount(string storageId, string componentId, int newCount);
+
+        int GetComponentCountFromStorage(string componentId, string storageId);
+
+        List<ComponentOnStorageDataModel> GetComponentsFromStorage(string storageId);
+
+        StorageDataModel GetStorageById(string storageId);
+    }
+
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISupplyBusinessLogicContract.cs

@@ -0,0 +1,25 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.BusinessLogicsContracts
+{
+    public interface ISupplyBusinessLogicContract
+    {
+        void CreateSupply(SupplyDataModel supply);
+
+        SupplyDataModel GetSupplyById(string supplyId);
+
+        List<SupplyDataModel> GetSuppliesByStorageId(string storageId);
+
+        void AddOrUpdateComponentInSupply(ComponentInSupplyDataModel componentInSupply);
+
+        void UpdateComponentCountInSupply(string supplyId, string componentId, int newCount);
+
+        void RemoveComponentFromSupply(string supplyId, string componentId);
+    }
+
+}

NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs

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

NorthBridge/NorthBridgeContract/DataModels/BuyerDataModel.cs

@@ -0,0 +1,36 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+using System.Text.RegularExpressions;
+
+namespace NorthBridgeContract.DataModels;
+
+public class BuyerDataModel(string id, string fio, string phoneNumber) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string FIO { get; private set; } = fio;
+
+	public string PhoneNumber { get; private set; } = phoneNumber;
+
+	public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (FIO.IsEmpty())
+			throw new ValidationException("Field FIO is empty");
+
+		if (PhoneNumber.IsEmpty())
+			throw new ValidationException("Field PhoneNumber is empty");
+
+		if (!Regex.IsMatch(PhoneNumber, @"^((8|\+7)[\- ]?)?(\(?\d{3}\)?[\- ]?)?[\d\- ]{7,10}$"))
+			throw new ValidationException("Field PhoneNumber is not a phone number");
+
+		if (!Regex.IsMatch(FIO, @"^[А-ЯЁ][а-яё]+(?:-[А-ЯЁ][а-яё]+)?\s[А-ЯЁ][а-яё]+(?:\s[А-ЯЁ][а-яё]+)?$"))
+			throw new ValidationException("Field FIO is not a fio");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/ComponentDataModel.cs

@@ -0,0 +1,45 @@
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class ComponentDataModel(string id, string componentName, ComponentType componentType, string manufacturerId, double price, bool isDeleted) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string ComponentName { get; private set; } = componentName;
+
+	public ComponentType ComponentType { get; private set; } = componentType;
+
+	public string ManufacturerId { get; private set; } = manufacturerId;
+
+	public double Price { get; private set; } = price;
+
+	public bool IsDeleted { get; private set; } = isDeleted;
+
+	public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (ComponentName.IsEmpty())
+			throw new ValidationException("Field ProductName is empty");
+
+		if (ComponentType == ComponentType.None)
+			throw new ValidationException("Field ProductType is empty");
+
+		if (ManufacturerId.IsEmpty())
+			throw new ValidationException("Field ManufacturerId is empty");
+
+		if (!ManufacturerId.IsGuid())
+			throw new ValidationException("The value in the field ManufacturerId is not a unique identifier");
+
+		if (Price <= 0)
+			throw new ValidationException("Field Price is less than or equal to 0");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/ComponentHistoryDataModel.cs

@@ -0,0 +1,26 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class ComponentHistoryDataModel(string componentId, double oldPrice) : IValidation
+{
+	public string ComponentId { get; private set; } = componentId;
+
+	public double OldPrice { get; private set; } = oldPrice;
+
+	public DateTime ChangeDate { get; private set; } = DateTime.UtcNow;
+
+	public void Validate()
+	{
+		if (ComponentId.IsEmpty())
+			throw new ValidationException("Field ComponentId is empty");
+
+		if (!ComponentId.IsGuid())
+			throw new ValidationException("The value in the field ComponentId is not a unique identifier");
+
+		if (OldPrice <= 0)
+			throw new ValidationException("Field OldPrice is less than or equal to 0");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/ComponentInProductDataModel.cs

@@ -0,0 +1,28 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels
+{
+    public class ComponentInProductDataModel(string componentId, string productId) : IValidation
+    {
+        public string ComponentId { get; private set; } = componentId;
+        public string ProductId { get; private set;} = productId;
+
+        public void Validate()
+        {
+            if (ComponentId.IsEmpty())
+                throw new ValidationException("Field ComponentId is empty");
+
+            if (!ComponentId.IsGuid())
+                throw new ValidationException("The value in the field ComponentId is not a unique identifier");
+
+            if (ProductId.IsEmpty())
+                throw new ValidationException("Field ProductId is empty");
+
+            if (!ProductId.IsGuid())
+                throw new ValidationException("The value in the field ProductId is not a unique identifier");
+
+        }
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/ComponentInSupplyDataModel.cs

@@ -0,0 +1,32 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+
+namespace NorthBridgeContract.DataModels
+{
+    public class ComponentInSupplyDataModel(string supplyId, string componentId, int count)
+    {
+        public string SupplyId { get; private set; } = supplyId;
+
+        public string ComponentId { get; private set; } = componentId;
+
+        public int Count { get; private set; } = count;
+
+        public void Validate()
+        {
+            if (SupplyId.IsEmpty())
+                throw new ValidationException("Field SupplyId is empty");
+
+            if (!SupplyId.IsGuid())
+                throw new ValidationException("The value in the field SupplyId is not a unique identifier");
+
+            if (ComponentId.IsEmpty())
+                throw new ValidationException("Field ProductId is empty");
+
+            if (!ComponentId.IsGuid())
+                throw new ValidationException("The value in the field ProductId is not a unique identifier");
+
+            if (Count <= 0)
+                throw new ValidationException("Field Count is less than or equal to 0");
+        }
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/ComponentOnStorageDataModel.cs

@@ -0,0 +1,30 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels
+{
+    public class ComponentOnStorageDataModel(string storageId, string componentId, int count) : IValidation
+    {
+        public string StorageId { get; private set; } = storageId;
+
+        public string ComponentId { get; private set; } = componentId;
+
+        public int Count { get; private set; } = count;
+
+        public void Validate()
+        {
+            if (StorageId.IsEmpty())
+                throw new ValidationException("Field StorageId is empty");
+
+            if (!StorageId.IsGuid())
+                throw new ValidationException("The value in the field StorageId is not a unique identifier");
+
+            if (ComponentId.IsEmpty())
+                throw new ValidationException("Field ProductId is empty");
+
+            if (!ComponentId.IsGuid())
+                throw new ValidationException("The value in the field ProductId is not a unique identifier");
+        }
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/ManufacturerDataModel.cs

@@ -0,0 +1,28 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class ManufacturerDataModel(string id, string manufacturerName, string? prevManufacturerName, string? prevPrevManufacturerName) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string ManufacturerName { get; private set; } = manufacturerName;
+
+	public string? PrevManufacturerName { get; private set; } = prevManufacturerName;
+
+	public string? PrevPrevManufacturerName { get; private set; } = prevPrevManufacturerName;
+
+	public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (ManufacturerName.IsEmpty())
+			throw new ValidationException("Field ManufacturerName is empty");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/PostDataModel.cs

@@ -0,0 +1,39 @@
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class PostDataModel(string id, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	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()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (PostName.IsEmpty())
+			throw new ValidationException("Field PostName is empty");
+
+		if (PostType == PostType.None)
+			throw new ValidationException("Field PostType is empty");
+
+		if (Salary <= 0)
+			throw new ValidationException("Field Salary is empty");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/ProductDataModel.cs

@@ -0,0 +1,47 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class ProductDataModel(string id, string productName, string workerId, bool isDeleted, List<ComponentDataModel> components) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string ProductName { get; private set; } = productName;
+
+	public string WorkerId { get; private set; } = workerId;
+
+	public bool IsDeleted { get; private set; } = isDeleted;
+
+	public List<ComponentDataModel> Components { get; private set; } = components;
+
+	public double TotalPrice => Components.Sum(x => x.Price);
+
+    public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (ProductName.IsEmpty())
+			throw new ValidationException("Field ProductName is empty");
+
+		if (WorkerId.IsEmpty())
+			throw new ValidationException("Field ManufacturerId is empty");
+
+		if (!WorkerId.IsGuid())
+			throw new ValidationException("The value in the field ManufacturerId is not a unique identifier");
+
+		if (TotalPrice <= 0)
+			throw new ValidationException("Field Price is less than or equal to 0");
+
+		if (TotalPrice != Components.Sum(x => x.Price))
+            throw new ValidationException("The total price of the components does not match");
+
+        if (Components.Count == 0)
+            throw new ValidationException("At least 1 component is needed");
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/SalaryDataModel.cs

@@ -0,0 +1,26 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class SalaryDataModel(string workerId, DateTime salaryDate, double workerSalary) : IValidation
+{
+	public string WorkerId { get; private set; } = workerId;
+
+	public DateTime SalaryDate { get; private set; } = salaryDate;
+
+	public double Salary { get; private set; } = workerSalary;
+
+	public void Validate()
+	{
+		if (WorkerId.IsEmpty())
+			throw new ValidationException("Field WorkerId is empty");
+
+		if (!WorkerId.IsGuid())
+			throw new ValidationException("The value in the field WorkerId is not a unique identifier");
+
+		if (Salary <= 0)
+			throw new ValidationException("Field Salary is less than or equal to 0");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/SaleDataModel.cs

@@ -0,0 +1,47 @@
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class SaleDataModel(string id, string workerId, string? buyerId, double sum, bool isCancel, List<SaleProductDataModel> products) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string WorkerId { get; private set; } = workerId;
+
+	public string? BuyerId { get; private set; } = buyerId;
+
+	public DateTime SaleDate { get; private set; } = DateTime.UtcNow;
+
+	public double Sum { get; private set; } = sum;
+
+	public bool IsCancel { get; private set; } = isCancel;
+
+	public List<SaleProductDataModel> Products { get; private set; } = products;
+
+	public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (WorkerId.IsEmpty())
+			throw new ValidationException("Field WorkerId is empty");
+
+		if (!WorkerId.IsGuid())
+			throw new ValidationException("The value in the field WorkerId is not a unique identifier");
+
+		if (!BuyerId?.IsGuid() ?? !BuyerId?.IsEmpty() ?? false)
+			throw new ValidationException("The value in the field BuyerId is not a unique identifier");
+
+		if (Sum <= 0)
+			throw new ValidationException("Field Sum is less than or equal to 0");
+
+		if ((Products?.Count ?? 0) == 0)
+			throw new ValidationException("The sale must include products");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/SaleProductDataModel.cs

@@ -0,0 +1,32 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class SaleProductDataModel(string saleId, string productId, int count) : IValidation
+{
+	public string SaleId { get; private set; } = saleId;
+
+	public string ProductId { get; private set; } = productId;
+
+	public int Count { get; private set; } = count;
+
+	public void Validate()
+	{
+		if (SaleId.IsEmpty())
+			throw new ValidationException("Field SaleId is empty");
+
+		if (!SaleId.IsGuid())
+			throw new ValidationException("The value in the field SaleId is not a unique identifier");
+
+		if (ProductId.IsEmpty())
+			throw new ValidationException("Field ProductId is empty");
+
+		if (!ProductId.IsGuid())
+			throw new ValidationException("The value in the field ProductId is not a unique identifier");
+
+		if (Count <= 0)
+			throw new ValidationException("Field Count is less than or equal to 0");
+	}
+}

NorthBridge/NorthBridgeContract/DataModels/StorageDataModel.cs

@@ -0,0 +1,26 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels
+{
+    public class StorageDataModel(string id, string address, bool isOpen,  List<ComponentOnStorageDataModel> components) : IValidation
+    {
+	    public string Id { get; private set; } = id;
+	    public string Address { get; private set; } = address;
+        public bool IsOpen { get; private set; } = isOpen;
+        public List<ComponentOnStorageDataModel> Components { get; private set; } = components;
+
+        public void Validate()
+        {
+            if (Id.IsEmpty())
+                throw new ValidationException("Field Id is empty");
+
+            if (!Id.IsGuid())
+                throw new ValidationException("The value in the field Id is not a unique identifier");
+            
+            if (Address.IsEmpty())
+                throw new ValidationException("Field Address is empty");
+        }
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/SupplyDataModel.cs

@@ -0,0 +1,38 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.DataModels
+{
+    public class SupplyDataModel(string id, string storageId, DateTime date, List<ComponentInSupplyDataModel> components) : IValidation
+    {
+        public string Id { get; private set; } = id;
+        public string StorageId { get; private set; } = storageId;
+        public DateTime Date { get; private set; } = date;
+        public List<ComponentInSupplyDataModel> Components { get; private set; } = components;
+
+
+        public void Validate()
+        {
+            if (StorageId.IsEmpty())
+                throw new ValidationException("Field StorageId is empty");
+
+            if (!StorageId.IsGuid())
+                throw new ValidationException("The value in the field StorageId is not a unique identifier");
+
+            if (Id.IsEmpty())
+                throw new ValidationException("Field Id is empty");
+
+            if (!Id.IsGuid())
+                throw new ValidationException("The value in the field Id is not a unique identifier");
+
+            if (Components.Count == 0)
+                throw new ValidationException("At least 1 component is needed");
+        }
+    }
+}

NorthBridge/NorthBridgeContract/DataModels/WorkerDataModel.cs

@@ -0,0 +1,47 @@
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.Extensions;
+using NorthBridgeContract.Infrastructure;
+
+namespace NorthBridgeContract.DataModels;
+
+public class WorkerDataModel(string id, string fio, string postId, DateTime birthDate, DateTime employmentDate, bool isDeleted) : IValidation
+{
+	public string Id { get; private set; } = id;
+
+	public string FIO { get; private set; } = fio;
+
+	public string PostId { get; private set; } = postId;
+
+	public DateTime BirthDate { get; private set; } = birthDate;
+
+	public DateTime EmploymentDate { get; private set; } = employmentDate;
+
+	public bool IsDeleted { get; private set; } = isDeleted;
+
+	public void Validate()
+	{
+		if (Id.IsEmpty())
+			throw new ValidationException("Field Id is empty");
+
+		if (!Id.IsGuid())
+			throw new ValidationException("The value in the field Id is not a unique identifier");
+
+		if (FIO.IsEmpty())
+			throw new ValidationException("Field FIO is empty");
+
+		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 (BirthDate.Date > DateTime.Now.AddYears(-16).Date)
+			throw new ValidationException($"Minors cannot be hired (BirthDate = {BirthDate.ToShortDateString()})");
+
+		if (EmploymentDate.Date < BirthDate.Date)
+			throw new ValidationException("The date of employment cannot be less than the date of birth");
+
+		if ((EmploymentDate - BirthDate).TotalDays / 365 < 16) // EmploymentDate.Year - BirthDate.Year
+			throw new ValidationException($"Minors cannot be hired (EmploymentDate - {EmploymentDate.ToShortDateString()}, BirthDate - {BirthDate.ToShortDateString()})");
+	}
+}

NorthBridge/NorthBridgeContract/Enums/ComponentType.cs

@@ -0,0 +1,14 @@
+namespace NorthBridgeContract.Enums;
+
+public enum ComponentType
+{
+    None = 0,
+    GraphicsCard = 1,
+    Motherboard = 2,
+    RAM = 3,
+    Storage = 4, 
+    PowerSupply = 5,
+    CoolingSystem = 6,
+    Case = 7,
+    Processor = 8
+}

NorthBridge/NorthBridgeContract/Enums/PostType.cs

@@ -0,0 +1,9 @@
+namespace NorthBridgeContract.Enums;
+
+public enum PostType
+{
+	None = 0,
+	Supervisor = 1,
+	CashierConsultant = 2,
+	Assistant = 3
+}

NorthBridge/NorthBridgeContract/Exceptions/ElementExistsException.cs

@@ -0,0 +1,14 @@
+namespace NorthBridgeContract.Exceptions;
+
+public class ElementExistsException : Exception
+{
+	public string ParamName { get; private set; }
+
+	public string ParamValue { get; private set; }
+
+	public ElementExistsException(string paramName, string paramValue) : base($"There is already an element with value{paramValue} of parameter {paramName}")
+	{
+		ParamName = paramName;
+		ParamValue = paramValue;
+	}
+}

NorthBridge/NorthBridgeContract/Exceptions/ElementNotFoundException.cs

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

NorthBridge/NorthBridgeContract/Exceptions/IncorrectDatesException.cs

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

NorthBridge/NorthBridgeContract/Exceptions/NullListException.cs

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

NorthBridge/NorthBridgeContract/Exceptions/OutOfStockException.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.Exceptions
+{
+    public class OutOfStockException : Exception
+    {
+        public OutOfStockException(string itemName) : base($"Item {itemName} is not available at this storage") { }
+    }
+}

NorthBridge/NorthBridgeContract/Exceptions/StorageException.cs

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

NorthBridge/NorthBridgeContract/Exceptions/ValidationException.cs

@@ -0,0 +1,5 @@
+namespace NorthBridgeContract.Exceptions;
+
+public class ValidationException(string message) : Exception(message)
+{
+}

NorthBridge/NorthBridgeContract/Extensions/DateTimeExtensions.cs

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

NorthBridge/NorthBridgeContract/Extensions/StringExtensions.cs

@@ -0,0 +1,14 @@
+namespace NorthBridgeContract.Extensions;
+
+public static class StringExtensions
+{
+	public static bool IsEmpty(this string str)
+	{
+		return string.IsNullOrWhiteSpace(str);
+	}
+
+	public static bool IsGuid(this string str)
+	{
+		return Guid.TryParse(str, out _);
+	}
+}

NorthBridge/NorthBridgeContract/Infrastructure/IValidation.cs

@@ -0,0 +1,8 @@
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeContract.Infrastructure;
+
+public interface IValidation
+{
+	void Validate();
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IBuyerStorageContract.cs

@@ -0,0 +1,20 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.StoragesContracts;
+
+public interface IBuyerStorageContract
+{
+	List<BuyerDataModel> GetList();
+
+	BuyerDataModel? GetElementById(string id);
+
+	BuyerDataModel? GetElementByPhoneNumber(string phoneNumber);
+
+	BuyerDataModel? GetElementByFIO(string fio);
+
+	void AddElement(BuyerDataModel buyerDataModel);
+
+	void UpdElement(BuyerDataModel buyerDataModel);
+
+	void DelElement(string id);
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IComponentStorageContract.cs

@@ -0,0 +1,32 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.StoragesContracts
+{
+    public interface IComponentStorageContract
+    {
+        List<ComponentDataModel> GetList(bool onlyActual = true);
+
+        ComponentDataModel? GetElementById(string id);
+
+        ComponentDataModel? GetElementByName(string name);
+
+        void AddElement(ComponentDataModel componentDataModel);
+
+        void UpdElement(ComponentDataModel componentDataModel);
+
+        void DelElement(string id);
+
+        void ResElement(string id);
+
+        // Методы работы с историей
+        void AddComponentHistory(ComponentHistoryDataModel historyData);
+
+        List<ComponentHistoryDataModel> GetComponentHistory(string componentId);
+    }
+
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IManufacturerStorageContract.cs

@@ -0,0 +1,20 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.StoragesContracts;
+
+public interface IManufacturerStorageContract
+{
+	List<ManufacturerDataModel> GetList();
+
+	ManufacturerDataModel? GetElementById(string id);
+
+	ManufacturerDataModel? GetElementByName(string name);
+
+	ManufacturerDataModel? GetElementByOldName(string name);
+
+	void AddElement(ManufacturerDataModel manufacturerDataModel);
+
+	void UpdElement(ManufacturerDataModel manufacturerDataModel);
+
+	void DelElement(string id);
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IPostStorageContract.cs

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

NorthBridge/NorthBridgeContract/StoragesContracts/IProductStorageContract.cs

@@ -0,0 +1,26 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.StoragesContracts;
+
+public interface IProductStorageContract
+{
+    List<ProductDataModel> GetList(bool onlyActive);
+
+    List<ProductDataModel> GetListByManufacturer(string manufacturerId, bool onlyActive);
+
+    ProductDataModel? GetElementById(string id);
+
+    ProductDataModel? GetElementByName(string name);
+
+    void AddElement(ProductDataModel productDataModel);
+
+    void UpdElement(ProductDataModel productDataModel);
+
+    void DelElement(string id);
+
+    List<ComponentDataModel> GetComponentsByProductId(string productId);
+
+    void AddComponentToProduct(ComponentInProductDataModel componentInProduct);
+
+    void RemoveComponentFromProduct(string componentId, string productId);
+}

NorthBridge/NorthBridgeContract/StoragesContracts/ISalaryStorageContract.cs

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

NorthBridge/NorthBridgeContract/StoragesContracts/ISaleStorageContract.cs

@@ -0,0 +1,14 @@
+using NorthBridgeContract.DataModels;
+
+namespace NorthBridgeContract.StoragesContracts;
+
+public interface ISaleStorageContract
+{
+	List<SaleDataModel> GetList(DateTime? startDate = null, DateTime? endDate = null, string? workerId = null, string? buyerId = null, string? productId = null);
+
+	SaleDataModel? GetElementById(string id);
+
+	void AddElement(SaleDataModel saleDataModel);
+
+	void DelElement(string id);
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IStorageStorageContract.cs

@@ -0,0 +1,29 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.StoragesContracts
+{
+    public interface IStorageContract
+    {
+        List<StorageDataModel> GetAllStorages();
+
+        StorageDataModel? GetStorageById(string storageId);
+
+        void AddStorage(StorageDataModel storage);
+
+        void CloseStorage(string storageId);
+
+        void AddOrUpdateComponentOnStorage(ComponentOnStorageDataModel component);
+
+        void UpdateComponentCount(string storageId, string componentId, int newCount);
+
+        ComponentOnStorageDataModel GetComponentOnStorage(string storageId, string componentId);
+
+        List<ComponentOnStorageDataModel> GetComponentsOnStorage(string storageId);
+    }
+
+}

NorthBridge/NorthBridgeContract/StoragesContracts/ISupplyStorageContract.cs

@@ -0,0 +1,25 @@
+using NorthBridgeContract.DataModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeContract.StoragesContracts
+{
+    public interface ISupplyStorageContract
+    {
+        void AddSupply(SupplyDataModel supply);
+
+        SupplyDataModel? GetSupplyById(string supplyId);
+
+        List<SupplyDataModel> GetSuppliesByStorageId(string storageId);
+
+        void AddOrUpdateComponentInSupply(ComponentInSupplyDataModel componentInSupply);
+
+        void UpdateComponentCountInSupply(string supplyId, string componentId, int newCount);
+
+        void RemoveComponentFromSupply(string supplyId, string componentId);
+    }
+
+}

NorthBridge/NorthBridgeContract/StoragesContracts/IWorkerStorageContract.cs

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

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/BuyerBusinessLogicContractTests.cs

@@ -0,0 +1,350 @@
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class BuyerBusinessLogicContractTests
+{
+    private BuyerBusinessLogicContract _buyerBusinessLogicContract;
+    private Mock<IBuyerStorageContract> _buyerStorageContract;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _buyerStorageContract = new Mock<IBuyerStorageContract>();
+        _buyerBusinessLogicContract = new BuyerBusinessLogicContract(_buyerStorageContract.Object, new Mock<ILogger>().Object);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _buyerStorageContract.Reset();
+    }
+
+    [Test]
+    public void GetAllBuyers_ReturnListOfRecords_Test()
+    {
+        //Arrange
+        var listOriginal = new List<BuyerDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "fio 1", "+7-111-111-11-11"),
+            new(Guid.NewGuid().ToString(), "fio 2", "+7-555-444-33-23"),
+            new(Guid.NewGuid().ToString(), "fio 3", "+7-777-777-7777"),
+        };
+        _buyerStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+        //Act
+        var list = _buyerBusinessLogicContract.GetAllBuyers();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.EquivalentTo(listOriginal));
+    }
+
+    [Test]
+    public void GetAllBuyers_ReturnEmptyList_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.GetList()).Returns([]);
+        //Act
+        var list = _buyerBusinessLogicContract.GetAllBuyers();
+        //Assert
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+        _buyerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllBuyers_ReturnNull_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetAllBuyers(), Throws.TypeOf<NullListException>());
+        _buyerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetAllBuyers_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetAllBuyers(), Throws.TypeOf<StorageException>());
+        _buyerStorageContract.Verify(x => x.GetList(), Times.Once);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetById_ReturnRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var record = new BuyerDataModel(id, "Иванов Иван Иванович", "+7-111-111-11-11");
+        _buyerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+        //Act
+        var element = _buyerBusinessLogicContract.GetBuyerByData(id);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(id));
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetByFio_ReturnRecord_Test()
+    {
+        //Arrange
+        var fio = "Иванов Иван Иванович";
+        var record = new BuyerDataModel(Guid.NewGuid().ToString(), fio, "+7-111-111-11-11");
+        _buyerStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record);
+        //Act
+        var element = _buyerBusinessLogicContract.GetBuyerByData(fio);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.FIO, Is.EqualTo(fio));
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetByPhoneNumber_ReturnRecord_Test()
+    {
+        //Arrange
+        var phoneNumber = "+7-111-111-11-11";
+        var record = new BuyerDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", phoneNumber);
+        _buyerStorageContract.Setup(x => x.GetElementByPhoneNumber(phoneNumber)).Returns(record);
+        //Act
+        var element = _buyerBusinessLogicContract.GetBuyerByData(phoneNumber);
+        //Assert
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.PhoneNumber, Is.EqualTo(phoneNumber));
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBuyerByData_EmptyData_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetById_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetByFio_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("Иванов Иван Иванович"), Throws.TypeOf<ElementNotFoundException>());
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void GetBuyerByData_GetByPhoneNumber_NotFoundRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("+7-111-111-11-12"), Throws.TypeOf<ElementNotFoundException>());
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void GetBuyerByData_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _buyerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        _buyerStorageContract.Setup(x => x.GetElementByPhoneNumber(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("Иванов Иван Иванович"), Throws.TypeOf<StorageException>());
+        Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("+7-111-111-11-12"), Throws.TypeOf<StorageException>());
+        _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
+        _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertBuyer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new BuyerDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11");
+        _buyerStorageContract.Setup(x => x.AddElement(It.IsAny<BuyerDataModel>()))
+            .Callback((BuyerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO &&
+                    x.PhoneNumber == record.PhoneNumber;
+            });
+        //Act
+        _buyerBusinessLogicContract.InsertBuyer(record);
+        //Assert
+        _buyerStorageContract.Verify(x => x.AddElement(It.IsAny<BuyerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void InsertBuyer_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.AddElement(It.IsAny<BuyerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<ElementExistsException>());
+        _buyerStorageContract.Verify(x => x.AddElement(It.IsAny<BuyerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void InsertBuyer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(null), Throws.TypeOf<ArgumentNullException>());
+        _buyerStorageContract.Verify(x => x.AddElement(It.IsAny<BuyerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertBuyer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new BuyerDataModel("id", "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<ValidationException>());
+        _buyerStorageContract.Verify(x => x.AddElement(It.IsAny<BuyerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void InsertBuyer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.AddElement(It.IsAny<BuyerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<StorageException>());
+        _buyerStorageContract.Verify(x => x.AddElement(It.IsAny<BuyerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateBuyer_CorrectRecord_Test()
+    {
+        //Arrange
+        var flag = false;
+        var record = new BuyerDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11");
+        _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny<BuyerDataModel>()))
+            .Callback((BuyerDataModel x) =>
+            {
+                flag = x.Id == record.Id && x.FIO == record.FIO &&
+                    x.PhoneNumber == record.PhoneNumber;
+            });
+        //Act
+        _buyerBusinessLogicContract.UpdateBuyer(record);
+        //Assert
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void UpdateBuyer_RecordWithIncorrectData_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny<BuyerDataModel>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<ElementNotFoundException>());
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateBuyer_RecordWithExistsData_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny<BuyerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<ElementExistsException>());
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void UpdateBuyer_NullRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(null), Throws.TypeOf<ArgumentNullException>());
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateBuyer_InvalidRecord_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new BuyerDataModel("id", "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<ValidationException>());
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Never);
+    }
+
+    [Test]
+    public void UpdateBuyer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny<BuyerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "+7-111-111-11-11")), Throws.TypeOf<StorageException>());
+        _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny<BuyerDataModel>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteBuyer_CorrectRecord_Test()
+    {
+        //Arrange
+        var id = Guid.NewGuid().ToString();
+        var flag = false;
+        _buyerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+        //Act
+        _buyerBusinessLogicContract.DeleteBuyer(id);
+        //Assert
+        _buyerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        Assert.That(flag);
+    }
+
+    [Test]
+    public void DeleteBuyer_RecordWithIncorrectId_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(""));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+        _buyerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteBuyer_IdIsNullOrEmpty_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(null), Throws.TypeOf<ArgumentNullException>());
+        Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(string.Empty), Throws.TypeOf<ArgumentNullException>());
+        _buyerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteBuyer_IdIsNotGuid_ThrowException_Test()
+    {
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer("id"), Throws.TypeOf<ValidationException>());
+        _buyerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+    }
+
+    [Test]
+    public void DeleteBuyer_StorageThrowError_ThrowException_Test()
+    {
+        //Arrange
+        _buyerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+        //Act&Assert
+        Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+        _buyerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+    }
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ComponentBusinessLogicTests.cs

@@ -0,0 +1,188 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    internal class ComponentBusinessLogicContractTests
+    {
+        private ComponentBusinessLogicContract _componentBusinessLogicContract;
+        private Mock<IComponentStorageContract> _componentStorageContract;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _componentStorageContract = new Mock<IComponentStorageContract>();
+            _componentBusinessLogicContract = new ComponentBusinessLogicContract(_componentStorageContract.Object, new Mock<ILogger>().Object);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _componentStorageContract.Reset();
+        }
+
+        [Test]
+        public void GetAllComponents_ReturnListOfRecords_Test()
+        {
+            // Arrange
+            var listOriginal = new List<ComponentDataModel>()
+        {
+            new(Guid.NewGuid().ToString(), "component 1", ComponentType.RAM, Guid.NewGuid().ToString(), 20, false),
+            new(Guid.NewGuid().ToString(), "component 2", ComponentType.CoolingSystem, Guid.NewGuid().ToString(), 30, true),
+            new(Guid.NewGuid().ToString(), "component 3", ComponentType.PowerSupply, Guid.NewGuid().ToString(), 40, false),
+        };
+            _componentStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns(listOriginal);
+
+            // Act
+            var listOnlyActive = _componentBusinessLogicContract.GetAllComponents(true);
+            var list = _componentBusinessLogicContract.GetAllComponents(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));
+            });
+            _componentStorageContract.Verify(x => x.GetList(true), Times.Once);
+            _componentStorageContract.Verify(x => x.GetList(false), Times.Once);
+        }
+
+        [Test]
+        public void GetAllComponents_ReturnEmptyList_Test()
+        {
+            // Arrange
+            _componentStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns([]);
+
+            // Act
+            var listOnlyActive = _componentBusinessLogicContract.GetAllComponents(true);
+            var list = _componentBusinessLogicContract.GetAllComponents(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));
+            });
+            _componentStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
+        }
+
+        [Test]
+        public void GetAllComponents_ReturnNull_ThrowException_Test()
+        {
+            Assert.That(() => _componentBusinessLogicContract.GetAllComponents(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
+            _componentStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+        }
+
+        [Test]
+        public void GetAllComponents_StorageThrowError_ThrowException_Test()
+        {
+            _componentStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _componentBusinessLogicContract.GetAllComponents(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
+            _componentStorageContract.Verify(x => x.GetList(It.IsAny<bool>()), Times.Once);
+        }
+
+        [Test]
+        public void GetComponentByData_GetById_ReturnRecord_Test()
+        {
+            var id = Guid.NewGuid().ToString();
+            var record = new ComponentDataModel(id, "component name", ComponentType.Processor, Guid.NewGuid().ToString(), 100, false);
+            _componentStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+
+            var element = _componentBusinessLogicContract.GetComponentById(id);
+
+            Assert.That(element, Is.Not.Null);
+            Assert.That(element.Id, Is.EqualTo(id));
+            _componentStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void GetComponentByData_EmptyData_ThrowException_Test()
+        {
+            Assert.That(() => _componentBusinessLogicContract.GetComponentByData(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _componentBusinessLogicContract.GetComponentByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+            _componentStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void InsertComponent_CorrectRecord_Test()
+        {
+            var flag = false;
+            var record = new ComponentDataModel(Guid.NewGuid().ToString(), "component name", ComponentType.Motherboard, Guid.NewGuid().ToString(), 200, false);
+            _componentStorageContract.Setup(x => x.AddElement(It.IsAny<ComponentDataModel>()))
+                .Callback((ComponentDataModel x) =>
+                {
+                    flag = x.Id == record.Id && x.ComponentName == record.ComponentName && x.ComponentType == record.ComponentType &&
+                           x.ManufacturerId == record.ManufacturerId && x.Price == record.Price && x.IsDeleted == record.IsDeleted;
+                });
+
+            _componentBusinessLogicContract.InsertComponent(record);
+
+            _componentStorageContract.Verify(x => x.AddElement(It.IsAny<ComponentDataModel>()), Times.Once);
+            Assert.That(flag);
+        }
+
+        [Test]
+        public void UpdateComponent_CorrectRecord_Test()
+        {
+            // Arrange
+            var flag = false;
+            var existingRecord = new ComponentDataModel(Guid.NewGuid().ToString(), "component name", ComponentType.Processor, Guid.NewGuid().ToString(), 140, true);
+            var updatedRecord = new ComponentDataModel(existingRecord.Id, existingRecord.ComponentName, existingRecord.ComponentType, existingRecord.ManufacturerId, 150, true);
+
+            _componentStorageContract.Setup(x => x.GetElementById(existingRecord.Id)).Returns(existingRecord);
+            _componentStorageContract.Setup(x => x.UpdElement(It.IsAny<ComponentDataModel>()))
+                .Callback((ComponentDataModel x) =>
+                {
+                    flag = x.Id == updatedRecord.Id && x.ComponentName == updatedRecord.ComponentName &&
+                           x.ComponentType == updatedRecord.ComponentType && x.ManufacturerId == updatedRecord.ManufacturerId &&
+                           x.Price == updatedRecord.Price && x.IsDeleted == updatedRecord.IsDeleted;
+                });
+
+            // Act
+            _componentBusinessLogicContract.UpdateComponent(updatedRecord);
+
+            // Assert
+            _componentStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+            _componentStorageContract.Verify(x => x.UpdElement(It.IsAny<ComponentDataModel>()), Times.Once);
+            _componentStorageContract.Verify(x => x.AddComponentHistory(It.IsAny<ComponentHistoryDataModel>()), Times.Once);
+            Assert.That(flag);
+        }
+
+
+        [Test]
+        public void DeleteComponent_CorrectRecord_Test()
+        {
+            var id = Guid.NewGuid().ToString();
+            _componentStorageContract.Setup(x => x.DelElement(id)).Verifiable();
+
+            _componentBusinessLogicContract.DeleteComponent(id);
+
+            _componentStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void DeleteComponent_EmptyId_ThrowException_Test()
+        {
+            Assert.That(() => _componentBusinessLogicContract.DeleteComponent(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _componentBusinessLogicContract.DeleteComponent(string.Empty), Throws.TypeOf<ArgumentNullException>());
+            _componentStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+    }
+
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ManufacturerBusinessLogicContractTests.cs

@@ -0,0 +1,349 @@
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class ManufacturerBusinessLogicContractTests
+{
+	private ManufacturerBusinessLogicContract _manufacturerBusinessLogicContract;
+	private Mock<IManufacturerStorageContract> _manufacturerStorageContract;
+
+	[OneTimeSetUp]
+	public void OneTimeSetUp()
+	{
+		_manufacturerStorageContract = new Mock<IManufacturerStorageContract>();
+		_manufacturerBusinessLogicContract = new ManufacturerBusinessLogicContract(_manufacturerStorageContract.Object, new Mock<ILogger>().Object);
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		_manufacturerStorageContract.Reset();
+	}
+
+	[Test]
+	public void GetAllManufacturers_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var listOriginal = new List<ManufacturerDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), "name 1", null, null),
+			new(Guid.NewGuid().ToString(), "name 2", null, null),
+			new(Guid.NewGuid().ToString(), "name 3", null, null),
+		};
+		_manufacturerStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
+		//Act
+		var list = _manufacturerBusinessLogicContract.GetAllManufacturers();
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+	}
+
+	[Test]
+	public void GetAllManufacturers_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.GetList()).Returns([]);
+		//Act
+		var list = _manufacturerBusinessLogicContract.GetAllManufacturers();
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+	}
+
+	[Test]
+	public void GetAllManufacturers_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetAllManufacturers(), Throws.TypeOf<NullListException>());
+		_manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+	}
+
+	[Test]
+	public void GetAllManufacturers_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetAllManufacturers(), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.GetList(), Times.Once);
+	}
+
+	[Test]
+	public void GetManufacturerByData_GetById_ReturnRecord_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		var record = new ManufacturerDataModel(id, "name", null, null);
+		_manufacturerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+		//Act
+		var element = _manufacturerBusinessLogicContract.GetManufacturerByData(id);
+		//Assert
+		Assert.That(element, Is.Not.Null);
+		Assert.That(element.Id, Is.EqualTo(id));
+		_manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetManufacturerByData_GetByName_ReturnRecord_Test()
+	{
+		//Arrange
+		var manufacturerName = "name";
+		var record = new ManufacturerDataModel(Guid.NewGuid().ToString(), manufacturerName, null, null);
+		_manufacturerStorageContract.Setup(x => x.GetElementByName(manufacturerName)).Returns(record);
+		//Act
+		var element = _manufacturerBusinessLogicContract.GetManufacturerByData(manufacturerName);
+		//Assert
+		Assert.That(element, Is.Not.Null);
+		Assert.That(element.ManufacturerName, Is.EqualTo(manufacturerName));
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetManufacturerByData_GetByOldName_ReturnRecord_Test()
+	{
+		//Arrange
+		var manufacturerOldName = "name before";
+		var record = new ManufacturerDataModel(Guid.NewGuid().ToString(), "name", manufacturerOldName, null);
+		_manufacturerStorageContract.Setup(x => x.GetElementByOldName(manufacturerOldName)).Returns(record);
+		//Act
+		var element = _manufacturerBusinessLogicContract.GetManufacturerByData(manufacturerOldName);
+		//Assert
+		Assert.That(element, Is.Not.Null);
+		Assert.That(element.PrevManufacturerName, Is.EqualTo(manufacturerOldName));
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetManufacturerByData_EmptyData_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(null), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+		_manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetManufacturerByData__GetById_NotFoundRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+		_manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetManufacturerByData_GetByNameOrOldName_NotFoundRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf<ElementNotFoundException>());
+		_manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetManufacturerByData_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		_manufacturerStorageContract.Setup(x => x.GetElementByName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetManufacturerByData_GetByOldName_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.GetElementByOldName(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Once);
+		_manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void InsertManufacturer_CorrectRecord_Test()
+	{
+		//Arrange
+		var flag = false;
+		var record = new ManufacturerDataModel(Guid.NewGuid().ToString(), "name", null, null);
+		_manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<ManufacturerDataModel>()))
+			.Callback((ManufacturerDataModel x) =>
+			{
+				flag = x.Id == record.Id && x.ManufacturerName == record.ManufacturerName;
+			});
+		//Act
+		_manufacturerBusinessLogicContract.InsertManufacturer(record);
+		//Assert
+		_manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+		Assert.That(flag);
+	}
+
+	[Test]
+	public void InsertManufacturer_RecordWithExistsData_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<ManufacturerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf<ElementExistsException>());
+		_manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void InsertManufacturer_NullRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(null), Throws.TypeOf<ArgumentNullException>());
+		_manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<ManufacturerDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void InsertManufacturer_InvalidRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new ManufacturerDataModel("id", "name", null, null)), Throws.TypeOf<ValidationException>());
+		_manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<ManufacturerDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void InsertManufacturer_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny<ManufacturerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void UpdateManufacturer_CorrectRecord_Test()
+	{
+		//Arrange
+		var flag = false;
+		var record = new ManufacturerDataModel(Guid.NewGuid().ToString(), "name", null, null);
+		_manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()))
+			.Callback((ManufacturerDataModel x) =>
+			{
+				flag = x.Id == record.Id && x.ManufacturerName == record.ManufacturerName;
+			});
+		//Act
+		_manufacturerBusinessLogicContract.UpdateManufacturer(record);
+		//Assert
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+		Assert.That(flag);
+	}
+
+	[Test]
+	public void UpdateManufacturer_RecordWithIncorrectData_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<ManufacturerDataModel>())).Throws(new ElementNotFoundException(""));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf<ElementNotFoundException>());
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void UpdateManufacturer_RecordWithExistsData_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<ManufacturerDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf<ElementExistsException>());
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void UpdateManufacturer_NullRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(null), Throws.TypeOf<ArgumentNullException>());
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void UpdateManufacturer_InvalidRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new ManufacturerDataModel("id", "name", null, null)), Throws.TypeOf<ValidationException>());
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void UpdateManufacturer_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny<ManufacturerDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny<ManufacturerDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void DeleteManufacturer_CorrectRecord_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		var flag = false;
+		_manufacturerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+		//Act
+		_manufacturerBusinessLogicContract.DeleteManufacturer(id);
+		//Assert
+		_manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+		Assert.That(flag);
+	}
+
+	[Test]
+	public void DeleteManufacturer_RecordWithIncorrectId_ThrowException_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		_manufacturerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+		_manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void DeleteManufacturer_IdIsNullOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(null), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(string.Empty), Throws.TypeOf<ArgumentNullException>());
+		_manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void DeleteManufacturer_IdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer("id"), Throws.TypeOf<ValidationException>());
+		_manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void DeleteManufacturer_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_manufacturerStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+		_manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+	}
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs

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

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ProductBusinessLogicTests.cs

@@ -0,0 +1,238 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    internal class ProductBusinessLogicTests
+    {
+        private ProductBusinessLogicContract _productBusinessLogicContract;
+        private Mock<IProductStorageContract> _productStorageContract;
+        private Mock<IComponentStorageContract> _componentStorageContract;
+        private Mock<ILogger> _logger;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _logger = new Mock<ILogger>();
+            _productStorageContract = new Mock<IProductStorageContract>();
+            _componentStorageContract = new Mock<IComponentStorageContract>();
+
+            _productBusinessLogicContract = new ProductBusinessLogicContract(_productStorageContract.Object, _componentStorageContract.Object, _logger.Object);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _productStorageContract.Reset();
+            _componentStorageContract.Reset();
+        }
+
+        [Test]
+        public void AddComponentToProduct_Successful_Test()
+        {
+            // Arrange
+            var productId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var componentOnStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), componentId, 5);
+            var component = new ComponentDataModel(componentId, "Test Component", ComponentType.RAM, Guid.NewGuid().ToString(), 100, false);
+
+            _componentStorageContract.Setup(x => x.GetElementById(componentId)).Returns(component);
+            _productStorageContract.Setup(x => x.AddComponentToProduct(It.IsAny<ComponentInProductDataModel>()));
+
+            // Act
+            _productBusinessLogicContract.AddComponentToProduct(componentOnStorage, productId);
+
+            // Assert
+            _componentStorageContract.Verify(x => x.GetElementById(componentId), Times.Once);
+            _productStorageContract.Verify(x => x.AddComponentToProduct(It.Is<ComponentInProductDataModel>(
+                p => p.ComponentId == componentId && p.ProductId == productId)), Times.Once);
+        }
+
+        [Test]
+        public void AddComponentToProduct_ComponentNotFound_ThrowsException_Test()
+        {
+            // Arrange
+            var productId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var componentOnStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), componentId, 5);
+
+            _componentStorageContract.Setup(x => x.GetElementById(componentId)).Returns((ComponentDataModel)null!);
+
+            // Act & Assert
+            var ex = Assert.Throws<ArgumentNullException>(() => _productBusinessLogicContract.AddComponentToProduct(componentOnStorage, productId));
+            Assert.That(ex.Message, Does.Contain($"Component {componentId} not found"));
+
+            _componentStorageContract.Verify(x => x.GetElementById(componentId), Times.Once);
+            _productStorageContract.Verify(x => x.AddComponentToProduct(It.IsAny<ComponentInProductDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void AddComponentToProduct_NullComponentOnStorage_ThrowsException_Test()
+        {
+            // Arrange
+            var productId = Guid.NewGuid().ToString();
+
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() => _productBusinessLogicContract.AddComponentToProduct(null!, productId));
+
+            _componentStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+            _productStorageContract.Verify(x => x.AddComponentToProduct(It.IsAny<ComponentInProductDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void AddComponentToProduct_InvalidComponentOnStorage_ThrowsValidationException_Test()
+        {
+            // Arrange
+            var productId = Guid.NewGuid().ToString();
+            var componentOnStorage = new ComponentOnStorageDataModel("", "", 0); // Невалидные данные
+
+            // Act & Assert
+            Assert.Throws<ValidationException>(() => _productBusinessLogicContract.AddComponentToProduct(componentOnStorage, productId));
+
+            _componentStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+            _productStorageContract.Verify(x => x.AddComponentToProduct(It.IsAny<ComponentInProductDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void GetAllProducts_ReturnsListOfProducts_Test()
+        {
+            // Arrange
+            var components = new List<ComponentDataModel>
+        {
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 1", ComponentType.RAM, Guid.NewGuid().ToString(), 100, false),
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 2", ComponentType.Processor, Guid.NewGuid().ToString(), 200, true)
+        };
+
+            var products = new List<ProductDataModel>
+        {
+            new ProductDataModel(Guid.NewGuid().ToString(), "Product 1", Guid.NewGuid().ToString(), true, components),
+            new ProductDataModel(Guid.NewGuid().ToString(), "Product 2", Guid.NewGuid().ToString(), false, components)
+        };
+
+            _productStorageContract.Setup(x => x.GetList(It.IsAny<bool>())).Returns(products);
+
+            // Act
+            var result = _productBusinessLogicContract.GetAllProducts(true);
+
+            // Assert
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result, Is.EquivalentTo(products));
+            });
+
+            _productStorageContract.Verify(x => x.GetList(true), Times.Once);
+        }
+
+        [Test]
+        public void InsertProduct_CorrectProduct_Test()
+        {
+            // Arrange
+            var components = new List<ComponentDataModel>
+        {
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 1", ComponentType.RAM, Guid.NewGuid().ToString(), 100, false),
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 2", ComponentType.Processor, Guid.NewGuid().ToString(), 200, true)
+        };
+            var product = new ProductDataModel(Guid.NewGuid().ToString(), "Product 1", Guid.NewGuid().ToString(), true, components);
+
+            _productStorageContract.Setup(x => x.AddElement(It.IsAny<ProductDataModel>()));
+
+            // Act
+            _productBusinessLogicContract.InsertProduct(product);
+
+            // Assert
+            _productStorageContract.Verify(x => x.AddElement(It.Is<ProductDataModel>(p =>
+                p.Id == product.Id && p.ProductName == product.ProductName && p.WorkerId == product.WorkerId && p.Components == product.Components)), Times.Once);
+        }
+
+        [Test]
+        public void UpdateProduct_CorrectProduct_Test()
+        {
+            // Arrange
+            var components = new List<ComponentDataModel>
+        {
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 1", ComponentType.RAM, Guid.NewGuid().ToString(), 100, false),
+            new ComponentDataModel(Guid.NewGuid().ToString(), "Component 2", ComponentType.Processor, Guid.NewGuid().ToString(), 200, true)
+        };
+            var productId = "6F9619FF-8B86-D011-B42D-00CF4FC964FF";
+            var product = new ProductDataModel(productId, "Product 1", Guid.NewGuid().ToString(), true, components);
+
+            _productStorageContract.Setup(x => x.GetElementById(productId)).Returns(product);
+            _productStorageContract.Setup(x => x.UpdElement(It.IsAny<ProductDataModel>()));
+
+            // Act
+            _productBusinessLogicContract.UpdateProduct(product);
+
+            // Assert
+            _productStorageContract.Verify(x => x.GetElementById(productId), Times.Once);
+            _productStorageContract.Verify(x => x.UpdElement(It.Is<ProductDataModel>(p =>
+                p.Id == product.Id && p.ProductName == product.ProductName && p.WorkerId == product.WorkerId && p.Components == product.Components)), Times.Once);
+        }
+
+        [Test]
+        public void DeleteProduct_ValidId_Test()
+        {
+            // Arrange
+            var id = Guid.NewGuid().ToString();
+            _productStorageContract.Setup(x => x.DelElement(id)).Verifiable();
+
+            // Act
+            _productBusinessLogicContract.DeleteProduct(id);
+
+            // Assert
+            _productStorageContract.Verify(x => x.DelElement(id), Times.Once);
+        }
+
+        [Test]
+        public void DeleteProduct_InvalidId_ThrowsException_Test()
+        {
+            // Arrange
+            var id = string.Empty;
+
+            // Act & Assert
+            Assert.That(() => _productBusinessLogicContract.DeleteProduct(id), Throws.TypeOf<ArgumentNullException>());
+            _productStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void AddComponentToProduct_SuccessfullyAddsComponent()
+        {
+            // Arrange
+            string productId = Guid.NewGuid().ToString();
+            string componentId = Guid.NewGuid().ToString();
+            string storageId = Guid.NewGuid().ToString();
+            var count = 5;
+
+            var componentOnStorage = new ComponentOnStorageDataModel(storageId, componentId, count);
+
+            var component = new ComponentDataModel(
+                componentId,
+                "RAM",
+                ComponentType.RAM,
+                Guid.NewGuid().ToString(),
+                100.50,
+                false
+            );
+
+            _componentStorageContract
+                .Setup(cs => cs.GetElementById(componentId))
+                .Returns(component);
+
+            // Act
+            _productBusinessLogicContract.AddComponentToProduct(componentOnStorage, productId);
+
+            // Assert
+            _productStorageContract.Verify(ps => ps.AddComponentToProduct(
+                It.Is<ComponentInProductDataModel>(c => c.ComponentId == componentId && c.ProductId == productId)
+            ), Times.Once);
+        }
+    }
+
+
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs

@@ -0,0 +1,346 @@
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class SalaryBusinessLogicContractTests
+{
+	private SalaryBusinessLogicContract _salaryBusinessLogicContract;
+	private Mock<ISalaryStorageContract> _salaryStorageContract;
+	private Mock<ISaleStorageContract> _saleStorageContract;
+	private Mock<IPostStorageContract> _postStorageContract;
+	private Mock<IWorkerStorageContract> _workerStorageContract;
+
+	[OneTimeSetUp]
+	public void OneTimeSetUp()
+	{
+		_salaryStorageContract = new Mock<ISalaryStorageContract>();
+		_saleStorageContract = new Mock<ISaleStorageContract>();
+		_postStorageContract = new Mock<IPostStorageContract>();
+		_workerStorageContract = new Mock<IWorkerStorageContract>();
+		_salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object,
+			_saleStorageContract.Object, _postStorageContract.Object, _workerStorageContract.Object, new Mock<ILogger>().Object);
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		_salaryStorageContract.Reset();
+		_saleStorageContract.Reset();
+		_postStorageContract.Reset();
+		_workerStorageContract.Reset();
+	}
+
+	[Test]
+	public void GetAllSalaries_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var startDate = DateTime.UtcNow;
+		var endDate = DateTime.UtcNow.AddDays(1);
+		var listOriginal = new List<SalaryDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10),
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14),
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30),
+		};
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(startDate, endDate);
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_salaryStorageContract.Verify(x => x.GetList(startDate, endDate, null), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalaries_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalaries_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var dateTime = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalaries_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalaries_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var startDate = DateTime.UtcNow;
+		var endDate = DateTime.UtcNow.AddDays(1);
+		var workerId = Guid.NewGuid().ToString();
+		var listOriginal = new List<SalaryDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10),
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14),
+			new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30),
+		};
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(startDate, endDate, workerId);
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_salaryStorageContract.Verify(x => x.GetList(startDate, endDate, workerId), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString());
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var dateTime = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime, Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime.AddSeconds(-1), Guid.NewGuid().ToString()), Throws.TypeOf<IncorrectDatesException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_WorkerIdIsNUllOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), null), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), string.Empty), Throws.TypeOf<ArgumentNullException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_WorkerIdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), "workerId"), Throws.TypeOf<ValidationException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalariesByWorker_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_salaryStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+		_salaryStorageContract.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_CalculateSalary_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		var saleSum = 200.0;
+		var postSalary = 2000.0;
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, saleSum, false, [])]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, postSalary, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		var sum = 0.0;
+		var expectedSum = postSalary + saleSum * 0.1;
+		_salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+			.Callback((SalaryDataModel x) =>
+			{
+				sum = x.Salary;
+			});
+		//Act
+		_salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+		//Assert
+		Assert.That(sum, Is.EqualTo(expectedSum));
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_WithSeveralWorkers_Test()
+	{
+		//Arrange
+		var worker1Id = Guid.NewGuid().ToString();
+		var worker2Id = Guid.NewGuid().ToString();
+		var worker3Id = Guid.NewGuid().ToString();
+		var list = new List<WorkerDataModel>() {
+			new(worker1Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false),
+			new(worker2Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false),
+			new(worker3Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)
+		};
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), worker1Id, null, 1, false, []),
+			new SaleDataModel(Guid.NewGuid().ToString(), worker1Id, null, 1, false, []),
+			new SaleDataModel(Guid.NewGuid().ToString(), worker2Id, null, 1, false, []),
+			new SaleDataModel(Guid.NewGuid().ToString(), worker3Id, null, 1, false, []),
+			new SaleDataModel(Guid.NewGuid().ToString(), worker3Id, null, 1, false, [])]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns(list);
+		//Act
+		_salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+		//Assert
+		_salaryStorageContract.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Exactly(list.Count));
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_WithoitSalesByWorker_Test()
+	{
+		//Arrange
+		var postSalary = 2000.0;
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, postSalary, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		var sum = 0.0;
+		var expectedSum = postSalary;
+		_salaryStorageContract.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
+			.Callback((SalaryDataModel x) =>
+			{
+				sum = x.Salary;
+			});
+		//Act
+		_salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow);
+		//Assert
+		Assert.That(sum, Is.EqualTo(expectedSum));
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_SaleStorageReturnNull_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_PostStorageReturnNull_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]);
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_WorkerStorageReturnNull_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow));
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<NullListException>());
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_SaleStorageThrowException_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Throws(new StorageException(new InvalidOperationException()));
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_PostStorageThrowException_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Throws(new StorageException(new InvalidOperationException()));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]);
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+	}
+
+	[Test]
+	public void CalculateSalaryByMounth_WorkerStorageThrowException_ThrowException_Test()
+	{
+		//Arrange
+		var workerId = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+			.Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]);
+		_postStorageContract.Setup(x => x.GetElementById(It.IsAny<string>()))
+			.Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow));
+		_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
+			.Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
+	}
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SaleBusinessLogicContractTests.cs

@@ -0,0 +1,500 @@
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+using NorthBridgeContract.StoragesContracts;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests;
+
+[TestFixture]
+internal class SaleBusinessLogicContractTests
+{
+	private SaleBusinessLogicContract _saleBusinessLogicContract;
+	private Mock<ISaleStorageContract> _saleStorageContract;
+
+	[OneTimeSetUp]
+	public void OneTimeSetUp()
+	{
+		_saleStorageContract = new Mock<ISaleStorageContract>();
+		_saleBusinessLogicContract = new SaleBusinessLogicContract(_saleStorageContract.Object, new Mock<ILogger>().Object);
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		_saleStorageContract.Reset();
+	}
+
+	[Test]
+	public void GetAllSalesByPeriod_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		var listOriginal = new List<SaleDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false,
+				[new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+		};
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByPeriod(date, date.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, null, null), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByPeriod_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByPeriod_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByPeriod_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByPeriod_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		var workerId = Guid.NewGuid().ToString();
+		var listOriginal = new List<SaleDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false,
+				[new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+		};
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(workerId, date, date.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), workerId, null, null), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod("workerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByWorkerByPeriod_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		var buyerId = Guid.NewGuid().ToString();
+		var listOriginal = new List<SaleDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false,
+				[new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+		};
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(buyerId, date, date.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, buyerId, null), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_BuyerIdIsNullOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_BuyerIdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod("buyerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByBuyerByPeriod_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_ReturnListOfRecords_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		var productId = Guid.NewGuid().ToString();
+		var listOriginal = new List<SaleDataModel>()
+		{
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false,
+				[new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+			new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, 10, false, []),
+		};
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns(listOriginal);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByProductByPeriod(productId, date, date.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.EquivalentTo(listOriginal));
+		_saleStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, null, productId), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_ReturnEmptyList_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns([]);
+		//Act
+		var list = _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1));
+		//Assert
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_IncorrectDates_ThrowException_Test()
+	{
+		//Arrange
+		var date = DateTime.UtcNow;
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf<IncorrectDatesException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_ProductIdIsNullOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_ProductIdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod("productId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_ReturnNull_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<NullListException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetAllSalesByProductByPeriod_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetSaleByData_GetById_ReturnRecord_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		var record = new SaleDataModel(id, Guid.NewGuid().ToString(), null, 10, false,
+				[new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+		_saleStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
+		//Act
+		var element = _saleBusinessLogicContract.GetSaleByData(id);
+		//Assert
+		Assert.That(element, Is.Not.Null);
+		Assert.That(element.Id, Is.EqualTo(id));
+		_saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetSaleByData_EmptyData_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetSaleByData(null), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _saleBusinessLogicContract.GetSaleByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetSaleByData_IdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetSaleByData("saleId"), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void GetSaleByData_GetById_NotFoundRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+		_saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void GetSaleByData_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void InsertSale_CorrectRecord_Test()
+	{
+		//Arrange
+		var flag = false;
+		var record = new SaleDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10,
+			false, [new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]);
+		_saleStorageContract.Setup(x => x.AddElement(It.IsAny<SaleDataModel>()))
+			.Callback((SaleDataModel x) =>
+			{
+				flag = x.Id == record.Id && x.WorkerId == record.WorkerId && x.BuyerId == record.BuyerId &&
+					x.SaleDate == record.SaleDate && x.Sum == record.Sum  &&
+					x.IsCancel == record.IsCancel && x.Products.Count == record.Products.Count &&
+					x.Products.First().ProductId == record.Products.First().ProductId &&
+					x.Products.First().SaleId == record.Products.First().SaleId &&
+					x.Products.First().Count == record.Products.First().Count;
+			});
+		//Act
+		_saleBusinessLogicContract.InsertSale(record);
+		//Assert
+		_saleStorageContract.Verify(x => x.AddElement(It.IsAny<SaleDataModel>()), Times.Once);
+		Assert.That(flag);
+	}
+
+	[Test]
+	public void InsertSale_RecordWithExistsData_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.AddElement(It.IsAny<SaleDataModel>())).Throws(new ElementExistsException("Data", "Data"));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.InsertSale(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
+			Guid.NewGuid().ToString(), 10, false, [new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<ElementExistsException>());
+		_saleStorageContract.Verify(x => x.AddElement(It.IsAny<SaleDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void InsertSale_NullRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.InsertSale(null), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.AddElement(It.IsAny<SaleDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void InsertSale_InvalidRecord_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.InsertSale(new SaleDataModel("id", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, [])), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.AddElement(It.IsAny<SaleDataModel>()), Times.Never);
+	}
+
+	[Test]
+	public void InsertSale_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.AddElement(It.IsAny<SaleDataModel>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.InsertSale(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
+			Guid.NewGuid().ToString(), 10, false, [new SaleProductDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.AddElement(It.IsAny<SaleDataModel>()), Times.Once);
+	}
+
+	[Test]
+	public void CancelSale_CorrectRecord_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		var flag = false;
+		_saleStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
+		//Act
+		_saleBusinessLogicContract.CancelSale(id);
+		//Assert
+		_saleStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+		Assert.That(flag);
+	}
+
+	[Test]
+	public void CancelSale_RecordWithIncorrectId_ThrowException_Test()
+	{
+		//Arrange
+		var id = Guid.NewGuid().ToString();
+		_saleStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(id));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.CancelSale(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+		_saleStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+	}
+
+	[Test]
+	public void CancelSale_IdIsNullOrEmpty_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.CancelSale(null), Throws.TypeOf<ArgumentNullException>());
+		Assert.That(() => _saleBusinessLogicContract.CancelSale(string.Empty), Throws.TypeOf<ArgumentNullException>());
+		_saleStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void CancelSale_IdIsNotGuid_ThrowException_Test()
+	{
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.CancelSale("id"), Throws.TypeOf<ValidationException>());
+		_saleStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+	}
+
+	[Test]
+	public void CancelSale_StorageThrowError_ThrowException_Test()
+	{
+		//Arrange
+		_saleStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
+		//Act&Assert
+		Assert.That(() => _saleBusinessLogicContract.CancelSale(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
+		_saleStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
+	}
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/StorageBusinessLogicContractTests.cs

@@ -0,0 +1,233 @@
+using Moq;
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.StoragesContracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    internal class StorageBusinessLogicContractTests
+    {
+        private StorageBusinessLogicContract _storageBusinessLogicContract;
+        private Mock<IStorageContract> _storageContract;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _storageContract = new Mock<IStorageContract>();
+            _storageBusinessLogicContract = new StorageBusinessLogicContract(_storageContract.Object);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _storageContract.Reset();
+        }
+
+        [Test]
+        public void CreateStorage_ValidParameters_CreatesStorage_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var address = "ул. Пионерская д. 2В";
+            var isOpen = true;
+            var components = new List<ComponentOnStorageDataModel>
+        {
+            new ComponentOnStorageDataModel("storage1", "component1", 100)
+        };
+
+            _storageContract.Setup(x => x.AddStorage(It.IsAny<StorageDataModel>())).Verifiable();
+
+            // Act
+            _storageBusinessLogicContract.CreateStorage(storageId, address, isOpen, components);
+
+            // Assert
+            _storageContract.Verify(x => x.AddStorage(It.Is<StorageDataModel>(s =>
+                s.Id == storageId && s.Address == address && s.IsOpen == isOpen && s.Components == components)), Times.Once);
+        }
+
+        [Test]
+        public void CreateStorage_InvalidParameters_ThrowsArgumentException_Test()
+        {
+            // Arrange
+            var storageId = "";
+            var address = "ул. Пионерская д. 2В";
+            var isOpen = true;
+            var components = new List<ComponentOnStorageDataModel>
+        {
+            new ComponentOnStorageDataModel("storage1", "component1", 100)
+        };
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.CreateStorage(storageId, address, isOpen, components),
+                Throws.ArgumentException.With.Message.Contains("Invalid storage parameters"));
+            _storageContract.Verify(x => x.AddStorage(It.IsAny<StorageDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void CloseStorage_ValidStorage_ClosesStorage_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var storage = new StorageDataModel(storageId, "ул. Пионерская д. 2В", true, new List<ComponentOnStorageDataModel>());
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns(storage);
+            _storageContract.Setup(x => x.CloseStorage(storageId)).Verifiable();
+
+            // Act
+            _storageBusinessLogicContract.CloseStorage(storageId);
+
+            // Assert
+            _storageContract.Verify(x => x.CloseStorage(storageId), Times.Once);
+        }
+
+        [Test]
+        public void CloseStorage_StorageNotFound_ThrowsArgumentNullException_Test()
+        {
+            // Arrange
+            var storageId = "non-existent";
+
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns((StorageDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.CloseStorage(storageId),
+                Throws.ArgumentNullException.With.Message.Contains("Storage not found"));
+            _storageContract.Verify(x => x.CloseStorage(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void AddComponentToStorage_ValidComponent_AddsComponent_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var component = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), "component1", 100);
+            var storage = new StorageDataModel(storageId, "ул. Пионерская д. 2В", true, new List<ComponentOnStorageDataModel>());
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns(storage);
+            _storageContract.Setup(x => x.AddOrUpdateComponentOnStorage(It.IsAny<ComponentOnStorageDataModel>())).Verifiable();
+
+            // Act
+            _storageBusinessLogicContract.AddComponentToStorage(storageId, component);
+
+            // Assert
+            _storageContract.Verify(x => x.AddOrUpdateComponentOnStorage(It.Is<ComponentOnStorageDataModel>(c =>
+                c.StorageId == component.StorageId && c.ComponentId == component.ComponentId && c.Count == component.Count)), Times.Once);
+        }
+
+        [Test]
+        public void AddComponentToStorage_StorageNotFound_ThrowsArgumentNullException_Test()
+        {
+            // Arrange
+            var storageId = "non-existent";
+            var component = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), "component1", 100);
+
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns((StorageDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.AddComponentToStorage(storageId, component),
+                Throws.ArgumentNullException.With.Message.Contains("Storage not found"));
+            _storageContract.Verify(x => x.AddOrUpdateComponentOnStorage(It.IsAny<ComponentOnStorageDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void UpdateComponentCount_ValidParameters_UpdatesCount_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var componentId = "component1";
+            var newCount = 200;
+            var storage = new StorageDataModel(storageId, "ул. Пионерская д. 2В", true, new List<ComponentOnStorageDataModel>
+        {
+            new ComponentOnStorageDataModel(storageId, componentId, 100)
+        });
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns(storage);
+            _storageContract.Setup(x => x.UpdateComponentCount(storageId, componentId, newCount)).Verifiable();
+
+            // Act
+            _storageBusinessLogicContract.UpdateComponentCount(storageId, componentId, newCount);
+
+            // Assert
+            _storageContract.Verify(x => x.UpdateComponentCount(storageId, componentId, newCount), Times.Once);
+        }
+
+        [Test]
+        public void UpdateComponentCount_StorageNotFound_ThrowsArgumentNullException_Test()
+        {
+            // Arrange
+            var storageId = "non-existent";
+            var componentId = "component1";
+            var newCount = 200;
+
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns((StorageDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.UpdateComponentCount(storageId, componentId, newCount),
+                Throws.ArgumentNullException.With.Message.Contains("Storage not found"));
+            _storageContract.Verify(x => x.UpdateComponentCount(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [Test]
+        public void UpdateComponentCount_NegativeCount_ThrowsArgumentException_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var componentId = "component1";
+            var newCount = -10;
+            var storage = new StorageDataModel(storageId, "ул. Пионерская д. 2В", true, new List<ComponentOnStorageDataModel>
+        {
+            new ComponentOnStorageDataModel(storageId, componentId, 100)
+        });
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns(storage);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.UpdateComponentCount(storageId, componentId, newCount),
+                Throws.ArgumentException.With.Message.Contains("Count cannot be negative"));
+            _storageContract.Verify(x => x.UpdateComponentCount(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [Test]
+        public void GetComponentsFromStorage_StorageNotFound_ThrowsArgumentNullException_Test()
+        {
+            // Arrange
+            var storageId = "non-existent";
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns((StorageDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.GetComponentsFromStorage(storageId),
+                Throws.ArgumentNullException.With.Message.Contains("Storage not found"));
+        }
+
+        [Test]
+        public void GetStorageById_StorageFound_ReturnsStorage_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var storage = new StorageDataModel(storageId, "ул. Пионерская д. 2В", true, new List<ComponentOnStorageDataModel>());
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns(storage);
+
+            // Act
+            var result = _storageBusinessLogicContract.GetStorageById(storageId);
+
+            // Assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Id, Is.EqualTo(storageId));
+            _storageContract.Verify(x => x.GetStorageById(storageId), Times.Once);
+        }
+
+        [Test]
+        public void GetStorageById_StorageNotFound_ThrowsArgumentNullException_Test()
+        {
+            // Arrange
+            var storageId = "non-existent";
+            _storageContract.Setup(x => x.GetStorageById(storageId)).Returns((StorageDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _storageBusinessLogicContract.GetStorageById(storageId),
+                Throws.ArgumentNullException.With.Message.Contains("Storage not found"));
+        }
+    }
+
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SupplyBusinessLogicContractTests.cs

@@ -0,0 +1,200 @@
+using Moq;
+using NorthBridgeBusinessLogic.Implementations;
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.StoragesContracts;
+using NorthBridgeContract.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeTest.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    internal class SupplyBusinessLogicContractTests
+    {
+        private SupplyBusinessLogicContract _supplyBusinessLogicContract;
+        private Mock<ISupplyStorageContract> _supplyStorageContract;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _supplyStorageContract = new Mock<ISupplyStorageContract>();
+            _supplyBusinessLogicContract = new SupplyBusinessLogicContract(_supplyStorageContract.Object);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _supplyStorageContract.Reset();
+        }
+
+        [Test]
+        public void CreateSupply_ValidSupply_CreatesSupply_Test()
+        {
+            // Arrange
+            var supply = new SupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.UtcNow, new List<ComponentInSupplyDataModel>
+        {
+            new ComponentInSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 100)
+        });
+
+            _supplyStorageContract.Setup(x => x.AddSupply(It.IsAny<SupplyDataModel>())).Verifiable();
+
+            // Act
+            _supplyBusinessLogicContract.CreateSupply(supply);
+
+            // Assert
+            _supplyStorageContract.Verify(x => x.AddSupply(It.Is<SupplyDataModel>(s =>
+                s.Id == supply.Id && s.StorageId == supply.StorageId && s.Date == supply.Date && s.Components == supply.Components)), Times.Once);
+        }
+
+        [Test]
+        public void CreateSupply_InvalidSupply_ThrowsValidationException_Test()
+        {
+            // Arrange
+            var supply = new SupplyDataModel(Guid.NewGuid().ToString(), "", DateTime.UtcNow, new List<ComponentInSupplyDataModel>());
+
+            // Act & Assert
+            Assert.That(() => _supplyBusinessLogicContract.CreateSupply(supply),
+                Throws.TypeOf<ValidationException>());
+            _supplyStorageContract.Verify(x => x.AddSupply(It.IsAny<SupplyDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void GetSupplyById_SupplyFound_ReturnsSupply_Test()
+        {
+            // Arrange
+            var supplyId = Guid.NewGuid().ToString();
+            var supply = new SupplyDataModel(supplyId, Guid.NewGuid().ToString(), DateTime.UtcNow, new List<ComponentInSupplyDataModel>());
+            _supplyStorageContract.Setup(x => x.GetSupplyById(supplyId)).Returns(supply);
+
+            // Act
+            var result = _supplyBusinessLogicContract.GetSupplyById(supplyId);
+
+            // Assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Id, Is.EqualTo(supplyId));
+            _supplyStorageContract.Verify(x => x.GetSupplyById(supplyId), Times.Once);
+        }
+
+        [Test]
+        public void GetSupplyById_SupplyNotFound_ThrowsArgumentException_Test()
+        {
+            // Arrange
+            var supplyId = "non-existent";
+            _supplyStorageContract.Setup(x => x.GetSupplyById(supplyId)).Returns((SupplyDataModel?)null);
+
+            // Act & Assert
+            Assert.That(() => _supplyBusinessLogicContract.GetSupplyById(supplyId),
+                Throws.ArgumentException.With.Message.Contains($"Supply with ID {supplyId} not found."));
+            _supplyStorageContract.Verify(x => x.GetSupplyById(supplyId), Times.Once);
+        }
+
+        [Test]
+        public void GetSuppliesByStorageId_ReturnsSupplies_Test()
+        {
+            // Arrange
+            var storageId = Guid.NewGuid().ToString();
+            var supplies = new List<SupplyDataModel>
+        {
+            new SupplyDataModel(Guid.NewGuid().ToString(), storageId, DateTime.UtcNow, new List<ComponentInSupplyDataModel>())
+        };
+            _supplyStorageContract.Setup(x => x.GetSuppliesByStorageId(storageId)).Returns(supplies);
+
+            // Act
+            var result = _supplyBusinessLogicContract.GetSuppliesByStorageId(storageId);
+
+            // Assert
+            Assert.That(result, Is.Not.Empty);
+            Assert.That(result.First().StorageId, Is.EqualTo(storageId));
+            _supplyStorageContract.Verify(x => x.GetSuppliesByStorageId(storageId), Times.Once);
+        }
+
+        [Test]
+        public void AddOrUpdateComponentInSupply_ValidComponent_AddsOrUpdatesComponent_Test()
+        {
+            // Arrange
+            var component = new ComponentInSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 100);
+            _supplyStorageContract.Setup(x => x.AddOrUpdateComponentInSupply(It.IsAny<ComponentInSupplyDataModel>())).Verifiable();
+
+            // Act
+            _supplyBusinessLogicContract.AddOrUpdateComponentInSupply(component);
+
+            // Assert
+            _supplyStorageContract.Verify(x => x.AddOrUpdateComponentInSupply(It.Is<ComponentInSupplyDataModel>(c =>
+                c.SupplyId == component.SupplyId && c.ComponentId == component.ComponentId && c.Count == component.Count)), Times.Once);
+        }
+
+        [Test]
+        public void AddOrUpdateComponentInSupply_InvalidComponent_ThrowsValidationException_Test()
+        {
+            // Arrange
+            var component = new ComponentInSupplyDataModel(Guid.NewGuid().ToString(), "", -10);
+
+            // Act & Assert
+            Assert.That(() => _supplyBusinessLogicContract.AddOrUpdateComponentInSupply(component),
+                Throws.TypeOf<ValidationException>());
+            _supplyStorageContract.Verify(x => x.AddOrUpdateComponentInSupply(It.IsAny<ComponentInSupplyDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void UpdateComponentCountInSupply_ValidCount_UpdatesCount_Test()
+        {
+            // Arrange
+            var supplyId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var newCount = 200;
+            _supplyStorageContract.Setup(x => x.UpdateComponentCountInSupply(supplyId, componentId, newCount)).Verifiable();
+
+            // Act
+            _supplyBusinessLogicContract.UpdateComponentCountInSupply(supplyId, componentId, newCount);
+
+            // Assert
+            _supplyStorageContract.Verify(x => x.UpdateComponentCountInSupply(supplyId, componentId, newCount), Times.Once);
+        }
+
+        [Test]
+        public void UpdateComponentCountInSupply_NegativeCount_ThrowsArgumentException_Test()
+        {
+            // Arrange
+            var supplyId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var newCount = -10;
+
+            // Act & Assert
+            Assert.That(() => _supplyBusinessLogicContract.UpdateComponentCountInSupply(supplyId, componentId, newCount),
+                Throws.ArgumentException.With.Message.Contains("Component count must be greater than zero."));
+            _supplyStorageContract.Verify(x => x.UpdateComponentCountInSupply(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [Test]
+        public void RemoveComponentFromSupply_RemovesComponent_Test()
+        {
+            // Arrange
+            var supplyId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            _supplyStorageContract.Setup(x => x.RemoveComponentFromSupply(supplyId, componentId)).Verifiable();
+
+            // Act
+            _supplyBusinessLogicContract.RemoveComponentFromSupply(supplyId, componentId);
+
+            // Assert
+            _supplyStorageContract.Verify(x => x.RemoveComponentFromSupply(supplyId, componentId), Times.Once);
+        }
+
+        [Test]
+        public void RemoveComponentFromSupply_SupplyNotFound_ThrowsArgumentException_Test()
+        {
+            // Arrange
+            var supplyId = "abc";
+            var componentId = Guid.NewGuid().ToString();
+            _supplyStorageContract.Setup(x => x.RemoveComponentFromSupply(supplyId, componentId)).Throws(new ArgumentException("Supply not found"));
+
+            // Act & Assert
+            Assert.That(() => _supplyBusinessLogicContract.RemoveComponentFromSupply(supplyId, componentId),
+                Throws.ArgumentException.With.Message.Contains("Supply not found"));
+        }
+    }
+
+}

NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs

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

NorthBridge/NorthBridgeTest/DataModelsTests/BuyerDataModelTests.cs

@@ -0,0 +1,69 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class BuyerDataModelTests
+{
+	[Test]
+	public void IdIsNullOrEmptyTest()
+	{
+		var buyer = CreateDataModel(null, "Иванов Иван Иванович", "number");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+		buyer = CreateDataModel(string.Empty, "Иванов Иван Иванович", "number");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var buyer = CreateDataModel("id", "Иванов Иван Иванович", "number");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void FIOIsNullOrEmptyTest()
+	{
+		var buyer = CreateDataModel(Guid.NewGuid().ToString(), null, "number");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+		buyer = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, "number");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PhoneNumberIsNullOrEmptyTest()
+	{
+		var buyer = CreateDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", null);
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+		buyer = CreateDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", string.Empty);
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PhoneNumberIsIncorrectTest()
+	{
+		var buyer = CreateDataModel(Guid.NewGuid().ToString(), "Иванов Иван Иванович", "777");
+		Assert.That(() => buyer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var buyerId = Guid.NewGuid().ToString();
+		var fio = "Иванов Иван Иванович";
+		var phoneNumber = "+7-777-777-77-77";
+		var buyer = CreateDataModel(buyerId, fio, phoneNumber);
+		Assert.That(() => buyer.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(buyer.Id, Is.EqualTo(buyerId));
+			Assert.That(buyer.FIO, Is.EqualTo(fio));
+			Assert.That(buyer.PhoneNumber, Is.EqualTo(phoneNumber));
+		});
+	}
+
+	private static BuyerDataModel CreateDataModel(string? id, string? fio, string? phoneNumber) =>
+		new(id, fio, phoneNumber);
+
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ComponentDataModelTests.cs

@@ -0,0 +1,91 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class ComponentDataModelTests
+{
+	[Test]
+	public void IdIsNullOrEmptyTest()
+	{
+		var component = CreateDataModel(null, "name", ComponentType.Processor, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+		component = CreateDataModel(string.Empty, "name", ComponentType.Processor, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var component = CreateDataModel("id", "name", ComponentType.Processor, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ComponentNameIsEmptyTest()
+	{
+		var component = CreateDataModel(Guid.NewGuid().ToString(), null, ComponentType.Processor, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+		component = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, ComponentType.Processor, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ComponentTypeIsNoneTest()
+	{
+		var component = CreateDataModel(Guid.NewGuid().ToString(), null, ComponentType.None, Guid.NewGuid().ToString(), 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ManufacturerIdIsNullOrEmptyTest()
+	{
+		var component = CreateDataModel(Guid.NewGuid().ToString(), "name", ComponentType.Processor, null, 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+		component = CreateDataModel(Guid.NewGuid().ToString(), "name", ComponentType.Processor, string.Empty, 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ManufacturerIdIsNotGuidTest()
+	{
+		var component = CreateDataModel(Guid.NewGuid().ToString(), "name", ComponentType.Processor, "manufacturerId", 10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PriceIsLessOrZeroTest()
+	{
+		var component = CreateDataModel(Guid.NewGuid().ToString(), "name", ComponentType.Processor, Guid.NewGuid().ToString(), 0, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+		component = CreateDataModel(Guid.NewGuid().ToString(), "name", ComponentType.Processor, Guid.NewGuid().ToString(), -10, false);
+		Assert.That(() => component.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var componentId = Guid.NewGuid().ToString();
+		var componentName = "name";
+		var componentType = ComponentType.Processor;
+		var componentManufacturerId = Guid.NewGuid().ToString();
+		var componentPrice = 10;
+		var componentIsDelete = false;
+		var component = CreateDataModel(componentId, componentName, componentType, componentManufacturerId, componentPrice, componentIsDelete);
+		Assert.That(() => component.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(component.Id, Is.EqualTo(componentId));
+			Assert.That(component.ComponentName, Is.EqualTo(componentName));
+			Assert.That(component.ComponentType, Is.EqualTo(componentType));
+			Assert.That(component.ManufacturerId, Is.EqualTo(componentManufacturerId));
+			Assert.That(component.Price, Is.EqualTo(componentPrice));
+			Assert.That(component.IsDeleted, Is.EqualTo(componentIsDelete));
+		});
+	}
+
+	private static ComponentDataModel CreateDataModel(string? id, string? componentName, ComponentType componentType, string? manufacturerId, double price, bool isDeleted) =>
+		new(id, componentName, componentType, manufacturerId, price, isDeleted);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ComponentHistoryDataModelTests.cs

@@ -0,0 +1,52 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class ComponentHistoryDataModelTests
+{
+    [Test]
+    public void ComponentIdIsNullOrEmptyTest()
+    {
+        var product = CreateDataModel(null, 10);
+        Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        product = CreateDataModel(string.Empty, 10);
+        Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void ComponentIdIsNotGuidTest()
+    {
+        var product = CreateDataModel("id", 10);
+        Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void OldPriceIsLessOrZeroTest()
+    {
+        var product = CreateDataModel(Guid.NewGuid().ToString(), 0);
+        Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        product = CreateDataModel(Guid.NewGuid().ToString(), -10);
+        Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void AllFieldsIsCorrectTest()
+    {
+        var componentId = Guid.NewGuid().ToString();
+        var oldPrice = 10;
+        var productHistory = CreateDataModel(componentId, oldPrice);
+        Assert.That(() => productHistory.Validate(), Throws.Nothing);
+        Assert.Multiple(() =>
+        {
+            Assert.That(productHistory.ComponentId, Is.EqualTo(componentId));
+            Assert.That(productHistory.OldPrice, Is.EqualTo(oldPrice));
+            Assert.That(productHistory.ChangeDate, Is.LessThan(DateTime.UtcNow));
+            Assert.That(productHistory.ChangeDate, Is.GreaterThan(DateTime.UtcNow.AddMinutes(-1)));
+        });
+    }
+
+    private static ComponentHistoryDataModel CreateDataModel(string? componentId, double oldPrice) =>
+        new(componentId, oldPrice);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ComponentInProductDataModelTests.cs

@@ -0,0 +1,63 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using NUnit.Framework;
+using System;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class ComponentInProductDataModelTests
+    {
+        [Test]
+        public void ComponentIdIsNullOrEmptyTest()
+        {
+            var componentInProduct = CreateDataModel(null, Guid.NewGuid().ToString());
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+
+            componentInProduct = CreateDataModel(string.Empty, Guid.NewGuid().ToString());
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ComponentIdIsNotGuidTest()
+        {
+            var componentInProduct = CreateDataModel("invalid_id", Guid.NewGuid().ToString());
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNullOrEmptyTest()
+        {
+            var componentInProduct = CreateDataModel(Guid.NewGuid().ToString(), null);
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+
+            componentInProduct = CreateDataModel(Guid.NewGuid().ToString(), string.Empty);
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNotGuidTest()
+        {
+            var componentInProduct = CreateDataModel(Guid.NewGuid().ToString(), "invalid_id");
+            Assert.That(() => componentInProduct.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AllFieldsAreCorrectTest()
+        {
+            var componentId = Guid.NewGuid().ToString();
+            var productId = Guid.NewGuid().ToString();
+            var componentInProduct = CreateDataModel(componentId, productId);
+
+            Assert.That(() => componentInProduct.Validate(), Throws.Nothing);
+            Assert.Multiple(() =>
+            {
+                Assert.That(componentInProduct.ComponentId, Is.EqualTo(componentId));
+                Assert.That(componentInProduct.ProductId, Is.EqualTo(productId));
+            });
+        }
+
+        private static ComponentInProductDataModel CreateDataModel(string? componentId, string? productId) =>
+            new(componentId, productId);
+    }
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ComponentInSupplyDataModelTests.cs

@@ -0,0 +1,70 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class ComponentInSupplyDataModelTests
+    {
+        [Test]
+        public void SupplyIdIsNullOrEmptyTest()
+        {
+            var componentSupply = CreateDataModel(null, Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+            componentSupply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void SupplyIdIsNotGuidTest()
+        {
+            var componentSupply = CreateDataModel("id", Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNullOrEmptyTest()
+        {
+            var componentSupply = CreateDataModel(Guid.NewGuid().ToString(), null, 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+            componentSupply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNotGuidTest()
+        {
+            var componentSupply = CreateDataModel(Guid.NewGuid().ToString(), "id", 1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void CountIsLessThanOrEqualToZeroTest()
+        {
+            var componentSupply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+            componentSupply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), -1);
+            Assert.That(() => componentSupply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AllFieldsAreCorrectTest()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var count = 5;
+            var componentSupply = CreateDataModel(supplyId, componentId, count);
+            Assert.That(() => componentSupply.Validate(), Throws.Nothing);
+            Assert.Multiple(() =>
+            {
+                Assert.That(componentSupply.SupplyId, Is.EqualTo(supplyId));
+                Assert.That(componentSupply.ComponentId, Is.EqualTo(componentId));
+                Assert.That(componentSupply.Count, Is.EqualTo(count));
+            });
+        }
+
+        private static ComponentInSupplyDataModel CreateDataModel(string? supplyId, string? componentId, int count) =>
+            new(supplyId, componentId, count);
+    }
+
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ComponentOnStorageDataModelTests.cs

@@ -0,0 +1,71 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class ComponentOnStorageDataModelTests
+    {
+        [Test]
+        public void StorageIdIsNullOrEmptyTest()
+        {
+            var componentStorage = new ComponentOnStorageDataModel(null, Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+            componentStorage = new ComponentOnStorageDataModel(string.Empty, Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void StorageIdIsNotGuidTest()
+        {
+            var componentStorage = new ComponentOnStorageDataModel("id", Guid.NewGuid().ToString(), 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNullOrEmptyTest()
+        {
+            var componentStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), null, 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+            componentStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), string.Empty, 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductIdIsNotGuidTest()
+        {
+            var componentStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), "id", 1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void CountIsLessThanOrEqualToZeroTest()
+        {
+            var componentStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+            componentStorage = new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), -1);
+            Assert.That(() => componentStorage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AllFieldsAreCorrectTest()
+        {
+            var storageId = Guid.NewGuid().ToString();
+            var componentId = Guid.NewGuid().ToString();
+            var count = 5;
+            var componentStorage = new ComponentOnStorageDataModel(storageId, componentId, count);
+            Assert.That(() => componentStorage.Validate(), Throws.Nothing);
+            Assert.Multiple(() =>
+            {
+                Assert.That(componentStorage.StorageId, Is.EqualTo(storageId));
+                Assert.That(componentStorage.ComponentId, Is.EqualTo(componentId));
+                Assert.That(componentStorage.Count, Is.EqualTo(count));
+            });
+        }
+    }
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ManufacturerDataModelTests.cs

@@ -0,0 +1,54 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class ManufacturerDataModelTests
+{
+	[Test]
+	public void IdIsNullEmptyTest()
+	{
+		var manufacturer = CreateDataModel(null, "name");
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+		manufacturer = CreateDataModel(string.Empty, "name");
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var manufacturer = CreateDataModel("id", "name");
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ManufacturerNameIsNullOrEmptyTest()
+	{
+		var manufacturer = CreateDataModel(Guid.NewGuid().ToString(), null);
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+		manufacturer = CreateDataModel(Guid.NewGuid().ToString(), string.Empty);
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var manufacturerId = Guid.NewGuid().ToString();
+		var manufacturerName = "name";
+		var prevManufacturerName = "prevManufacturerName";
+		var prevPrevManufacturerName = "prevPrevManufacturerName";
+		var manufacturer = CreateDataModel(manufacturerId, manufacturerName, prevManufacturerName, prevPrevManufacturerName);
+		Assert.That(() => manufacturer.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(manufacturer.Id, Is.EqualTo(manufacturerId));
+			Assert.That(manufacturer.ManufacturerName, Is.EqualTo(manufacturerName));
+			Assert.That(manufacturer.PrevManufacturerName, Is.EqualTo(prevManufacturerName));
+			Assert.That(manufacturer.PrevPrevManufacturerName, Is.EqualTo(prevPrevManufacturerName));
+		});
+	}
+
+	private static ManufacturerDataModel CreateDataModel(string? id, string? manufacturerName, string? prevManufacturerName = null, string? prevPrevManufacturerName = null) =>
+		new(id, manufacturerName, prevManufacturerName, prevPrevManufacturerName);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/PostDataModelTests.cs

@@ -0,0 +1,75 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeContract.DataModelsTests;
+
+[TestFixture]
+internal class PostDataModelTests
+{
+	[Test]
+	public void IdIsNullOrEmptyTest()
+	{
+		var post = CreateDataModel(null, "name", PostType.Assistant, 10, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+		post = CreateDataModel(string.Empty, "name", PostType.Assistant, 10, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var post = CreateDataModel("id", "name", PostType.Assistant, 10, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PostNameIsEmptyTest()
+	{
+		var manufacturer = CreateDataModel(Guid.NewGuid().ToString(), null, PostType.Assistant, 10, true, DateTime.UtcNow);
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+		manufacturer = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, PostType.Assistant, 10, true, DateTime.UtcNow);
+		Assert.That(() => manufacturer.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PostTypeIsNoneTest()
+	{
+		var post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.None, 10, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void SalaryIsLessOrZeroTest()
+	{
+		var post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 0, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+		post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, -10, true, DateTime.UtcNow);
+		Assert.That(() => post.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var postId = Guid.NewGuid().ToString();
+		var postName = "name";
+		var postType = PostType.Assistant;
+		var salary = 10;
+		var isActual = false;
+		var changeDate = DateTime.UtcNow.AddDays(-1);
+		var post = CreateDataModel(postId, postName, postType, salary, isActual, changeDate);
+		Assert.That(() => post.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(post.Id, 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? postName, PostType postType, double salary, bool isActual, DateTime changeDate) =>
+		new(id, postName, postType, salary, isActual, changeDate);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/ProductDataModelTests.cs

@@ -0,0 +1,75 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class ProductDataModelTests
+    {
+        [Test]
+        public void IdIsNullOrEmptyTest()
+        {
+            var product = CreateDataModel(null, "Processor", Guid.NewGuid().ToString(), false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+            product = CreateDataModel(string.Empty, "Processor", Guid.NewGuid().ToString(), false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void IdIsNotGuidTest()
+        {
+            var product = CreateDataModel("id", "Processor", Guid.NewGuid().ToString(), false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ProductNameIsNullOrEmptyTest()
+        {
+            var product = CreateDataModel(Guid.NewGuid().ToString(), null, Guid.NewGuid().ToString(), false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+            product = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, Guid.NewGuid().ToString(), false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void WorkerIdIsNullOrEmptyTest()
+        {
+            var product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", null, false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+            product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", string.Empty, false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void WorkerIdIsNotGuidTest()
+        {
+            var product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", "workerId", false, new List<ComponentDataModel> { new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false) });
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ComponentsAreNullOrEmptyTest()
+        {
+            var product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", Guid.NewGuid().ToString(), false, null);
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+            product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", Guid.NewGuid().ToString(), false, new List<ComponentDataModel>());
+            Assert.That(() => product.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void TotalPriceIsIncorrectTest()
+        {
+            var components = new List<ComponentDataModel>
+            {
+                new ComponentDataModel(Guid.NewGuid().ToString(), "CPU", ComponentType.Processor, Guid.NewGuid().ToString(), 200, false),
+                new ComponentDataModel(Guid.NewGuid().ToString(), "GPU", ComponentType.GraphicsCard, Guid.NewGuid().ToString(), 300, false)
+            };
+            var product = CreateDataModel(Guid.NewGuid().ToString(), "Processor", Guid.NewGuid().ToString(), false, components);
+            Assert.That(product.TotalPrice, Is.EqualTo(500));
+        }
+
+        private static ProductDataModel CreateDataModel(string? id, string? productName, string? workerId, bool isDeleted, List<ComponentDataModel>? components) =>
+            new(id, productName, workerId, isDeleted, components ?? new List<ComponentDataModel>());
+    }
+}

NorthBridge/NorthBridgeTest/DataModelsTests/SalaryDataModelTests.cs

@@ -0,0 +1,52 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class SalaryDataModelTests
+{
+	[Test]
+	public void WorkerIdIsEmptyTest()
+	{
+		var salary = CreateDataModel(null, DateTime.Now, 10);
+		Assert.That(() => salary.Validate(), Throws.TypeOf<ValidationException>());
+		salary = CreateDataModel(string.Empty, DateTime.Now, 10);
+		Assert.That(() => salary.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void WorkerIdIsNotGuidTest()
+	{
+		var salary = CreateDataModel("workerId", DateTime.Now, 10);
+		Assert.That(() => salary.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PriceIsLessOrZeroTest()
+	{
+		var salary = CreateDataModel(Guid.NewGuid().ToString(), DateTime.Now, 0);
+		Assert.That(() => salary.Validate(), Throws.TypeOf<ValidationException>());
+		salary = CreateDataModel(Guid.NewGuid().ToString(), DateTime.Now, -10);
+		Assert.That(() => salary.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var workerId = Guid.NewGuid().ToString();
+		var salaryDate = DateTime.Now.AddDays(-3).AddMinutes(-5);
+		var workerSalary = 10;
+		var salary = CreateDataModel(workerId, salaryDate, workerSalary);
+		Assert.That(() => salary.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(salary.WorkerId, Is.EqualTo(workerId));
+			Assert.That(salary.SalaryDate, Is.EqualTo(salaryDate));
+			Assert.That(salary.Salary, Is.EqualTo(workerSalary));
+		});
+	}
+
+	private static SalaryDataModel CreateDataModel(string? workerId, DateTime salaryDate, double workerSalary) =>
+		new(workerId, salaryDate, workerSalary);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/SaleDataModelTests.cs

@@ -0,0 +1,93 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Enums;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class SaleDataModelTests
+{
+	[Test]
+	public void IdIsNullOrEmptyTest()
+	{
+		var sale = CreateDataModel(null, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+		sale = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var sale = CreateDataModel("id", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+	[Test]
+	public void WorkerIdIsNullOrEmptyTest()
+	{
+		var sale = CreateDataModel(Guid.NewGuid().ToString(), null, Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+		sale = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void WorkerIdIsNotGuidTest()
+	{
+		var sale = CreateDataModel(Guid.NewGuid().ToString(), "workerId", Guid.NewGuid().ToString(), 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void BuyerIdIsNotGuidTest()
+	{
+		var sale = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "buyerId", 10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void SumIsLessOrZeroTest()
+	{
+		var sale = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+		sale = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), -10, false, CreateSubDataModel());
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ProductsIsNullOrEmptyTest()
+	{
+		var sale = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, null);
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+		sale = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10, false, []);
+		Assert.That(() => sale.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var saleId = Guid.NewGuid().ToString();
+		var workerId = Guid.NewGuid().ToString();
+		var buyerId = Guid.NewGuid().ToString();
+		var sum = 10;
+		var isCancel = true;
+		var products = CreateSubDataModel();
+		var sale = CreateDataModel(saleId, workerId, buyerId, sum, isCancel, products);
+		Assert.That(() => sale.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(sale.Id, Is.EqualTo(saleId));
+			Assert.That(sale.WorkerId, Is.EqualTo(workerId));
+			Assert.That(sale.BuyerId, Is.EqualTo(buyerId));
+			Assert.That(sale.Sum, Is.EqualTo(sum));
+			Assert.That(sale.IsCancel, Is.EqualTo(isCancel));
+			Assert.That(sale.Products, Is.EquivalentTo(products));
+		});
+	}
+
+	private static SaleDataModel CreateDataModel(string? id, string? workerId, string? buyerId, double sum, bool isCancel, List<SaleProductDataModel>? products) =>
+		new(id, workerId, buyerId, sum, isCancel, products);
+
+	private static List<SaleProductDataModel> CreateSubDataModel()
+		=> [new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 1)];
+}

NorthBridge/NorthBridgeTest/DataModelsTests/SaleProductDataModelTests.cs

@@ -0,0 +1,68 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class SaleProductDataModelTests
+{
+	[Test]
+	public void SaleIdIsNullOrEmptyTest()
+	{
+		var saleProduct = CreateDataModel(null, Guid.NewGuid().ToString(), 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+		saleProduct = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void SaleIdIsNotGuidTest()
+	{
+		var saleProduct = CreateDataModel("saleId", Guid.NewGuid().ToString(), 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ProductIdIsNullOrEmptyTest()
+	{
+		var saleProduct = CreateDataModel(Guid.NewGuid().ToString(), null, 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+		saleProduct = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void ProductIdIsNotGuidTest()
+	{
+		var saleProduct = CreateDataModel(Guid.NewGuid().ToString(), "productId", 10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void CountIsLessOrZeroTest()
+	{
+		var saleProduct = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+		saleProduct = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), -10);
+		Assert.That(() => saleProduct.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var saleId = Guid.NewGuid().ToString();
+		var productId = Guid.NewGuid().ToString();
+		var count = 10;
+		var saleProduct = CreateDataModel(saleId, productId, count);
+		Assert.That(() => saleProduct.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(saleProduct.SaleId, Is.EqualTo(saleId));
+			Assert.That(saleProduct.ProductId, Is.EqualTo(productId));
+			Assert.That(saleProduct.Count, Is.EqualTo(count));
+		});
+	}
+
+	private static SaleProductDataModel CreateDataModel(string? saleId, string? productId, int count) =>
+		new(saleId, productId, count);
+}

NorthBridge/NorthBridgeTest/DataModelsTests/StorageDateModelTests.cs

@@ -0,0 +1,66 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class StorageDataModelTests
+    {
+        [Test]
+        public void IdIsNullOrEmptyTest()
+        {
+            var components = CreateComponents();
+            var storage = CreateDataModel(null, "ул. Ленина, д. 10", components);
+            Assert.That(() => storage.Validate(), Throws.TypeOf<ValidationException>());
+
+            storage = CreateDataModel(string.Empty, "ул. Ленина, д. 10", components);
+            Assert.That(() => storage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void IdIsNotGuidTest()
+        {
+            var storage = CreateDataModel("id", "ул. Ленина, д. 10", CreateComponents());
+            Assert.That(() => storage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AddressIsNullOrEmptyTest()
+        {
+            var components = CreateComponents();
+            var storage = CreateDataModel(Guid.NewGuid().ToString(), null, components);
+            Assert.That(() => storage.Validate(), Throws.TypeOf<ValidationException>());
+
+            storage = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, components);
+            Assert.That(() => storage.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AllFieldsAreCorrectTest()
+        {
+            var storageId = Guid.NewGuid().ToString();
+            var address = "ул. Ленина, д. 10";
+            var components = CreateComponents();
+
+            var storage = CreateDataModel(storageId, address, components);
+            Assert.That(() => storage.Validate(), Throws.Nothing);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(storage.Id, Is.EqualTo(storageId));
+                Assert.That(storage.Address, Is.EqualTo(address));
+                Assert.That(storage.Components, Is.EquivalentTo(components));
+            });
+        }
+
+        private static StorageDataModel CreateDataModel(string? id, string? address, List<ComponentOnStorageDataModel> components) =>
+            new(id, address, true, components);
+
+        private static List<ComponentOnStorageDataModel> CreateComponents() =>
+            new()
+            {
+                new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10),
+                new ComponentOnStorageDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20)
+            };
+    }
+}

NorthBridge/NorthBridgeTest/DataModelsTests/SupplyDataModelTests.cs

@@ -0,0 +1,83 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests
+{
+    [TestFixture]
+    internal class SupplyDataModelTests
+    {
+        [Test]
+        public void IdIsNullOrEmptyTest()
+        {
+            var components = CreateComponents();
+            var supply = CreateDataModel(null, Guid.NewGuid().ToString(), DateTime.Now, components);
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+
+            supply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), DateTime.Now, components);
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void IdIsNotGuidTest()
+        {
+            var supply = CreateDataModel("id", Guid.NewGuid().ToString(), DateTime.Now, CreateComponents());
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void StorageIdIsNullOrEmptyTest()
+        {
+            var components = CreateComponents();
+            var supply = CreateDataModel(Guid.NewGuid().ToString(), null, DateTime.Now, components);
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+
+            supply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, DateTime.Now, components);
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void StorageIdIsNotGuidTest()
+        {
+            var supply = CreateDataModel(Guid.NewGuid().ToString(), "id", DateTime.Now, CreateComponents());
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void ComponentsListIsEmptyTest()
+        {
+            var supply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.Now, new List<ComponentInSupplyDataModel>());
+            Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        }
+
+        [Test]
+        public void AllFieldsAreCorrectTest()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var storageId = Guid.NewGuid().ToString();
+            var date = DateTime.Now;
+            var components = CreateComponents();
+
+            var supply = CreateDataModel(supplyId, storageId, date, components);
+            Assert.That(() => supply.Validate(), Throws.Nothing);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(supply.Id, Is.EqualTo(supplyId));
+                Assert.That(supply.StorageId, Is.EqualTo(storageId));
+                Assert.That(supply.Date, Is.EqualTo(date));
+                Assert.That(supply.Components, Is.EquivalentTo(components));
+            });
+        }
+
+        private static SupplyDataModel CreateDataModel(string? id, string? storageId, DateTime date, List<ComponentInSupplyDataModel> components) =>
+            new(id, storageId, date, components);
+
+        private static List<ComponentInSupplyDataModel> CreateComponents() =>
+            new()
+            {
+            new ComponentInSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5),
+            new ComponentInSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)
+            };
+        
+    }
+}

NorthBridge/NorthBridgeTest/DataModelsTests/WorkerDataModelTests.cs

@@ -0,0 +1,90 @@
+using NorthBridgeContract.DataModels;
+using NorthBridgeContract.Exceptions;
+
+namespace NorthBridgeTest.DataModelsTests;
+
+[TestFixture]
+internal class WorkerDataModelTests
+{
+	[Test]
+	public void IdIsNullOrEmptyTest()
+	{
+		var worker = CreateDataModel(null, "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+		worker = CreateDataModel(string.Empty, "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void IdIsNotGuidTest()
+	{
+		var worker = CreateDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void FIOIsNullOrEmptyTest()
+	{
+		var worker = CreateDataModel(Guid.NewGuid().ToString(), null, Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+		worker = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PostIdIsNullOrEmptyTest()
+	{
+		var worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", null, DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+		worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", string.Empty, DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void PostIdIsNotGuidTest()
+	{
+		var worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", "postId", DateTime.Now.AddYears(-18), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void BirthDateIsNotCorrectTest()
+	{
+		var worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(1), DateTime.Now, false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void BirthDateAndEmploymentDateIsNotCorrectTest()
+	{
+		var worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now.AddYears(-18).AddDays(-1), false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+		worker = CreateDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18), DateTime.Now.AddYears(-16), false);
+		Assert.That(() => worker.Validate(), Throws.TypeOf<ValidationException>());
+	}
+
+	[Test]
+	public void AllFieldsIsCorrectTest()
+	{
+		var workerId = Guid.NewGuid().ToString();
+		var fio = "fio";
+		var postId = Guid.NewGuid().ToString();
+		var birthDate = DateTime.Now.AddYears(-16).AddDays(-1);
+		var employmentDate = DateTime.Now;
+		var isDelete = false;
+		var worker = CreateDataModel(workerId, fio, postId, birthDate, employmentDate, isDelete);
+		Assert.That(() => worker.Validate(), Throws.Nothing);
+		Assert.Multiple(() =>
+		{
+			Assert.That(worker.Id, Is.EqualTo(workerId));
+			Assert.That(worker.FIO, Is.EqualTo(fio));
+			Assert.That(worker.PostId, Is.EqualTo(postId));
+			Assert.That(worker.BirthDate, Is.EqualTo(birthDate));
+			Assert.That(worker.EmploymentDate, Is.EqualTo(employmentDate));
+			Assert.That(worker.IsDeleted, Is.EqualTo(isDelete));
+		});
+	}
+
+	private static WorkerDataModel CreateDataModel(string? id, string? fio, string? postId, DateTime birthDate, DateTime employmentDate, bool isDeleted) =>
+		new(id, fio, postId, birthDate, employmentDate, isDeleted);
+}

NorthBridge/NorthBridgeTest/NorthBridgeTest.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NorthBridgeBusinessLogic\NorthBridgeBusinessLogic.csproj" />
+    <ProjectReference Include="..\NorthBridgeContract\NorthBridgeContract.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>