diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/CollectBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/CollectBusinessLogicContractTests.cs new file mode 100644 index 0000000..327b0b0 --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/CollectBusinessLogicContractTests.cs @@ -0,0 +1,353 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.DataModels; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +[TestFixture] +internal class CollectBusinessLogicContractTests +{ + private CollectBusinessLogicContract _collectBusinessLogicContract; + private Mock _collectStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _collectStorageContract = new Mock(); + _collectBusinessLogicContract = new CollectBusinessLogicContract(_collectStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _collectStorageContract.Reset(); + } + [Test] + public void GetAllCollectsByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20), + }; + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, null), Times.Once); + } + + [Test] + public void GetAllCollectsByPeriod_ReturnEmptyList_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByPeriod_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByPeriod_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var workerId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20), + }; + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(workerId, date, date.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), workerId, null), Times.Once); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_ReturnEmptyList_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_WorkerIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_WorkerIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod("workerId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByWorkerByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByWorkerByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + [Test] + public void GetAllCollectsByFurnitureByPeriod_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var furnitureId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15), + new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20), + }; + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(furnitureId, date, date.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _collectStorageContract.Verify(x => x.GetList(date, date.AddDays(1), null, furnitureId), Times.Once); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_ReturnEmptyList_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), date, date), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), date, date.AddSeconds(-1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_FurnitureIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(null, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(string.Empty, DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_FurnitureIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod("furnitureId", DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllCollectsByFurnitureByPeriod_StorageThrowError_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetAllCollectsByFurnitureByPeriod(Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + [Test] + public void GetCollectByData_GetById_ReturnRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var record = new CollectDataModel(id, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10); + _collectStorageContract.Setup(x => x.GetElementById(id)).Returns(record); + //Act + var element = _collectBusinessLogicContract.GetCollectByData(id); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Id, Is.EqualTo(id)); + _collectStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetCollectByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetCollectByData(null), Throws.TypeOf()); + Assert.That(() => _collectBusinessLogicContract.GetCollectByData(string.Empty), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + } + + [Test] + public void GetCollectByData_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetCollectByData("collectId"), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + } + + [Test] + public void GetCollectByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetCollectByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetCollectByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.GetCollectByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + [Test] + public void InsertCollect_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new CollectDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10); + _collectStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((CollectDataModel x) => + { + flag = x.Id == record.Id && + x.WorkerId == record.WorkerId && + x.FurnitureId == record.FurnitureId && + x.Sum == record.Sum; + }); + //Act + _collectBusinessLogicContract.InsertCollect(record); + //Assert + _collectStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertCollect_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.InsertCollect(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertCollect_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.InsertCollect(null), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertCollect_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.InsertCollect(new CollectDataModel("id", Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertCollect_StorageThrowError_ThrowException_Test() + { + //Arrange + _collectStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _collectBusinessLogicContract.InsertCollect(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10)), Throws.TypeOf()); + _collectStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } +} diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/FurnitureBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/FurnitureBusinessLogicContractTests.cs new file mode 100644 index 0000000..3efcde5 --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/FurnitureBusinessLogicContractTests.cs @@ -0,0 +1,498 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.DataModels; +using SoftBedContracts.Enums; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; +using static NUnit.Framework.Internal.OSPlatform; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +[TestFixture] +internal class FurnitureBusinessLogicContractTests +{ + private FurnitureBusinessLogicContract _furnitureBusinessLogicContract; + private Mock _furnitureStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _furnitureStorageContract = new Mock(); + _furnitureBusinessLogicContract = new FurnitureBusinessLogicContract(_furnitureStorageContract.Object, new Mock().Object); + } + [SetUp] + public void SetUp() + { + _furnitureStorageContract.Reset(); + } + [Test] + public void GetAllFurniture_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "name 1", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),5)]), + new(Guid.NewGuid().ToString(), "name 2", FurnitureType.CabinetFurniture, 10, false, []), + new(Guid.NewGuid().ToString(), "name 3", FurnitureType.CabinetFurniture, 10, false, []), + }; + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurniture(true); + var list = _furnitureBusinessLogicContract.GetAllFurniture(false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(list, Is.Not.Null); + Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal)); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _furnitureStorageContract.Verify(x => x.GetList(true, null), Times.Once); + _furnitureStorageContract.Verify(x => x.GetList(false, null), Times.Once); + } + + [Test] + public void GetAllFurniture_ReturnEmptyList_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Returns([]); + //Act + var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurniture(true); + var list = _furnitureBusinessLogicContract.GetAllFurniture(false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(list, Is.Not.Null); + Assert.That(listOnlyActive, Has.Count.EqualTo(0)); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), null), Times.Exactly(2)); + } + + [Test] + public void GetAllFurniture_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurniture(It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllFurniture_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurniture(It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllFurnitureByWorkPieces_ReturnListOfRecords_Test() + { + //Arrange + var workPieceId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "name 1", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),5)]), + new(Guid.NewGuid().ToString(), "name 2", FurnitureType.CabinetFurniture, 10, false, []), + new(Guid.NewGuid().ToString(), "name 3", FurnitureType.CabinetFurniture, 10, false, []), + }; + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, true); + var list = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(list, Is.Not.Null); + Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal)); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _furnitureStorageContract.Verify(x => x.GetList(true, workPieceId), Times.Once); + _furnitureStorageContract.Verify(x => x.GetList(false, workPieceId), Times.Once); + } + [Test] + public void GetAllFurnitureByWorkPieces_ReturnEmptyList_Test() + { + //Arrange + var workPieceId = Guid.NewGuid().ToString(); + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Returns([]); + //Act + var listOnlyActive = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, true); + var list = _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(workPieceId, false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(list, Is.Not.Null); + Assert.That(listOnlyActive, Has.Count.EqualTo(0)); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), workPieceId), Times.Exactly(2)); + } + + [Test] + public void GetAllFurnitureByWorkPieces_WorkPieceIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(null, It.IsAny()), Throws.TypeOf()); + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(string.Empty, It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllFurnitureByWorkPieces_WorkPieceIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces("workPieceId", It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllFurnitureByWorkPieces_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(Guid.NewGuid().ToString(), It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllFurnitureByWorkPieces_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetAllFurnitureByWorkPieces(Guid.NewGuid().ToString(), It.IsAny()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny()), Times.Once); + } + [Test] + public void GetFurnitureHistoryByFurniture_ReturnListOfRecords_Test() + { + //Arrange + var furnitureId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), 10), + new(Guid.NewGuid().ToString(), 15), + new(Guid.NewGuid().ToString(), 10), + }; + _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny())).Returns(listOriginal); + //Act + var list = _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(furnitureId); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(furnitureId), Times.Once); + } + + [Test] + public void GetFurnitureHistoryByFurniture_ReturnEmptyList_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny())).Returns([]); + //Act + var list = _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString()); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureHistoryByFurniture_FurnitureIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(null), Throws.TypeOf()); + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(string.Empty), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny()), Times.Never); + } + + [Test] + public void GetFurnitureHistoryByFurniture_FurnitureIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture("furnitureId"), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny()), Times.Never); + } + + [Test] + public void GetFurnitureHistoryByFurniture_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureHistoryByFurniture_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetHistoryByFurnitureId(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureHistoryByFurniture(Guid.NewGuid().ToString()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetHistoryByFurnitureId(It.IsAny()), Times.Once); + } + [Test] + public void GetFurnitureByData_GetById_ReturnRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var record = new FurnitureDataModel(id, "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]); + _furnitureStorageContract.Setup(x => x.GetElementById(id)).Returns(record); + //Act + var element = _furnitureBusinessLogicContract.GetFurnitureByData(id); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Id, Is.EqualTo(id)); + _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureByData_GetByName_ReturnRecord_Test() + { + //Arrange + var name = "name"; + var record = new FurnitureDataModel(Guid.NewGuid().ToString(), name, FurnitureType.CabinetFurniture, 10, false, []); + _furnitureStorageContract.Setup(x => x.GetElementByName(name)).Returns(record); + //Act + var element = _furnitureBusinessLogicContract.GetFurnitureByData(name); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.FurnitureName, Is.EqualTo(name)); + _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(null), Throws.TypeOf()); + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(string.Empty), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + } + + [Test] + public void GetFurnitureByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureByData_GetByName_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData("name"), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void GetFurnitureByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _furnitureStorageContract.Setup(x => x.GetElementByName(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _furnitureBusinessLogicContract.GetFurnitureByData("name"), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _furnitureStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + [Test] + public void InsertFurniture_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new FurnitureDataModel(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]); + _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((FurnitureDataModel x) => + { + flag = x.Id == record.Id && x.FurnitureName == record.FurnitureName && x.FurnitureType == record.FurnitureType + && x.Price == record.Price && x.IsDeleted == record.IsDeleted && + x.WorkPieces.Count == record.WorkPieces.Count && + x.WorkPieces.First().FurnitureId == record.WorkPieces.First().FurnitureId && + x.WorkPieces.First().WorkPieceId == record.WorkPieces.First().WorkPieceId && + x.WorkPieces.First().Count == record.WorkPieces.First().Count; ; + }); + //Act + _furnitureBusinessLogicContract.InsertFurniture(record); + //Assert + _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertFurniture_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertFurniture_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(null), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertFurniture_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new FurnitureDataModel("id", "name", FurnitureType.CabinetFurniture, 10, false, + [])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertFurniture_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.InsertFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateFurniture_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new FurnitureDataModel(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)]); + _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .Callback((FurnitureDataModel x) => + { + flag = x.Id == record.Id && x.FurnitureName == record.FurnitureName && x.FurnitureType == record.FurnitureType + && x.Price == record.Price && x.IsDeleted == record.IsDeleted && + x.WorkPieces.Count == record.WorkPieces.Count && + x.WorkPieces.First().FurnitureId == record.WorkPieces.First().FurnitureId && + x.WorkPieces.First().WorkPieceId == record.WorkPieces.First().WorkPieceId && + x.WorkPieces.First().Count == record.WorkPieces.First().Count; ; + }); + //Act + _furnitureBusinessLogicContract.UpdateFurniture(record); + //Assert + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateFurniture_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateFurniture_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateFurniture_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(null), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateFurniture_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new FurnitureDataModel("id", "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateFurniture_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.UpdateFurniture(new(Guid.NewGuid().ToString(), "name", FurnitureType.CabinetFurniture, 10, false, + [new FurnitureWorkPieceDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)])), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteFurniture_CorrectRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var flag = false; + _furnitureStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; }); + //Act + _furnitureBusinessLogicContract.DeleteFurniture(id); + //Assert + _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void DeleteFurniture_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + _furnitureStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(Guid.NewGuid().ToString()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteFurniture_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(null), Throws.TypeOf()); + Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(string.Empty), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteFurniture_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture("id"), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteFurniture_StorageThrowError_ThrowException_Test() + { + //Arrange + _furnitureStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _furnitureBusinessLogicContract.DeleteFurniture(Guid.NewGuid().ToString()), Throws.TypeOf()); + _furnitureStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs new file mode 100644 index 0000000..cb52a9e --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/PostBusinessLogicContractTests.cs @@ -0,0 +1,454 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.DataModels; +using SoftBedContracts.Enums; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +[TestFixture] +internal class PostBusinessLogicContractTests +{ + private PostBusinessLogicContract _postBusinessLogicContract; + private Mock _postStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _postStorageContract = new Mock(); + _postBusinessLogicContract = new PostBusinessLogicContract(_postStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _postStorageContract.Reset(); + } + + [Test] + public void GetAllPosts_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(),"name 1", PostType.Loader, 10, true, DateTime.UtcNow), + new(Guid.NewGuid().ToString(), "name 2", PostType.Loader, 10, false, DateTime.UtcNow), + new(Guid.NewGuid().ToString(), "name 3", PostType.Loader, 10, true, DateTime.UtcNow), + }; + _postStorageContract.Setup(x => x.GetList(It.IsAny())).Returns(listOriginal); + //Act + var listOnlyActive = _postBusinessLogicContract.GetAllPosts(true); + var listAll = _postBusinessLogicContract.GetAllPosts(false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(listAll, Is.Not.Null); + Assert.That(listOnlyActive, Is.EquivalentTo(listOriginal)); + Assert.That(listAll, Is.EquivalentTo(listOriginal)); + }); + _postStorageContract.Verify(x => x.GetList(true), Times.Once); + _postStorageContract.Verify(x => x.GetList(false), Times.Once); + } + + [Test] + public void GetAllPosts_ReturnEmptyList_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetList(It.IsAny())).Returns([]); + //Act + var listOnlyActive = _postBusinessLogicContract.GetAllPosts(true); + var listAll = _postBusinessLogicContract.GetAllPosts(false); + //Assert + Assert.Multiple(() => + { + Assert.That(listOnlyActive, Is.Not.Null); + Assert.That(listAll, Is.Not.Null); + Assert.That(listOnlyActive, Has.Count.EqualTo(0)); + Assert.That(listAll, Has.Count.EqualTo(0)); + }); + _postStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Exactly(2)); + } + + [Test] + public void GetAllPosts_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllPosts_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetList(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllPosts(It.IsAny()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetList(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_ReturnListOfRecords_Test() + { + //Arrange + var postId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(postId, "name 1", PostType.Loader, 10, true, DateTime.UtcNow), + new(postId, "name 2", PostType.Loader, 10, false, DateTime.UtcNow) + }; + _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny())).Returns(listOriginal); + //Act + var list = _postBusinessLogicContract.GetAllDataOfPost(postId); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(2)); + _postStorageContract.Verify(x => x.GetPostWithHistory(postId), Times.Once); + } + + [Test] + public void GetAllDataOfPost_ReturnEmptyList_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny())).Returns([]); + //Act + var list = _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_PostIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Never); + } + + [Test] + public void GetAllDataOfPost_PostIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Never); + } + + [Test] + public void GetAllDataOfPost_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Once); + } + + [Test] + public void GetAllDataOfPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetPostWithHistory(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetAllDataOfPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetPostWithHistory(It.IsAny()), Times.Once); + } + + [Test] + public void GetPostByData_GetById_ReturnRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var record = new PostDataModel(id, "name", PostType.Loader, 10, true, DateTime.UtcNow); + _postStorageContract.Setup(x => x.GetElementById(id)).Returns(record); + //Act + var element = _postBusinessLogicContract.GetPostByData(id); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Id, Is.EqualTo(id)); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetPostByData_GetByName_ReturnRecord_Test() + { + //Arrange + var postName = "name"; + var record = new PostDataModel(Guid.NewGuid().ToString(), postName, PostType.Loader, 10, true, DateTime.UtcNow); + _postStorageContract.Setup(x => x.GetElementByName(postName)).Returns(record); + //Act + var element = _postBusinessLogicContract.GetPostByData(postName); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.PostName, Is.EqualTo(postName)); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void GetPostByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetPostByData(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + } + + [Test] + public void GetPostByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Never); + } + + [Test] + public void GetPostByData_GetByName_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void GetPostByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _postStorageContract.Setup(x => x.GetElementByName(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.GetPostByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.GetPostByData("name"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _postStorageContract.Verify(x => x.GetElementByName(It.IsAny()), Times.Once); + } + + [Test] + public void InsertPost_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow.AddDays(-1)); + _postStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((PostDataModel x) => + { + flag = x.Id == record.Id && x.PostName == record.PostName && x.PostType == record.PostType && x.Salary == record.Salary && + x.ChangeDate == record.ChangeDate; + }); + //Act + _postBusinessLogicContract.InsertPost(record); + //Assert + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertPost_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertPost_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(null), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertPost_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(new PostDataModel("id", "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.InsertPost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdatePost_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow.AddDays(-1)); + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .Callback((PostDataModel x) => + { + flag = x.Id == record.Id && x.PostName == record.PostName && x.PostType == record.PostType && x.Salary == record.Salary && + x.ChangeDate == record.ChangeDate; + }); + //Act + _postBusinessLogicContract.UpdatePost(record); + //Assert + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdatePost_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdatePost_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "anme", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdatePost_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(null), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdatePost_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new PostDataModel("id", "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdatePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.UpdatePost(new(Guid.NewGuid().ToString(), "name", PostType.Assistent, 10, true, DateTime.UtcNow)), Throws.TypeOf()); + _postStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeletePost_CorrectRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var flag = false; + _postStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; }); + //Act + _postBusinessLogicContract.DeletePost(id); + //Assert + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void DeletePost_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + _postStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeletePost_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.DeletePost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeletePost_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeletePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.DeletePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void RestorePost_CorrectRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var flag = false; + _postStorageContract.Setup(x => x.ResElement(It.Is((string x) => x == id))).Callback(() => { flag = true; }); + //Act + _postBusinessLogicContract.RestorePost(id); + //Assert + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void RestorePost_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + _postStorageContract.Setup(x => x.ResElement(It.IsAny())).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Once); + } + + [Test] + public void RestorePost_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(null), Throws.TypeOf()); + Assert.That(() => _postBusinessLogicContract.RestorePost(string.Empty), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Never); + } + + [Test] + public void RestorePost_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost("id"), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Never); + } + + [Test] + public void RestorePost_StorageThrowError_ThrowException_Test() + { + //Arrange + _postStorageContract.Setup(x => x.ResElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _postBusinessLogicContract.RestorePost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _postStorageContract.Verify(x => x.ResElement(It.IsAny()), Times.Once); + } +} diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs new file mode 100644 index 0000000..4c7af80 --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/SalaryBusinessLogicContractTests.cs @@ -0,0 +1,346 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.DataModels; +using SoftBedContracts.Enums; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +[TestFixture] +internal class SalaryBusinessLogicContractTests +{ + private SalaryBusinessLogicContract _salaryBusinessLogicContract; + private Mock _salaryStorageContract; + private Mock _collectStorageContract; + private Mock _postStorageContract; + private Mock _workerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _salaryStorageContract = new Mock(); + _collectStorageContract = new Mock(); + _postStorageContract = new Mock(); + _workerStorageContract = new Mock(); + _salaryBusinessLogicContract = new SalaryBusinessLogicContract(_salaryStorageContract.Object, + _collectStorageContract.Object, _postStorageContract.Object, _workerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _salaryStorageContract.Reset(); + _collectStorageContract.Reset(); + _postStorageContract.Reset(); + _workerStorageContract.Reset(); + } + + [Test] + public void GetAllSalaries_ReturnListOfRecords_Test() + { + //Arrange + var startDate = DateTime.UtcNow; + var endDate = DateTime.UtcNow.AddDays(1); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10), + new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14), + new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30), + }; + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(startDate, endDate); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, null), Times.Once); + } + + [Test] + public void GetAllSalaries_ReturnEmptyList_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalaries_IncorrectDates_ThrowException_Test() + { + //Arrange + var dateTime = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime), Throws.TypeOf()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(dateTime, dateTime.AddSeconds(-1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalaries_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalaries_StorageThrowError_ThrowException_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriod(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalariesByWorker_ReturnListOfRecords_Test() + { + //Arrange + var startDate = DateTime.UtcNow; + var endDate = DateTime.UtcNow.AddDays(1); + var workerId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), DateTime.UtcNow, 10), + new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(1), 14), + new(Guid.NewGuid().ToString(), DateTime.UtcNow.AddDays(-1), 30), + }; + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(startDate, endDate, workerId); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + _salaryStorageContract.Verify(x => x.GetList(startDate, endDate, workerId), Times.Once); + } + + [Test] + public void GetAllSalariesByWorker_ReturnEmptyList_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()); + //Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalariesByWorker_IncorrectDates_ThrowException_Test() + { + //Arrange + var dateTime = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime, Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(dateTime, dateTime.AddSeconds(-1), Guid.NewGuid().ToString()), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalariesByWorker_WorkerIdIsNUllOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), null), Throws.TypeOf()); + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), string.Empty), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalariesByWorker_WorkerIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), "workerId"), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllSalariesByWorker_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllSalariesByWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _salaryStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.GetAllSalariesByPeriodByWorker(DateTime.UtcNow, DateTime.UtcNow.AddDays(1), Guid.NewGuid().ToString()), Throws.TypeOf()); + _salaryStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void CalculateSalaryByMonth_CalculateSalary_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + var collectSum = 300.0; + var postSalary = 3000.0; + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 300)]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, postSalary, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + var sum = 0.0; + var expectedSum = postSalary + collectSum * 0.1; + _salaryStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((SalaryDataModel x) => + { + sum = x.Salary; + }); + //Act + _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow); + //Assert + Assert.That(sum, Is.EqualTo(expectedSum)); + } + + [Test] + public void CalculateSalaryByMonth_WithSeveralWorkers_Test() + { + //Arrange + var worker1Id = Guid.NewGuid().ToString(); + var worker2Id = Guid.NewGuid().ToString(); + var worker3Id = Guid.NewGuid().ToString(); + var list = new List() { + new(worker1Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow), + new(worker2Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow), + new(worker3Id, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow) + }; + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), worker1Id, Guid.NewGuid().ToString(), 10), + new CollectDataModel(Guid.NewGuid().ToString(), worker1Id, Guid.NewGuid().ToString(), 10), + new CollectDataModel(Guid.NewGuid().ToString(), worker2Id, Guid.NewGuid().ToString(), 10), + new CollectDataModel(Guid.NewGuid().ToString(), worker3Id, Guid.NewGuid().ToString(), 10), + new CollectDataModel(Guid.NewGuid().ToString(), worker3Id, Guid.NewGuid().ToString(), 10)]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(list); + //Act + _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow); + //Assert + _salaryStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Exactly(list.Count)); + } + + [Test] + public void CalculateSalaryByMonth_WithoutCollectsByWorker_Test() + { + //Arrange + var postSalary = 3000.0; + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, postSalary, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + var sum = 0.0; + var expectedSum = postSalary; + _salaryStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((SalaryDataModel x) => + { + sum = x.Salary; + }); + //Act + _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow); + //Assert + Assert.That(sum, Is.EqualTo(expectedSum)); + } + + [Test] + public void CalculateSalaryByMonth_CollectStorageReturnNull_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMonth_PostStorageReturnNull_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]); + _workerStorageContract.Setup(x => x.GetList( It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMonth_WorkerStorageReturnNull_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow)); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMonth_CollectStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMonth_PostStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new WorkerDataModel(workerId, "Test", Guid.NewGuid().ToString(), DateTime.UtcNow, DateTime.UtcNow)]); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } + + [Test] + public void CalculateSalaryByMonth_WorkerStorageThrowException_ThrowException_Test() + { + //Arrange + var workerId = Guid.NewGuid().ToString(); + _collectStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns([new CollectDataModel(Guid.NewGuid().ToString(), workerId, Guid.NewGuid().ToString(), 10)]); + _postStorageContract.Setup(x => x.GetElementById(It.IsAny())) + .Returns(new PostDataModel(Guid.NewGuid().ToString(), "name", PostType.Loader, 2000, true, DateTime.UtcNow)); + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _salaryBusinessLogicContract.CalculateSalaryByMonth(DateTime.UtcNow), Throws.TypeOf()); + } +} \ No newline at end of file diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkPieceBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkPieceBusinessLogicContractTests.cs new file mode 100644 index 0000000..6287e25 --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkPieceBusinessLogicContractTests.cs @@ -0,0 +1,311 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.BusinessLogicsContracts; +using SoftBedContracts.DataModels; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +[TestFixture] +internal class WorkPieceBusinessLogicContractTests +{ + private IWorkPieceBusinessLogicContract _workPieceBusinessLogicContract; + private Mock _workPieceStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _workPieceStorageContract = new Mock(); + _workPieceBusinessLogicContract = new WorkPieceBusinessLogicContract(_workPieceStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _workPieceStorageContract.Reset(); + } + [Test] + public void GetAllWorkPieces_ReturnListOfRecords_Test() + { + // Arrange + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(),"100x100",100), + new(Guid.NewGuid().ToString(),"20x20",20), + new(Guid.NewGuid().ToString(),"30x100",30), + }; + _workPieceStorageContract.Setup(x => x.GetList()).Returns(listOriginal); + // Act + var list = _workPieceBusinessLogicContract.GetAllWorkPieces(); + // Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + } + [Test] + public void GetAllWorkPieces_ReturnEmptyList_Test() + { + // Arrange + _workPieceStorageContract.Setup(x => x.GetList()).Returns([]); + // Act + var list = _workPieceBusinessLogicContract.GetAllWorkPieces(); + // Assert + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + _workPieceStorageContract.Verify(x => x.GetList(), Times.Once); + } + [Test] + public void GetAllWorkPieces_ReturnNull_ThrowException_Test() + { + // Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetAllWorkPieces(), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetList(), Times.Once); + } + [Test] + public void GetAllWorkPieces_StorageThrowError_ThrowException_Test() + { + // Arrange + _workPieceStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException())); + // Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetAllWorkPieces(), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetList(), Times.Once); + } + [Test] + public void GetWorkPieceByData_GetById_ReturnRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var record = new WorkPieceDataModel(id, "100x100", 100); + _workPieceStorageContract.Setup(x => x.GetElementById(id)).Returns(record); + //Act + var element = _workPieceBusinessLogicContract.GetWorkPiecesByData(id); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Id, Is.EqualTo(id)); + _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkPieceByData_GetBySize_ReturnRecord_Test() + { + //Arrange + var size = "100x100"; + var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), size, 0); + _workPieceStorageContract.Setup(x => x.GetElementBySize(size)).Returns(record); + //Act + var element = _workPieceBusinessLogicContract.GetWorkPiecesByData(size); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Size, Is.EqualTo(size)); + _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkPieceByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(null), Throws.TypeOf()); + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(string.Empty), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkPieceByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkPieceByData_GetBySize_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData("100x100"), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny()), Times.Once); + } + [Test] + public void GetWorkPieceByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _workPieceStorageContract.Setup(x => x.GetElementBySize(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _workPieceBusinessLogicContract.GetWorkPiecesByData("100x100"), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workPieceStorageContract.Verify(x => x.GetElementBySize(It.IsAny()), Times.Once); + } + + [Test] + public void InsertWorkPiece_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), "100x100", 10); + _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((WorkPieceDataModel x) => + { + flag = x.Id == record.Id && x.Size == record.Size && x.Weight == record.Weight; + }); + //Act + _workPieceBusinessLogicContract.InsertWorkPiece(record); + //Assert + _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + [Test] + public void InsertWorkPiece_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertWorkPiece_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(null), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertWorkPiece_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new WorkPieceDataModel("id", "100x100", 10)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertWorkPiece_StorageThrowError_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.InsertWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + [Test] + public void UpdateWorkPiece_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new WorkPieceDataModel(Guid.NewGuid().ToString(), "100x100", 100); + _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .Callback((WorkPieceDataModel x) => + { + flag = x.Id == record.Id && x.Size == record.Size; + }); + //Act + _workPieceBusinessLogicContract.UpdateWorkPiece(record); + //Assert + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateWorkPiece_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateWorkPiece_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateWorkPiece_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(null), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateWorkPiece_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new WorkPieceDataModel("id", "100x100", 10)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateWorkPiece_StorageThrowError_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.UpdateWorkPiece(new(Guid.NewGuid().ToString(), "100x100", 100)), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteWorkPiece_CorrectRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var flag = false; + _workPieceStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; }); + //Act + _workPieceBusinessLogicContract.DeleteWorkPiece(id); + //Assert + _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void DeleteWorkPiece_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteWorkPiece_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(null), Throws.TypeOf()); + Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(string.Empty), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorkPiece_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece("id"), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorkPiece_StorageThrowError_ThrowException_Test() + { + //Arrange + _workPieceStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workPieceBusinessLogicContract.DeleteWorkPiece(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workPieceStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} + diff --git a/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs new file mode 100644 index 0000000..d901eae --- /dev/null +++ b/TheSoftBedProject/SoftBedTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs @@ -0,0 +1,531 @@ +using Microsoft.Extensions.Logging; +using Moq; +using SoftBedBusinessLogic.Implementations; +using SoftBedContracts.DataModels; +using SoftBedContracts.Exceptions; +using SoftBedContracts.StoragesContracts; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SoftBedTests.BusinessLogicsContractsTests; + +internal class WorkerBusinessLogicContractTests +{ + private WorkerBusinessLogicContract _workerBusinessLogicContract; + private Mock _workerStorageContract; + + [OneTimeSetUp] + public void OneTimeSetUp() + { + _workerStorageContract = new Mock(); + _workerBusinessLogicContract = new WorkerBusinessLogicContract(_workerStorageContract.Object, new Mock().Object); + } + + [SetUp] + public void SetUp() + { + _workerStorageContract.Reset(); + } + + [Test] + public void GetAllWorkers_ReturnListOfRecords_Test() + { + //Arrange + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + }; + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _workerBusinessLogicContract.GetAllWorkers(); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once); + } + + [Test] + public void GetAllWorkers_ReturnEmptyList_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _workerBusinessLogicContract.GetAllWorkers(); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once); + } + + [Test] + public void GetAllWorkers_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkers_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkers(), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(null, null, null, null, null), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_ReturnListOfRecords_Test() + { + //Arrange + var postId = Guid.NewGuid().ToString(); + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + }; + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _workerBusinessLogicContract.GetAllWorkersByPost(postId); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _workerStorageContract.Verify(x => x.GetList(postId, null, null, null, null), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_ReturnEmptyList_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString()); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_PostIdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(null), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(string.Empty), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByPost_PostIdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost("postId"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByPost_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByPost_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByPost(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + }; + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date.AddDays(1)); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _workerStorageContract.Verify(x => x.GetList(null, date, date.AddDays(1), null, null), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_ReturnEmptyList_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _workerBusinessLogicContract.GetAllWorkers(); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _workerStorageContract.Verify(x => x.GetList(null, It.IsAny(), It.IsAny(), null, null), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(date, date.AddSeconds(-1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByBirthDate_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByBirthDate_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByBirthDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_ReturnListOfRecords_Test() + { + //Arrange + var date = DateTime.UtcNow; + var listOriginal = new List() + { + new(Guid.NewGuid().ToString(), "fio 1", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 2", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + new(Guid.NewGuid().ToString(), "fio 3", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now), + }; + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(listOriginal); + //Act + var list = _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date.AddDays(1)); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Is.EquivalentTo(listOriginal)); + }); + _workerStorageContract.Verify(x => x.GetList(null, null, null, date, date.AddDays(1)), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_ReturnEmptyList_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns([]); + //Act + var list = _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)); + //Assert + Assert.Multiple(() => + { + Assert.That(list, Is.Not.Null); + Assert.That(list, Has.Count.EqualTo(0)); + }); + _workerStorageContract.Verify(x => x.GetList(null, null, null, It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_IncorrectDates_ThrowException_Test() + { + //Arrange + var date = DateTime.UtcNow; + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(date, date.AddSeconds(-1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void GetAllWorkersByEmploymentDate_ReturnNull_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetAllWorkersByEmploymentDate_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetAllWorkersByEmploymentDate(DateTime.UtcNow, DateTime.UtcNow.AddDays(1)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetList(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkerByData_GetById_ReturnRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var record = new WorkerDataModel(id, "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now); + _workerStorageContract.Setup(x => x.GetElementById(id)).Returns(record); + //Act + var element = _workerBusinessLogicContract.GetWorkerByData(id); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.Id, Is.EqualTo(id)); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkerByData_GetByFio_ReturnRecord_Test() + { + //Arrange + var fio = "fio"; + var record = new WorkerDataModel(Guid.NewGuid().ToString(), fio, Guid.NewGuid().ToString(), DateTime.Now.AddYears(-16).AddDays(-1), DateTime.Now); + _workerStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record); + //Act + var element = _workerBusinessLogicContract.GetWorkerByData(fio); + //Assert + Assert.That(element, Is.Not.Null); + Assert.That(element.FIO, Is.EqualTo(fio)); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkerByData_EmptyData_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(null), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(string.Empty), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkerByData_GetById_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Never); + } + + [Test] + public void GetWorkerByData_GetByFio_NotFoundRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Never); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + } + + [Test] + public void GetWorkerByData_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.GetElementById(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + _workerStorageContract.Setup(x => x.GetElementByFIO(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData(Guid.NewGuid().ToString()), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.GetWorkerByData("fio"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.GetElementById(It.IsAny()), Times.Once); + _workerStorageContract.Verify(x => x.GetElementByFIO(It.IsAny()), Times.Once); + } + + [Test] + public void InsertWorker_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now); + _workerStorageContract.Setup(x => x.AddElement(It.IsAny())) + .Callback((WorkerDataModel x) => + { + flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate && + x.EmploymentDate == record.EmploymentDate; + }); + //Act + _workerBusinessLogicContract.InsertWorker(record); + //Assert + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void InsertWorker_RecordWithExistsData_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new ElementExistsException("Data", "Data")); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.InsertWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void InsertWorker_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.InsertWorker(null), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertWorker_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.InsertWorker(new WorkerDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Never); + } + + [Test] + public void InsertWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.AddElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.InsertWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.AddElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateWorker_CorrectRecord_Test() + { + //Arrange + var flag = false; + var record = new WorkerDataModel(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now); + _workerStorageContract.Setup(x => x.UpdElement(It.IsAny())) + .Callback((WorkerDataModel x) => + { + flag = x.Id == record.Id && x.FIO == record.FIO && x.PostId == record.PostId && x.BirthDate == record.BirthDate && + x.EmploymentDate == record.EmploymentDate; + }); + //Act + _workerBusinessLogicContract.UpdateWorker(record); + //Assert + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void UpdateWorker_RecordWithIncorrectData_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new ElementNotFoundException("")); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void UpdateWorker_NullRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.UpdateWorker(null), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateWorker_InvalidRecord_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new WorkerDataModel("id", "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Never); + } + + [Test] + public void UpdateWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.UpdElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.UpdateWorker(new(Guid.NewGuid().ToString(), "fio", Guid.NewGuid().ToString(), DateTime.Now.AddYears(-18).AddDays(-1), DateTime.Now)), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.UpdElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteWorker_CorrectRecord_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + var flag = false; + _workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; }); + //Act + _workerBusinessLogicContract.DeleteWorker(id); + //Assert + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + Assert.That(flag); + } + + [Test] + public void DeleteWorker_RecordWithIncorrectId_ThrowException_Test() + { + //Arrange + var id = Guid.NewGuid().ToString(); + _workerStorageContract.Setup(x => x.DelElement(It.Is((string x) => x != id))).Throws(new ElementNotFoundException(id)); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } + + [Test] + public void DeleteWorker_IdIsNullOrEmpty_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(null), Throws.TypeOf()); + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(string.Empty), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorker_IdIsNotGuid_ThrowException_Test() + { + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker("id"), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Never); + } + + [Test] + public void DeleteWorker_StorageThrowError_ThrowException_Test() + { + //Arrange + _workerStorageContract.Setup(x => x.DelElement(It.IsAny())).Throws(new StorageException(new InvalidOperationException())); + //Act&Assert + Assert.That(() => _workerBusinessLogicContract.DeleteWorker(Guid.NewGuid().ToString()), Throws.TypeOf()); + _workerStorageContract.Verify(x => x.DelElement(It.IsAny()), Times.Once); + } +} \ No newline at end of file diff --git a/TheSoftBedProject/SoftBedTests/SoftBedTests.csproj b/TheSoftBedProject/SoftBedTests/SoftBedTests.csproj index 3bc0e7c..f85f111 100644 --- a/TheSoftBedProject/SoftBedTests/SoftBedTests.csproj +++ b/TheSoftBedProject/SoftBedTests/SoftBedTests.csproj @@ -12,12 +12,14 @@ + +