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

Добавил тесты и ошибки

Browse Source
This commit is contained in:
romtec
2025-02-20 17:26:40 +04:00
parent 71bdeaee7c
commit 92adcaabcd
36 changed files with 3483 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,10 +1,12 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class ComplitedWorkBusinessLogicContract : IComplitedWorkBusinessLogicContract
internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract _complitedWorkStorageContract) : IComplitedWorkBusinessLogicContract
{
private IComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
public List<ComplitedWorkDataModel> GetAllComplitedWorks()
{
return [];
@@ -39,10 +41,6 @@ internal class ComplitedWorkBusinessLogicContract : IComplitedWorkBusinessLogicC
{
}
public void UpdateComplitedWork(ComplitedWorkDataModel complitedWorkDataModel)
{
}
public void DeleteComplitedWork(string id)
{
}

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

@@ -1,10 +1,12 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class RoomBusinessLogicContract : IRoomBusinessLogicContract
internal class RoomBusinessLogicContract(IRoomStorageContract _roomStorageContract) : IRoomBusinessLogicContract
{
private IRoomStorageContract roomStorageContract = _roomStorageContract;
public List<RoomDataModel> GetAllRooms()
{
return [];

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

@@ -1,10 +1,12 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class RoomHistoryBusinessLogicContract : IRoomHistoryBusinessLogicContract
internal class RoomHistoryBusinessLogicContract(IRoomHistoryStorageContract _roomHistoryStorageContract) : IRoomHistoryBusinessLogicContract
{
private IRoomHistoryStorageContract roomHistoryStorageContract = _roomHistoryStorageContract;
public List<RoomHistoryDataModel> GetRoomHistory(string roomId)
{
return [];

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

@@ -1,10 +1,16 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class SalaryBusinessLogicContract : ISalaryBusinessLogicContract
internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorageContract, IWorkerStorageContract _workerStorageContract,
IComplitedWorkStorageContract _сomplitedWorkStorageContract, ISpecializationStorageContract _specializationStorageContract) : ISalaryBusinessLogicContract
{
private ISalaryStorageContract salaryStorageContract = _salaryStorageContract;
private IWorkerStorageContract workerStorageContract = _workerStorageContract;
private IComplitedWorkStorageContract сomplitedWorkStorageContract = _сomplitedWorkStorageContract;
private ISpecializationStorageContract specializationStorageContract = _specializationStorageContract;
public List<SalaryDataModel> GetSalariesByPeriod(DateTime fromDate, DateTime toDate)
{
return [];
@@ -17,5 +23,6 @@ internal class SalaryBusinessLogicContract : ISalaryBusinessLogicContract
public void CalculateSalaryByMonth(DateTime date)
{
return;
}
}

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

@@ -1,21 +1,28 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class SpecializationBusinessLogicContract : ISpecializationBusinessLogicContract
internal class SpecializationBusinessLogicContract(ISpecializationStorageContract _specializationStorageContract) : ISpecializationBusinessLogicContract
{
private ISpecializationStorageContract specializationStorageContract = _specializationStorageContract;
public List<Specialization> GetAllSpecializations(bool onlyActual = true)
{
return [];
}
public Specialization GetLatestSpecialization(string specializationId)
public Specialization GetLatestSpecializationById(string specializationId)
{
return new Specialization("", "", "", 0, true, DateTime.Now);
}
public void AddSpecialization(string specializationId, string name, double salary)
public Specialization GetLatestSpecializationByName(string specializationyName)
{
return new Specialization("", "", "", 0, true, DateTime.Now);
}
public void AddSpecialization(Specialization specializationId)
{
}

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

@@ -1,16 +1,18 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class WorkBusinessLogicContract : IWorkBusinessLogicContract
internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContract) : IWorkBusinessLogicContract
{
private IWorkStorageContract workStorageContract = _workStorageContract;
public List<WorkDataModel> GetAllWorks()
{
return [];
}
public WorkDataModel GetWorkByData(string data)
public WorkDataModel GetWorkByData(DateTime dataFrom, DateTime dataTo)
{
return new WorkDataModel("", TwoFromTheCasketContracts.Enums.TypeWork.Carpentry, "", DateTime.Now);
}

5
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WorkerBusinessLogicContract.cs
View File

@@ -1,12 +1,13 @@

using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class WorkerBusinessLogicContract : IWorkerBusinessLogicContract
internal class WorkerBusinessLogicContract(IWorkerStorageContract _workerStorageContract) : IWorkerBusinessLogicContract
{
private IWorkerStorageContract workerStorageContract = _workerStorageContract;
public List<WorkerDataModel> GetAllWorkers(bool onlyActive = true)
{

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

@@ -1,14 +1,12 @@
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketBusinessLogic.Implementation;
internal class WorkerComplitedWorkBusinessLogicContract : IWorkerComplitedWorkBusinessLogicContract
internal class WorkerComplitedWorkBusinessLogicContract(IWorkerComplitedWorkStorageContract _complitedWorkStorageContract) : IWorkerComplitedWorkBusinessLogicContract
{
public List<WorkerComplitedWorkDataModel> GetAllWorkerComplitedWorks()
{
return [];
}
private IWorkerComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
public List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId)
{
@@ -20,11 +18,6 @@ internal class WorkerComplitedWorkBusinessLogicContract : IWorkerComplitedWorkBu
return [];
}
public WorkerComplitedWorkDataModel GetWorkerComplitedWorkByData(string data)
{
return new WorkerComplitedWorkDataModel("", "", 0);
}
public void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel)
{
}
@@ -37,4 +30,5 @@ internal class WorkerComplitedWorkBusinessLogicContract : IWorkerComplitedWorkBu
{
}
}

2
TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/TwoFromTheCasketBusinessLogic.csproj
View File

@@ -8,6 +8,8 @@
<ItemGroup>
<ProjectReference Include="..\TwoFromTheCasketContracts\TwoFromTheCasketContracts.csproj" />
<InternalsVisibleTo Include="TwoFromTheCasketTests" />
<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
</ItemGroup>
</Project>

1
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IComplitedWorkBusinessLogicContract.cs
View File

@@ -10,6 +10,5 @@ public interface IComplitedWorkBusinessLogicContract
ComplitedWorkDataModel GetComplitedWorkByData(string data);
void InsertComplitedWork(ComplitedWorkDataModel complitedWorkDataModel);
void UpdateComplitedWork(ComplitedWorkDataModel complitedWorkDataModel);
void DeleteComplitedWork(string id);
}

6
TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/ISpecializationBusinessLogicContract.cs
View File

@@ -3,9 +3,9 @@ namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
public interface ISpecializationBusinessLogicContract
{
List<Specialization> GetAllSpecializations(bool onlyActual = true);
Specialization GetLatestSpecialization(string specializationId);
void AddSpecialization(string specializationId, string name, double salary);
Specialization GetLatestSpecializationById(string specializationId);
Specialization GetLatestSpecializationByName(string specializationName);
void AddSpecialization(Specialization specializationId);
void DeactivateSpecialization(string specializationId);
void RestoreSpecialization(string specializationId);
}

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

@@ -4,7 +4,7 @@ public interface IWorkBusinessLogicContract
{
List<WorkDataModel> GetAllWorks();
WorkDataModel GetWorkByData(string data);
WorkDataModel GetWorkByData(DateTime dataFrom, DateTime dataTo);
void InsertWork(WorkDataModel workDataModel);
void UpdateWork(WorkDataModel workDataModel);

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

@@ -5,7 +5,6 @@ public interface IWorkerComplitedWorkBusinessLogicContract
List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId);
List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWork(string workId);
WorkerComplitedWorkDataModel GetWorkerComplitedWorkByData(string data);
void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
void UpdateWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);

14
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Exceptions/ElementExistsException.cs Normal file
View File

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

11
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Exceptions/ElementNotFoundException.cs Normal file
View File

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

6
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Exceptions/IncorrectDatesException.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace TwoFromTheCasketContracts.Exceptions;
public class IncorrectDatesException : Exception
{
public IncorrectDatesException(DateTime start, DateTime end) : base($"The end date must be later than the start date.. StartDate: {start:dd.MM.YYYY}. EndDate: {end:dd.MM.YYYY}") { }
}

6
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Exceptions/NullListException.cs Normal file
View File

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

6
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Exceptions/StorageException.cs Normal file
View File

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

9
TwoFromTheCasketContracts/TwoFromTheCasketContracts/Extensions/DateTimeExtensions.cs Normal file
View File

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

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IComplitedWorkStorageContract.cs
View File

@@ -1,5 +1,5 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IComplitedWorkStorageContract
{
List<ComplitedWorkDataModel> GetList(DateTime? startTime, DateTime? endTime, string? RoomId, string? WorkId, string? WorkerId);

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

@@ -1,5 +1,5 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IRoomHistoryStorageContract
{
List<RoomHistoryDataModel> GetList(string roomId);

6
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IRoomStorageContract.cs
View File

@@ -1,12 +1,12 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IRoomStorageContract
{
List<RoomDataModel> GetList();
List<RoomHistoryDataModel> GetHistoryRoomId(string id);
List<RoomDataModel> GetListByOwner(string OwnerFIO);
List<RoomDataModel> GetListByAddress(string Address);
RoomDataModel? GetElementById(string id);
RoomDataModel? GetElementByOwnerFIO(string OwnerFIO);
RoomDataModel? GetElementByAddress(string Address);
void AddElement(RoomDataModel roomDataModel);
void UpdElement(RoomDataModel roomDataModel);
void DelElement(string id);

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/ISalaryStorageContract.cs
View File

@@ -1,5 +1,5 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface ISalaryStorageContract
{
List<SalaryDataModel> GetList(DateTime startDate, DateTime endDate, string? workerId = null);

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/ISpecializationStorageContract.cs
View File

@@ -1,5 +1,5 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface ISpecializationStorageContract
{
List<Specialization> GetList(bool onlyActive = true);

2
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkStorageContract.cs
View File

@@ -1,5 +1,5 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IWorkStorageContract
{
List<WorkDataModel> GetList(DateTime? fromEndDate = null, DateTime? toEndDate = null);

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

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

4
TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkerStorageContract.cs
View File

@@ -1,8 +1,8 @@
using TwoFromTheCasketContracts.DataModels;
namespace TwoFromTheCasketContracts.StorageContracts
namespace TwoFromTheCasketContracts.StorageContracts;
public interface IWorkerStorageContract
{
List<WorkerDataModel> GetList(bool onlyActive = true, string? SpecializationId = null, DateTime? fromBirthDate, DateTime? toBirthDate, DateTime? fromEmploymentDate = null, DateTime? toEmploymentDate = null);
List<WorkerDataModel> GetList(bool onlyActive = true, string? SpecializationId = null, DateTime? fromBirthDate = null, DateTime? toBirthDate = null, DateTime? fromEmploymentDate = null, DateTime? toEmploymentDate = null);
WorkerDataModel? GetElementById(string id);
WorkerDataModel? GetElementByFIO(string FIO);
WorkerDataModel? GetElementByPhoneNumber(string PhoneNumber);

598
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/ComplitedWorkBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,598 @@
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
[TestFixture]
internal class ComplitedWorkBusinessLogicContractTests
{
private ComplitedWorkBusinessLogicContract _complitedWorkBusinessLogicContract;
private Mock<IComplitedWorkStorageContract> _complitedWorkStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_complitedWorkStorageMock = new Mock<IComplitedWorkStorageContract>();
_complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(_complitedWorkStorageMock.Object);
}
[SetUp]
public void SetUp()
{
_complitedWorkStorageMock.Reset();
}
[Test]
public void GetAllComplitedWorks_ReturnListOfRecords_Test()
{
var listOriginal = new List<ComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())
};
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Returns(listOriginal);
var list = _complitedWorkBusinessLogicContract.GetAllComplitedWorks();
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
_complitedWorkStorageMock.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
}
[Test]
public void GetAllComplitedWorks_ReturnEmptyList_Test()
{
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Returns(new List<ComplitedWorkDataModel>());
var list = _complitedWorkBusinessLogicContract.GetAllComplitedWorks();
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
_complitedWorkStorageMock.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
}
[Test]
public void GetAllComplitedWorks_ReturnNull_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetAllComplitedWorks(), Throws.TypeOf<NullListException>());
_complitedWorkStorageMock.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
}
[Test]
public void GetAllComplitedWorks_StorageThrowError_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetAllComplitedWorks(), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetList(null, null, null, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByPeriod_ReturnListOfRecords_Test()
{
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
var listOriginal = new List<ComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())
};
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Returns(listOriginal);
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByPeriod_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Returns(new List<ComplitedWorkDataModel>());
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByPeriod_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
}
[Test]
public void GetComplitedWorksByPeriod_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(fromDate, toDate), Throws.TypeOf<NullListException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByPeriod_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByPeriod(fromDate, toDate), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_ReturnListOfRecords_Test()
{
var roomId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
var listOriginal = new List<ComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), roomId, new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), roomId, new List<WorkerComplitedWorkDataModel>())
};
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, roomId, null)).Returns(listOriginal);
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, roomId, null), Times.Once);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_ReturnEmptyList_Test()
{
var roomId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, roomId, null)).Returns(new List<ComplitedWorkDataModel>());
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, roomId, null), Times.Once);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_RoomIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(null, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(string.Empty, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, It.IsAny<string>(), null), Times.Never);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_RoomIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod("invalid_id", DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ValidationException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, It.IsAny<string>(), null), Times.Never);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_IncorrectDates_ThrowException_Test()
{
var roomId = Guid.NewGuid().ToString();
var date = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, It.IsAny<string>(), null), Times.Never);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_ReturnNull_ThrowException_Test()
{
var roomId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, fromDate, toDate), Throws.TypeOf<NullListException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, roomId, null), Times.Once);
}
[Test]
public void GetComplitedWorksByRoomByPeriod_StorageThrowError_ThrowException_Test()
{
var roomId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, roomId, null)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByRoomByPeriod(roomId, fromDate, toDate), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, roomId, null), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_ReturnListOfRecords_Test()
{
var workTypeId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
var listOriginal = new List<ComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), workTypeId, Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>()),
new(Guid.NewGuid().ToString(), workTypeId, Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())
};
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, workTypeId, null, null)).Returns(listOriginal);
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, workTypeId, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_ReturnEmptyList_Test()
{
var workTypeId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, workTypeId, null, null)).Returns(new List<ComplitedWorkDataModel>());
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, workTypeId, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_WorkTypeIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(null, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(string.Empty, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), null, null), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_WorkTypeIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod("invalid_id", DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ValidationException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), null, null), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_IncorrectDates_ThrowException_Test()
{
var workTypeId = Guid.NewGuid().ToString();
var date = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), null, null), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_ReturnNull_ThrowException_Test()
{
var workTypeId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, fromDate, toDate), Throws.TypeOf<NullListException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, workTypeId, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkTypeByPeriod_StorageThrowError_ThrowException_Test()
{
var workTypeId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, workTypeId, null, null)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkTypeByPeriod(workTypeId, fromDate, toDate), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, workTypeId, null, null), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_ReturnListOfRecords_Test()
{
var workerId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
var listOriginal = new List<ComplitedWorkDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
new List<WorkerComplitedWorkDataModel> { new(Guid.NewGuid().ToString(), workerId, 5) }),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
new List<WorkerComplitedWorkDataModel> { new(Guid.NewGuid().ToString(), workerId, 8) })
};
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, null, workerId)).Returns(listOriginal);
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, workerId), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_ReturnEmptyList_Test()
{
var workerId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, null, workerId)).Returns(new List<ComplitedWorkDataModel>());
var list = _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, fromDate, toDate);
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, workerId), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(null, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(string.Empty, DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ArgumentNullException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, null, It.IsAny<string>()), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod("invalid_id", DateTime.UtcNow.AddDays(-30), DateTime.UtcNow), Throws.TypeOf<ValidationException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, null, It.IsAny<string>()), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_IncorrectDates_ThrowException_Test()
{
var workerId = Guid.NewGuid().ToString();
var date = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, null, It.IsAny<string>()), Times.Never);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_ReturnNull_ThrowException_Test()
{
var workerId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, fromDate, toDate), Throws.TypeOf<NullListException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, workerId), Times.Once);
}
[Test]
public void GetComplitedWorksByWorkerByPeriod_StorageThrowError_ThrowException_Test()
{
var workerId = Guid.NewGuid().ToString();
var fromDate = DateTime.UtcNow.AddDays(-30);
var toDate = DateTime.UtcNow;
_complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, null, workerId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorksByWorkerByPeriod(workerId, fromDate, toDate), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, workerId), Times.Once);
}
[Test]
public void GetComplitedWorkByData_GetById_ReturnRecord_Test()
{
var id = Guid.NewGuid().ToString();
var record = new ComplitedWorkDataModel(id, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>());
_complitedWorkStorageMock.Setup(x => x.GetElementById(id)).Returns(record);
var element = _complitedWorkBusinessLogicContract.GetComplitedWorkByData(id);
Assert.That(element, Is.Not.Null);
Assert.That(element.Id, Is.EqualTo(id));
_complitedWorkStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void GetComplitedWorkByData_GetById_NotFoundRecord_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorkByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
_complitedWorkStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void GetComplitedWorkByData_StorageThrowError_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.GetComplitedWorkByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void InsertComplitedWork_CorrectRecord_Test()
{
var flag = false;
var record = new ComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>());
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Callback((ComplitedWorkDataModel x) =>
{
flag = x.Id == record.Id && x.WorkId == record.WorkId && x.RoomId == record.RoomId && x.Workers == record.Workers;
});
_complitedWorkBusinessLogicContract.InsertComplitedWork(record);
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void InsertComplitedWork_RecordWithExistsData_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Throws(new ElementExistsException("Data", "Data"));
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
Throws.TypeOf<ElementExistsException>());
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void InsertComplitedWork_NullRecord_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(null), Throws.TypeOf<ArgumentNullException>());
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void InsertComplitedWork_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
new ComplitedWorkDataModel("invalid", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
Throws.TypeOf<ValidationException>());
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Never);
}
[Test]
public void InsertComplitedWork_StorageThrowError_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
}
[Test]
public void DeleteComplitedWork_CorrectRecord_Test()
{
var id = Guid.NewGuid().ToString();
var flag = false;
_complitedWorkStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x == id)))
.Callback(() => { flag = true; });
_complitedWorkBusinessLogicContract.DeleteComplitedWork(id);
_complitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeleteComplitedWork_RecordWithIncorrectId_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_complitedWorkStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x != id)))
.Throws(new ElementNotFoundException(id));
Assert.That(() => _complitedWorkBusinessLogicContract.DeleteComplitedWork(Guid.NewGuid().ToString()),
Throws.TypeOf<ElementNotFoundException>());
_complitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
[Test]
public void DeleteComplitedWork_IdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.DeleteComplitedWork(null),
Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _complitedWorkBusinessLogicContract.DeleteComplitedWork(string.Empty),
Throws.TypeOf<ArgumentNullException>());
_complitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteComplitedWork_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _complitedWorkBusinessLogicContract.DeleteComplitedWork("invalid-id"),
Throws.TypeOf<ValidationException>());
_complitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteComplitedWork_StorageThrowError_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _complitedWorkBusinessLogicContract.DeleteComplitedWork(Guid.NewGuid().ToString()),
Throws.TypeOf<StorageException>());
_complitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
}
}

439
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,439 @@
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;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
{
[TestFixture]
public class RoomBusinessLogicContractTests
{
private RoomBusinessLogicContract _roomBusinessLogic;
private Mock<IRoomStorageContract> _roomStorageMock;
[SetUp]
public void Setup()
{
_roomStorageMock = new Mock<IRoomStorageContract>();
_roomBusinessLogic = new RoomBusinessLogicContract(_roomStorageMock.Object);
}
[Test]
public void GetAllRooms_ReturnsListOfRooms()
{
var rooms = new List<RoomDataModel>
{
new(Guid.NewGuid().ToString(), "John Doe", "ул. Ленина, д. 10", 50, TypeRoom.Office),
new(Guid.NewGuid().ToString(), "Jane Doe", "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding),
new(Guid.NewGuid().ToString(), "Alice Smith", "ул. Пушкина, д. 5", 100, TypeRoom.Residential)
};
_roomStorageMock.Setup(x => x.GetList()).Returns(rooms);
var result = _roomBusinessLogic.GetAllRooms();
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(3));
Assert.That(result, Is.EquivalentTo(rooms));
});
_roomStorageMock.Verify(x => x.GetList(), Times.Once);
}
[Test]
public void GetAllRooms_ReturnsEmptyList()
{
_roomStorageMock.Setup(x => x.GetList()).Returns(new List<RoomDataModel>());
var result = _roomBusinessLogic.GetAllRooms();
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(0));
});
_roomStorageMock.Verify(x => x.GetList(), Times.Once);
}
[Test]
public void GetAllRooms_StorageReturnsNull_ThrowsException()
{
Assert.That(() => _roomBusinessLogic.GetAllRooms(), Throws.TypeOf<NullListException>());
_roomStorageMock.Verify(x => x.GetList(), Times.Once);
}
[Test]
public void GetAllRooms_StorageThrowsException_ThrowsStorageException()
{
_roomStorageMock.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.GetAllRooms(), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.GetList(), Times.Once);
}
[Test]
public void GetRoomsByOwner_ReturnsListOfRooms()
{
var ownerId = Guid.NewGuid().ToString();
var rooms = new List<RoomDataModel>
{
new(Guid.NewGuid().ToString(), ownerId, "ул. Ленина, д. 10", 50, TypeRoom.Office),
new(Guid.NewGuid().ToString(), ownerId, "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)
};
_roomStorageMock.Setup(x => x.GetListByOwner(ownerId)).Returns(rooms);
var result = _roomBusinessLogic.GetRoomsByOwner(ownerId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(2));
Assert.That(result, Is.EquivalentTo(rooms));
});
_roomStorageMock.Verify(x => x.GetListByOwner(ownerId), Times.Once);
}
[Test]
public void GetRoomsByOwner_ReturnsEmptyList()
{
var ownerId = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.GetListByOwner(ownerId)).Returns(new List<RoomDataModel>());
var result = _roomBusinessLogic.GetRoomsByOwner(ownerId);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(0));
});
_roomStorageMock.Verify(x => x.GetListByOwner(ownerId), Times.Once);
}
[Test]
public void GetRoomsByOwner_OwnerIdIsNullOrEmpty_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.GetRoomsByOwner(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomBusinessLogic.GetRoomsByOwner(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.GetListByOwner(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomsByOwner_OwnerIdIsNotGuid_ThrowsValidationException()
{
Assert.That(() => _roomBusinessLogic.GetRoomsByOwner("invalid-guid"), Throws.TypeOf<ValidationException>());
_roomStorageMock.Verify(x => x.GetListByOwner(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomsByOwner_StorageReturnsNull_ThrowsNullListException()
{
var ownerId = Guid.NewGuid().ToString();
Assert.That(() => _roomBusinessLogic.GetRoomsByOwner(ownerId), Throws.TypeOf<NullListException>());
_roomStorageMock.Verify(x => x.GetListByOwner(ownerId), Times.Once);
}
[Test]
public void GetRoomsByOwner_StorageThrowsException_ThrowsStorageException()
{
var ownerId = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.GetListByOwner(ownerId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.GetRoomsByOwner(ownerId), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.GetListByOwner(ownerId), Times.Once);
}
[Test]
public void GetRoomsByAddress_ReturnsListOfRooms()
{
var address = "ул. Ленина, д. 10";
var rooms = new List<RoomDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), address, 50, TypeRoom.Office),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), address, 75, TypeRoom.PublicBuilding)
};
_roomStorageMock.Setup(x => x.GetListByAddress(address)).Returns(rooms);
var result = _roomBusinessLogic.GetRoomsByAddress(address);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(2));
Assert.That(result, Is.EquivalentTo(rooms));
});
_roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
}
[Test]
public void GetRoomsByAddress_ReturnsEmptyList()
{
var address = "ул. Гагарина, д. 20";
_roomStorageMock.Setup(x => x.GetListByAddress(address)).Returns(new List<RoomDataModel>());
var result = _roomBusinessLogic.GetRoomsByAddress(address);
Assert.Multiple(() =>
{
Assert.That(result, Is.Not.Null);
Assert.That(result, Has.Count.EqualTo(0));
});
_roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
}
[Test]
public void GetRoomsByAddress_AddressIsNullOrEmpty_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.GetRoomsByAddress(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomBusinessLogic.GetRoomsByAddress(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.GetListByAddress(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomsByAddress_StorageReturnsNull_ThrowsNullListException()
{
var address = "ул. Ленина, д. 10";
Assert.That(() => _roomBusinessLogic.GetRoomsByAddress(address), Throws.TypeOf<NullListException>());
_roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
}
[Test]
public void GetRoomsByAddress_StorageThrowsException_ThrowsStorageException()
{
var address = "ул. Гагарина, д. 20";
_roomStorageMock.Setup(x => x.GetListByAddress(address)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.GetRoomsByAddress(address), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
}
[Test]
public void GetRoomByData_GetById_ReturnsRoom()
{
var id = Guid.NewGuid().ToString();
var room = new RoomDataModel(id, Guid.NewGuid().ToString(), "ул. Ленина, д. 10", 50, TypeRoom.Office);
_roomStorageMock.Setup(x => x.GetElementById(id)).Returns(room);
var result = _roomBusinessLogic.GetRoomByData(id);
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(id));
_roomStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void GetRoomByData_DataIsNullOrEmpty_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.GetRoomByData(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomBusinessLogic.GetRoomByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetRoomByData_GetById_NotFound_ThrowsElementNotFoundException()
{
Assert.That(() => _roomBusinessLogic.GetRoomByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
_roomStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void GetRoomByData_StorageThrowsException_ThrowsStorageException()
{
_roomStorageMock.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.GetRoomByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void InsertRoom_CorrectRecord_Test()
{
var flag = false;
var room = new RoomDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding);
_roomStorageMock.Setup(x => x.AddElement(It.IsAny<RoomDataModel>()))
.Callback((RoomDataModel x) =>
{
flag = x.Id == room.Id && x.OwnerFIO == room.OwnerFIO && x.Address == room.Address &&
x.Space == room.Space && x.Type == room.Type;
});
_roomBusinessLogic.InsertRoom(room);
_roomStorageMock.Verify(x => x.AddElement(It.IsAny<RoomDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void InsertRoom_RecordWithExistsData_ThrowsElementExistsException()
{
_roomStorageMock.Setup(x => x.AddElement(It.IsAny<RoomDataModel>())).Throws(new ElementExistsException("Room", "Address"));
Assert.That(() => _roomBusinessLogic.InsertRoom(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<ElementExistsException>());
_roomStorageMock.Verify(x => x.AddElement(It.IsAny<RoomDataModel>()), Times.Once);
}
[Test]
public void InsertRoom_NullRecord_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.InsertRoom(null), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.AddElement(It.IsAny<RoomDataModel>()), Times.Never);
}
[Test]
public void InsertRoom_InvalidRecord_ThrowsValidationException()
{
Assert.That(() => _roomBusinessLogic.InsertRoom(new RoomDataModel("id", Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<ValidationException>());
_roomStorageMock.Verify(x => x.AddElement(It.IsAny<RoomDataModel>()), Times.Never);
}
[Test]
public void InsertRoom_StorageThrowsException_ThrowsStorageException()
{
_roomStorageMock.Setup(x => x.AddElement(It.IsAny<RoomDataModel>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.InsertRoom(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.AddElement(It.IsAny<RoomDataModel>()), Times.Once);
}
[Test]
public void UpdateRoom_CorrectRecord_Test()
{
var flag = false;
var room = new RoomDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding);
_roomStorageMock.Setup(x => x.UpdElement(It.IsAny<RoomDataModel>()))
.Callback((RoomDataModel x) =>
{
flag = x.Id == room.Id && x.OwnerFIO == room.OwnerFIO && x.Address == room.Address &&
x.Space == room.Space && x.Type == room.Type;
});
_roomBusinessLogic.UpdateRoom(room);
_roomStorageMock.Verify(x => x.UpdElement(It.IsAny<RoomDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void UpdateRoom_RecordWithIncorrectData_ThrowsElementNotFoundException()
{
_roomStorageMock.Setup(x => x.UpdElement(It.IsAny<RoomDataModel>())).Throws(new ElementNotFoundException("Room"));
Assert.That(() => _roomBusinessLogic.UpdateRoom(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<ElementNotFoundException>());
_roomStorageMock.Verify(x => x.UpdElement(It.IsAny<RoomDataModel>()), Times.Once);
}
[Test]
public void UpdateRoom_NullRecord_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.UpdateRoom(null), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.UpdElement(It.IsAny<RoomDataModel>()), Times.Never);
}
[Test]
public void UpdateRoom_InvalidRecord_ThrowsValidationException()
{
Assert.That(() => _roomBusinessLogic.UpdateRoom(new RoomDataModel("id", Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<ValidationException>());
_roomStorageMock.Verify(x => x.UpdElement(It.IsAny<RoomDataModel>()), Times.Never);
}
[Test]
public void UpdateRoom_StorageThrowsException_ThrowsStorageException()
{
_roomStorageMock.Setup(x => x.UpdElement(It.IsAny<RoomDataModel>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.UpdateRoom(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "ул. Гагарина, д. 20", 75, TypeRoom.PublicBuilding)),
Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.UpdElement(It.IsAny<RoomDataModel>()), Times.Once);
}
[Test]
public void DeleteRoom_CorrectRecord_Test()
{
var id = Guid.NewGuid().ToString();
var flag = false;
_roomStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x == id))).Callback(() => { flag = true; });
_roomBusinessLogic.DeleteRoom(id);
_roomStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeleteRoom_RecordWithIncorrectId_ThrowsElementNotFoundException()
{
var id = Guid.NewGuid().ToString();
_roomStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x != id))).Throws(new ElementNotFoundException(id));
Assert.That(() => _roomBusinessLogic.DeleteRoom(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
_roomStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
[Test]
public void DeleteRoom_IdIsNullOrEmpty_ThrowsArgumentNullException()
{
Assert.That(() => _roomBusinessLogic.DeleteRoom(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _roomBusinessLogic.DeleteRoom(string.Empty), Throws.TypeOf<ArgumentNullException>());
_roomStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteRoom_IdIsNotGuid_ThrowsValidationException()
{
Assert.That(() => _roomBusinessLogic.DeleteRoom("invalid_id"), Throws.TypeOf<ValidationException>());
_roomStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteRoom_StorageThrowsException_ThrowsStorageException()
{
_roomStorageMock.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _roomBusinessLogic.DeleteRoom(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_roomStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
}
}

246
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomHistoryBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,246 @@
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;
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);
}
[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);
}
}

324
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,324 @@
using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
public class SalaryBusinessLogicContractTests
{
private SalaryBusinessLogicContract _salaryBusinessLogicContract;
private Mock<ISalaryStorageContract> _salaryStorageMock;
private Mock<IWorkerStorageContract> _workerStorageMock;
private Mock<IComplitedWorkStorageContract> _complitedWorkStorageMock;
private Mock<ISpecializationStorageContract> _specializationStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_salaryStorageMock = new Mock<ISalaryStorageContract>();
_workerStorageMock = new Mock<IWorkerStorageContract>();
_complitedWorkStorageMock = new Mock<IComplitedWorkStorageContract>();
_specializationStorageMock = new Mock<ISpecializationStorageContract>();
_salaryBusinessLogicContract = new SalaryBusinessLogicContract(
_salaryStorageMock.Object,
_workerStorageMock.Object,
_complitedWorkStorageMock.Object,
_specializationStorageMock.Object);
}
[SetUp]
public void SetUp()
{
_salaryStorageMock.Reset();
_workerStorageMock.Reset();
_complitedWorkStorageMock.Reset();
_specializationStorageMock.Reset();
}
[Test]
public void GetSalariesByWorkerByPeriod_ReturnListOfRecords_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var workerId = Guid.NewGuid().ToString();
var listOriginal = new List<SalaryDataModel>
{
new(Guid.NewGuid().ToString(), workerId, 5000),
new(Guid.NewGuid().ToString(), workerId, 6000),
new(Guid.NewGuid().ToString(), workerId, 7000)
};
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, workerId)).Returns(listOriginal);
var list = _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, workerId), Times.Once);
}
[Test]
public void GetSalariesByWorkerByPeriod_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var workerId = Guid.NewGuid().ToString();
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, workerId)).Returns(new List<SalaryDataModel>());
var list = _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
});
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, workerId), Times.Once);
}
[Test]
public void GetSalariesByWorkerByPeriod_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
var workerId = Guid.NewGuid().ToString();
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_salaryStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>()), Times.Never);
}
[Test]
public void GetSalariesByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(null, fromDate, toDate), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(string.Empty, fromDate, toDate), Throws.TypeOf<ArgumentNullException>());
_salaryStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>()), Times.Never);
}
[Test]
public void GetSalariesByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var workerId = "invalid-guid";
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, fromDate, toDate), Throws.TypeOf<ValidationException>());
_salaryStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>()), Times.Never);
}
[Test]
public void GetSalariesByWorkerByPeriod_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var workerId = Guid.NewGuid().ToString();
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, workerId)).Returns((List<SalaryDataModel>)null);
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, fromDate, toDate), Throws.TypeOf<NullListException>());
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, workerId), Times.Once);
}
[Test]
public void GetSalariesByWorkerByPeriod_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var workerId = Guid.NewGuid().ToString();
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, workerId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByWorkerByPeriod(workerId, fromDate, toDate), Throws.TypeOf<StorageException>());
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, workerId), Times.Once);
}
[Test]
public void GetSalariesByPeriod_ReturnListOfRecords_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var listOriginal = new List<SalaryDataModel>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5000),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 6000),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 7000)
};
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns(listOriginal);
var list = _salaryBusinessLogicContract.GetSalariesByPeriod(fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSalariesByPeriod_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns(new List<SalaryDataModel>());
var list = _salaryBusinessLogicContract.GetSalariesByPeriod(fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
});
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSalariesByPeriod_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
_salaryStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>()), Times.Never);
}
[Test]
public void GetSalariesByPeriod_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns((List<SalaryDataModel>)null);
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByPeriod(fromDate, toDate), Throws.TypeOf<NullListException>());
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void GetSalariesByPeriod_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_salaryStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _salaryBusinessLogicContract.GetSalariesByPeriod(fromDate, toDate), Throws.TypeOf<StorageException>());
_salaryStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
}
[Test]
public void CalculateSalaryByMounth_CalculateSalary_Test()
{
var workerId = Guid.NewGuid().ToString();
var workId = Guid.NewGuid().ToString();
var roomId = Guid.NewGuid().ToString();
var numberOfWorkingHours = 10.0;
var specializationSalary = 2000.0;
var hourlyRate = 100.0;
var expectedSalary = specializationSalary + (numberOfWorkingHours * hourlyRate);
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<string?>()))
.Returns([
new ComplitedWorkDataModel(
Guid.NewGuid().ToString(),
workId,
roomId,
[new WorkerComplitedWorkDataModel(workerId, workId, numberOfWorkingHours)])
]);
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Returns(new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Specialist", specializationSalary, true, DateTime.UtcNow));
_workerStorageMock.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns([new WorkerDataModel(workerId, "Test Worker", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))]);
var calculatedSalary = 0.0;
_salaryStorageMock.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
.Callback((SalaryDataModel x) => { calculatedSalary = x.Sum; });
_salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
Assert.That(calculatedSalary, Is.EqualTo(expectedSalary));
}
[Test]
public void CalculateSalaryByMounth_WithSeveralWorkers_Test()
{
var workerIds = new List<string> { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() };
var numberOfWorkingHours = new List<double> { 5.0, 8.0, 12.0 };
var hourlyRate = 100.0;
var specializationSalary = 2000.0;
var expectedSalaries = workerIds.Select((id, index) => specializationSalary + (numberOfWorkingHours[index] * hourlyRate)).ToList();
var workers = workerIds.Select((id, index) => new WorkerDataModel(id, $"Worker {index + 1}", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))).ToList();
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Returns(workerIds.Select((id, index) =>
new ComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
[new WorkerComplitedWorkDataModel(id, Guid.NewGuid().ToString(), numberOfWorkingHours[index])])
).ToList());
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Returns(new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Specialist", specializationSalary, true, DateTime.UtcNow));
_workerStorageMock.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(workers);
var calculatedSalaries = new List<double>();
_salaryStorageMock.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
.Callback((SalaryDataModel x) => { calculatedSalaries.Add(x.Sum); });
_salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow);
Assert.That(calculatedSalaries, Is.EquivalentTo(expectedSalaries));
}
[Test]
public void CalculateSalaryByMounth_WorkerStorageReturnNull_ThrowException_Test()
{
_workerStorageMock.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
}
[Test]
public void CalculateSalaryByMounth_ComplitedWorkStorageReturnNull_ThrowException_Test()
{
_complitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf<StorageException>());
}
}

392
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SpecializationBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,392 @@
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.BusinessLogicsContracts;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
public class SpecializationBusinessLogicContractTests
{
private Mock<ISpecializationStorageContract> _specializationStorageMock;
private ISpecializationBusinessLogicContract _specializationBusinessLogic;
[SetUp]
public void Setup()
{
_specializationStorageMock = new Mock<ISpecializationStorageContract>();
_specializationBusinessLogic = new SpecializationBusinessLogicContract(_specializationStorageMock.Object);
}
[Test]
public void GetAllSpecializations_ReturnListOfRecords_Test()
{
var specializations = new List<Specialization>
{
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Specialization 1", 50000, true, DateTime.UtcNow),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Specialization 2", 60000, false, DateTime.UtcNow),
new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Specialization 3", 55000, true, DateTime.UtcNow)
};
_specializationStorageMock.Setup(x => x.GetList(It.IsAny<bool>())).Returns(specializations);
var actualList = _specializationBusinessLogic.GetAllSpecializations(true);
var fullList = _specializationBusinessLogic.GetAllSpecializations(false);
Assert.Multiple(() =>
{
Assert.That(actualList, Is.Not.Null);
Assert.That(fullList, Is.Not.Null);
Assert.That(actualList, Is.EquivalentTo(specializations));
Assert.That(fullList, Is.EquivalentTo(specializations));
});
_specializationStorageMock.Verify(x => x.GetList(true), Times.Once);
_specializationStorageMock.Verify(x => x.GetList(false), Times.Once);
}
[Test]
public void GetAllSpecializations_ReturnEmptyList_Test()
{
_specializationStorageMock.Setup(x => x.GetList(It.IsAny<bool>())).Returns(new List<Specialization>());
var actualList = _specializationBusinessLogic.GetAllSpecializations(true);
var fullList = _specializationBusinessLogic.GetAllSpecializations(false);
Assert.Multiple(() =>
{
Assert.That(actualList, Is.Not.Null);
Assert.That(fullList, Is.Not.Null);
Assert.That(actualList, Has.Count.EqualTo(0));
Assert.That(fullList, Has.Count.EqualTo(0));
});
_specializationStorageMock.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
}
[Test]
public void GetAllSpecializations_ReturnNull_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetList(It.IsAny<bool>())).Returns((List<Specialization>)null);
Assert.That(() => _specializationBusinessLogic.GetAllSpecializations(true), Throws.TypeOf<NullListException>());
Assert.That(() => _specializationBusinessLogic.GetAllSpecializations(false), Throws.TypeOf<NullListException>());
_specializationStorageMock.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
}
[Test]
public void GetAllSpecializations_StorageThrowsException_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetList(It.IsAny<bool>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.GetAllSpecializations(true), Throws.TypeOf<StorageException>());
Assert.That(() => _specializationBusinessLogic.GetAllSpecializations(false), Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.GetList(It.IsAny<bool>()), Times.Exactly(2));
}
[Test]
public void GetLatestSpecializationById_ReturnsLatestRecord_Test()
{
var specializationId = Guid.NewGuid().ToString();
var latestSpecialization = new Specialization(Guid.NewGuid().ToString(), specializationId, "Latest Specialization", 70000, true, DateTime.UtcNow);
_specializationStorageMock.Setup(x => x.GetElementById(specializationId)).Returns(latestSpecialization);
var actualSpecialization = _specializationBusinessLogic.GetLatestSpecializationById(specializationId);
Assert.That(actualSpecialization, Is.Not.Null);
Assert.That(actualSpecialization, Is.EqualTo(latestSpecialization));
_specializationStorageMock.Verify(x => x.GetElementById(specializationId), Times.Once);
}
[Test]
public void GetLatestSpecializationById_SpecializationIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationById(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationById(string.Empty), Throws.TypeOf<ArgumentNullException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetLatestSpecializationById_SpecializationIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationById("invalid-id"), Throws.TypeOf<ValidationException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetLatestSpecializationById_NotFound_ThrowException_Test()
{
var specializationId = Guid.NewGuid().ToString();
_specializationStorageMock.Setup(x => x.GetElementById(specializationId)).Returns((Specialization)null);
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationById(specializationId), Throws.TypeOf<ElementNotFoundException>());
_specializationStorageMock.Verify(x => x.GetElementById(specializationId), Times.Once);
}
[Test]
public void GetLatestSpecializationById_StorageThrowsException_ThrowException_Test()
{
var specializationId = Guid.NewGuid().ToString();
_specializationStorageMock.Setup(x => x.GetElementById(specializationId)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationById(specializationId), Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.GetElementById(specializationId), Times.Once);
}
[Test]
public void GetLatestSpecializationByName_ReturnsLatestRecord_Test()
{
var specializationName = "Software Engineer";
var latestSpecialization = new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), specializationName, 75000, true, DateTime.UtcNow);
_specializationStorageMock.Setup(x => x.GetElementByName(specializationName)).Returns(latestSpecialization);
var actualSpecialization = _specializationBusinessLogic.GetLatestSpecializationByName(specializationName);
Assert.That(actualSpecialization, Is.Not.Null);
Assert.That(actualSpecialization, Is.EqualTo(latestSpecialization));
_specializationStorageMock.Verify(x => x.GetElementByName(specializationName), Times.Once);
}
[Test]
public void GetLatestSpecializationByName_SpecializationNameIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationByName(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationByName(string.Empty), Throws.TypeOf<ArgumentNullException>());
_specializationStorageMock.Verify(x => x.GetElementByName(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetLatestSpecializationByName_NotFound_ThrowException_Test()
{
var specializationName = "Non-Existent Specialization";
_specializationStorageMock.Setup(x => x.GetElementByName(specializationName)).Returns((Specialization)null);
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationByName(specializationName), Throws.TypeOf<ElementNotFoundException>());
_specializationStorageMock.Verify(x => x.GetElementByName(specializationName), Times.Once);
}
[Test]
public void GetLatestSpecializationByName_StorageThrowsException_ThrowException_Test()
{
var specializationName = "System Administrator";
_specializationStorageMock.Setup(x => x.GetElementByName(specializationName)).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.GetLatestSpecializationByName(specializationName), Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.GetElementByName(specializationName), Times.Once);
}
[Test]
public void AddSpecialization_CorrectRecord_Test()
{
var flag = false;
var specialization = new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Software Engineer", 75000, true, DateTime.UtcNow);
_specializationStorageMock.Setup(x => x.AddElement(It.IsAny<Specialization>()))
.Callback((Specialization x) =>
{
flag = x.Id == specialization.Id && x.SpecializationId == specialization.SpecializationId &&
x.SpecializationName == specialization.SpecializationName && x.Salary == specialization.Salary &&
x.IsActual == specialization.IsActual && x.ChangeDate == specialization.ChangeDate;
});
_specializationBusinessLogic.AddSpecialization(specialization);
_specializationStorageMock.Verify(x => x.AddElement(It.IsAny<Specialization>()), Times.Once);
Assert.That(flag);
}
[Test]
public void AddSpecialization_RecordWithExistsData_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.AddElement(It.IsAny<Specialization>()))
.Throws(new ElementExistsException("Specialization", "Specialization"));
Assert.That(() => _specializationBusinessLogic.AddSpecialization(new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Software Engineer", 75000, true, DateTime.UtcNow)),
Throws.TypeOf<ElementExistsException>());
_specializationStorageMock.Verify(x => x.AddElement(It.IsAny<Specialization>()), Times.Once);
}
[Test]
public void AddSpecialization_NullRecord_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.AddSpecialization(null), Throws.TypeOf<ArgumentNullException>());
_specializationStorageMock.Verify(x => x.AddElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void AddSpecialization_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.AddSpecialization(new Specialization("id", "", "", -1000, true, DateTime.UtcNow)),
Throws.TypeOf<ValidationException>());
_specializationStorageMock.Verify(x => x.AddElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void AddSpecialization_StorageThrowError_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.AddElement(It.IsAny<Specialization>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.AddSpecialization(new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Software Engineer", 75000, true, DateTime.UtcNow)),
Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.AddElement(It.IsAny<Specialization>()), Times.Once);
}
[Test]
public void DeactivateSpecialization_CorrectRecord_Test()
{
var flag = false;
var specialization = new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Software Engineer", 75000, true, DateTime.UtcNow);
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Returns(specialization);
_specializationStorageMock.Setup(x => x.UpdElement(It.IsAny<Specialization>()))
.Callback((Specialization x) =>
{
flag = x.Id == specialization.Id && !x.IsActual;
});
_specializationBusinessLogic.DeactivateSpecialization(specialization.Id);
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeactivateSpecialization_RecordNotFound_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Throws(new ElementNotFoundException("Specialization not found"));
Assert.That(() => _specializationBusinessLogic.DeactivateSpecialization(Guid.NewGuid().ToString()),
Throws.TypeOf<ElementNotFoundException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void DeactivateSpecialization_NullOrEmptyId_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.DeactivateSpecialization(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _specializationBusinessLogic.DeactivateSpecialization(string.Empty), Throws.TypeOf<ArgumentNullException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void DeactivateSpecialization_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.DeactivateSpecialization("not-a-guid"), Throws.TypeOf<ValidationException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void DeactivateSpecialization_StorageThrowsError_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.DeactivateSpecialization(Guid.NewGuid().ToString()),
Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void RestoreSpecialization_CorrectRecord_Test()
{
var flag = false;
var specialization = new Specialization(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), "Software Engineer", 75000, false, DateTime.UtcNow);
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Returns(specialization);
_specializationStorageMock.Setup(x => x.UpdElement(It.IsAny<Specialization>()))
.Callback((Specialization x) =>
{
flag = x.Id == specialization.Id && x.IsActual;
});
_specializationBusinessLogic.RestoreSpecialization(specialization.Id);
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Once);
Assert.That(flag);
}
[Test]
public void RestoreSpecialization_RecordNotFound_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Throws(new ElementNotFoundException("Specialization not found"));
Assert.That(() => _specializationBusinessLogic.RestoreSpecialization(Guid.NewGuid().ToString()),
Throws.TypeOf<ElementNotFoundException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void RestoreSpecialization_NullOrEmptyId_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.RestoreSpecialization(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _specializationBusinessLogic.RestoreSpecialization(string.Empty), Throws.TypeOf<ArgumentNullException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void RestoreSpecialization_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _specializationBusinessLogic.RestoreSpecialization("not-a-guid"), Throws.TypeOf<ValidationException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
[Test]
public void RestoreSpecialization_StorageThrowsError_ThrowException_Test()
{
_specializationStorageMock.Setup(x => x.GetElementById(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _specializationBusinessLogic.RestoreSpecialization(Guid.NewGuid().ToString()),
Throws.TypeOf<StorageException>());
_specializationStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
_specializationStorageMock.Verify(x => x.UpdElement(It.IsAny<Specialization>()), Times.Never);
}
}

372
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,372 @@
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.Enums;
using TwoFromTheCasketContracts.Exceptions;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
internal class WorkBusinessLogicContractTests
{
private WorkBusinessLogicContract _workBusinessLogicContract;
private Mock<IWorkStorageContract> _workStorageMock;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_workStorageMock = new Mock<IWorkStorageContract>();
_workBusinessLogicContract = new WorkBusinessLogicContract(_workStorageMock.Object);
}
[SetUp]
public void SetUp()
{
_workStorageMock.Reset();
}
[Test]
public void GetAllWorks_ReturnListOfRecords_Test()
{
var listOriginal = new List<WorkDataModel>
{
new(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Description 1", DateTime.UtcNow),
new(Guid.NewGuid().ToString(), TypeWork.Plumbing, "Description 2", DateTime.UtcNow),
new(Guid.NewGuid().ToString(), TypeWork.Electrical, "Description 3", DateTime.UtcNow),
};
_workStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(listOriginal);
var list = _workBusinessLogicContract.GetAllWorks();
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workStorageMock.Verify(x => x.GetList(null, null), Times.Once);
}
[Test]
public void GetAllWorks_ReturnEmptyList_Test()
{
_workStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns([]);
var list = _workBusinessLogicContract.GetAllWorks();
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Has.Count.EqualTo(0));
});
_workStorageMock.Verify(x => x.GetList(null, null), Times.Once);
}
[Test]
public void GetAllWorks_ReturnNull_ThrowException_Test()
{
_workStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns((List<WorkDataModel>?)null);
Assert.That(() => _workBusinessLogicContract.GetAllWorks(), Throws.TypeOf<NullListException>());
_workStorageMock.Verify(x => x.GetList(null, null), Times.Once);
}
[Test]
public void GetAllWorks_StorageThrowError_ThrowException_Test()
{
_workStorageMock
.Setup(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workBusinessLogicContract.GetAllWorks(), Throws.TypeOf<StorageException>());
_workStorageMock.Verify(x => x.GetList(null, null), Times.Once);
}
[Test]
public void GetWorkByData_ByDateRange_ReturnList_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
var listOriginal = new List<WorkDataModel>
{
new(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Description 1", fromDate.AddDays(5)),
new(Guid.NewGuid().ToString(), TypeWork.Plumbing, "Description 2", fromDate.AddDays(10)),
};
_workStorageMock
.Setup(x => x.GetList(fromDate, toDate))
.Returns(listOriginal);
var list = _workBusinessLogicContract.GetWorkByData(fromDate, toDate);
Assert.Multiple(() =>
{
Assert.That(list, Is.Not.Null);
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workStorageMock.Verify(x => x.GetList(fromDate, toDate), Times.Once);
}
[Test]
public void GetWorkByData_ByDateRange_StorageThrowsError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddMonths(-1);
var toDate = DateTime.UtcNow;
_workStorageMock
.Setup(x => x.GetList(fromDate, toDate))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workBusinessLogicContract.GetWorkByData(fromDate, toDate), Throws.TypeOf<StorageException>());
_workStorageMock.Verify(x => x.GetList(fromDate, toDate), Times.Once);
}
[Test]
public void GetAllWorks_ByDateRange_FromDateGreaterThanToDate_ThrowException_Test()
{
var fromDate = DateTime.UtcNow;
var toDate = DateTime.UtcNow.AddMonths(-1);
Assert.That(() => _workBusinessLogicContract.GetWorkByData(fromDate, toDate), Throws.TypeOf<IncorrectDatesException>());
_workStorageMock.Verify(x => x.GetList(It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
}
[Test]
public void InsertWork_CorrectRecord_Test()
{
var flag = false;
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Fixing wooden furniture", DateTime.UtcNow);
_workStorageMock.Setup(x => x.AddElement(It.IsAny<WorkDataModel>()))
.Callback((WorkDataModel x) =>
{
flag = x.Id == work.Id && x.Type == work.Type && x.Description == work.Description && x.Date == work.Date;
});
_workBusinessLogicContract.InsertWork(work);
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void InsertWork_RecordWithExistingId_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Plumbing, "Pipe fixing", DateTime.UtcNow);
_workStorageMock.Setup(x => x.AddElement(It.IsAny<WorkDataModel>()))
.Throws(new ElementExistsException("Work", "Id"));
Assert.That(() => _workBusinessLogicContract.InsertWork(work), Throws.TypeOf<ElementExistsException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Once);
}
[Test]
public void InsertWork_NullRecord_ThrowException_Test()
{
Assert.That(() => _workBusinessLogicContract.InsertWork(null), Throws.TypeOf<ArgumentNullException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void InsertWork_InvalidId_ThrowException_Test()
{
var work = new WorkDataModel("invalid_guid", TypeWork.Electrical, "Fixing electric wiring", DateTime.UtcNow);
Assert.That(() => _workBusinessLogicContract.InsertWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void InsertWork_EmptyDescription_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "", DateTime.UtcNow);
Assert.That(() => _workBusinessLogicContract.InsertWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void InsertWork_EndDateInFuture_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Future job", DateTime.UtcNow.AddDays(10));
Assert.That(() => _workBusinessLogicContract.InsertWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void InsertWork_StorageThrowsError_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Storage error simulation", DateTime.UtcNow);
_workStorageMock.Setup(x => x.AddElement(It.IsAny<WorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workBusinessLogicContract.InsertWork(work), Throws.TypeOf<StorageException>());
_workStorageMock.Verify(x => x.AddElement(It.IsAny<WorkDataModel>()), Times.Once);
}
[Test]
public void UpdateWork_CorrectRecord_Test()
{
var flag = false;
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Updated description", DateTime.UtcNow);
_workStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkDataModel>()))
.Callback((WorkDataModel x) =>
{
flag = x.Id == work.Id && x.Type == work.Type && x.Description == work.Description && x.Date == work.Date;
});
_workBusinessLogicContract.UpdateWork(work);
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void UpdateWork_RecordWithIncorrectId_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Plumbing, "Updated description", DateTime.UtcNow);
_workStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkDataModel>()))
.Throws(new ElementNotFoundException("Work"));
Assert.That(() => _workBusinessLogicContract.UpdateWork(work), Throws.TypeOf<ElementNotFoundException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Once);
}
[Test]
public void UpdateWork_NullRecord_ThrowException_Test()
{
Assert.That(() => _workBusinessLogicContract.UpdateWork(null), Throws.TypeOf<ArgumentNullException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWork_InvalidId_ThrowException_Test()
{
var work = new WorkDataModel("invalid_guid", TypeWork.Electrical, "Updated description", DateTime.UtcNow);
Assert.That(() => _workBusinessLogicContract.UpdateWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWork_EmptyDescription_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "", DateTime.UtcNow);
Assert.That(() => _workBusinessLogicContract.UpdateWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWork_EndDateInFuture_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Future update", DateTime.UtcNow.AddDays(10));
Assert.That(() => _workBusinessLogicContract.UpdateWork(work), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Never);
}
[Test]
public void UpdateWork_StorageThrowsError_ThrowException_Test()
{
var work = new WorkDataModel(Guid.NewGuid().ToString(), TypeWork.Carpentry, "Storage error simulation", DateTime.UtcNow);
_workStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workBusinessLogicContract.UpdateWork(work), Throws.TypeOf<StorageException>());
_workStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkDataModel>()), Times.Once);
}
[Test]
public void DeleteWork_CorrectRecord_Test()
{
var id = Guid.NewGuid().ToString();
var flag = false;
_workStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x == id)))
.Callback(() => { flag = true; });
_workBusinessLogicContract.DeleteWork(id);
_workStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeleteWork_RecordWithIncorrectId_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_workStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x != id)))
.Throws(new ElementNotFoundException(id));
Assert.That(() => _workBusinessLogicContract.DeleteWork(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
_workStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
[Test]
public void DeleteWork_IdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _workBusinessLogicContract.DeleteWork(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workBusinessLogicContract.DeleteWork(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWork_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workBusinessLogicContract.DeleteWork("invalid_guid"), Throws.TypeOf<ValidationException>());
_workStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWork_StorageThrowsError_ThrowException_Test()
{
_workStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workBusinessLogicContract.DeleteWork(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_workStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
}

646
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,646 @@
using TwoFromTheCasketBusinessLogic.Implementation;
using TwoFromTheCasketContracts.DataModels;
using TwoFromTheCasketContracts.Exceptions;
using Moq;
using TwoFromTheCasketContracts.StorageContracts;
namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
[TestFixture]
internal class WorkerBusinessLogicContractTests
{
private WorkerBusinessLogicContract _workerBusinessLogicContract;
private Mock<IWorkerStorageContract> _workerStorageContract;
[OneTimeSetUp]
public void OneTimeSetUp()
{
_workerStorageContract = new Mock<IWorkerStorageContract>();
_workerBusinessLogicContract = new WorkerBusinessLogicContract(
_workerStorageContract.Object
);
}
[SetUp]
public void SetUp()
{
_workerStorageContract.Reset();
}
[Test]
public void GetAllWorkers_ReturnListOfRecords_Test()
{
var listOriginal = new List<WorkerDataModel>
{
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30)),
new(Guid.NewGuid().ToString(), "Jane Smith", Guid.NewGuid().ToString(), "+7-777-777-77-78", DateTime.UtcNow.AddYears(-25)),
new(Guid.NewGuid().ToString(), "Sam Brown", Guid.NewGuid().ToString(), "+7-777-777-77-79", DateTime.UtcNow.AddYears(-40)),
};
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(listOriginal);
var listOnlyActive = _workerBusinessLogicContract.GetAllWorkers(true);
var list = _workerBusinessLogicContract.GetAllWorkers(false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerStorageContract.Verify(x => x.GetList(true, null, null, null, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, null, null, null, null), Times.Once);
}
[Test]
public void GetAllWorkers_ReturnEmptyList_Test()
{
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(new List<WorkerDataModel>());
var listOnlyActive = _workerBusinessLogicContract.GetAllWorkers(true);
var list = _workerBusinessLogicContract.GetAllWorkers(false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Has.Count.EqualTo(0));
Assert.That(list, Has.Count.EqualTo(0));
});
_workerStorageContract.Verify(x => x.GetList(true, null, null, null, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, null, null, null, null), Times.Once);
}
[Test]
public void GetAllWorkers_ReturnNull_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns((List<WorkerDataModel>)null);
Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(It.IsAny<bool>()), Throws.TypeOf<NullListException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetAllWorkers_StorageThrowError_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(It.IsAny<bool>()), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetWorkersByBirthDate_ReturnListOfRecords_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-40);
var toDate = DateTime.UtcNow.AddYears(-20);
var listOriginal = new List<WorkerDataModel>
{
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30)),
new(Guid.NewGuid().ToString(), "Jane Smith", Guid.NewGuid().ToString(), "+7-777-777-77-78", DateTime.UtcNow.AddYears(-35)),
new(Guid.NewGuid().ToString(), "Sam Brown", Guid.NewGuid().ToString(), "+7-777-777-77-79", DateTime.UtcNow.AddYears(-28)),
};
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(listOriginal);
var listOnlyActive = _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, true);
var list = _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerStorageContract.Verify(x => x.GetList(true, null, fromDate, toDate, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, fromDate, toDate, null, null), Times.Once);
}
[Test]
public void GetWorkersByBirthDate_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-40);
var toDate = DateTime.UtcNow.AddYears(-20);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(new List<WorkerDataModel>());
var listOnlyActive = _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, true);
var list = _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Has.Count.EqualTo(0));
Assert.That(list, Has.Count.EqualTo(0));
});
_workerStorageContract.Verify(x => x.GetList(true, null, fromDate, toDate, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, fromDate, toDate, null, null), Times.Once);
}
[Test]
public void GetWorkersByBirthDate_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
Assert.That(() => _workerBusinessLogicContract.GetWorkersByBirthDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _workerBusinessLogicContract.GetWorkersByBirthDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
}
[Test]
public void GetWorkersByBirthDate_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-40);
var toDate = DateTime.UtcNow.AddYears(-20);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns((List<WorkerDataModel>)null);
Assert.That(() => _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, It.IsAny<bool>()), Throws.TypeOf<NullListException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetWorkersByBirthDate_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-40);
var toDate = DateTime.UtcNow.AddYears(-20);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.GetWorkersByBirthDate(fromDate, toDate, It.IsAny<bool>()), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), fromDate, toDate, It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetWorkersByEmploymentDate_ReturnListOfRecords_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-5);
var toDate = DateTime.UtcNow.AddYears(-1);
var listOriginal = new List<WorkerDataModel>
{
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30)),
new(Guid.NewGuid().ToString(), "Jane Smith", Guid.NewGuid().ToString(), "+7-777-777-77-78", DateTime.UtcNow.AddYears(-25)),
new(Guid.NewGuid().ToString(), "Sam Brown", Guid.NewGuid().ToString(), "+7-777-777-77-79", DateTime.UtcNow.AddYears(-28)),
};
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate))
.Returns(listOriginal);
var listOnlyActive = _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, true);
var list = _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerStorageContract.Verify(x => x.GetList(true, null, null, null, fromDate, toDate), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, null, null, fromDate, toDate), Times.Once);
}
[Test]
public void GetWorkersByEmploymentDate_ReturnEmptyList_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-5);
var toDate = DateTime.UtcNow.AddYears(-1);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate))
.Returns(new List<WorkerDataModel>());
var listOnlyActive = _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, true);
var list = _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Has.Count.EqualTo(0));
Assert.That(list, Has.Count.EqualTo(0));
});
_workerStorageContract.Verify(x => x.GetList(true, null, null, null, fromDate, toDate), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, null, null, null, fromDate, toDate), Times.Once);
}
[Test]
public void GetWorkersByEmploymentDate_IncorrectDates_ThrowException_Test()
{
var date = DateTime.UtcNow;
Assert.That(() => _workerBusinessLogicContract.GetWorkersByEmploymentDate(date, date, It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
Assert.That(() => _workerBusinessLogicContract.GetWorkersByEmploymentDate(date, date.AddSeconds(-1), It.IsAny<bool>()), Throws.TypeOf<IncorrectDatesException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime>(), It.IsAny<DateTime>()), Times.Never);
}
[Test]
public void GetWorkersByEmploymentDate_ReturnNull_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-5);
var toDate = DateTime.UtcNow.AddYears(-1);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate))
.Returns((List<WorkerDataModel>)null);
Assert.That(() => _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, It.IsAny<bool>()), Throws.TypeOf<NullListException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate), Times.Once);
}
[Test]
public void GetWorkersByEmploymentDate_StorageThrowError_ThrowException_Test()
{
var fromDate = DateTime.UtcNow.AddYears(-5);
var toDate = DateTime.UtcNow.AddYears(-1);
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.GetWorkersByEmploymentDate(fromDate, toDate, It.IsAny<bool>()), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), fromDate, toDate), Times.Once);
}
[Test]
public void GetWorkersBySpecialization_ReturnListOfRecords_Test()
{
var specializationId = Guid.NewGuid().ToString();
var listOriginal = new List<WorkerDataModel>
{
new(Guid.NewGuid().ToString(), "John Doe", specializationId, "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30)),
new(Guid.NewGuid().ToString(), "Jane Smith", specializationId, "+7-777-777-77-78", DateTime.UtcNow.AddYears(-25)),
new(Guid.NewGuid().ToString(), "Sam Brown", specializationId, "+7-777-777-77-79", DateTime.UtcNow.AddYears(-28)),
};
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(listOriginal);
var listOnlyActive = _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, true);
var list = _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal));
Assert.That(list, Is.EquivalentTo(listOriginal));
});
_workerStorageContract.Verify(x => x.GetList(true, specializationId, null, null, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, specializationId, null, null, null, null), Times.Once);
}
[Test]
public void GetWorkersBySpecialization_ReturnEmptyList_Test()
{
var specializationId = Guid.NewGuid().ToString();
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns(new List<WorkerDataModel>());
var listOnlyActive = _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, true);
var list = _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, false);
Assert.Multiple(() =>
{
Assert.That(listOnlyActive, Is.Not.Null);
Assert.That(list, Is.Not.Null);
Assert.That(listOnlyActive, Has.Count.EqualTo(0));
Assert.That(list, Has.Count.EqualTo(0));
});
_workerStorageContract.Verify(x => x.GetList(true, specializationId, null, null, null, null), Times.Once);
_workerStorageContract.Verify(x => x.GetList(false, specializationId, null, null, null, null), Times.Once);
}
[Test]
public void GetWorkersBySpecialization_SpecializationIdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.GetWorkersBySpecialization(null, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerBusinessLogicContract.GetWorkersBySpecialization(string.Empty, It.IsAny<bool>()), Throws.TypeOf<ArgumentNullException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
}
[Test]
public void GetWorkersBySpecialization_SpecializationIdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.GetWorkersBySpecialization("invalid_guid", It.IsAny<bool>()), Throws.TypeOf<ValidationException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Never);
}
[Test]
public void GetWorkersBySpecialization_ReturnNull_ThrowException_Test()
{
var specializationId = Guid.NewGuid().ToString();
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Returns((List<WorkerDataModel>)null);
Assert.That(() => _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, It.IsAny<bool>()), Throws.TypeOf<NullListException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetWorkersBySpecialization_StorageThrowError_ThrowException_Test()
{
var specializationId = Guid.NewGuid().ToString();
_workerStorageContract.Setup(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.GetWorkersBySpecialization(specializationId, It.IsAny<bool>()), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.GetList(It.IsAny<bool>(), specializationId, It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>(), It.IsAny<DateTime?>()), Times.Once);
}
[Test]
public void GetWorkerByData_GetById_ReturnRecord_Test()
{
var id = Guid.NewGuid().ToString();
var record = new WorkerDataModel(id, "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30));
_workerStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
var element = _workerBusinessLogicContract.GetWorkerByData(id);
Assert.That(element, Is.Not.Null);
Assert.That(element.Id, Is.EqualTo(id));
_workerStorageContract.Verify(x => x.GetElementById(id), Times.Once);
}
[Test]
public void GetWorkerByData_GetByFio_ReturnRecord_Test()
{
var fio = "John Doe";
var record = new WorkerDataModel(Guid.NewGuid().ToString(), fio, Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30));
_workerStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record);
var element = _workerBusinessLogicContract.GetWorkerByData(fio);
Assert.That(element, Is.Not.Null);
Assert.That(element.FIO, Is.EqualTo(fio));
_workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
}
[Test]
public void GetWorkerByData_EmptyData_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWorkerByData_GetById_NotFoundRecord_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_workerStorageContract.Setup(x => x.GetElementById(id)).Returns((WorkerDataModel)null);
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(id), Throws.TypeOf<ElementNotFoundException>());
_workerStorageContract.Verify(x => x.GetElementById(id), Times.Once);
_workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
}
[Test]
public void GetWorkerByData_GetByFio_NotFoundRecord_ThrowException_Test()
{
var fio = "John Doe";
_workerStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns((WorkerDataModel)null);
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(fio), Throws.TypeOf<ElementNotFoundException>());
_workerStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
_workerStorageContract.Verify(x => x.GetElementByFIO(fio), Times.Once);
}
[Test]
public void GetWorkerByData_StorageThrowError_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
var fio = "John Doe";
_workerStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
_workerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(id), Throws.TypeOf<StorageException>());
Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(fio), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.GetElementById(id), Times.Once);
_workerStorageContract.Verify(x => x.GetElementByFIO(fio), Times.Once);
}
[Test]
public void InsertWorker_CorrectRecord_Test()
{
var flag = false;
var record = new WorkerDataModel(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30));
_workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>()))
.Callback((WorkerDataModel x) =>
{
flag = x.Id == record.Id &&
x.FIO == record.FIO &&
x.SpecializationId == record.SpecializationId &&
x.PhoneNumber == record.PhoneNumber &&
x.DateBirthDay == record.DateBirthDay;
});
_workerBusinessLogicContract.InsertWorker(record);
_workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void InsertWorker_RecordWithExistsData_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>()))
.Throws(new ElementExistsException("Worker already exists", "ID"));
Assert.That(() => _workerBusinessLogicContract.InsertWorker(
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<ElementExistsException>());
_workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
}
[Test]
public void InsertWorker_NullRecord_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.InsertWorker(null), Throws.TypeOf<ArgumentNullException>());
_workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
}
[Test]
public void InsertWorker_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.InsertWorker(
new WorkerDataModel("invalid-guid", "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<ValidationException>());
_workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Never);
}
[Test]
public void InsertWorker_StorageThrowError_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.AddElement(It.IsAny<WorkerDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.InsertWorker(
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.AddElement(It.IsAny<WorkerDataModel>()), Times.Once);
}
[Test]
public void UpdateWorker_CorrectRecord_Test()
{
var flag = false;
var record = new WorkerDataModel(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30));
_workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>()))
.Callback((WorkerDataModel x) =>
{
flag = x.Id == record.Id &&
x.FIO == record.FIO &&
x.SpecializationId == record.SpecializationId &&
x.PhoneNumber == record.PhoneNumber &&
x.DateBirthDay == record.DateBirthDay;
});
_workerBusinessLogicContract.UpdateWorker(record);
_workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
Assert.That(flag);
}
[Test]
public void UpdateWorker_RecordWithIncorrectData_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>())).Throws(new ElementNotFoundException("Worker not found"));
Assert.That(() => _workerBusinessLogicContract.UpdateWorker(
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<ElementNotFoundException>());
_workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
}
[Test]
public void UpdateWorker_NullRecord_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.UpdateWorker(null), Throws.TypeOf<ArgumentNullException>());
_workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
}
[Test]
public void UpdateWorker_InvalidRecord_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.UpdateWorker(
new WorkerDataModel("invalid-guid", "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<ValidationException>());
_workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Never);
}
[Test]
public void UpdateWorker_StorageThrowError_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.UpdElement(It.IsAny<WorkerDataModel>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.UpdateWorker(
new(Guid.NewGuid().ToString(), "John Doe", Guid.NewGuid().ToString(), "+7-777-777-77-77", DateTime.UtcNow.AddYears(-30))),
Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.UpdElement(It.IsAny<WorkerDataModel>()), Times.Once);
}
[Test]
public void DeleteWorker_CorrectRecord_Test()
{
var id = Guid.NewGuid().ToString();
var flag = false;
_workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id)))
.Callback(() => { flag = true; });
_workerBusinessLogicContract.DeleteWorker(id);
_workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
Assert.That(flag);
}
[Test]
public void DeleteWorker_RecordWithIncorrectId_ThrowException_Test()
{
var id = Guid.NewGuid().ToString();
_workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x != id)))
.Throws(new ElementNotFoundException(id));
Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
_workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
[Test]
public void DeleteWorker_IdIsNullOrEmpty_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.DeleteWorker(null), Throws.TypeOf<ArgumentNullException>());
Assert.That(() => _workerBusinessLogicContract.DeleteWorker(string.Empty), Throws.TypeOf<ArgumentNullException>());
_workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWorker_IdIsNotGuid_ThrowException_Test()
{
Assert.That(() => _workerBusinessLogicContract.DeleteWorker("invalid-id"), Throws.TypeOf<ValidationException>());
_workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
}
[Test]
public void DeleteWorker_StorageThrowError_ThrowException_Test()
{
_workerStorageContract.Setup(x => x.DelElement(It.IsAny<string>()))
.Throws(new StorageException(new InvalidOperationException()));
Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
_workerStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
}
}

356
TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerComplitedWorkBusinessLogicContractTests.cs Normal file
View File

@@ -0,0 +1,356 @@
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);
}
[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);
}
}

2
TwoFromTheCasketContracts/TwoFromTheCasketTests/TwoFromTheCasketTests.csproj
View File

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