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

Объединение 3 усложненой и 4 обычной

Browse Source
This commit is contained in:
romtec
2025-04-18 18:26:27 +04:00
parent 06021f5f57 f2139897bc
commit 90ba84d636
54 changed files with 3309 additions and 954 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

@@ -26,7 +26,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();
@@ -38,7 +38,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();
@@ -47,7 +47,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, 0, 0, 0, DateTimeKind.Utc);
var finishDate = new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month), 23, 59, 59, DateTimeKind.Utc);
@@ -71,7 +71,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
var salary = specialization.Salary * totalHours;
_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));
}

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

@@ -5,7 +5,7 @@ public interface IRoomBusinessLogicContract
List<RoomDataModel> GetAllRooms();
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");
}
}

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);
}

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

@@ -0,0 +1,20 @@
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);
void ReserveWorksForComplitedWork(ComplitedWorkDataModel workDataModel);
}

15
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkSupplyStorageContract.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IWorkSupplyStorageContract
{
List<WorkSupplyDataModel> GetListBySupplyId(string supplyId);
void AddElement(WorkSupplyDataModel workSupply);
void DelElement(string workId, string supplyId);
}

18
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkWarehouseStorageContract.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.StorageContracts;
public interface IWorkWarehouseStorageContract
{
List<WorkWarehouseDataModel> GetListByWorkId(string workId);
List<WorkWarehouseDataModel> GetListByWarehouseId(string warehouseId);
WorkWarehouseDataModel? GetElementByWorkAndWarehouse(string workId, string warehouseId);
void AddElement(WorkWarehouseDataModel workWarehouseDataModel);
void UpdElement(WorkWarehouseDataModel workWarehouseDataModel);
void DelElement(string workId, string warehouseId);
}

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);
}

37
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/ComplitedWorkStorageContract.cs
View File

@@ -11,11 +11,14 @@ namespace TwoFromTheCasketDatabase.Implementations;
public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
{
private readonly TwoFromTheCasketDbContext _dbContext;
private readonly IWarehouseStorageContract _warehouseStorage;
private readonly Mapper _mapper;
public ComplitedWorkStorageContract(TwoFromTheCasketDbContext context)
public ComplitedWorkStorageContract(TwoFromTheCasketDbContext context, IWarehouseStorageContract warehouseStorage)
{
_dbContext = context;
_warehouseStorage = warehouseStorage;
var conf = new MapperConfiguration(cfg =>
{
cfg.CreateMap<ComplitedWork, ComplitedWorkDataModel>()
@@ -90,37 +93,19 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
{
try
{
if (complitedWorkDataModel.Workers == null || complitedWorkDataModel.Workers.Count == 0)
if (!_warehouseStorage.CheckWorks(complitedWorkDataModel))
{
throw new ValidationException("The value in the Workers must include workers");
throw new ElementNotFoundException("Not enough work available in warehouses.");
}
if (!_dbContext.Rooms.Any(x => x.Id == complitedWorkDataModel.RoomId))
{
throw new ElementNotFoundException($"Room with ID {complitedWorkDataModel.RoomId} not found.");
}
var complitedWork = _mapper.Map<ComplitedWork>(complitedWorkDataModel);
_dbContext.ComplitedWorks.Add(complitedWork);
foreach (var worker in complitedWorkDataModel.Workers)
{
_dbContext.WorkerComplitedWorks.Add(new WorkerComplitedWork
{
WorkerId = worker.WorkerId,
ComplitedWorkId = complitedWork.Id,
NumberOfWorkingHours = worker.NumberOfWorkingHours
});
}
_warehouseStorage.ReserveWorksForComplitedWork(complitedWorkDataModel);
_dbContext.ComplitedWorks.Add(_mapper.Map<ComplitedWork>(complitedWorkDataModel));
_dbContext.SaveChanges();
}
catch (ValidationException)
{
throw;
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "PK_ComplitedWorks" })
@@ -135,10 +120,6 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
}
}
public void DelElement(string id)
{
try

157
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/SupplyStorageContract.cs Normal file
View File

@@ -0,0 +1,157 @@
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketDatabase.Implementations;
public class SupplyStorageContract : ISupplyStorageContract
{
private readonly TwoFromTheCasketDbContext _dbContext;
private readonly IMapper _mapper;
public SupplyStorageContract(TwoFromTheCasketDbContext context)
{
_dbContext = context;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<SupplyDataModel, Supply>();
cfg.CreateMap<Supply, SupplyDataModel>();
cfg.CreateMap<WorkSupplyDataModel, Work_Supply>();
});
_mapper = new Mapper(config);
}
public List<SupplyDataModel> GetList(DateTime startDate, DateTime endDate, string? warehouseId = null)
{
try
{
var query = _dbContext.Supplies
.Include(x => x.Works)
.Where(x => x.SupplyDate >= startDate && x.SupplyDate <= endDate);
if (!string.IsNullOrEmpty(warehouseId))
query = query.Where(x => x.WarehouseId == warehouseId);
return query
.Select(x => _mapper.Map<SupplyDataModel>(x))
.ToList();
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public SupplyDataModel? GetElementById(string id)
{
try
{
var entity = _dbContext.Supplies
.Include(x => x.Works)
.FirstOrDefault(x => x.Id == id);
return _mapper.Map<SupplyDataModel>(entity);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void AddElement(SupplyDataModel supplyDataModel)
{
try
{
var entity = _mapper.Map<Supply>(supplyDataModel);
_dbContext.Supplies.Add(entity);
foreach (var ws in supplyDataModel.Works)
{
var workSupply = new Work_Supply
{
SupplyId = supplyDataModel.Id,
WorkId = ws.WorkId,
Quantity = (decimal)ws.Quantity
};
_dbContext.WorkSupplyies.Add(workSupply);
var existing = _dbContext.WorkWarehouses
.FirstOrDefault(x => x.WorkId == ws.WorkId && x.WarehouseId == supplyDataModel.WarehouseId);
if (existing != null)
{
existing.Quantity += (decimal)ws.Quantity;
_dbContext.WorkWarehouses.Update(existing);
}
else
{
_dbContext.WorkWarehouses.Add(new Work_Warehouse
{
WorkId = ws.WorkId,
WarehouseId = supplyDataModel.WarehouseId,
Quantity = (decimal)ws.Quantity
});
}
}
_dbContext.SaveChanges();
}
catch (DbUpdateException ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void DelElement(string id)
{
try
{
var supply = _dbContext.Supplies
.Include(x => x.Works)
.FirstOrDefault(x => x.Id == id)
?? throw new ElementNotFoundException(id);
foreach (var ws in supply.Works)
{
var warehouseItem = _dbContext.WorkWarehouses
.FirstOrDefault(x => x.WarehouseId == supply.WarehouseId && x.WorkId == ws.WorkId);
if (warehouseItem != null)
{
warehouseItem.Quantity -= ws.Quantity;
if (warehouseItem.Quantity < 0)
warehouseItem.Quantity = 0;
}
}
_dbContext.WorkSupplyies.RemoveRange(supply.Works);
_dbContext.Supplies.Remove(supply);
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
}

213
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WarehouseStorageContract.cs Normal file
View File

@@ -0,0 +1,213 @@
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketDatabase.Implementations
{
public class WarehouseStorageContract : IWarehouseStorageContract
{
private readonly TwoFromTheCasketDbContext _dbContext;
private readonly Mapper _mapper;
public WarehouseStorageContract(TwoFromTheCasketDbContext context)
{
_dbContext = context;
var conf = new MapperConfiguration(cfg =>
{
cfg.CreateMap<WarehouseDataModel, Warehouse>();
cfg.CreateMap<Warehouse, WarehouseDataModel>();
});
_mapper = new Mapper(conf);
}
public List<WarehouseDataModel> GetListByLocation(string location)
{
try
{
return [.. _dbContext.Warehouses
.Where(w => w.Location == location)
.Select(w => _mapper.Map<WarehouseDataModel>(w))];
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public List<WarehouseDataModel> GetListByName(string name)
{
try
{
return [.. _dbContext.Warehouses
.Where(w => w.Name == name)
.Select(w => _mapper.Map<WarehouseDataModel>(w))];
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public WarehouseDataModel? GetElementById(string id)
{
try
{
var warehouse = _dbContext.Warehouses.FirstOrDefault(w => w.Id == id);
return _mapper.Map<WarehouseDataModel>(warehouse);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void AddElement(WarehouseDataModel warehouseDataModel)
{
try
{
_dbContext.Warehouses.Add(_mapper.Map<Warehouse>(warehouseDataModel));
_dbContext.SaveChanges();
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Warehouses_Name_Location" })
{
_dbContext.ChangeTracker.Clear();
throw new ElementExistsException("Name", warehouseDataModel.Name);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void UpdElement(WarehouseDataModel warehouseDataModel)
{
try
{
var existingWarehouse = _dbContext.Warehouses
.FirstOrDefault(w => w.Id == warehouseDataModel.Id)
?? throw new ElementNotFoundException(warehouseDataModel.Id);
_dbContext.Warehouses.Update(_mapper.Map(warehouseDataModel, existingWarehouse));
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Warehouses_Name_Location" })
{
_dbContext.ChangeTracker.Clear();
throw new ElementExistsException("Name", warehouseDataModel.Name);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void DelElement(string id)
{
try
{
var warehouse = _dbContext.Warehouses.FirstOrDefault(w => w.Id == id)
?? throw new ElementNotFoundException(id);
_dbContext.Warehouses.Remove(warehouse);
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public bool CheckWorks(ComplitedWorkDataModel workDataModel)
{
try
{
var requiredWork = _dbContext.Works
.FirstOrDefault(w => w.Id == workDataModel.WorkId)
?? throw new ElementNotFoundException(workDataModel.WorkId);
var availableWorkQuantities = _dbContext.WorkWarehouses
.Where(ww => ww.WorkId == requiredWork.Id)
.ToList();
var totalAvailable = availableWorkQuantities.Sum(ww => ww.Quantity);
return totalAvailable > 0;
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void ReserveWorksForComplitedWork(ComplitedWorkDataModel workDataModel)
{
try
{
var requiredWork = _dbContext.Works
.FirstOrDefault(w => w.Id == workDataModel.WorkId)
?? throw new ElementNotFoundException(workDataModel.WorkId);
var workStocks = _dbContext.WorkWarehouses
.Where(ww => ww.WorkId == requiredWork.Id)
.OrderByDescending(ww => ww.Quantity)
.ToList();
int requiredQuantity = 1;
foreach (var stock in workStocks)
{
if (requiredQuantity <= 0) break;
int taken = (int)Math.Min(stock.Quantity, requiredQuantity);
stock.Quantity -= taken;
requiredQuantity -= taken;
}
if (requiredQuantity > 0)
{
throw new ElementNotFoundException("Not enough work");
}
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
}
}

122
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WorkSupplyStorageContract.cs Normal file
View File

@@ -0,0 +1,122 @@
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketDatabase.Implementations;
public class WorkSupplyStorageContract : IWorkSupplyStorageContract
{
private readonly TwoFromTheCasketDbContext _dbContext;
private readonly Mapper _mapper;
public WorkSupplyStorageContract(TwoFromTheCasketDbContext context)
{
_dbContext = context;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Work_Supply, WorkSupplyDataModel>();
cfg.CreateMap<WorkSupplyDataModel, Work_Supply>();
});
_mapper = new Mapper(config);
}
public List<WorkSupplyDataModel> GetListBySupplyId(string supplyId)
{
try
{
var list = _dbContext.WorkSupplyies
.Where(x => x.SupplyId == supplyId)
.ToList();
return list.Select(x => _mapper.Map<WorkSupplyDataModel>(x)).ToList();
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void AddElement(WorkSupplyDataModel workSupply)
{
try
{
var entity = _mapper.Map<Work_Supply>(workSupply);
_dbContext.WorkSupplyies.Add(entity);
var warehouseId = _dbContext.Supplies
.Where(s => s.Id == workSupply.SupplyId)
.Select(s => s.WarehouseId)
.FirstOrDefault();
if (warehouseId == null)
throw new ElementNotFoundException("SupplyId not linked to any Warehouse");
var warehouseWork = _dbContext.WorkWarehouses
.FirstOrDefault(x => x.WorkId == workSupply.WorkId && x.WarehouseId == warehouseId);
if (warehouseWork != null)
{
warehouseWork.Quantity += (decimal)workSupply.Quantity;
}
else
{
_dbContext.WorkWarehouses.Add(new Work_Warehouse
{
WorkId = workSupply.WorkId,
WarehouseId = warehouseId,
Quantity = (decimal)workSupply.Quantity
});
}
_dbContext.SaveChanges();
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void DelElement(string workId, string supplyId)
{
try
{
var entity = _dbContext.WorkSupplyies
.FirstOrDefault(x => x.WorkId == workId && x.SupplyId == supplyId)
?? throw new ElementNotFoundException($"Work_Supply: WorkId={workId}, SupplyId={supplyId}");
var supply = _dbContext.Supplies.FirstOrDefault(x => x.Id == supplyId)
?? throw new ElementNotFoundException(supplyId);
var warehouseWork = _dbContext.WorkWarehouses
.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == supply.WarehouseId);
if (warehouseWork != null)
{
warehouseWork.Quantity -= entity.Quantity;
if (warehouseWork.Quantity < 0)
warehouseWork.Quantity = 0;
}
_dbContext.WorkSupplyies.Remove(entity);
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
}

138
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WorkWarehouseStorageContract.cs Normal file
View File

@@ -0,0 +1,138 @@
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketDatabase.Implementations;
public class WorkWarehouseStorageContract : IWorkWarehouseStorageContract
{
private readonly TwoFromTheCasketDbContext _dbContext;
private readonly Mapper _mapper;
public WorkWarehouseStorageContract(TwoFromTheCasketDbContext context)
{
_dbContext = context;
var conf = new MapperConfiguration(cfg =>
{
cfg.CreateMap<WorkWarehouseDataModel, Work_Warehouse>();
cfg.CreateMap<Work_Warehouse, WorkWarehouseDataModel>();
});
_mapper = new Mapper(conf);
}
public List<WorkWarehouseDataModel> GetListByWorkId(string workId)
{
try
{
return [.. _dbContext.WorkWarehouses
.Where(x => x.WorkId == workId)
.Select(x => _mapper.Map<WorkWarehouseDataModel>(x))];
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public List<WorkWarehouseDataModel> GetListByWarehouseId(string warehouseId)
{
try
{
return [.. _dbContext.WorkWarehouses
.Where(x => x.WarehouseId == warehouseId)
.Select(x => _mapper.Map<WorkWarehouseDataModel>(x))];
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public WorkWarehouseDataModel? GetElementByWorkAndWarehouse(string workId, string warehouseId)
{
try
{
var workWarehouse = _dbContext.WorkWarehouses
.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouseId);
return _mapper.Map<WorkWarehouseDataModel>(workWarehouse);
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void AddElement(WorkWarehouseDataModel workWarehouseDataModel)
{
try
{
_dbContext.WorkWarehouses.Add(_mapper.Map<Work_Warehouse>(workWarehouseDataModel));
_dbContext.SaveChanges();
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "PK_Work_Warehouse" })
{
_dbContext.ChangeTracker.Clear();
throw new ElementExistsException("WorkWarehouse", $"{workWarehouseDataModel.WorkId}, {workWarehouseDataModel.WarehouseId}");
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void UpdElement(WorkWarehouseDataModel workWarehouseDataModel)
{
try
{
var element = _dbContext.WorkWarehouses.FirstOrDefault(x => x.WorkId == workWarehouseDataModel.WorkId &&
x.WarehouseId == workWarehouseDataModel.WarehouseId)
?? throw new ElementNotFoundException($"{workWarehouseDataModel.WorkId}, {workWarehouseDataModel.WarehouseId}");
element.Quantity = (decimal)workWarehouseDataModel.Quantity;
_dbContext.WorkWarehouses.Update(element);
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
public void DelElement(string workId, string warehouseId)
{
try
{
var element = _dbContext.WorkWarehouses.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouseId)
?? throw new ElementNotFoundException($"{workId}, {warehouseId}");
_dbContext.WorkWarehouses.Remove(element);
_dbContext.SaveChanges();
}
catch (ElementNotFoundException)
{
_dbContext.ChangeTracker.Clear();
throw;
}
catch (Exception ex)
{
_dbContext.ChangeTracker.Clear();
throw new StorageException(ex);
}
}
}

17
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Supply.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TwoFromTheCasketDatabase.Models;
public class Supply
{
public required string Id { get; set; }
public required string WarehouseId { get; set; }
public DateTime SupplyDate { get; set; }
public Warehouse? Warehouse { get; set; }
public List<Work_Supply>? Works { get; set; }
}

17
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Warehouse.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TwoFromTheCasketDatabase.Models;
public class Warehouse
{
public required string Id { get; set; }
public required string Name { get; set; }
public required string Location { get; set; }
public List<Supply>? Supplies { get; set; }
public List<Work_Warehouse>? WorkWarehouses { get; set; }
}

4
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work.cs
View File

@@ -21,4 +21,8 @@ public class Work
public DateTime Date { get; set; }
public List<ComplitedWork>? ComplitedWorks { get; set; }
public List<Work_Supply>? WorkSupplies { get; set; }
public List<Work_Warehouse>? WorkWarehouses { get; set; }
}

17
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work_Supply.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TwoFromTheCasketDatabase.Models;
public class Work_Supply
{
public required string WorkId { get; set; }
public required string SupplyId { get; set; }
public decimal Quantity { get; set; }
public Work? Work { get; set; }
public Supply? Supply { get; set; }
}

17
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work_Warehouse.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TwoFromTheCasketDatabase.Models;
public class Work_Warehouse
{
public required string WorkId { get; set; }
public required string WarehouseId { get; set; }
public decimal Quantity { get; set; }
public Work? Work { get; set; }
public Warehouse? Warehouse { get; set; }
}

40
TwoFromTheCasketContracts/TwoFromTheCasketDatabase/TwoFromTheCasketDbContext.cs
View File

@@ -66,6 +66,42 @@ public class TwoFromTheCasketDbContext : DbContext
modelBuilder.Entity<Specialization>()
.HasIndex(s => s.SpecializationName)
.IsUnique();
modelBuilder.Entity<Work_Supply>()
.HasKey(ws => new { ws.WorkId, ws.SupplyId });
modelBuilder.Entity<Work_Warehouse>()
.HasKey(ww => new { ww.WorkId, ww.WarehouseId });
modelBuilder.Entity<Warehouse>()
.HasMany(w => w.Supplies)
.WithOne(s => s.Warehouse)
.HasForeignKey(s => s.WarehouseId);
modelBuilder.Entity<Warehouse>()
.HasMany(w => w.WorkWarehouses)
.WithOne(ww => ww.Warehouse)
.HasForeignKey(ww => ww.WarehouseId);
modelBuilder.Entity<Supply>()
.HasMany(s => s.Works)
.WithOne(ws => ws.Supply)
.HasForeignKey(ws => ws.SupplyId);
modelBuilder.Entity<Work>()
.HasMany(w => w.ComplitedWorks)
.WithOne(cw => cw.Work)
.HasForeignKey(cw => cw.WorkId);
modelBuilder.Entity<Work>()
.HasMany(w => w.WorkSupplies)
.WithOne(ws => ws.Work)
.HasForeignKey(ws => ws.WorkId);
modelBuilder.Entity<Work>()
.HasMany(w => w.WorkWarehouses)
.WithOne(ww => ww.Work)
.HasForeignKey(ww => ww.WorkId);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
@@ -82,4 +118,8 @@ public class TwoFromTheCasketDbContext : DbContext
public DbSet<Work> Works { get; set; }
public DbSet<Worker> Workers { get; set; }
public DbSet<WorkerComplitedWork> WorkerComplitedWorks { get; set; }
public DbSet<Warehouse> Warehouses { get; set; }
public DbSet<Work_Warehouse> WorkWarehouses { get; set; }
public DbSet<Work_Supply> WorkSupplyies { get; set; }
public DbSet<Supply> Supplies { get; set; }
}

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);
}

93
TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/ComplitedWorkStorageContractTests.cs
View File

@@ -1,9 +1,11 @@
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;
using System.Net;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Enums;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
using TwoFromTheCasketDatabase.Implementations;
using TwoFromTheCasketDatabase.Models;
@@ -13,11 +15,17 @@ namespace TwoFromTheCasketTests.StorageContracts;
public class ComplitedWorkStorageContractTests : BaseStorageContractTest
{
private ComplitedWorkStorageContract _complitedWorkStorageContract;
private Mock<IWarehouseStorageContract> _warehouseStorageMock;
[SetUp]
public void SetUp()
{
_complitedWorkStorageContract = new ComplitedWorkStorageContract(TwoFromTheCasketDb);
_warehouseStorageMock = new Mock<IWarehouseStorageContract>();
_complitedWorkStorageContract = new ComplitedWorkStorageContract(
TwoFromTheCasketDb,
_warehouseStorageMock.Object
);
}
[TearDown]
@@ -56,17 +64,6 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
Assert.That(element, Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString());
_complitedWorkStorageContract.AddElement(complitedWorkDataModel);
var element = GetComplitedWorkFromDatabase(complitedWorkDataModel.Id);
AssertElement(element, complitedWorkDataModel);
}
[Test]
public void Try_AddElement_WhenWorkersAreEmpty_Test()
{
@@ -84,6 +81,45 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
Throws.TypeOf<ValidationException>());
}
[Test]
public void Try_AddElement_WhenEnoughWorkAvailable_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse1 = InsertWarehouseToDatabase();
var warehouse2 = InsertWarehouseToDatabase();
InsertWorkToWarehouse(warehouse1.Id, workId, 2);
InsertWorkToWarehouse(warehouse2.Id, workId, 3);
var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString(), workId);
_complitedWorkStorageContract.AddElement(complitedWorkDataModel);
var element = GetComplitedWorkFromDatabase(complitedWorkDataModel.Id);
Assert.That(element, Is.Not.Null);
var remainingWork1 = GetWorkQuantityFromWarehouse(warehouse1.Id, workId);
var remainingWork2 = GetWorkQuantityFromWarehouse(warehouse2.Id, workId);
Assert.That(remainingWork1 + remainingWork2, Is.EqualTo(4));
}
[Test]
public void Try_AddElement_WhenNotEnoughWorkAvailable_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse = InsertWarehouseToDatabase();
InsertWorkToWarehouse(warehouse.Id, workId, 0);
var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString(), workId);
Assert.That(() => _complitedWorkStorageContract.AddElement(complitedWorkDataModel),
Throws.TypeOf<StorageException>().With.Message.Contains("Not enough work available"));
}
[Test]
public void Try_DelElement_Test()
@@ -242,6 +278,39 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
return worker;
}
private Warehouse InsertWarehouseToDatabase(string name = "Test Warehouse", string location = "Test Location")
{
var warehouse = new Warehouse
{
Id = Guid.NewGuid().ToString(),
Name = name,
Location = location
};
TwoFromTheCasketDb.Warehouses.Add(warehouse);
TwoFromTheCasketDb.SaveChanges();
return warehouse;
}
private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
{
var workWarehouse = new Work_Warehouse
{
WorkId = workId,
WarehouseId = warehouseId,
Quantity = quantity
};
TwoFromTheCasketDb.WorkWarehouses.Add(workWarehouse);
TwoFromTheCasketDb.SaveChanges();
}
private int GetWorkQuantityFromWarehouse(string warehouseId, string workId)
{
return (int)TwoFromTheCasketDb.WorkWarehouses
.Where(x => x.WarehouseId == warehouseId && x.WorkId == workId)
.Select(x => x.Quantity)
.FirstOrDefault();
}
private TwoFromTheCasketDatabase.Models.Specialization InsertSpecializationToDatabase(string id, string name = null, double salary = 50000)
{

246
TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/SupplyStorageContractTests.cs Normal file
View File

@@ -0,0 +1,246 @@
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketDatabase.Implementations;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketTests.StorageContracts;
[TestFixture]
public class SupplyStorageContractTests : BaseStorageContractTest
{
private SupplyStorageContract _supplyStorageContract;
[SetUp]
public void SetUp()
{
_supplyStorageContract = new SupplyStorageContract(TwoFromTheCasketDb);
}
[TearDown]
public void TearDown()
{
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"WorkSupplyies\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Supplies\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Work_Warehouses\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
}
[Test]
public void Try_GetList_WhenHaveRecords_Test()
{
var warehouse1 = InsertWarehouse("MainWarehouse", "Moscow");
var supply1 = InsertSupply(warehouse1.Id, DateTime.UtcNow.AddDays(-3));
var supply2 = InsertSupply(warehouse1.Id, DateTime.UtcNow.AddDays(-1));
var list = _supplyStorageContract.GetList(
DateTime.UtcNow.AddDays(-7),
DateTime.UtcNow.AddDays(1),
warehouse1.Id
);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(2));
AssertElement(list.FirstOrDefault(x => x.Id == supply1.Id), supply1);
AssertElement(list.FirstOrDefault(x => x.Id == supply2.Id), supply2);
}
[Test]
public void Try_GetList_WhenNoRecords_Test()
{
var warehouse = InsertWarehouse("SomeWarehouse", "SPB");
var list = _supplyStorageContract.GetList(
DateTime.UtcNow.AddDays(-7),
DateTime.UtcNow.AddDays(1),
warehouse.Id
);
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
var supply = InsertSupply(warehouse.Id, DateTime.UtcNow);
var element = _supplyStorageContract.GetElementById(supply.Id);
AssertElement(element, supply);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
var element = _supplyStorageContract.GetElementById(Guid.NewGuid().ToString());
Assert.That(element, Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
var supply = CreateSupplyDataModel(warehouse.Id);
_supplyStorageContract.AddElement(supply);
var fromDb = TwoFromTheCasketDb.Supplies
.Include(x => x.Works)
.FirstOrDefault(x => x.Id == supply.Id);
Assert.That(fromDb, Is.Not.Null);
AssertElement(fromDb, supply);
var workId = supply.Works[0].WorkId;
var whItem = TwoFromTheCasketDb.WorkWarehouses
.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == supply.WarehouseId);
Assert.That(whItem, Is.Not.Null);
Assert.That(whItem.Quantity, Is.EqualTo(supply.Works[0].Quantity));
}
[Test]
public void Try_DelElement_Test()
{
var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
var supply = InsertSupply(warehouse.Id, DateTime.UtcNow);
var workId = InsertWork().Id;
InsertWorkSupply(supply.Id, workId, 5);
InsertWorkToWarehouse(warehouse.Id, workId, 5);
_supplyStorageContract.DelElement(supply.Id);
var fromDb = TwoFromTheCasketDb.Supplies
.FirstOrDefault(x => x.Id == supply.Id);
Assert.That(fromDb, Is.Null);
var ws = TwoFromTheCasketDb.WorkSupplyies
.FirstOrDefault(x => x.SupplyId == supply.Id && x.WorkId == workId);
Assert.That(ws, Is.Null);
var whItem = TwoFromTheCasketDb.WorkWarehouses
.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouse.Id);
Assert.That(whItem.Quantity, Is.EqualTo(0));
}
[Test]
public void Try_DelElement_WhenNoRecord_Test()
{
Assert.That(() => _supplyStorageContract.DelElement(Guid.NewGuid().ToString()),
Throws.TypeOf<ElementNotFoundException>());
}
private Warehouse InsertWarehouse(string name, string location)
{
var warehouse = new Warehouse
{
Id = Guid.NewGuid().ToString(),
Name = name,
Location = location
};
TwoFromTheCasketDb.Warehouses.Add(warehouse);
TwoFromTheCasketDb.SaveChanges();
return warehouse;
}
private Supply InsertSupply(string warehouseId, DateTime supplyDate)
{
var supply = new Supply
{
Id = Guid.NewGuid().ToString(),
WarehouseId = warehouseId,
SupplyDate = supplyDate
};
TwoFromTheCasketDb.Supplies.Add(supply);
TwoFromTheCasketDb.SaveChanges();
return supply;
}
private Work InsertWork(string desc = "Some work")
{
var work = new Work
{
Id = Guid.NewGuid().ToString(),
Type = TwoFromTheCasketContracts.Enums.TypeWork.None,
Description = desc,
Date = DateTime.UtcNow
};
TwoFromTheCasketDb.Works.Add(work);
TwoFromTheCasketDb.SaveChanges();
return work;
}
private void InsertWorkSupply(string supplyId, string workId, int quantity)
{
var ws = new Work_Supply
{
WorkId = workId,
SupplyId = supplyId,
Quantity = quantity
};
TwoFromTheCasketDb.WorkSupplyies.Add(ws);
TwoFromTheCasketDb.SaveChanges();
}
private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
{
var existing = TwoFromTheCasketDb.WorkWarehouses
.FirstOrDefault(x => x.WarehouseId == warehouseId && x.WorkId == workId);
if (existing != null)
{
existing.Quantity += quantity;
}
else
{
var ww = new Work_Warehouse
{
WorkId = workId,
WarehouseId = warehouseId,
Quantity = quantity
};
TwoFromTheCasketDb.WorkWarehouses.Add(ww);
}
TwoFromTheCasketDb.SaveChanges();
}
private SupplyDataModel CreateSupplyDataModel(string warehouseId)
{
var workId = InsertWork().Id;
return new SupplyDataModel(
Guid.NewGuid().ToString(),
warehouseId,
DateTime.UtcNow,
new List<WorkSupplyDataModel>
{
new WorkSupplyDataModel(workId, Guid.NewGuid().ToString(), 5)
}
);
}
private void AssertElement(Supply? actual, SupplyDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual!.Id, Is.EqualTo(expected.Id));
Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
Assert.That(actual.SupplyDate, Is.EqualTo(expected.SupplyDate).Within(1).Seconds);
});
}
private void AssertElement(SupplyDataModel? actual, Supply expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual!.Id, Is.EqualTo(expected.Id));
Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
Assert.That(actual.SupplyDate, Is.EqualTo(expected.SupplyDate).Within(1).Seconds);
});
}
}

284
TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/WarehouseStorageContract.cs Normal file
View File

@@ -0,0 +1,284 @@
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketDatabase.Implementations;
using TwoFromTheCasketDatabase.Models;
namespace TwoFromTheCasketTests.StorageContracts;
[TestFixture]
public class WarehouseStorageContractTests : BaseStorageContractTest
{
private WarehouseStorageContract _warehouseStorageContract;
[SetUp]
public void SetUp()
{
_warehouseStorageContract = new WarehouseStorageContract(TwoFromTheCasketDb);
}
[TearDown]
public void TearDown()
{
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Work_Warehouses\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"ComplitedWorks\" CASCADE;");
}
[Test]
public void Try_GetListByLocation_WhenHaveRecords_Test()
{
var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
InsertWarehouseToDatabase("Склад2", "Moscow");
InsertWarehouseToDatabase("Склад3", "SPB");
var list = _warehouseStorageContract.GetListByLocation("Moscow");
Assert.That(list, Is.Not.Null);
Assert.That(list.Count, Is.EqualTo(2));
AssertElement(list.First(x => x.Id == warehouse1.Id), warehouse1);
}
[Test]
public void Try_GetListByLocation_WhenNoRecord_Test()
{
InsertWarehouseToDatabase("Склад1", "SPB");
var list = _warehouseStorageContract.GetListByLocation("Moscow");
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetListByName_WhenHaveRecords_Test()
{
var warehouse1 = InsertWarehouseToDatabase("MainStorage", "Moscow");
InsertWarehouseToDatabase("MainStorage", "SPB");
InsertWarehouseToDatabase("OtherStorage", "SPB");
var list = _warehouseStorageContract.GetListByName("MainStorage");
Assert.That(list, Is.Not.Null);
Assert.That(list.Count, Is.EqualTo(2));
AssertElement(list.First(x => x.Id == warehouse1.Id), warehouse1);
}
[Test]
public void Try_GetListByName_WhenNoRecord_Test()
{
InsertWarehouseToDatabase("RandomStorage", "SPB");
var list = _warehouseStorageContract.GetListByName("MainStorage");
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.Empty);
}
[Test]
public void Try_GetElementById_WhenHaveRecord_Test()
{
var warehouse = InsertWarehouseToDatabase("Склад1", "Moscow");
var element = _warehouseStorageContract.GetElementById(warehouse.Id);
AssertElement(element, warehouse);
}
[Test]
public void Try_GetElementById_WhenNoRecord_Test()
{
var element = _warehouseStorageContract.GetElementById(Guid.NewGuid().ToString());
Assert.That(element, Is.Null);
}
[Test]
public void Try_AddElement_Test()
{
var warehouseData = new WarehouseDataModel(Guid.NewGuid().ToString(), "Склад1", "Moscow", new List<WorkWarehouseDataModel>());
_warehouseStorageContract.AddElement(warehouseData);
var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouseData.Id);
Assert.That(fromDb, Is.Not.Null);
AssertElement(fromDb, warehouseData);
}
[Test]
public void Try_UpdElement_Test()
{
var warehouse = InsertWarehouseToDatabase("Склад1", "Moscow");
var updated = new WarehouseDataModel(warehouse.Id, "NewName", "Kazan", new List<WorkWarehouseDataModel>());
_warehouseStorageContract.UpdElement(updated);
var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouse.Id);
AssertElement(fromDb, updated);
}
[Test]
public void Try_DelElement_Test()
{
var warehouse = InsertWarehouseToDatabase("СкладForDel", "Location");
_warehouseStorageContract.DelElement(warehouse.Id);
var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouse.Id);
Assert.That(fromDb, Is.Null);
}
[Test]
public void Try_CheckWorks_WhenEnough_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
var warehouse2 = InsertWarehouseToDatabase("Склад2", "Moscow");
InsertWorkToWarehouse(warehouse1.Id, workId, 2);
InsertWorkToWarehouse(warehouse2.Id, workId, 3);
var complitedWork = CreateComplitedWork(workId);
var checkResult = _warehouseStorageContract.CheckWorks(complitedWork);
Assert.That(checkResult, Is.True);
}
[Test]
public void Try_CheckWorks_WhenNotEnough_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse = InsertWarehouseToDatabase("Склад1", "Location");
InsertWorkToWarehouse(warehouse.Id, workId, 0);
var complitedWork = CreateComplitedWork(workId);
var checkResult = _warehouseStorageContract.CheckWorks(complitedWork);
Assert.That(checkResult, Is.False);
}
[Test]
public void Try_ReserveWorksForComplitedWork_WhenEnough_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
var warehouse2 = InsertWarehouseToDatabase("Склад2", "SPB");
InsertWorkToWarehouse(warehouse1.Id, workId, 2);
InsertWorkToWarehouse(warehouse2.Id, workId, 3);
var complitedWork = CreateComplitedWork(workId);
_warehouseStorageContract.ReserveWorksForComplitedWork(complitedWork);
var total = TwoFromTheCasketDb.WorkWarehouses
.Where(x => x.WorkId == workId)
.Sum(x => x.Quantity);
Assert.That(total, Is.EqualTo(4));
}
[Test]
public void Try_ReserveWorksForComplitedWork_WhenNotEnough_Test()
{
var workId = Guid.NewGuid().ToString();
InsertWorkToDatabase(workId);
var warehouse = InsertWarehouseToDatabase("Склад1", "Location");
InsertWorkToWarehouse(warehouse.Id, workId, 0);
var complitedWork = CreateComplitedWork(workId);
Assert.That(() => _warehouseStorageContract.ReserveWorksForComplitedWork(complitedWork),
Throws.TypeOf<StorageException>().With.Message.Contains("Not enough work available"));
}
private Warehouse InsertWarehouseToDatabase(string name, string location)
{
var entity = new Warehouse
{
Id = Guid.NewGuid().ToString(),
Name = name,
Location = location
};
TwoFromTheCasketDb.Warehouses.Add(entity);
TwoFromTheCasketDb.SaveChanges();
return entity;
}
private Work InsertWorkToDatabase(string workId, string description = "Test work")
{
var work = new Work
{
Id = workId,
Type = TwoFromTheCasketContracts.Enums.TypeWork.None,
Description = description,
Date = DateTime.UtcNow
};
TwoFromTheCasketDb.Works.Add(work);
TwoFromTheCasketDb.SaveChanges();
return work;
}
private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
{
var existing = TwoFromTheCasketDb.WorkWarehouses
.FirstOrDefault(x => x.WarehouseId == warehouseId && x.WorkId == workId);
if (existing == null)
{
TwoFromTheCasketDb.WorkWarehouses.Add(new Work_Warehouse
{
WarehouseId = warehouseId,
WorkId = workId,
Quantity = quantity
});
}
else
{
existing.Quantity += quantity;
}
TwoFromTheCasketDb.SaveChanges();
}
private ComplitedWorkDataModel CreateComplitedWork(string workId)
{
return new ComplitedWorkDataModel(
Guid.NewGuid().ToString(),
workId,
Guid.NewGuid().ToString(),
new List<WorkerComplitedWorkDataModel>
{
new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 8)
}
);
}
private static void AssertElement(WarehouseDataModel? actual, Warehouse expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual!.Id, Is.EqualTo(expected.Id));
Assert.That(actual.Name, Is.EqualTo(expected.Name));
Assert.That(actual.Location, Is.EqualTo(expected.Location));
});
}
private static void AssertElement(Warehouse? actual, WarehouseDataModel expected)
{
Assert.That(actual, Is.Not.Null);
Assert.Multiple(() =>
{
Assert.That(actual!.Id, Is.EqualTo(expected.Id));
Assert.That(actual.Name, Is.EqualTo(expected.Name));
Assert.That(actual.Location, Is.EqualTo(expected.Location));
});
}
}