romtec/PIbd-22_Buslaev.R.V_TwoFromTheCasketProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request 'Task_2_BuisnessLogic_Hard' (#7) from Task_2_BuisnessLogic_Hard into Task_3_Storage_Hard

Browse Source 
Reviewed-on: #7
This commit was merged in pull request #7.
This commit is contained in:
romtec
2025-03-21 17:37:33 +04:00
parent ea0b04710b c272951579
commit f68fd160d5
40 changed files with 1913 additions and 923 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/ComplitedWorkBusinessLogicContract.cs
View File

@@ -7,9 +7,10 @@ using static System.Runtime.InteropServices.JavaScript.JSType;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract _complitedWorkStorageContract, ILogger _logger) : IComplitedWorkBusinessLogicContract
internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract _complitedWorkStorageContract, IWarehouseStorageContract _complitedWorkDataModel, ILogger _logger) : IComplitedWorkBusinessLogicContract
{
private IComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
private IWarehouseStorageContract warehouseStorageContract = _complitedWorkDataModel;
private ILogger logger = _logger;
public List<ComplitedWorkDataModel> GetComplitedWorksByPeriod(DateTime fromDate, DateTime toDate)
@@ -189,6 +190,12 @@ internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract
throw new ValidationException("Completed work must have at least one assigned worker.");
}
if (!warehouseStorageContract.CheckWorks(complitedWorkDataModel))
{
logger.LogError("Not enough works for ComplitedWorks.");
throw new ValidationException("Not enough works for ComplitedWorks.");
}
logger.LogInformation("Completed work {ComplitedWorkId} has been validated successfully.", complitedWorkDataModel.Id);
complitedWorkStorageContract.AddElement(complitedWorkDataModel);
}

28
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/RoomBusinessLogicContract.cs
View File

@@ -67,6 +67,34 @@ internal class RoomBusinessLogicContract(IRoomStorageContract _roomStorageContra
return rooms;
}
public List<RoomHistoryDataModel> GetRoomHistory(string roomId)
{
logger.LogInformation("Retrieving history for room: {RoomId}", roomId);
if (string.IsNullOrWhiteSpace(roomId))
{
logger.LogError("Room ID is null or empty.");
throw new ArgumentNullException(nameof(roomId));
}
if (!Guid.TryParse(roomId, out _))
{
logger.LogError("Invalid room ID format: {RoomId}", roomId);
throw new ValidationException("Invalid room ID.");
}
var history = roomStorageContract.GetHistoryRoomId(roomId);
if (history == null)
{
logger.LogError("No history found for room ID: {RoomId}", roomId);
throw new NullListException();
}
logger.LogInformation("Retrieved {Count} history records for room ID: {RoomId}", history.Count, roomId);
return history;
}
public RoomDataModel GetRoomByData(string roomId)
{
logger.LogInformation("Retrieving room by ID: {RoomId}", roomId);

101
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/RoomHistoryBusinessLogicContract.cs
View File

@@ -1,101 +0,0 @@
using Microsoft.Extensions.Logging;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class RoomHistoryBusinessLogicContract(IRoomHistoryStorageContract _roomHistoryStorageContract, ILogger _logger) : IRoomHistoryBusinessLogicContract
{
private IRoomHistoryStorageContract roomHistoryStorageContract = _roomHistoryStorageContract;
private ILogger logger = _logger;
public List<RoomHistoryDataModel> GetRoomHistory(string roomId)
{
logger.LogInformation("Retrieving history for room: {RoomId}", roomId);
if (string.IsNullOrWhiteSpace(roomId))
{
logger.LogError("Room ID is null or empty.");
throw new ArgumentNullException(nameof(roomId));
}
if (!Guid.TryParse(roomId, out _))
{
logger.LogError("Invalid room ID format: {RoomId}", roomId);
throw new ValidationException("Invalid room ID.");
}
var history = roomHistoryStorageContract.GetList(roomId);
if (history == null)
{
logger.LogError("No history found for room ID: {RoomId}", roomId);
throw new NullListException();
}
logger.LogInformation("Retrieved {Count} history records for room ID: {RoomId}", history.Count, roomId);
return history;
}
public RoomHistoryDataModel GetLatestRoomHistory(string roomId)
{
logger.LogInformation("Retrieving latest history for room: {RoomId}", roomId);
if (string.IsNullOrWhiteSpace(roomId))
{
logger.LogError("Room ID is null or empty.");
throw new ArgumentNullException(nameof(roomId));
}
if (!Guid.TryParse(roomId, out _))
{
logger.LogError("Invalid room ID format: {RoomId}", roomId);
throw new ValidationException("Invalid room ID.");
}
var historyRecords = roomHistoryStorageContract.GetList(roomId);
if (historyRecords == null || historyRecords.Count == 0)
{
logger.LogError("No history records found for room ID: {RoomId}", roomId);
throw new NullListException();
}
var latestHistory = historyRecords.MaxBy(h => h.DateChange);
if (latestHistory == null)
{
logger.LogError("Failed to determine latest history record for room ID: {RoomId}", roomId);
throw new NullListException();
}
logger.LogInformation("Retrieved latest history record for room ID: {RoomId}", roomId);
return latestHistory;
}
public void AddRoomHistory(RoomHistoryDataModel roomHistoryDataModel)
{
logger.LogInformation("Adding room history.");
if (roomHistoryDataModel == null)
{
logger.LogError("Attempted to insert a null room history.");
throw new ArgumentNullException(nameof(roomHistoryDataModel));
}
if (!Guid.TryParse(roomHistoryDataModel.RoomId, out _))
{
logger.LogError("Invalid room ID: {RoomId}", roomHistoryDataModel.RoomId);
throw new ValidationException("Invalid room ID.");
}
if (roomHistoryDataModel.DateChange == default)
{
logger.LogError("Invalid change date.");
throw new ValidationException("Invalid change date.");
}
roomHistoryStorageContract.AddElement(roomHistoryDataModel);
logger.LogInformation("Room history added successfully for room: {RoomId}", roomHistoryDataModel.RoomId);
}
}

8
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/SalaryBusinessLogicContract.cs
View File

@@ -25,7 +25,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
if (fromDate >= toDate)
throw new IncorrectDatesException(fromDate,toDate);
_logger.LogInformation("Fetching salaries for worker {WorkerId} from {FromDate} to {ToDate}", workerId, fromDate, toDate);
logger.LogInformation("Fetching salaries for worker {WorkerId} from {FromDate} to {ToDate}", workerId, fromDate, toDate);
var salaries = _salaryStorageContract.GetList(fromDate, toDate, workerId) ?? throw new NullListException();
@@ -37,7 +37,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
if (fromDate >= toDate)
throw new IncorrectDatesException(fromDate,toDate);
_logger.LogInformation("Fetching salaries from {FromDate} to {ToDate}", fromDate, toDate);
logger.LogInformation("Fetching salaries from {FromDate} to {ToDate}", fromDate, toDate);
var salaries = _salaryStorageContract.GetList(fromDate, toDate, null) ?? throw new NullListException();
@@ -46,7 +46,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
public void CalculateSalaryByMonth(DateTime date)
{
_logger.LogInformation("Calculating salary for month: {Date}", date);
logger.LogInformation("Calculating salary for month: {Date}", date);
var startDate = new DateTime(date.Year, date.Month, 1);
var finishDate = new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month));
@@ -70,7 +70,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
var salary = specialization.Salary + (totalHours * 100);
_logger.LogDebug("Calculated salary for worker {WorkerId}: {Salary}", worker.Id, salary);
logger.LogDebug("Calculated salary for worker {WorkerId}: {Salary}", worker.Id, salary);
_salaryStorageContract.AddElement(new SalaryDataModel(Guid.NewGuid().ToString(), worker.Id, salary));
}

1
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/SpecializationBusinessLogicContract.cs
View File

@@ -90,7 +90,6 @@ internal class SpecializationBusinessLogicContract(ISpecializationStorageContrac
public void AddSpecialization(SpecializationDataModel specialization)
{
logger.LogInformation("Adding new specialization: {SpecializationName}", specialization.SpecializationName);
if (_specializationStorageContract.GetList()?.Any(s => s.SpecializationName.Equals(specialization.SpecializationName, StringComparison.OrdinalIgnoreCase)) == true)

177
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/SupplyBusinessLogicContract.cs Normal file
View File

@@ -0,0 +1,177 @@
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class SupplyBusinessLogicContract(ISupplyStorageContract _supplyStorageContract, ILogger _logger) : ISupplyBuisnessLogicContract
{
private ISupplyStorageContract supplyStorageContract = _supplyStorageContract;
private ILogger logger = _logger;
public List<SupplyDataModel> GetSuppliesByPeriod(DateTime fromDate, DateTime toDate)
{
logger.LogInformation("Retrieving supplies from {FromDate} to {ToDate}", fromDate, toDate);
if (fromDate >= toDate)
{
throw new IncorrectDatesException(fromDate, toDate);
}
var supplies = supplyStorageContract.GetList(fromDate, toDate);
if (supplies == null)
{
throw new NullListException();
}
if (supplies.Count == 0)
{
throw new ElementNotFoundException($"No supplies found in the period from {fromDate} to {toDate}.");
}
return supplies;
}
public List<SupplyDataModel> GetSuppliesByWarehouseId(string warehouseId)
{
logger.LogInformation("Retrieving supplies for warehouse: {WarehouseId}", warehouseId);
if (string.IsNullOrWhiteSpace(warehouseId))
{
throw new ArgumentNullException(nameof(warehouseId));
}
if (!Guid.TryParse(warehouseId, out _))
{
throw new ValidationException("Invalid warehouse ID format.");
}
var supplies = supplyStorageContract.GetList(DateTime.MinValue, DateTime.MaxValue, warehouseId);
if (supplies == null)
{
throw new NullListException();
}
if (supplies.Count == 0)
{
throw new ElementNotFoundException($"No supplies found for warehouse ID: {warehouseId}.");
}
return supplies;
}
public SupplyDataModel GetSupplyByData(string data)
{
logger.LogInformation("Retrieving supply by data: {Data}", data);
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentNullException(nameof(data));
}
if (!Guid.TryParse(data, out _))
{
throw new ValidationException("The value in the field Id is not a unique identifier.");
}
List<SupplyDataModel>? supplies;
try
{
supplies = supplyStorageContract.GetList(DateTime.MinValue, DateTime.MaxValue);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
if (!supplies.Any())
{
throw new ElementNotFoundException($"No supply found for data: {data}");
}
if (supplies == null)
{
throw new NullListException();
}
var supply = supplies.FirstOrDefault(s => s.Id == data || s.WarehouseId == data);
if (supply == null)
{
throw new ElementNotFoundException($"No supply found for data: {data}");
}
return supply;
}
public void InsertSupply(SupplyDataModel supplyDataModel)
{
logger.LogInformation("Inserting new supply: {@Supply}", supplyDataModel);
if (supplyDataModel == null)
{
throw new ArgumentNullException(nameof(supplyDataModel));
}
supplyDataModel.Validate();
var existingSupply = supplyStorageContract.GetElementById(supplyDataModel.Id);
if (existingSupply != null)
{
throw new ElementExistsException($"Supply", supplyDataModel.Id);
}
try
{
supplyStorageContract.AddElement(supplyDataModel);
logger.LogInformation("Supply {SupplyId} inserted successfully", supplyDataModel.Id);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
}
public void DeleteSupply(string id)
{
logger.LogInformation("Deleting supply with ID: {SupplyId}", id);
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentNullException(nameof(id));
}
if (!Guid.TryParse(id, out _))
{
throw new ValidationException("Invalid supply ID format.");
}
var existingSupply = supplyStorageContract.GetElementById(id);
if (existingSupply == null)
{
throw new ElementNotFoundException($"Supply with ID {id} not found.");
}
try
{
supplyStorageContract.DelElement(id);
logger.LogInformation("Supply {SupplyId} deleted successfully", id);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
}
}

168
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WarehouseBusinessLogicContract.cs Normal file
View File

@@ -0,0 +1,168 @@
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Extensions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class WarehouseBusinessLogicContract(IWarehouseStorageContract _warehouseStorageContract, ILogger _logger) : IWarehouseBuisnessLogicContract
{
private IWarehouseStorageContract warehouseStorageContract = _warehouseStorageContract;
private ILogger logger = _logger;
public WarehouseDataModel GetWarehouseByData(string warehouseId)
{
logger.LogInformation("Retrieving warehouse data for ID: {WarehouseId}", warehouseId);
if (string.IsNullOrWhiteSpace(warehouseId))
throw new ArgumentNullException(nameof(warehouseId));
if (!warehouseId.IsGuid())
throw new ValidationException($"Invalid warehouse ID format: {warehouseId}");
var warehouse = warehouseStorageContract.GetElementById(warehouseId);
if (warehouse == null)
throw new ElementNotFoundException($"Warehouse with ID {warehouseId} not found.");
logger.LogInformation("Warehouse found: {WarehouseName}, Location: {WarehouseLocation}",
warehouse.Name, warehouse.Location);
return warehouse;
}
public List<WarehouseDataModel> GetWarehousesByLocation(string warehouseLocation)
{
logger.LogInformation("Retrieving warehouses at location: {WarehouseLocation}", warehouseLocation);
if (string.IsNullOrWhiteSpace(warehouseLocation))
throw new ArgumentNullException(nameof(warehouseLocation));
var warehouses = warehouseStorageContract.GetListByLocation(warehouseLocation);
if (warehouses == null)
throw new NullListException();
if (warehouses.Count == 0)
throw new ElementNotFoundException($"No warehouses found at location {warehouseLocation}.");
logger.LogInformation("Found {Count} warehouses at location {WarehouseLocation}", warehouses.Count, warehouseLocation);
return warehouses;
}
public List<WarehouseDataModel> GetWarehousesByName(string warehouseName)
{
logger.LogInformation("Retrieving warehouses with name: {WarehouseName}", warehouseName);
if (string.IsNullOrWhiteSpace(warehouseName))
throw new ArgumentNullException(nameof(warehouseName));
var warehouses = warehouseStorageContract.GetListByName(warehouseName);
if (warehouses == null)
throw new NullListException();
if (warehouses.Count == 0)
throw new ElementNotFoundException($"No warehouses found with name {warehouseName}.");
logger.LogInformation("Found {Count} warehouses with name {WarehouseName}", warehouses.Count, warehouseName);
return warehouses;
}
public void InsertWarehouse(WarehouseDataModel warehouseDataModel)
{
logger.LogInformation("Inserting warehouse: {@Warehouse}", warehouseDataModel);
if (warehouseDataModel == null)
throw new ArgumentNullException(nameof(warehouseDataModel));
if (warehouseStorageContract.GetElementById(warehouseDataModel.Id) != null)
throw new ElementExistsException($"Warehouse", warehouseDataModel.Id);
if (warehouseDataModel.WorkWarehouseDataModels == null || warehouseDataModel.WorkWarehouseDataModels.Count == 0)
throw new ValidationException("The value in the workWarehouseDataModels must include at least one warehouse.");
warehouseDataModel.Validate();
try
{
warehouseStorageContract.AddElement(warehouseDataModel);
logger.LogInformation("Warehouse {WarehouseId} inserted successfully", warehouseDataModel.Id);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
}
public void UpdateWarehouse(WarehouseDataModel warehouseDataModel)
{
logger.LogInformation("Updating warehouse: {@Warehouse}", warehouseDataModel);
if (warehouseDataModel == null)
throw new ArgumentNullException(nameof(warehouseDataModel));
if (!Guid.TryParse(warehouseDataModel.Id, out _))
throw new ValidationException("Invalid warehouse ID format.");
var existingWarehouse = warehouseStorageContract.GetElementById(warehouseDataModel.Id);
if (existingWarehouse == null)
throw new ElementNotFoundException($"Warehouse with ID {warehouseDataModel.Id} not found.");
if (warehouseDataModel.WorkWarehouseDataModels == null || warehouseDataModel.WorkWarehouseDataModels.Count == 0)
throw new ValidationException("The warehouse must have at least one associated product.");
warehouseDataModel.Validate();
try
{
warehouseStorageContract.UpdElement(warehouseDataModel);
logger.LogInformation("Warehouse {WarehouseId} updated successfully", warehouseDataModel.Id);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
}
public void DeleteWarehouse(string warehouseId)
{
logger.LogInformation("Deleting warehouse with ID: {WarehouseId}", warehouseId);
if (string.IsNullOrWhiteSpace(warehouseId))
throw new ArgumentNullException(nameof(warehouseId));
if (!warehouseId.IsGuid())
throw new ValidationException($"Invalid warehouse ID format: {warehouseId}");
var existingWarehouse = warehouseStorageContract.GetElementById(warehouseId);
if (existingWarehouse == null)
throw new ElementNotFoundException($"Warehouse with ID {warehouseId} not found.");
try
{
warehouseStorageContract.DelElement(warehouseId);
logger.LogInformation("Warehouse with ID {WarehouseId} deleted successfully.", warehouseId);
}
catch (Exception ex)
{
throw new StorageException(ex);
}
}
}

14
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WorkBusinessLogicContract.cs
View File

@@ -13,7 +13,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
private ILogger logger = _logger;
public List<WorkDataModel> GetAllWorks()
{
_logger.LogInformation("Fetching all works.");
logger.LogInformation("Fetching all works.");
var works = _workStorageContract.GetList();
@@ -22,14 +22,14 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
throw new NullListException();
}
_logger.LogInformation("Fetched {Count} works.", works.Count);
logger.LogInformation("Fetched {Count} works.", works.Count);
return works;
}
public void InsertWork(WorkDataModel work)
{
_logger.LogInformation("InsertWork: {@work}", work);
logger.LogInformation("InsertWork: {@work}", work);
if (work == null)
throw new ArgumentNullException(nameof(work));
@@ -56,7 +56,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
public void UpdateWork(WorkDataModel work)
{
_logger.LogInformation("Updating work: {@work}", work);
logger.LogInformation("Updating work: {@work}", work);
if (work == null)
{
@@ -96,7 +96,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
public void DeleteWork(string workId)
{
_logger.LogInformation("DeleteWork: {workId}", workId);
logger.LogInformation("DeleteWork: {workId}", workId);
if (string.IsNullOrWhiteSpace(workId))
throw new ArgumentNullException(nameof(workId));
@@ -119,7 +119,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
}
public WorkDataModel GetWorkByData(DateTime dataFrom, DateTime dataTo)
{
_logger.LogInformation("Retrieving work data from {DataFrom} to {DataTo}", dataFrom, dataTo);
logger.LogInformation("Retrieving work data from {DataFrom} to {DataTo}", dataFrom, dataTo);
if (dataFrom >= dataTo)
{
@@ -145,7 +145,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
throw new ElementNotFoundException($"No work found in the given period.");
}
_logger.LogInformation("Found work: {WorkDescription} (ID: {WorkId})", latestWork.Description, latestWork.Id);
logger.LogInformation("Found work: {WorkDescription} (ID: {WorkId})", latestWork.Description, latestWork.Id);
return latestWork;
}

149
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WorkerComplitedWorkBusinessLogicContract.cs
View File

@@ -1,149 +0,0 @@
using Microsoft.Extensions.Logging;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class WorkerComplitedWorkBusinessLogicContract(IWorkerComplitedWorkStorageContract _complitedWorkStorageContract,
ILogger _logger) : IWorkerComplitedWorkBusinessLogicContract
{
private IWorkerComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
private ILogger logger = _logger;
public List<WorkerComplitedWorkDataModel> GetAllWorkerComplitedWorks()
{
logger.LogInformation("Fetching all worker completed works.");
var result = complitedWorkStorageContract.GetList();
if (result is null)
{
logger.LogError("No worker completed works found.");
throw new NullListException();
}
logger.LogInformation("Fetched {Count} worker completed works.", result.Count);
return result;
}
public List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWork(string workId)
{
logger.LogInformation("Fetching worker completed works by workId: {workId}", workId);
if (string.IsNullOrWhiteSpace(workId))
{
logger.LogError("Work ID is null or empty.");
throw new ArgumentNullException(nameof(workId));
}
if (!Guid.TryParse(workId, out _))
{
logger.LogError("Invalid work ID format: {workId}", workId);
throw new ValidationException("Invalid work ID format.");
}
var result = complitedWorkStorageContract.GetList(complitedWorkId: workId);
if (result is null)
{
logger.LogError("No completed works found for work ID: {workId}", workId);
throw new NullListException();
}
logger.LogInformation("Fetched {Count} worker completed works for workId: {workId}", result.Count, workId);
return result;
}
public List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId)
{
logger.LogInformation("Fetching worker completed works by workerId: {workerId}", workerId);
if (string.IsNullOrWhiteSpace(workerId))
{
logger.LogError("Worker ID is null or empty.");
throw new ArgumentNullException(nameof(workerId));
}
if (!Guid.TryParse(workerId, out _))
{
logger.LogError("Invalid worker ID format: {workerId}", workerId);
throw new ValidationException("Invalid worker ID format.");
}
var result = complitedWorkStorageContract.GetList(workerId: workerId);
if (result is null)
{
logger.LogError("No completed works found for worker ID: {workerId}", workerId);
throw new NullListException();
}
logger.LogInformation("Fetched {Count} worker completed works for workerId: {workerId}", result.Count, workerId);
return result;
}
public void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWork)
{
logger.LogInformation("Inserting new worker completed work: {workerComplitedWork}", workerComplitedWork);
if (workerComplitedWork is null)
{
logger.LogError("Worker completed work data is null.");
throw new ArgumentNullException(nameof(workerComplitedWork));
}
if (!Guid.TryParse(workerComplitedWork.WorkerId, out _))
throw new ValidationException("Invalid worker ID format.");
if (!Guid.TryParse(workerComplitedWork.ComplitedWorkId, out _))
throw new ValidationException("Invalid completed work ID format.");
if (workerComplitedWork.NumberOfWorkingHours <= 0)
throw new ValidationException("Number of working hours must be greater than zero.");
complitedWorkStorageContract.AddElement(workerComplitedWork);
_logger.LogInformation("Worker completed work inserted successfully: {workerComplitedWork}", workerComplitedWork);
}
public void UpdateWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWork)
{
logger.LogInformation("Updating worker completed work: {workerComplitedWork}", workerComplitedWork);
if (workerComplitedWork is null)
{
logger.LogError("Worker completed work data is null.");
throw new ArgumentNullException(nameof(workerComplitedWork));
}
if (!Guid.TryParse(workerComplitedWork.WorkerId, out _))
throw new ValidationException("Invalid worker ID format.");
if (!Guid.TryParse(workerComplitedWork.ComplitedWorkId, out _))
throw new ValidationException("Invalid completed work ID format.");
if (workerComplitedWork.NumberOfWorkingHours <= 0)
throw new ValidationException("Number of working hours must be greater than zero.");
complitedWorkStorageContract.UpdElement(workerComplitedWork);
logger.LogInformation("Worker completed work updated successfully: {workerComplitedWork}", workerComplitedWork);
}
public void DeleteWorkerComplitedWork(string workerComplitedWorkId)
{
logger.LogInformation("Deleting worker completed work: {workerComplitedWorkId}", workerComplitedWorkId);
if (string.IsNullOrWhiteSpace(workerComplitedWorkId))
{
logger.LogError("Worker completed work ID is null or empty.");
throw new ArgumentNullException(nameof(workerComplitedWorkId));
}
if (!Guid.TryParse(workerComplitedWorkId, out _))
{
logger.LogError("Invalid worker completed work ID format: {workerComplitedWorkId}", workerComplitedWorkId);
throw new ValidationException("Invalid worker completed work ID format.");
}
complitedWorkStorageContract.DelElement(workerComplitedWorkId);
logger.LogInformation("Worker completed work deleted successfully: {workerComplitedWorkId}", workerComplitedWorkId);
}
}

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IRoomBusinessLogicContract.cs
View File

@@ -4,7 +4,7 @@ public interface IRoomBusinessLogicContract
{
List<RoomDataModel> GetRoomsByOwner(string ownerName);
List<RoomDataModel> GetRoomsByAddress(string address);
List<RoomHistoryDataModel> GetRoomHistory(string roomId);
RoomDataModel GetRoomByData(string data);
void InsertRoom(RoomDataModel roomDataModel);

9
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IRoomHistoryBusinessLogicContract.cs
View File

@@ -1,9 +0,0 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
public interface IRoomHistoryBusinessLogicContract
{
List<RoomHistoryDataModel> GetRoomHistory(string roomId);
RoomHistoryDataModel GetLatestRoomHistory(string roomId);
void AddRoomHistory(RoomHistoryDataModel roomHistoryDataModel);
}

18
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/ISupplyBuisnessLogicContract.cs Normal file
View File

@@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
public interface ISupplyBuisnessLogicContract
{
List<SupplyDataModel> GetSuppliesByPeriod(DateTime fromDate, DateTime toDate);
List<SupplyDataModel> GetSuppliesByWarehouseId(string warehouseId);
SupplyDataModel GetSupplyByData(string data);
void InsertSupply(SupplyDataModel supplyDataModel);
void DeleteSupply(string id);
}

14
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IWarehouseBuisnessLogicContract.cs Normal file
View File

@@ -0,0 +1,14 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
public interface IWarehouseBuisnessLogicContract
{
List<WarehouseDataModel> GetWarehousesByName(string WarehouseName);
List<WarehouseDataModel> GetWarehousesByLocation(string WarehouseLocation);
WarehouseDataModel GetWarehouseByData(string data);
void InsertWarehouse(WarehouseDataModel warehouseDataModel);
void UpdateWarehouse(WarehouseDataModel warehouseDataModel);
void DeleteWarehouse(string id);
}

12
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IWorkerComplitedWorkBusinessLogicContract.cs
View File

@@ -1,12 +0,0 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
public interface IWorkerComplitedWorkBusinessLogicContract
{
List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId);
List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWork(string workId);
void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
void UpdateWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
void DeleteWorkerComplitedWork(string id);
}

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/ComplitedWorkDataModel.cs
View File

@@ -3,7 +3,7 @@ using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Infastructure;
namespace TwoFromTheCasketContracts.DataModels;
public class ComplitedWorkDataModel(string id, string workId, string roomId, List<WorkerComplitedWorkDataModel> workers ) :IValidation
public class ComplitedWorkDataModel(string id, string workId, string roomId, List<WorkerComplitedWorkDataModel> workers) :IValidation
{
public string Id { get; private set; } = id;
public string WorkId { get; private set; } = workId;

23
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/SupplyDataModel.cs Normal file
View File

@@ -0,0 +1,23 @@
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Extensions;
using TwoFromTheCasketContracts.Infastructure;
namespace TwoFromTheCasketContracts.DataModels;
public class SupplyDataModel(string id, string warehouseId, DateTime supplyDate, List<WorkSupplyDataModel> works) : IValidation
{
public string Id { get; private set; } = id;
public string WarehouseId { get; private set; } = warehouseId;
public DateTime SupplyDate { get; private set; } = supplyDate;
public List<WorkSupplyDataModel> Works { get; private set; } = works;
public void Validate()
{
if (Id.IsEmpty()) throw new ValidationException("Field Id is empty");
if (!Id.IsGuid()) throw new ValidationException("The value in the field Id is not a unique identifier");
if (WarehouseId.IsEmpty()) throw new ValidationException("Field WarehouseId is empty");
if (!WarehouseId.IsGuid()) throw new ValidationException("The value in the field WarehouseId is not a unique identifier");
if ((Works?.Count ?? 0) == 0)
throw new ValidationException("The value in the Works must include work");
}
}

25
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WarehouseDataModel.cs Normal file
View File

@@ -0,0 +1,25 @@
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Extensions;
using TwoFromTheCasketContracts.Infastructure;
namespace TwoFromTheCasketContracts.DataModels;
public class WarehouseDataModel(string id, string name, string location,
List<WorkWarehouseDataModel> workWarehouseDataModels) : IValidation
{
public string Id { get; private set; } = id;
public string Name { get; private set; } = name;
public string Location { get; private set; } = location;
public List<WorkWarehouseDataModel> WorkWarehouseDataModels { get; private set; } = workWarehouseDataModels;
public void Validate()
{
if (Id.IsEmpty()) throw new ValidationException("Field Id is empty");
if (!Id.IsGuid()) throw new ValidationException("The value in the field Id is not a unique identifier");
if (Name.IsEmpty()) throw new ValidationException("Field Name is empty");
if (Location.IsEmpty()) throw new ValidationException("Field Location is empty");
if ((WorkWarehouseDataModels?.Count ?? 0) == 0)
throw new ValidationException("The value in the workWarehouseDataModels must include warehouse");
}
}

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkDataModel.cs
View File

@@ -24,7 +24,5 @@ public class WorkDataModel(string id, TypeWork type, string description, DateTim
throw new ValidationException("Field Description is empty");
if (Date < DateTime.Now)
throw new ValidationException("Field Date is earlier than today");
}
}

21
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkSupplyDataModel.cs Normal file
View File

@@ -0,0 +1,21 @@
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Extensions;
using TwoFromTheCasketContracts.Infastructure;
namespace TwoFromTheCasketContracts.DataModels;
public class WorkSupplyDataModel(string workId, string supplyId, double quantity) : IValidation
{
public string WorkId { get; private set; } = workId;
public string SupplyId { get; private set; } = supplyId;
public double Quantity { get; private set; } = quantity;
public void Validate()
{
if (WorkId.IsEmpty()) throw new ValidationException("Field WorkId is empty");
if (!WorkId.IsGuid()) throw new ValidationException("The value in the field WorkId is not a unique identifier");
if (SupplyId.IsEmpty()) throw new ValidationException("Field SupplyId is empty");
if (!SupplyId.IsGuid()) throw new ValidationException("The value in the field SupplyId is not a unique identifier");
if (Quantity <= 0) throw new ValidationException("Field Quantity must be greater than zero");
}
}

26
TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkWarehouseDataModel.cs Normal file
View File

@@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.Extensions;
using TwoFromTheCasketContracts.Infastructure;
namespace TwoFromTheCasketContracts.DataModels;
public class WorkWarehouseDataModel(string workId, string warehouseId, double quantity) : IValidation
{
public string WorkId { get; private set; } = workId;
public string WarehouseId { get; private set; } = warehouseId;
public double Quantity { get; private set; } = quantity;
public void Validate()
{
if (WorkId.IsEmpty()) throw new ValidationException("Field WorkId is empty");
if (!WorkId.IsGuid()) throw new ValidationException("The value in the field WorkId is not a unique identifier");
if (WarehouseId.IsEmpty()) throw new ValidationException("Field WarehouseId is empty");
if (!WarehouseId.IsGuid()) throw new ValidationException("The value in the field WarehouseId is not a unique identifier");
if (Quantity <= 0) throw new ValidationException("Field Quantity must be greater than zero");
}
}

8
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IRoomHistoryStorageContract.cs
View File

@@ -1,8 +0,0 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IRoomHistoryStorageContract
{
List<RoomHistoryDataModel> GetList(string roomId);
RoomHistoryDataModel? GetLatestByRoomId(string roomId);
void AddElement(RoomHistoryDataModel roomHistoryDataModel);
}

16
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/ISupplyStorageContract.cs Normal file
View File

@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts;
public interface ISupplyStorageContract
{
List<SupplyDataModel> GetList(DateTime startDate, DateTime endDate, string? warehouseId = null);
SupplyDataModel? GetElementById(string id);
void AddElement(SupplyDataModel supplyDataModel);
void DelElement(string id);
}

19
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWarehouseStorageContract.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IWarehouseStorageContract
{
List<WarehouseDataModel> GetListByLocation(string Location);
List<WarehouseDataModel> GetListByName(string Name);
WarehouseDataModel? GetElementById(string id);
void AddElement(WarehouseDataModel warehouseDataModel);
void UpdElement(WarehouseDataModel warehouseDataModel);
void DelElement(string id);
bool CheckWorks(ComplitedWorkDataModel workDataModel);
}

10
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkerComplitedWorkStorageContract.cs
View File

@@ -1,10 +0,0 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IWorkerComplitedWorkStorageContract
{
List<WorkerComplitedWorkDataModel> GetList(string? workerId = null, string? complitedWorkId = null);
WorkerComplitedWorkDataModel? GetElementById(string id);
void AddElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
void UpdElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
void DelElement(string id);
}

25
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/ComplitedWorkBusinessLogicContractTests.cs
View File

@@ -14,19 +14,23 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
internal class ComplitedWorkBusinessLogicContractTests
{
private ComplitedWorkBusinessLogicContract _complitedWorkBusinessLogicContract;
private WarehouseBusinessLogicContract _warehouseBusinessLogicContract;
private Mock<IComplitedWorkStorageContract> _complitedWorkStorageMock;
private Mock<IWarehouseStorageContract> _warehouseStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_complitedWorkStorageMock = new Mock<IComplitedWorkStorageContract>();
_complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(_complitedWorkStorageMock.Object, new Mock<ILogger>().Object);
_warehouseStorageMock = new Mock<IWarehouseStorageContract>();
_complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(_complitedWorkStorageMock.Object, _warehouseStorageMock.Object, new Mock<ILogger>().Object);
}
[SetUp]
public void SetUp()
[TearDown]
public void TearDown()
{
_complitedWorkStorageMock.Reset();
_warehouseStorageMock.Reset();
}
[Test]
@@ -443,6 +447,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
var flag = false;
var record = new ComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>());
_warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Callback((ComplitedWorkDataModel x) =>
@@ -461,6 +466,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Throws(new ElementExistsException("Data", "Data"));
_warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
Throws.TypeOf<ElementExistsException>());
@@ -483,6 +489,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
_warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
@@ -491,6 +498,18 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void InsertComplitedWork_NotEnoughWorks_ThrowException_Test()
{
_warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(false);
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
Throws.TypeOf<ValidationException>());
_warehouseStorageMock.Verify(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void DeleteComplitedWork_CorrectRecord_Test()
{

90
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomBusinessLogicContractTests.cs
View File

@@ -18,13 +18,20 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
private RoomBusinessLogicContract _roomBusinessLogic;
private Mock<IRoomStorageContract> _roomStorageMock;
[SetUp]
public void Setup()
[OneTimeSetUp]
public void OneTimeSetUp()
{
_roomStorageMock = new Mock<IRoomStorageContract>();
_roomBusinessLogic = new RoomBusinessLogicContract(_roomStorageMock.Object, new Mock<ILogger>().Object);
}
[TearDown]
public void TearDown()
{
_roomStorageMock.Reset();
}
[Test]
public void GetAllRooms_ReturnsListOfRooms()
{
@@ -225,6 +232,85 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
_roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
}
[Test]
public void GetRoomHistory_ReturnsListOfRecords_Test()
{
var roomId = Guid.NewGuid().ToString();
var listOriginal = new List<RoomHistoryDataModel>
{
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow.AddMonths(-1))
};
_roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(listOriginal);
var result = _roomBusinessLogic.GetRoomHistory(roomId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(listOriginal));
});
_roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_ReturnsEmptyList_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(new List<RoomHistoryDataModel>());
var result = _roomBusinessLogic.GetRoomHistory(roomId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(0));
});
_roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
{
Assert.That(() => _roomBusinessLogic.GetRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomBusinessLogic.GetRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.GetHistoryRoomId(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
{
Assert.That(() => _roomBusinessLogic.GetRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
_roomStorageMock.Verify(x => x.GetHistoryRoomId(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomHistory_ReturnsNull_ThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(() => null);
Assert.That(() => _roomBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<NullListException>());
_roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_StorageThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
}
[Test]
public void GetRoomByData_GetById_ReturnsRoom()
{

247
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomHistoryBusinessLogicContractTests.cs
View File

@@ -1,247 +0,0 @@
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.Enums;
using Microsoft.Extensions.Logging;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
public class RoomHistoryBusinessLogicContractTests
{
private RoomHistoryBusinessLogicContract _roomHistoryBusinessLogic;
private Mock<IRoomHistoryStorageContract> _roomHistoryStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_roomHistoryStorageMock = new Mock<IRoomHistoryStorageContract>();
_roomHistoryBusinessLogic = new RoomHistoryBusinessLogicContract(_roomHistoryStorageMock.Object, new Mock<ILogger>().Object);
}
[SetUp]
public void SetUp()
{
_roomHistoryStorageMock.Reset();
}
[Test]
public void GetRoomHistory_ReturnsListOfRecords_Test()
{
var roomId = Guid.NewGuid().ToString();
var listOriginal = new List<RoomHistoryDataModel>
{
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow.AddMonths(-1))
};
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(listOriginal);
var result = _roomHistoryBusinessLogic.GetRoomHistory(roomId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(listOriginal));
});
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_ReturnsEmptyList_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(new List<RoomHistoryDataModel>());
var result = _roomHistoryBusinessLogic.GetRoomHistory(roomId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result.Count, Is.EqualTo(0));
});
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
{
Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
{
Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
_roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomHistory_ReturnsNull_ThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(() => null);
Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<NullListException>());
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetRoomHistory_StorageThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<StorageException>());
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetLatestRoomHistory_ReturnsLatestRecord_Test()
{
var roomId = Guid.NewGuid().ToString();
var latestHistory = new RoomHistoryDataModel(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow);
var historyList = new List<RoomHistoryDataModel>
{
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Residential, DateTime.UtcNow.AddMonths(-1)),
latestHistory
};
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(historyList);
var result = _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(latestHistory));
});
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetLatestRoomHistory_EmptyHistoryList_ThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(new List<RoomHistoryDataModel>());
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<NullListException>());
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetLatestRoomHistory_NullHistoryList_ThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(() => null);
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<NullListException>());
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void GetLatestRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
{
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetLatestRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
{
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
_roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetLatestRoomHistory_StorageThrowsException_Test()
{
var roomId = Guid.NewGuid().ToString();
_roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<StorageException>());
_roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
}
[Test]
public void AddRoomHistory_CorrectRecord_Test()
{
var flag = false;
var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Residential, DateTime.UtcNow);
_roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
.Callback((RoomHistoryDataModel x) =>
{
flag = x.RoomId == roomHistory.RoomId && x.OwnerFIO == roomHistory.OwnerFIO &&
x.Type == roomHistory.Type && x.DateChange == roomHistory.DateChange;
});
_roomHistoryBusinessLogic.AddRoomHistory(roomHistory);
_roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void AddRoomHistory_RecordWithExistingData_ThrowsException_Test()
{
var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Office, DateTime.UtcNow);
_roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
.Throws(new ElementExistsException("RoomHistory", "Id"));
Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(roomHistory), Throws.TypeOf<ElementExistsException>());
_roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
}
[Test]
public void AddRoomHistory_NullRecord_ThrowsException_Test()
{
Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
_roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Never);
}
[Test]
public void AddRoomHistory_InvalidRecord_ThrowsException_Test()
{
var invalidRoomHistory = new RoomHistoryDataModel("", Guid.NewGuid().ToString(), TypeRoom.PublicBuilding, DateTime.UtcNow);
Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(invalidRoomHistory), Throws.TypeOf<ValidationException>());
_roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Never);
}
[Test]
public void AddRoomHistory_StorageThrowsException_Test()
{
var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Office, DateTime.UtcNow);
_roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(roomHistory), Throws.TypeOf<StorageException>());
_roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
}
}

4
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs
View File

@@ -37,8 +37,8 @@ public class SalaryBusinessLogicContractTests
new Mock<ILogger>().Object);
}
[SetUp]
public void SetUp()
[TearDown]
public void TearDown()
{
_salaryStorageMock.Reset();
_workerStorageMock.Reset();

10
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SpecializationBusinessLogicContractTests.cs
View File

@@ -19,13 +19,19 @@ public class SpecializationBusinessLogicContractTests
private Mock<ISpecializationStorageContract> _specializationStorageMock;
private ISpecializationBusinessLogicContract _specializationBusinessLogic;
[SetUp]
public void Setup()
[OneTimeSetUp]
public void OneTimeSetUp()
{
_specializationStorageMock = new Mock<ISpecializationStorageContract>();
_specializationBusinessLogic = new SpecializationBusinessLogicContract(_specializationStorageMock.Object, new Mock<ILogger>().Object);
}
[TearDown]
public void TearDown()
{
_specializationStorageMock.Reset();
}
[Test]
public void GetAllSpecializations_ReturnListOfRecords_Test()
{

478
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SupplyBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,478 @@
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.Enums;
using TwoFromTheCasketContracts.StorageContracts;
using Microsoft.Extensions.Logging;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
[TestFixture]
public class SupplyBusinessLogicContractTests
{
private SupplyBusinessLogicContract _supplyBusinessLogic;
private Mock<ISupplyStorageContract> _supplyStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_supplyStorageMock = new Mock<ISupplyStorageContract>();
_supplyBusinessLogic = new SupplyBusinessLogicContract(
_supplyStorageMock.Object,
new Mock<ILogger>().Object
);
}
[TearDown]
public void TearDown()
{
_supplyStorageMock.Reset();
}
[Test]
public void GetSuppliesByPeriod_ReturnListOfRecords_Test()
{
// Arrange
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var warehouseId = Guid.NewGuid().ToString();
var suppliesOriginal = new List<SupplyDataModel>
{
new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(5),
new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
}),
new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(10),
new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 200)
})
};
_supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns(suppliesOriginal);
var supplies = _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(supplies, Is.Not.Null);
Assert.That(supplies, Is.EquivalentTo(suppliesOriginal));
});
_supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSuppliesByPeriod_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_supplyStorageMock
.Setup(x => x.GetList(fromDate, toDate, null))
.Returns(new List<SupplyDataModel>());
Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<ElementNotFoundException>());
_supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSuppliesByPeriod_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
}
[Test]
public void GetSuppliesByPeriod_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns((List<SupplyDataModel>)null);
Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<NullListException>());
_supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSuppliesByPeriod_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<StorageException>());
_supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSuppliesByWarehouseId_ReturnListOfRecords_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var suppliesOriginal = new List<SupplyDataModel>
{
new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(5),
new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
}),
new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(10),
new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 200)
})
};
_supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId)).Returns(suppliesOriginal);
var supplies = _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId);
Assert.Multiple(() =>
{
Assert.That(supplies, Is.Not.Null);
Assert.That(supplies, Is.EquivalentTo(suppliesOriginal));
});
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
}
[Test]
public void GetSuppliesByWarehouseId_ReturnEmptyList_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_supplyStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId))
.Returns(new List<SupplyDataModel>());
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ElementNotFoundException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
}
[Test]
public void GetSuppliesByWarehouseId_WarehouseIdIsNullOrEmpty_ThrowException_Test()
{
var warehouseId = string.Empty;
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ArgumentNullException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
}
[Test]
public void GetSuppliesByWarehouseId_WarehouseIdIsNotGuid_ThrowException_Test()
{
var warehouseId = "invalid-guid";
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ValidationException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
}
[Test]
public void GetSuppliesByWarehouseId_ReturnNull_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId)).Returns((List<SupplyDataModel>)null);
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<NullListException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
}
[Test]
public void GetSuppliesByWarehouseId_StorageThrowError_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<StorageException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
}
[Test]
public void GetSupplyByData_ReturnRecord_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var supplyRecord = new SupplyDataModel(
supplyId,
warehouseId,
DateTime.UtcNow,
new List<WorkSupplyDataModel> { new WorkSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10) });
_supplyStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
.Returns(new List<SupplyDataModel> { supplyRecord });
var result = _supplyBusinessLogic.GetSupplyByData(supplyId);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(supplyRecord));
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
}
[Test]
public void GetSupplyByData_SupplyIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _supplyBusinessLogic.GetSupplyByData(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _supplyBusinessLogic.GetSupplyByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
_supplyStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetSupplyByData_SupplyIdIsNotGuid_ThrowException_Test()
{
var invalidSupplyId = "invalid-guid";
Assert.That(() => _supplyBusinessLogic.GetSupplyByData(invalidSupplyId), Throws.TypeOf<ValidationException>());
_supplyStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetSupplyByData_StorageThrowsException_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
_supplyStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _supplyBusinessLogic.GetSupplyByData(supplyId), Throws.TypeOf<StorageException>());
_supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
}
[Test]
public void InsertSupply_CorrectRecord_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var supplyDate = DateTime.UtcNow.AddDays(-10);
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
};
var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
_supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns((SupplyDataModel)null);
_supplyStorageMock.Setup(x => x.AddElement(It.IsAny<SupplyDataModel>()));
_supplyBusinessLogic.InsertSupply(supply);
_supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
_supplyStorageMock.Verify(x => x.AddElement(supply), Times.Once);
}
[Test]
public void InsertSupply_NullRecord_ThrowException_Test()
{
Assert.That(() => _supplyBusinessLogic.InsertSupply(null), Throws.TypeOf<ArgumentNullException>());
_supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
}
[Test]
public void InsertSupply_RecordWithExistingId_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var supplyDate = DateTime.UtcNow.AddDays(-10);
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
};
var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
_supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns(supply);
Assert.That(() => _supplyBusinessLogic.InsertSupply(supply), Throws.TypeOf<ElementExistsException>());
_supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
_supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
}
[Test]
public void InsertSupply_WarehouseIdIsNullOrEmpty_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
var supplyDate = DateTime.UtcNow.AddDays(-10);
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 100)
};
var invalidSupply = new SupplyDataModel(supplyId, "", supplyDate, products);
Assert.That(() => _supplyBusinessLogic.InsertSupply(invalidSupply), Throws.TypeOf<ValidationException>());
_supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
}
[Test]
public void InsertSupply_WarehouseIdIsNotGuid_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
var invalidWarehouseId = "invalid-guid";
var supplyDate = DateTime.UtcNow.AddDays(-10);
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), invalidWarehouseId, 100)
};
var invalidSupply = new SupplyDataModel(supplyId, invalidWarehouseId, supplyDate, products);
Assert.That(() => _supplyBusinessLogic.InsertSupply(invalidSupply), Throws.TypeOf<ValidationException>());
_supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
}
[Test]
public void InsertSupply_StorageThrowsError_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var supplyDate = DateTime.UtcNow.AddDays(-10);
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
};
var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
_supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns((SupplyDataModel)null);
_supplyStorageMock.Setup(x => x.AddElement(It.IsAny<SupplyDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _supplyBusinessLogic.InsertSupply(supply), Throws.TypeOf<StorageException>());
_supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
_supplyStorageMock.Verify(x => x.AddElement(supply), Times.Once);
}
[Test]
public void DeleteSupply_CorrectRecord_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), supplyId, 100)
};
_supplyStorageMock.Setup(x => x.GetElementById(supplyId))
.Returns(new SupplyDataModel(supplyId, warehouseId, DateTime.UtcNow, products));
_supplyBusinessLogic.DeleteSupply(supplyId);
_supplyStorageMock.Verify(x => x.DelElement(supplyId), Times.Once);
}
[Test]
public void DeleteSupply_NullOrEmptyId_ThrowException_Test()
{
Assert.That(() => _supplyBusinessLogic.DeleteSupply(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _supplyBusinessLogic.DeleteSupply(""), Throws.TypeOf<ArgumentNullException>());
_supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteSupply_InvalidSupplyId_ThrowException_Test()
{
var supplyId = "invalid-guid";
Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<ValidationException>());
_supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteSupply_NotFound_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
_supplyStorageMock.Setup(x => x.GetElementById(supplyId)).Returns((SupplyDataModel)null);
Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<ElementNotFoundException>());
_supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteSupply_StorageThrowsError_ThrowException_Test()
{
var supplyId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var products = new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(Guid.NewGuid().ToString(), supplyId, 100)
};
_supplyStorageMock.Setup(x => x.GetElementById(supplyId))
.Returns(new SupplyDataModel(supplyId, warehouseId, DateTime.UtcNow, products));
_supplyStorageMock.Setup(x => x.DelElement(supplyId))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<StorageException>());
_supplyStorageMock.Verify(x => x.DelElement(supplyId), Times.Once);
}
}
}

444
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WarehouseBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,444 @@
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.Enums;
using TwoFromTheCasketContracts.StorageContracts;
using Microsoft.Extensions.Logging;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
[TestFixture]
public class WarehouseBusinessLogicContractTests
{
private WarehouseBusinessLogicContract _warehouseBusinessLogic;
private Mock<IWarehouseStorageContract> _warehouseStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_warehouseStorageMock = new Mock<IWarehouseStorageContract>();
_warehouseBusinessLogic = new WarehouseBusinessLogicContract(_warehouseStorageMock.Object, new Mock<ILogger>().Object);
}
[TearDown]
public void TearDown()
{
_warehouseStorageMock.Reset();
}
[Test]
public void GetWarehouseByData_CorrectId_ReturnsRecord_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var warehouse = new WarehouseDataModel(warehouseId, "Main Warehouse", "New York", []);
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
.Returns(warehouse);
var result = _warehouseBusinessLogic.GetWarehouseByData(warehouseId);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(warehouse));
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
}
[Test]
public void GetWarehouseByData_NullOrEmptyId_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(null),
Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(""),
Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWarehouseByData_InvalidIdFormat_ThrowException_Test()
{
var invalidId = "invalid-guid";
Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(invalidId),
Throws.TypeOf<ValidationException>());
_warehouseStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWarehouseByData_NotFound_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
.Returns((WarehouseDataModel)null);
Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(warehouseId),
Throws.TypeOf<ElementNotFoundException>());
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
}
[Test]
public void GetWarehouseByData_StorageThrowsException_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(warehouseId),
Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
}
[Test]
public void GetWarehousesByLocation_CorrectLocation_ReturnsList_Test()
{
var location = "New York";
var warehouses = new List<WarehouseDataModel>
{
new(Guid.NewGuid().ToString(), "Warehouse A", location, []),
new(Guid.NewGuid().ToString(), "Warehouse B", location, [])
};
_warehouseStorageMock.Setup(x => x.GetListByLocation(location)).Returns(warehouses);
var result = _warehouseBusinessLogic.GetWarehousesByLocation(location);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(warehouses));
});
_warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
}
[Test]
public void GetWarehousesByLocation_LocationIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(null),
Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(""),
Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.GetListByLocation(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWarehousesByLocation_NoWarehousesFound_ThrowException_Test()
{
var location = "Unknown City";
_warehouseStorageMock.Setup(x => x.GetListByLocation(location))
.Returns(new List<WarehouseDataModel>());
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
Throws.TypeOf<ElementNotFoundException>());
_warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
}
[Test]
public void GetWarehousesByLocation_StorageReturnsNull_ThrowException_Test()
{
var location = "Los Angeles";
_warehouseStorageMock.Setup(x => x.GetListByLocation(location))
.Returns((List<WarehouseDataModel>)null);
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
Throws.TypeOf<NullListException>());
_warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
}
[Test]
public void GetWarehousesByLocation_StorageThrowsException_ThrowException_Test()
{
var location = "Chicago";
_warehouseStorageMock.Setup(x => x.GetListByLocation(location))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
}
[Test]
public void GetWarehousesByName_CorrectName_ReturnsList_Test()
{
var warehouseName = "Central Warehouse";
var warehouses = new List<WarehouseDataModel>
{
new(Guid.NewGuid().ToString(), warehouseName, "New York", []),
new(Guid.NewGuid().ToString(), warehouseName, "Los Angeles", [])
};
_warehouseStorageMock.Setup(x => x.GetListByName(warehouseName)).Returns(warehouses);
var result = _warehouseBusinessLogic.GetWarehousesByName(warehouseName);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EquivalentTo(warehouses));
});
_warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
}
[Test]
public void GetWarehousesByName_NameIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(null),
Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(""),
Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.GetListByName(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWarehousesByName_NoWarehousesFound_ThrowException_Test()
{
var warehouseName = "Unknown Warehouse";
_warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
.Returns(new List<WarehouseDataModel>());
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
Throws.TypeOf<ElementNotFoundException>());
_warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
}
[Test]
public void GetWarehousesByName_StorageReturnsNull_ThrowException_Test()
{
var warehouseName = "Central Warehouse";
_warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
.Returns((List<WarehouseDataModel>)null);
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
Throws.TypeOf<NullListException>());
_warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
}
[Test]
public void GetWarehousesByName_StorageThrowsException_ThrowException_Test()
{
var warehouseName = "East Warehouse";
_warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
}
[Test]
public void InsertWarehouse_CorrectRecord_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var workWarehouseDataModels = new List<WorkWarehouseDataModel>
{
new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
};
var warehouse = new WarehouseDataModel(warehouseId, "Main Warehouse", "New York", workWarehouseDataModels);
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel?)null);
_warehouseStorageMock.Setup(x => x.AddElement(warehouse));
_warehouseBusinessLogic.InsertWarehouse(warehouse);
_warehouseStorageMock.Verify(x => x.AddElement(warehouse), Times.Once);
}
[Test]
public void InsertWarehouse_NullRecord_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.InsertWarehouse(null),
Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Never);
}
[Test]
public void InsertWarehouse_StorageThrowsException_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var workWarehouseDataModels = new List<WorkWarehouseDataModel>
{
new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
};
var warehouse = new WarehouseDataModel(warehouseId, "Warehouse A", "Los Angeles", workWarehouseDataModels);
_warehouseStorageMock
.Setup(x => x.AddElement(It.IsAny<WarehouseDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.InsertWarehouse(warehouse), Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Once);
}
[Test]
public void UpdateWarehouse_CorrectRecord_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var workWarehouseDataModels = new List<WorkWarehouseDataModel>
{
new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
};
var warehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "New York", workWarehouseDataModels);
_warehouseStorageMock
.Setup(x => x.GetElementById(warehouseId))
.Returns(warehouse);
_warehouseStorageMock
.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>()))
.Verifiable();
_warehouseBusinessLogic.UpdateWarehouse(warehouse);
_warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
}
[Test]
public void UpdateWarehouse_NullRecord_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(null),
Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
}
[Test]
public void UpdateWarehouse_WarehouseNotFound_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var updatedWarehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "San Francisco", []);
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel)null);
Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(updatedWarehouse),
Throws.TypeOf<ElementNotFoundException>());
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
_warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
}
[Test]
public void UpdateWarehouse_StorageThrowsException_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var workWarehouseDataModels = new List<WorkWarehouseDataModel>
{
new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
};
var updatedWarehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "New Location", workWarehouseDataModels);
_warehouseStorageMock
.Setup(x => x.GetElementById(warehouseId))
.Returns(updatedWarehouse);
_warehouseStorageMock
.Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(updatedWarehouse), Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
}
[Test]
public void DeleteWarehouse_CorrectRecord_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var existingWarehouse = new WarehouseDataModel(warehouseId, "Warehouse 1", "New York", []);
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns(existingWarehouse);
_warehouseStorageMock.Setup(x => x.DelElement(warehouseId));
_warehouseBusinessLogic.DeleteWarehouse(warehouseId);
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
_warehouseStorageMock.Verify(x => x.DelElement(warehouseId), Times.Once);
}
[Test]
public void DeleteWarehouse_IdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(string.Empty), Throws.TypeOf<ArgumentNullException>());
_warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWarehouse_IdIsNotGuid_ThrowException_Test()
{
var invalidId = "invalid-id";
Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(invalidId), Throws.TypeOf<ValidationException>());
_warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWarehouse_WarehouseNotFound_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel)null);
Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(warehouseId), Throws.TypeOf<ElementNotFoundException>());
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
_warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWarehouse_StorageThrowsError_ThrowException_Test()
{
var warehouseId = Guid.NewGuid().ToString();
var existingWarehouse = new WarehouseDataModel(warehouseId, "Warehouse 1", "New York", []);
_warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns(existingWarehouse);
_warehouseStorageMock.Setup(x => x.DelElement(warehouseId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(warehouseId), Throws.TypeOf<StorageException>());
_warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
_warehouseStorageMock.Verify(x => x.DelElement(warehouseId), Times.Once);
}
}
}

4
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkBusinessLogicContractTests.cs
View File

@@ -26,8 +26,8 @@ internal class WorkBusinessLogicContractTests
_workBusinessLogicContract = new WorkBusinessLogicContract(_workStorageMock.Object, new Mock<ILogger>().Object);
}
[SetUp]
public void SetUp()
[TearDown]
public void TearDown()
{
_workStorageMock.Reset();
}

4
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs
View File

@@ -22,8 +22,8 @@ internal class WorkerBusinessLogicContractTests
);
}
[SetUp]
public void SetUp()
[TearDown]
public void TearDown()
{
_workerStorageContract.Reset();
}

357
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerComplitedWorkBusinessLogicContractTests.cs
View File

@@ -1,357 +0,0 @@
using Microsoft.Extensions.Logging;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
public class WorkerComplitedWorkBusinessLogicContractTests
{
private WorkerComplitedWorkBusinessLogicContract _workerComplitedWorkBusinessLogicContract;
private Mock<IWorkerComplitedWorkStorageContract> _workerComplitedWorkStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_workerComplitedWorkStorageMock = new Mock<IWorkerComplitedWorkStorageContract>();
_workerComplitedWorkBusinessLogicContract = new WorkerComplitedWorkBusinessLogicContract(_workerComplitedWorkStorageMock.Object, new Mock<ILogger>().Object);
}
[SetUp]
public void SetUp()
{
_workerComplitedWorkStorageMock.Reset();
}
[Test]
public void GetWorkerComplitedWorksByWorker_ReturnListOfRecords_Test()
{
var workerId = Guid.NewGuid().ToString();
var listOriginal = new List<WorkerComplitedWorkDataModel>
{
new(workerId, Guid.NewGuid().ToString(), 10),
new(workerId, Guid.NewGuid().ToString(), 12),
new(workerId, Guid.NewGuid().ToString(), 8)
};
_workerComplitedWorkStorageMock.Setup(x => x.GetList(workerId, null)).Returns(listOriginal);
var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(workerId);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerComplitedWorkStorageMock.Verify(x => x.GetList(workerId, null), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWorker_ReturnEmptyList_Test()
{
var workerId = Guid.NewGuid().ToString();
_workerComplitedWorkStorageMock.Setup(x => x.GetList(workerId, null)).Returns(new List<WorkerComplitedWorkDataModel>());
var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(workerId);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
});
_workerComplitedWorkStorageMock.Verify(x => x.GetList(workerId, null), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWorker_WorkerIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Never);
}
[Test]
public void GetWorkerComplitedWorksByWorker_WorkerIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker("invalid_guid"), Throws.TypeOf<ValidationException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Never);
}
[Test]
public void GetWorkerComplitedWorksByWorker_ReturnNull_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWorker_StorageThrowError_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<string>(), null)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWork_ReturnListOfRecords_Test()
{
var workId = Guid.NewGuid().ToString();
var listOriginal = new List<WorkerComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), workId, 10),
new(Guid.NewGuid().ToString(), workId, 12),
new(Guid.NewGuid().ToString(), workId, 8)
};
_workerComplitedWorkStorageMock.Setup(x => x.GetList(null, workId)).Returns(listOriginal);
var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(workId);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, workId), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWork_ReturnEmptyList_Test()
{
var workId = Guid.NewGuid().ToString();
_workerComplitedWorkStorageMock.Setup(x => x.GetList(null, workId)).Returns(new List<WorkerComplitedWorkDataModel>());
var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(workId);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
});
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, workId), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWork_WorkIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWorkerComplitedWorksByWork_WorkIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork("invalid_guid"), Throws.TypeOf<ValidationException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWorkerComplitedWorksByWork_ReturnNull_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Once);
}
[Test]
public void GetWorkerComplitedWorksByWork_StorageThrowError_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.GetList(null, It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Once);
}
[Test]
public void InsertWorkerComplitedWork_CorrectRecord_Test()
{
var flag = false;
var record = new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20.5);
_workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Callback((WorkerComplitedWorkDataModel x) =>
{
flag = x.WorkerId == record.WorkerId &&
x.ComplitedWorkId == record.ComplitedWorkId &&
x.NumberOfWorkingHours == record.NumberOfWorkingHours;
});
_workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(record);
_workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void InsertWorkerComplitedWork_RecordWithExistsData_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Throws(new ElementExistsException("Data", "Data"));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15.0)),
Throws.TypeOf<ElementExistsException>());
_workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void InsertWorkerComplitedWork_NullRecord_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(null),
Throws.TypeOf<ArgumentNullException>());
_workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void InsertWorkerComplitedWork_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
new WorkerComplitedWorkDataModel("invalid_guid", "invalid_guid", -10.0)),
Throws.TypeOf<ValidationException>());
_workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void InsertWorkerComplitedWork_StorageThrowError_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5.0)),
Throws.TypeOf<StorageException>());
_workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void UpdateWorkerComplitedWork_CorrectRecord_Test()
{
var flag = false;
var record = new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15.0);
_workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Callback((WorkerComplitedWorkDataModel x) =>
{
flag = x.WorkerId == record.WorkerId &&
x.ComplitedWorkId == record.ComplitedWorkId &&
x.NumberOfWorkingHours == record.NumberOfWorkingHours;
});
_workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(record);
_workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void UpdateWorkerComplitedWork_RecordWithIncorrectData_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Throws(new ElementNotFoundException(""));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20.0)),
Throws.TypeOf<ElementNotFoundException>());
_workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void UpdateWorkerComplitedWork_NullRecord_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(null),
Throws.TypeOf<ArgumentNullException>());
_workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWorkerComplitedWork_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
new WorkerComplitedWorkDataModel("invalid_guid", "invalid_guid", -5.0)),
Throws.TypeOf<ValidationException>());
_workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWorkerComplitedWork_StorageThrowError_ThrowException_Test()
{
_workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10.0)),
Throws.TypeOf<StorageException>());
_workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void DeleteWorkerComplitedWork_CorrectRecord_Test()
{
var id = Guid.NewGuid().ToString();
var flag = false;
_workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x == id)))
.Callback(() => { flag = true; });
_workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id);
_workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeleteWorkerComplitedWork_RecordWithIncorrectId_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
.Throws(new ElementNotFoundException($"WorkerComplitedWork with ID {id} not found"));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id),
Throws.TypeOf<ElementNotFoundException>());
_workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
[Test]
public void DeleteWorkerComplitedWork_NullOrEmptyId_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWorkerComplitedWork_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork("invalid_id"), Throws.TypeOf<ValidationException>());
_workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWorkerComplitedWork_StorageThrowError_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id),
Throws.TypeOf<StorageException>());
_workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
}

5
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/ComplitedWorkDataModelTests.cs
View File

@@ -53,6 +53,7 @@ internal class ComplitedWorkDataModelTests
{
List<WorkerComplitedWorkDataModel> workers = new List<WorkerComplitedWorkDataModel> { new("1", "2", 3) };
var complitedWork = CreateDataModel("1", "2", null, workers);
Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
@@ -65,6 +66,7 @@ internal class ComplitedWorkDataModelTests
{
List<WorkerComplitedWorkDataModel> workers = new List<WorkerComplitedWorkDataModel> { new("1", "2", 3) };
var complitedWork = CreateDataModel("1", "2", "not-a-guid", workers);
Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
}
@@ -79,6 +81,8 @@ internal class ComplitedWorkDataModelTests
Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void AllFieldsIsCorrectTest()
{
@@ -90,6 +94,7 @@ internal class ComplitedWorkDataModelTests
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)
};
var complitedWork = CreateDataModel(id, workId, roomId, workers);
Assert.That(() => complitedWork.Validate(), Throws.Nothing);

82
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/SupplyDataModelTests.cs Normal file
View File

@@ -0,0 +1,82 @@
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
namespace TwoFromTheCasketTests.DataModelsTests;
[TestFixture]
public class SupplyDataModelTests
{
[Test]
public void SupplyIdIsNullOrEmptyTest()
{
List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> {new (Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var supply = CreateDataModel(null, Guid.NewGuid().ToString(), DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
supply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void SupplyIdIsNotGuidTest()
{
List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var supply = CreateDataModel("1", Guid.NewGuid().ToString(), DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseIdIsNullOrEmptyTest()
{
List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var supply = CreateDataModel(Guid.NewGuid().ToString(), null, DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
supply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseIdIsNotGuidTest()
{
List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> {new (Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var supply = CreateDataModel(Guid.NewGuid().ToString(), "1", DateTime.UtcNow, products);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void ProductsIsNullOrEmptyTest()
{
var supply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.UtcNow, new List<WorkSupplyDataModel>());
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
supply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.UtcNow, null);
Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void AllFieldsAreCorrectTest()
{
var id = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var supplyDate = DateTime.UtcNow;
List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var supply = CreateDataModel(id, warehouseId, supplyDate, products);
Assert.That(() => supply.Validate(), Throws.Nothing);
Assert.Multiple(() =>
{
Assert.That(supply.Id, Is.EqualTo(id));
Assert.That(supply.WarehouseId, Is.EqualTo(warehouseId));
Assert.That(supply.SupplyDate, Is.EqualTo(supplyDate));
Assert.That(supply.Works, Is.EqualTo(products));
});
}
private static SupplyDataModel CreateDataModel(string? id, string? warehouseId, DateTime supplyDate, List<WorkSupplyDataModel> product)
=> new(id, warehouseId, supplyDate, product);
}

79
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WarehouseDataModelTests.cs Normal file
View File

@@ -0,0 +1,79 @@
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
namespace TwoFromTheCasketTests.DataModelsTests;
[TestFixture]
public class WarehouseDataModelTests
{
[Test]
public void WarehouseIdIsNullOrEmptyTest()
{
List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var warehouse = CreateDataModel(null, "Central Warehouse", "123 Main St", WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
warehouse = CreateDataModel(string.Empty, "Central Warehouse", "123 Main St", WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseIdIsNotGuidTest()
{
List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var warehouse = CreateDataModel("1", "Central Warehouse", "123 Main St", WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseNameIsEmptyTest()
{
List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var warehouse = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, "123 Main St", WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseLocationIsEmptyTest()
{
List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WorkWareHouseIsNullOrEmptyTest()
{
var warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, null);
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, new List<WorkWarehouseDataModel>());
Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void AllFieldsAreCorrectTest()
{
var id = Guid.NewGuid().ToString();
var name = "Central Warehouse";
var location = "123 Main St";
List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
var warehouse = CreateDataModel(id, name, location, WorkWareHouse);
Assert.That(() => warehouse.Validate(), Throws.Nothing);
Assert.Multiple(() =>
{
Assert.That(warehouse.Id, Is.EqualTo(id));
Assert.That(warehouse.Name, Is.EqualTo(name));
Assert.That(warehouse.Location, Is.EqualTo(location));
Assert.That(warehouse.WorkWarehouseDataModels, Is.EqualTo(WorkWareHouse));
});
}
private static WarehouseDataModel CreateDataModel(string? id, string name, string location, List<WorkWarehouseDataModel> workWarehouseDataModels)
=> new(id, name, location, workWarehouseDataModels);
}

3
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkDataModelTests.cs
View File

@@ -27,6 +27,7 @@ internal class WorkDataModelTests
[Test]
public void DescriptionIsEmptyTest()
{
var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.Plaster, "", DateTime.Now);
Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
}
@@ -34,6 +35,7 @@ internal class WorkDataModelTests
[Test]
public void DateIsInPastTest()
{
var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.Plaster, "Штукатурка стен", DateTime.Now.AddDays(-1));
Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
}
@@ -41,6 +43,7 @@ internal class WorkDataModelTests
[Test]
public void TypeIsNoneTest()
{
var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.None, "Штукатурка стен", DateTime.Now);
Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
}

71
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkSupplyDataModelTests.cs Normal file
View File

@@ -0,0 +1,71 @@
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
namespace TwoFromTheCasketTests.DataModelsTests;
[TestFixture]
public class WorkSupplyDataModelTests
{
[Test]
public void WorkIdIsNullOrEmptyTest()
{
var workSupply = CreateDataModel(null, Guid.NewGuid().ToString(), 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
workSupply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WorkIdIsNotGuidTest()
{
var workSupply = CreateDataModel("1", Guid.NewGuid().ToString(), 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void SupplyIdIsNullOrEmptyTest()
{
var workSupply = CreateDataModel(Guid.NewGuid().ToString(), null, 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
workSupply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void SupplyIdIsNotGuidTest()
{
var workSupply = CreateDataModel(Guid.NewGuid().ToString(), "1", 10);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void QuantityIsInvalidTest()
{
var workSupply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void AllFieldsAreCorrectTest()
{
var workId = Guid.NewGuid().ToString();
var supplyId = Guid.NewGuid().ToString();
var quantity = 10;
var workSupply = CreateDataModel(workId, supplyId, quantity);
Assert.That(() => workSupply.Validate(), Throws.Nothing);
Assert.Multiple(() =>
{
Assert.That(workSupply.WorkId, Is.EqualTo(workId));
Assert.That(workSupply.SupplyId, Is.EqualTo(supplyId));
Assert.That(workSupply.Quantity, Is.EqualTo(quantity));
});
}
private static WorkSupplyDataModel CreateDataModel(string? workId, string? supplyId, double quantity)
=> new(workId, supplyId, quantity);
}

71
TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkWarehouseDataModelTests.cs Normal file
View File

@@ -0,0 +1,71 @@
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
namespace TwoFromTheCasketTests.DataModelsTests;
[TestFixture]
public class WorkWarehouseDataModelTests
{
[Test]
public void WorkIdIsNullOrEmptyTest()
{
var workWarehouse = CreateDataModel(null, Guid.NewGuid().ToString(), 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
workWarehouse = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WorkIdIsNotGuidTest()
{
var workWarehouse = CreateDataModel("1", Guid.NewGuid().ToString(), 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseIdIsNullOrEmptyTest()
{
var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), null, 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void WarehouseIdIsNotGuidTest()
{
var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), "1", 10);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void QuantityIsInvalidTest()
{
var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
}
[Test]
public void AllFieldsAreCorrectTest()
{
var workId = Guid.NewGuid().ToString();
var warehouseId = Guid.NewGuid().ToString();
var quantity = 10;
var workWarehouse = CreateDataModel(workId, warehouseId, quantity);
Assert.That(() => workWarehouse.Validate(), Throws.Nothing);
Assert.Multiple(() =>
{
Assert.That(workWarehouse.WorkId, Is.EqualTo(workId));
Assert.That(workWarehouse.WarehouseId, Is.EqualTo(warehouseId));
Assert.That(workWarehouse.Quantity, Is.EqualTo(quantity));
});
}
private static WorkWarehouseDataModel CreateDataModel(string? workId, string? warehouseId, double quantity)
=> new(workId, warehouseId, quantity);
}