From c040470da2f4a5f431e4cef947f15aa387b9edce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=95=D1=81=D0=B5=D0=BD=D0=B8=D1=8F?= Date: Tue, 18 Feb 2025 01:17:27 +0400 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=B0=202=20=D0=B1=D0=B5?= =?UTF-8?q?=D0=B7=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- NorthBridge/NorthBridge.sln | 8 +- .../BuyerBusinessLogicContract.cs | 41 ++ .../ComponentBusinessLogicContract.cs | 74 +++ .../ManufacturerBusinessLogicContract.cs | 40 ++ .../PostBusinessLogicContract.cs | 51 ++ .../ProductBusinessLogicContract.cs | 61 ++ .../SalaryBusinessLogicContract.cs | 34 ++ .../SaleBusinessLogicContract.cs | 50 ++ .../WorkerBusinessLogicContract.cs | 56 ++ .../NorthBridgeBusinessLogic.csproj | 23 + .../IBuyerBusinessLogicContract.cs | 16 + .../IComponentBusinessLogicContract.cs | 31 + .../IManufacturerBusinessLogicContract.cs | 16 + .../IPostBusinessLogicContract.cs | 20 + .../IProductBusinessLogicContract.cs | 25 + .../ISalaryBusinessLogicContract.cs | 12 + .../ISaleBusinessLogicContract.cs | 20 + .../IWorkerBusinessLogicContract.cs | 22 + .../DataModels/PostDataModel.cs | 10 +- .../Exceptions/ElementExistsException.cs | 14 + .../Exceptions/ElementNotFoundException.cs | 11 + .../Exceptions/IncorrectDatesException.cs | 6 + .../Exceptions/NullListException.cs | 6 + .../Exceptions/StorageException.cs | 6 + .../IBuyerStorageContract.cs | 20 + .../IComponentStorageContract.cs | 32 + .../IManufacturerStorageContract.cs | 20 + .../StoragesContracts/IPostStorageContract.cs | 22 + .../IProductStorageContract.cs | 22 + .../ISalaryStorageContract.cs | 10 + .../StoragesContracts/ISaleStorageContract.cs | 14 + .../IWorkerStorageContract.cs | 18 + .../BuyerBusinessLogicContractTests.cs | 350 +++++++++++ .../ComponentBusinessLogicTests.cs | 178 ++++++ .../ManufacturerBusinessLogicContractTests.cs | 349 +++++++++++ .../PostBusinessLogicContractTests.cs | 454 ++++++++++++++ .../ProductBusinessLogicTests.cs | 12 + .../SalaryBusinessLogicContractTests.cs | 346 +++++++++++ .../SaleBusinessLogicContractTests.cs | 500 ++++++++++++++++ .../WorkerBusinessLogicContractTests.cs | 557 ++++++++++++++++++ .../DataModelsTests/PostDataModelTests.cs | 42 +- .../NorthBridgeTest/NorthBridgeTest.csproj | 4 +- 42 files changed, 3562 insertions(+), 41 deletions(-) create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/BuyerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/ComponentBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/ManufacturerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/PostBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/ProductBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/SalaryBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/SaleBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/Implementations/WorkerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeBusinessLogic/NorthBridgeBusinessLogic.csproj create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IBuyerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IComponentBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IManufacturerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IPostBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IProductBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISaleBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs create mode 100644 NorthBridge/NorthBridgeContract/Exceptions/ElementExistsException.cs create mode 100644 NorthBridge/NorthBridgeContract/Exceptions/ElementNotFoundException.cs create mode 100644 NorthBridge/NorthBridgeContract/Exceptions/IncorrectDatesException.cs create mode 100644 NorthBridge/NorthBridgeContract/Exceptions/NullListException.cs create mode 100644 NorthBridge/NorthBridgeContract/Exceptions/StorageException.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IBuyerStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IComponentStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IManufacturerStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IPostStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IProductStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/ISalaryStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/ISaleStorageContract.cs create mode 100644 NorthBridge/NorthBridgeContract/StoragesContracts/IWorkerStorageContract.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/BuyerBusinessLogicContractTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ComponentBusinessLogicTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ManufacturerBusinessLogicContractTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ProductBusinessLogicTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SaleBusinessLogicContractTests.cs create mode 100644 NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs diff --git a/NorthBridge/NorthBridge.sln b/NorthBridge/NorthBridge.sln index 63c4e27..143747d 100644 --- a/NorthBridge/NorthBridge.sln +++ b/NorthBridge/NorthBridge.sln @@ -5,11 +5,13 @@ VisualStudioVersion = 17.10.35013.160 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NorthBridgeContract", "NorthBridgeContract\NorthBridgeContract.csproj", "{28744C88-4DE9-429F-83DA-CA3670CE2D70}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NorthBridgeTest", "NorthBridgeTest\NorthBridgeTest.csproj", "{0105777C-5918-452B-9321-ECAEB1767753}" +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 Debug|Any CPU = Debug|Any CPU @@ -24,6 +26,10 @@ Global {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 diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/BuyerBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/BuyerBusinessLogicContract.cs new file mode 100644 index 0000000..5774654 --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/BuyerBusinessLogicContract.cs @@ -0,0 +1,41 @@ +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 GetAllBuyers() + { + return new List(); + } + + public BuyerDataModel GetBuyerByData(string data) + { + return new BuyerDataModel("", "", ""); + } + + public void InsertBuyer(BuyerDataModel buyerDataModel) + { + + } + + public void UpdateBuyer(BuyerDataModel buyerDataModel) + { + + } + + public void DeleteBuyer(string id) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/ComponentBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ComponentBusinessLogicContract.cs new file mode 100644 index 0000000..5d3a3ea --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ComponentBusinessLogicContract.cs @@ -0,0 +1,74 @@ +using Microsoft.Extensions.Logging; +using NorthBridgeContract.BusinessLogicsContracts; +using NorthBridgeContract.DataModels; +using NorthBridgeContract.Enums; +using NorthBridgeContract.Exceptions; +using NorthBridgeContract.StoragesContracts; + +namespace NorthBridgeBusinessLogic.Implementations +{ + internal class ComponentBusinessLogicContract(IComponentStorageContract componentStorageContract, ILogger logger) : IComponentBusinessLogicContract + { + private readonly ILogger _logger = logger; + private readonly IComponentStorageContract _componentStorageContract = componentStorageContract; + + public List GetAllComponents(bool onlyActive) + { + return []; + } + + public ComponentDataModel? GetComponentById(string id) + { + return new ComponentDataModel("", "", ComponentType.None, "", 0, false); + } + + public ComponentDataModel? GetComponentByName(string name) + { + return new ComponentDataModel("", "", ComponentType.None, "", 0, false); + } + + public void InsertComponent(ComponentDataModel componentDataModel) + { + componentDataModel.Validate(); + _componentStorageContract.AddElement(componentDataModel); + } + + public void UpdateComponent(ComponentDataModel componentDataModel) + { + var existingComponent = _componentStorageContract.GetElementById(componentDataModel.Id); + if (existingComponent == null) + throw new ValidationException("Component not found"); + + if (existingComponent.Price != componentDataModel.Price) + { + var historyEntry = new ComponentHistoryDataModel(existingComponent.Id, existingComponent.Price); + historyEntry.Validate(); + _componentStorageContract.AddComponentHistory(historyEntry); + } + + componentDataModel.Validate(); + _componentStorageContract.UpdElement(componentDataModel); + } + + public void DeleteComponent(string id) + { + _componentStorageContract.DelElement(id); + } + + public void RestoreComponent(string id) + { + _componentStorageContract.ResElement(id); + } + + public List GetComponentHistory(string componentId) + { + return _componentStorageContract.GetComponentHistory(componentId); + } + + public ComponentDataModel GetComponentByData(string data) + { + return new ComponentDataModel("", "", ComponentType.None, "", 0, false); + } + } + +} diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/ManufacturerBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ManufacturerBusinessLogicContract.cs new file mode 100644 index 0000000..90efdc4 --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ManufacturerBusinessLogicContract.cs @@ -0,0 +1,40 @@ +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 GetAllManufacturers() + { + return []; + } + + public ManufacturerDataModel GetManufacturerByData(string data) + { + return new("", "", "", "'"); + } + + public void InsertManufacturer(ManufacturerDataModel manufacturerDataModel) + { + + } + + public void UpdateManufacturer(ManufacturerDataModel manufacturerDataModel) + { + + } + + public void DeleteManufacturer(string id) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/PostBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/PostBusinessLogicContract.cs new file mode 100644 index 0000000..b40572f --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/PostBusinessLogicContract.cs @@ -0,0 +1,51 @@ +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 GetAllPosts(bool onlyActive = true) + { + return new List(); + } + + public List GetAllDataOfPost(string postId) + { + return new List(); + } + + public PostDataModel GetPostByData(string data) + { + return new PostDataModel("", "", PostType.None, 0, false, DateTime.Now); + } + + public void InsertPost(PostDataModel postDataModel) + { + + } + + public void UpdatePost(PostDataModel postDataModel) + { + + } + + public void DeletePost(string id) + { + + } + + public void RestorePost(string id) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/ProductBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ProductBusinessLogicContract.cs new file mode 100644 index 0000000..19715ad --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/ProductBusinessLogicContract.cs @@ -0,0 +1,61 @@ +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, ILogger logger) : IProductBusinessLogicContract +{ + private readonly ILogger _logger = logger; + private readonly IProductStorageContract _productStorageContract = productStorageContract; + + + public List GetAllProducts(bool onlyActive) + { + return new List(); + } + + public List GetAllProductsByManufacturer(string manufacturerId, bool onlyActive = true) + { + return new List(); + } + + public ProductDataModel GetProductByData(string data) + { + return new ProductDataModel("", "", "", false, new List()); + } + + public void InsertProduct(ProductDataModel productDataModel) + { + + } + + public void UpdateProduct(ProductDataModel productDataModel) + { + + } + + public void DeleteProduct(string id) + { + + } + + public List GetComponentsByProductId(string productId) + { + return new List(); + } + + public void AddComponentToProduct(ComponentInProductDataModel componentInProduct) + { + + } + + public void RemoveComponentFromProduct(string componentId, string productId) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/SalaryBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/SalaryBusinessLogicContract.cs new file mode 100644 index 0000000..807f0f4 --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/SalaryBusinessLogicContract.cs @@ -0,0 +1,34 @@ +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 GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate) + { + return new List(); + } + + public List GetAllSalariesByPeriodByWorker(DateTime fromDate, DateTime toDate, string workerId) + { + return new List(); + } + + public void CalculateSalaryByMounth(DateTime date) + { + + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/SaleBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/SaleBusinessLogicContract.cs new file mode 100644 index 0000000..8bb4fec --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/SaleBusinessLogicContract.cs @@ -0,0 +1,50 @@ +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 SaleBusinessLogicContract(ISaleStorageContract saleStorageContract, ILogger logger) : ISaleBusinessLogicContract +{ + private readonly ILogger _logger = logger; + private readonly ISaleStorageContract _saleStorageContract = saleStorageContract; + + public List GetAllSalesByPeriod(DateTime fromDate, DateTime toDate) + { + return new List(); + } + + public List GetAllSalesByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate) + { + return new List(); + } + + public List GetAllSalesByBuyerByPeriod(string buyerId, DateTime fromDate, DateTime toDate) + { + return new List(); + } + + public List GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate) + { + return new List(); + } + + public SaleDataModel GetSaleByData(string data) + { + return new SaleDataModel("", "", "", 0, false, new List()); + } + + public void InsertSale(SaleDataModel saleDataModel) + { + + } + + public void CancelSale(string id) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/Implementations/WorkerBusinessLogicContract.cs b/NorthBridge/NorthBridgeBusinessLogic/Implementations/WorkerBusinessLogicContract.cs new file mode 100644 index 0000000..baaf422 --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/Implementations/WorkerBusinessLogicContract.cs @@ -0,0 +1,56 @@ +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 GetAllWorkers(bool onlyActive = true) + { + return new List(); + } + + public List GetAllWorkersByPost(string postId, bool onlyActive = true) + { + return new List(); + } + + public List GetAllWorkersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true) + { + return new List(); + } + + public List GetAllWorkersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true) + { + return new List(); + } + + public WorkerDataModel GetWorkerByData(string data) + { + return new WorkerDataModel("", "", "", DateTime.Now, DateTime.Now, false); + } + + public void InsertWorker(WorkerDataModel workerDataModel) + { + + } + + public void UpdateWorker(WorkerDataModel workerDataModel) + { + + } + + public void DeleteWorker(string id) + { + + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeBusinessLogic/NorthBridgeBusinessLogic.csproj b/NorthBridge/NorthBridgeBusinessLogic/NorthBridgeBusinessLogic.csproj new file mode 100644 index 0000000..eeecdb8 --- /dev/null +++ b/NorthBridge/NorthBridgeBusinessLogic/NorthBridgeBusinessLogic.csproj @@ -0,0 +1,23 @@ + + + + net8.0 + enable + enable + + + + + + + + + + + + + + + + + diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IBuyerBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IBuyerBusinessLogicContract.cs new file mode 100644 index 0000000..cd7f451 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IBuyerBusinessLogicContract.cs @@ -0,0 +1,16 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface IBuyerBusinessLogicContract +{ + List GetAllBuyers(); + + BuyerDataModel GetBuyerByData(string data); + + void InsertBuyer(BuyerDataModel buyerDataModel); + + void UpdateBuyer(BuyerDataModel buyerDataModel); + + void DeleteBuyer(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IComponentBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IComponentBusinessLogicContract.cs new file mode 100644 index 0000000..42aed9f --- /dev/null +++ b/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 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 GetComponentHistory(string componentId); + } + +} diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IManufacturerBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IManufacturerBusinessLogicContract.cs new file mode 100644 index 0000000..3a34866 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IManufacturerBusinessLogicContract.cs @@ -0,0 +1,16 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface IManufacturerBusinessLogicContract +{ + List GetAllManufacturers(); + + ManufacturerDataModel GetManufacturerByData(string data); + + void InsertManufacturer(ManufacturerDataModel manufacturerDataModel); + + void UpdateManufacturer(ManufacturerDataModel manufacturerDataModel); + + void DeleteManufacturer(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IPostBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IPostBusinessLogicContract.cs new file mode 100644 index 0000000..8a58b4b --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IPostBusinessLogicContract.cs @@ -0,0 +1,20 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface IPostBusinessLogicContract +{ + List GetAllPosts(bool onlyActive); + + List GetAllDataOfPost(string postId); + + PostDataModel GetPostByData(string data); + + void InsertPost(PostDataModel postDataModel); + + void UpdatePost(PostDataModel postDataModel); + + void DeletePost(string id); + + void RestorePost(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IProductBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IProductBusinessLogicContract.cs new file mode 100644 index 0000000..59fdbee --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IProductBusinessLogicContract.cs @@ -0,0 +1,25 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicContracts +{ + public interface IProductBusinessLogicContract + { + List GetAllProducts(bool onlyActive = true); + + List GetAllProductsByManufacturer(string manufacturerId, bool onlyActive = true); + + ProductDataModel? GetProductByData(string data); + + void InsertProduct(ProductDataModel productDataModel); + + void UpdateProduct(ProductDataModel productDataModel); + + void DeleteProduct(string id); + + List GetComponentsByProductId(string productId); + + void AddComponentToProduct(ComponentInProductDataModel componentInProduct); + + void RemoveComponentFromProduct(string componentId, string productId); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs new file mode 100644 index 0000000..c086528 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISalaryBusinessLogicContract.cs @@ -0,0 +1,12 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface ISalaryBusinessLogicContract +{ + List GetAllSalariesByPeriod(DateTime fromDate, DateTime toDate); + + List GetAllSalariesByPeriodByWorker(DateTime fromDate, DateTime toDate, string workerId); + + void CalculateSalaryByMounth(DateTime date); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISaleBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISaleBusinessLogicContract.cs new file mode 100644 index 0000000..ef1e50d --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/ISaleBusinessLogicContract.cs @@ -0,0 +1,20 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface ISaleBusinessLogicContract +{ + List GetAllSalesByPeriod(DateTime fromDate, DateTime toDate); + + List GetAllSalesByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate); + + List GetAllSalesByBuyerByPeriod(string buyerId, DateTime fromDate, DateTime toDate); + + List GetAllSalesByProductByPeriod(string productId, DateTime fromDate, DateTime toDate); + + SaleDataModel GetSaleByData(string data); + + void InsertSale(SaleDataModel saleDataModel); + + void CancelSale(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs new file mode 100644 index 0000000..f3e88f4 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/BusinessLogicsContracts/IWorkerBusinessLogicContract.cs @@ -0,0 +1,22 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.BusinessLogicsContracts; + +public interface IWorkerBusinessLogicContract +{ + List GetAllWorkers(bool onlyActive = true); + + List GetAllWorkersByPost(string postId, bool onlyActive = true); + + List GetAllWorkersByBirthDate(DateTime fromDate, DateTime toDate, bool onlyActive = true); + + List GetAllWorkersByEmploymentDate(DateTime fromDate, DateTime toDate, bool onlyActive = true); + + WorkerDataModel GetWorkerByData(string data); + + void InsertWorker(WorkerDataModel workerDataModel); + + void UpdateWorker(WorkerDataModel workerDataModel); + + void DeleteWorker(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/DataModels/PostDataModel.cs b/NorthBridge/NorthBridgeContract/DataModels/PostDataModel.cs index 44d3ac9..19d8d9e 100644 --- a/NorthBridge/NorthBridgeContract/DataModels/PostDataModel.cs +++ b/NorthBridge/NorthBridgeContract/DataModels/PostDataModel.cs @@ -5,12 +5,10 @@ using NorthBridgeContract.Infrastructure; namespace NorthBridgeContract.DataModels; -public class PostDataModel(string id, string postId, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation +public class PostDataModel(string id, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation { public string Id { get; private set; } = id; - public string PostId { get; private set; } = postId; - public string PostName { get; private set; } = postName; public PostType PostType { get; private set; } = postType; @@ -29,12 +27,6 @@ public class PostDataModel(string id, string postId, string postName, PostType p if (!Id.IsGuid()) throw new ValidationException("The value in the field Id is not a unique identifier"); - if (PostId.IsEmpty()) - throw new ValidationException("Field PostId is empty"); - - if (!PostId.IsGuid()) - throw new ValidationException("The value in the field PostId is not a unique identifier"); - if (PostName.IsEmpty()) throw new ValidationException("Field PostName is empty"); diff --git a/NorthBridge/NorthBridgeContract/Exceptions/ElementExistsException.cs b/NorthBridge/NorthBridgeContract/Exceptions/ElementExistsException.cs new file mode 100644 index 0000000..4a8881c --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/Exceptions/ElementNotFoundException.cs b/NorthBridge/NorthBridgeContract/Exceptions/ElementNotFoundException.cs new file mode 100644 index 0000000..e432fc5 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/Exceptions/IncorrectDatesException.cs b/NorthBridge/NorthBridgeContract/Exceptions/IncorrectDatesException.cs new file mode 100644 index 0000000..fca159a --- /dev/null +++ b/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}") { } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/Exceptions/NullListException.cs b/NorthBridge/NorthBridgeContract/Exceptions/NullListException.cs new file mode 100644 index 0000000..0c200e4 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/Exceptions/NullListException.cs @@ -0,0 +1,6 @@ +namespace NorthBridgeContract.Exceptions; + +public class NullListException : Exception +{ + public NullListException() : base("The returned list is null") { } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/Exceptions/StorageException.cs b/NorthBridge/NorthBridgeContract/Exceptions/StorageException.cs new file mode 100644 index 0000000..340dac7 --- /dev/null +++ b/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) { } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IBuyerStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IBuyerStorageContract.cs new file mode 100644 index 0000000..b83e3fc --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/IBuyerStorageContract.cs @@ -0,0 +1,20 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface IBuyerStorageContract +{ + List 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); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IComponentStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IComponentStorageContract.cs new file mode 100644 index 0000000..e4f2514 --- /dev/null +++ b/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 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 GetComponentHistory(string componentId); + } + +} diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IManufacturerStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IManufacturerStorageContract.cs new file mode 100644 index 0000000..3f46e2a --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/IManufacturerStorageContract.cs @@ -0,0 +1,20 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface IManufacturerStorageContract +{ + List 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); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IPostStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IPostStorageContract.cs new file mode 100644 index 0000000..75da13c --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/IPostStorageContract.cs @@ -0,0 +1,22 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface IPostStorageContract +{ + List GetList(bool onlyActual = true); + + List 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); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IProductStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IProductStorageContract.cs new file mode 100644 index 0000000..320bb75 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/IProductStorageContract.cs @@ -0,0 +1,22 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface IProductStorageContract +{ + List GetList(bool onlyActual = true); + + List GetPostWithHistory(string productId); + + ProductDataModel? GetElementById(string id); + + ProductDataModel? GetElementByName(string name); + + void AddElement(ProductDataModel productDataModel); + + void UpdElement(ProductDataModel productDataModel); + + void DelElement(string id); + + void ResElement(string id); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/ISalaryStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/ISalaryStorageContract.cs new file mode 100644 index 0000000..94a124f --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/ISalaryStorageContract.cs @@ -0,0 +1,10 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface ISalaryStorageContract +{ + List GetList(DateTime startDate, DateTime endDate, string? workerId = null); + + void AddElement(SalaryDataModel salaryDataModel); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/ISaleStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/ISaleStorageContract.cs new file mode 100644 index 0000000..b5816a4 --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/ISaleStorageContract.cs @@ -0,0 +1,14 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface ISaleStorageContract +{ + List 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); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeContract/StoragesContracts/IWorkerStorageContract.cs b/NorthBridge/NorthBridgeContract/StoragesContracts/IWorkerStorageContract.cs new file mode 100644 index 0000000..7f4c9eb --- /dev/null +++ b/NorthBridge/NorthBridgeContract/StoragesContracts/IWorkerStorageContract.cs @@ -0,0 +1,18 @@ +using NorthBridgeContract.DataModels; + +namespace NorthBridgeContract.StoragesContracts; + +public interface IWorkerStorageContract +{ + List 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); +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/BuyerBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/BuyerBusinessLogicContractTests.cs new file mode 100644 index 0000000..aa48949 --- /dev/null +++ b/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 _buyerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _buyerStorageContract = new Mock(); + _buyerBusinessLogicContract = new BuyerBusinessLogicContract(_buyerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _buyerStorageContract.Reset(); + } + + [Test] + public void GetAllBuyers_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + 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()); + _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()); + _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, "fio", "+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()), Times.Once); + } + + [Test] + public void GetBuyerByData_GetByFio_ReturnRecord_Test() + { + //Arrange + var fio = "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()), Times.Once); + } + + [Test] + public void GetBuyerByData_GetByPhoneNumber_ReturnRecord_Test() + { + //Arrange + var phoneNumber = "+7-111-111-11-11"; + var record = new BuyerDataModel(Guid.NewGuid().ToString(), "fio", 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()), Times.Once); + } + + [Test] + public void GetBuyerByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(null), Throws.TypeOf()); + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(string.Empty), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetBuyerByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetBuyerByData_GetByFio_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("fio"), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny()), Times.Never); + } + + [Test] + public void GetBuyerByData_GetByPhoneNumber_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("+7-111-111-11-12"), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny()), Times.Once); + } + + [Test] + public void GetBuyerByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _buyerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _buyerStorageContract.Setup(x => x.GetElementByPhoneNumber(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("fio"), Throws.TypeOf()); + Assert.That(() => _buyerBusinessLogicContract.GetBuyerByData("+7-111-111-11-12"), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _buyerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + _buyerStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny()), Times.Once); + } + + [Test] + public void InsertBuyer_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new BuyerDataModel(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11"); + _buyerStorageContract.Setup(x => x.AddElement(It.IsAny())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertBuyer_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertBuyer_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(null), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertBuyer_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new BuyerDataModel("id", "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertBuyer_StorageThrowError_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.InsertBuyer(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateBuyer_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new BuyerDataModel(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11"); + _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateBuyer_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateBuyer_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateBuyer_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(null), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateBuyer_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new BuyerDataModel("id", "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateBuyer_StorageThrowError_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.UpdateBuyer(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11")), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void DeleteBuyer_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(Guid.NewGuid().ToString()), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteBuyer_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(null), Throws.TypeOf()); + Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(string.Empty), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteBuyer_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer("id"), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteBuyer_StorageThrowError_ThrowException_Test() + { + //Arrange + _buyerStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _buyerBusinessLogicContract.DeleteBuyer(Guid.NewGuid().ToString()), Throws.TypeOf()); + _buyerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ComponentBusinessLogicTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ComponentBusinessLogicTests.cs new file mode 100644 index 0000000..f054082 --- /dev/null +++ b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ComponentBusinessLogicTests.cs @@ -0,0 +1,178 @@ +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 _componentStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _componentStorageContract = new Mock(); + _componentBusinessLogicContract = new ComponentBusinessLogicContract(_componentStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _componentStorageContract.Reset(); + } + + [Test] + public void GetAllComponents_ReturnListOfRecords_Test() + { + // Arrange + var listOriginal = new List() + { + 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())).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())).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()), Times.Exactly(2)); + } + + [Test] + public void GetAllComponents_ReturnNull_ThrowException_Test() + { + Assert.That(() => _componentBusinessLogicContract.GetAllComponents(It.IsAny()), Throws.TypeOf()); + _componentStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllComponents_StorageThrowError_ThrowException_Test() + { + _componentStorageContract.Setup(x => x.GetList(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + + Assert.That(() => _componentBusinessLogicContract.GetAllComponents(It.IsAny()), Throws.TypeOf()); + _componentStorageContract.Verify(x => x.GetList(It.IsAny()), 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()), Times.Once); + } + + [Test] + public void GetComponentByData_EmptyData_ThrowException_Test() + { + Assert.That(() => _componentBusinessLogicContract.GetComponentByData(null), Throws.TypeOf()); + Assert.That(() => _componentBusinessLogicContract.GetComponentByData(string.Empty), Throws.TypeOf()); + _componentStorageContract.Verify(x => x.GetElementById(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateComponent_CorrectRecord_Test() + { + var flag = false; + var record = new ComponentDataModel(Guid.NewGuid().ToString(), "component name", ComponentType.Processor, Guid.NewGuid().ToString(), 150, false); + _componentStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .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.UpdateComponent(record); + + _componentStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()), Times.Once); + } + + [Test] + public void DeleteComponent_EmptyId_ThrowException_Test() + { + Assert.That(() => _componentBusinessLogicContract.DeleteComponent(null), Throws.TypeOf()); + Assert.That(() => _componentBusinessLogicContract.DeleteComponent(string.Empty), Throws.TypeOf()); + _componentStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + } + +} diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ManufacturerBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ManufacturerBusinessLogicContractTests.cs new file mode 100644 index 0000000..608dcb0 --- /dev/null +++ b/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 _manufacturerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _manufacturerStorageContract = new Mock(); + _manufacturerBusinessLogicContract = new ManufacturerBusinessLogicContract(_manufacturerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _manufacturerStorageContract.Reset(); + } + + [Test] + public void GetAllManufacturers_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + 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()); + _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()); + _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()), 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()), 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()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), Times.Once); + } + + [Test] + public void GetManufacturerByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(null), Throws.TypeOf()); + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(string.Empty), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), Times.Never); + } + + [Test] + public void GetManufacturerByData__GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), Times.Never); + } + + [Test] + public void GetManufacturerByData_GetByNameOrOldName_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), Times.Once); + } + + [Test] + public void GetManufacturerByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _manufacturerStorageContract.Setup(x => x.GetElementByName(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), Times.Never); + } + + [Test] + public void GetManufacturerByData_GetByOldName_StorageThrowError_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.GetElementByOldName(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.GetManufacturerByData("name"), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + _manufacturerStorageContract.Verify(x => x.GetElementByOldName(It.IsAny()), 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())) + .Callback((ManufacturerDataModel x) => + { + flag = x.Id == record.Id && x.ManufacturerName == record.ManufacturerName; + }); + //Act + _manufacturerBusinessLogicContract.InsertManufacturer(record); + //Assert + _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertManufacturer_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertManufacturer_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(null), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertManufacturer_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new ManufacturerDataModel("id", "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertManufacturer_StorageThrowError_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.InsertManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.AddElement(It.IsAny()), 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())) + .Callback((ManufacturerDataModel x) => + { + flag = x.Id == record.Id && x.ManufacturerName == record.ManufacturerName; + }); + //Act + _manufacturerBusinessLogicContract.UpdateManufacturer(record); + //Assert + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateManufacturer_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateManufacturer_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateManufacturer_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(null), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateManufacturer_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new ManufacturerDataModel("id", "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateManufacturer_StorageThrowError_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.UpdateManufacturer(new(Guid.NewGuid().ToString(), "name", null, null)), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()), 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())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(Guid.NewGuid().ToString()), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteManufacturer_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(null), Throws.TypeOf()); + Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(string.Empty), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteManufacturer_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer("id"), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteManufacturer_StorageThrowError_ThrowException_Test() + { + //Arrange + _manufacturerStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _manufacturerBusinessLogicContract.DeleteManufacturer(Guid.NewGuid().ToString()), Throws.TypeOf()); + _manufacturerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs new file mode 100644 index 0000000..9e0c417 --- /dev/null +++ b/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 _postStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _postStorageContract = new Mock(); + _postBusinessLogicContract = new PostBusinessLogicContract(_postStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _postStorageContract.Reset(); + } + + [Test] + public void GetAllPosts_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + 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())).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())).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()), Times.Exactly(2)); + } + + [Test] + public void GetAllPosts_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllPosts_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetList(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_ReturnListOfRecords_Test() + { + //Arrange + var postId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + 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())).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())).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()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_PostIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Never); + } + + [Test] + public void GetAllDataOfPost_PostIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Never); + } + + [Test] + public void GetAllDataOfPost_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), 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()), 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()), Times.Once); + } + + [Test] + public void GetPostByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetPostByData(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + } + + [Test] + public void GetPostByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + } + + [Test] + public void GetPostByData_GetByName_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void GetPostByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _postStorageContract.Setup(x => x.GetElementByName(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertPost_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Supervisor, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertPost_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(null), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), 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()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Supervisor, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdatePost_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Supervisor, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdatePost_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "anme", PostType.Supervisor, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdatePost_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(null), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdatePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Supervisor, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()), 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())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeletePost_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.DeletePost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeletePost_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeletePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), 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()), 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())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Once); + } + + [Test] + public void RestorePost_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.RestorePost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Never); + } + + [Test] + public void RestorePost_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Never); + } + + [Test] + public void RestorePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.ResElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ProductBusinessLogicTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ProductBusinessLogicTests.cs new file mode 100644 index 0000000..fb20546 --- /dev/null +++ b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/ProductBusinessLogicTests.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace NorthBridgeTest.BusinessLogicsContractsTests +{ + internal class ProductBusinessLogicTests + { + } +} diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs new file mode 100644 index 0000000..a927281 --- /dev/null +++ b/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 _salaryStorageContract; + private Mock _saleStorageContract; + private Mock _postStorageContract; + private Mock _workerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _salaryStorageContract = new Mock(); + _saleStorageContract = new Mock(); + _postStorageContract = new Mock(); + _workerStorageContract = new Mock(); + _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object, + _saleStorageContract.Object, _postStorageContract.Object, _workerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _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() + { + 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(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalaries_IncorrectDates_ThrowException_Test() + { + //Arrange + var dateTime = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime), Throws.TypeOf()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime.AddSeconds(-1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalaries_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalaries_StorageThrowError_ThrowException_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), 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() + { + 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(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny()), 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()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime.AddSeconds(-1), Guid.NewGuid().ToString()), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalariesByWorker_WorkerIdIsNUllOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), null), Throws.TypeOf()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), string.Empty), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalariesByWorker_WorkerIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), "workerId"), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), 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()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalariesByWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, saleSum, false, [])]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, postSalary, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .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())) + .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() { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .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())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(list); + //Act + _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow); + //Assert + _salaryStorageContract.Verify(x => x.AddElement(It.IsAny()), 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, postSalary, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .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())) + .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())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMounth_PostStorageReturnNull_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMounth_WorkerStorageReturnNull_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow)); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMounth_SaleStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMounth_PostStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow, false)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMounth_WorkerStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new SaleDataModel(Guid.NewGuid().ToString(), workerId, null, 200, false, [])]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMounth(DateTime.UtcNow), Throws.TypeOf()); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SaleBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/SaleBusinessLogicContractTests.cs new file mode 100644 index 0000000..25e84e8 --- /dev/null +++ b/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 _saleStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _saleStorageContract = new Mock(); + _saleBusinessLogicContract = new SaleBusinessLogicContract(_saleStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _saleStorageContract.Reset(); + } + + [Test] + public void GetAllSalesByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByPeriod_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByPeriod_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByWorkerByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var workerId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod("workerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByWorkerByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByBuyerByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var buyerId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByBuyerByPeriod_BuyerIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByBuyerByPeriod_BuyerIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod("buyerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByBuyerByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByBuyerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByProductByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var productId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByProductByPeriod_ProductIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalesByProductByPeriod_ProductIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod("productId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalesByProductByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetAllSalesByProductByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()), Times.Once); + } + + [Test] + public void GetSaleByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetSaleByData(null), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.GetSaleByData(string.Empty), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + } + + [Test] + public void GetSaleByData_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetSaleByData("saleId"), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + } + + [Test] + public void GetSaleByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetSaleByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.GetSaleByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.GetElementById(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertSale_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.AddElement(It.IsAny())).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()); + _saleStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertSale_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.InsertSale(null), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.AddElement(It.IsAny()), 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()); + _saleStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertSale_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.AddElement(It.IsAny())).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()); + _saleStorageContract.Verify(x => x.AddElement(It.IsAny()), 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()), 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())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.CancelSale(Guid.NewGuid().ToString()), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void CancelSale_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.CancelSale(null), Throws.TypeOf()); + Assert.That(() => _saleBusinessLogicContract.CancelSale(string.Empty), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void CancelSale_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.CancelSale("id"), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void CancelSale_StorageThrowError_ThrowException_Test() + { + //Arrange + _saleStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _saleBusinessLogicContract.CancelSale(Guid.NewGuid().ToString()), Throws.TypeOf()); + _saleStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs b/NorthBridge/NorthBridgeTest/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs new file mode 100644 index 0000000..37d8b58 --- /dev/null +++ b/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 _workerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _workerStorageContract = new Mock(); + _workerBusinessLogicContract = new WorkerBusinessLogicContract(_workerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _workerStorageContract.Reset(); + } + + [Test] + public void GetAllWorkers_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), null, null, null, null, null), Times.Exactly(2)); + } + + [Test] + public void GetAllWorkers_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkers_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), null, null, null, null, null), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_ReturnListOfRecords_Test() + { + //Arrange + var postId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Exactly(2)); + } + + [Test] + public void GetAllWorkersByPost_PostIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(null, It.IsAny()), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(string.Empty, It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByPost_PostIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost("postId", It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByPost_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString(), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString(), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), null, null), Times.Once); + _workerStorageContract.Verify(x => x.GetList(false, null, It.IsAny(), It.IsAny(), 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()), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date.AddSeconds(-1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByBirthDate_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + 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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).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(), It.IsAny()), Times.Once); + _workerStorageContract.Verify(x => x.GetList(false, null, null, null, It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date, It.IsAny()), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date.AddSeconds(-1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByEmploymentDate_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), It.IsAny()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), 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()), 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()), Times.Once); + } + + [Test] + public void GetWorkerByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(null), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(string.Empty), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkerByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkerByData_GetByFio_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkerByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _workerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertWorker_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.AddElement(It.IsAny())).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()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertWorker_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.InsertWorker(null), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), 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()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.AddElement(It.IsAny())).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()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), 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())) + .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()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateWorker_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.UpdElement(It.IsAny())).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()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateWorker_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.UpdateWorker(null), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.UpdElement(It.IsAny())).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()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), 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()), 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()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteWorker_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(null), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(string.Empty), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorker_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker("id"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/DataModelsTests/PostDataModelTests.cs b/NorthBridge/NorthBridgeTest/DataModelsTests/PostDataModelTests.cs index 56888c8..2958702 100644 --- a/NorthBridge/NorthBridgeTest/DataModelsTests/PostDataModelTests.cs +++ b/NorthBridge/NorthBridgeTest/DataModelsTests/PostDataModelTests.cs @@ -2,7 +2,7 @@ using NorthBridgeContract.Enums; using NorthBridgeContract.Exceptions; -namespace NorthBridgeTest.DataModelsTests; +namespace NorthBridgeContract.DataModelsTests; [TestFixture] internal class PostDataModelTests @@ -10,57 +10,41 @@ internal class PostDataModelTests [Test] public void IdIsNullOrEmptyTest() { - var post = CreateDataModel(null, Guid.NewGuid().ToString(), "name", PostType.Assistant, 10, true, DateTime.UtcNow); + var post = CreateDataModel(null, "name", PostType.Assistant, 10, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); - post = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), "name", PostType.Assistant, 10, true, DateTime.UtcNow); + post = CreateDataModel(string.Empty, "name", PostType.Assistant, 10, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); } [Test] public void IdIsNotGuidTest() { - var post = CreateDataModel("id", Guid.NewGuid().ToString(), "name", PostType.Assistant, 10, true, DateTime.UtcNow); - Assert.That(() => post.Validate(), Throws.TypeOf()); - } - - [Test] - public void PostIdIsNullEmptyTest() - { - var post = CreateDataModel(Guid.NewGuid().ToString(), null, "name", PostType.Assistant, 10, true, DateTime.UtcNow); - Assert.That(() => post.Validate(), Throws.TypeOf()); - post = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, "name", PostType.Assistant, 10, true, DateTime.UtcNow); - Assert.That(() => post.Validate(), Throws.TypeOf()); - } - - [Test] - public void PostIdIsNotGuidTest() - { - var post = CreateDataModel(Guid.NewGuid().ToString(), "postId", "name", PostType.Assistant, 10, true, DateTime.UtcNow); + var post = CreateDataModel("id", "name", PostType.Assistant, 10, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); } [Test] public void PostNameIsEmptyTest() { - var manufacturer = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), null, PostType.Assistant, 10, true, DateTime.UtcNow); + var manufacturer = CreateDataModel(Guid.NewGuid().ToString(), null, PostType.Assistant, 10, true, DateTime.UtcNow); Assert.That(() => manufacturer.Validate(), Throws.TypeOf()); - manufacturer = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), string.Empty, PostType.Assistant, 10, true, DateTime.UtcNow); + manufacturer = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, PostType.Assistant, 10, true, DateTime.UtcNow); Assert.That(() => manufacturer.Validate(), Throws.TypeOf()); } [Test] public void PostTypeIsNoneTest() { - var post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "name", PostType.None, 10, true, DateTime.UtcNow); + var post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.None, 10, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); } [Test] public void SalaryIsLessOrZeroTest() { - var post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "name", PostType.Assistant, 0, true, DateTime.UtcNow); + var post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, 0, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); - post = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "name", PostType.Assistant, -10, true, DateTime.UtcNow); + post = CreateDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistant, -10, true, DateTime.UtcNow); Assert.That(() => post.Validate(), Throws.TypeOf()); } @@ -68,18 +52,16 @@ internal class PostDataModelTests public void AllFieldsIsCorrectTest() { var postId = Guid.NewGuid().ToString(); - var postPostId = 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, postPostId, postName, postType, salary, isActual, changeDate); + 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.PostId, Is.EqualTo(postPostId)); Assert.That(post.PostName, Is.EqualTo(postName)); Assert.That(post.PostType, Is.EqualTo(postType)); Assert.That(post.Salary, Is.EqualTo(salary)); @@ -88,6 +70,6 @@ internal class PostDataModelTests }); } - private static PostDataModel CreateDataModel(string? id, string? postId, string? postName, PostType postType, double salary, bool isActual, DateTime changeDate) => - new(id, postId, postName, postType, salary, isActual, changeDate); + private static PostDataModel CreateDataModel(string? id, string? postName, PostType postType, double salary, bool isActual, DateTime changeDate) => + new(id, postName, postType, salary, isActual, changeDate); } \ No newline at end of file diff --git a/NorthBridge/NorthBridgeTest/NorthBridgeTest.csproj b/NorthBridge/NorthBridgeTest/NorthBridgeTest.csproj index 994fcf4..2698273 100644 --- a/NorthBridge/NorthBridgeTest/NorthBridgeTest.csproj +++ b/NorthBridge/NorthBridgeTest/NorthBridgeTest.csproj @@ -1,4 +1,4 @@ - + net8.0 @@ -12,12 +12,14 @@ + +