Тесты

TheSoftBedProject/SoftBedBusinessLogic/Implementations/CollectBusinessLogicContract.cs

@@ -42,7 +42,7 @@ internal class CollectBusinessLogicContract(ICollectStorageContract collectStora
 
     public List<CollectDataModel> GetAllCollectsByFurnitureByPeriod(string furnitureId, DateTime fromDate, DateTime toDate)
     {
-        _logger.LogInformation("GetAllCollects params: {buyerId}, {fromDate}, {toDate}", furnitureId, fromDate, toDate);
+        _logger.LogInformation("GetAllCollects params: {workPieceId}, {fromDate}, {toDate}", furnitureId, fromDate, toDate);
         if (fromDate.IsDateNotOlder(toDate))
         {
             throw new IncorrectDatesException(fromDate, toDate);
@@ -53,7 +53,7 @@ internal class CollectBusinessLogicContract(ICollectStorageContract collectStora
         }
         if (!furnitureId.IsGuid())
         {
-            throw new ValidationException("The value in the field buyerId is not a unique identifier.");
+            throw new ValidationException("The value in the field workPieceId is not a unique identifier.");
         }
         return _collectStorageContract.GetList(fromDate, toDate, furnitureId: furnitureId) ?? throw new NullListException();
     }

TheSoftBedProject/SoftBedContracts/DataModels/PostDataModel.cs

@@ -5,9 +5,9 @@ using SoftBedContracts.Infrastructure;
 
 namespace SoftBedContracts.DataModels;
 
-public class PostDataModel(string id, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation
+public class PostDataModel(string postId, string postName, PostType postType, double salary, bool isActual, DateTime changeDate) : IValidation
 {
-    public string Id { get; private set; } = id;
+    public string Id { get; private set; } = postId;
 
     public string PostName { get; private set; } = postName;
 

TheSoftBedProject/SoftBedContracts/DataModels/SalaryDataModel.cs

@@ -4,13 +4,13 @@ using SoftBedContracts.Infrastructure;
 
 namespace SoftBedContracts.DataModels;
 
-public class SalaryDataModel(string workerId, DateTime salaryDate, double salary) : IValidation
+public class SalaryDataModel(string workerId, DateTime salaryDate, double workerSalary) : IValidation
 {
     public string WorkerId { get; private set; } = workerId;
 
     public DateTime SalaryDate { get; private set; } = salaryDate;
 
-    public double Salary { get; private set; } = salary;
+    public double Salary { get; private set; } = workerSalary;
 
     public void Validate()
     {

TheSoftBedProject/SoftBedDatabase/Implementations/SalaryStorageContract.cs

@@ -18,8 +18,9 @@ internal class SalaryStorageContract : ISalaryStorageContract
         {
             cfg.CreateMap<Salary, SalaryDataModel>();
             cfg.CreateMap<SalaryDataModel, Salary>()
-                .ForMember(dest => dest.WorkerSalary, opt => opt.MapFrom(src => src.Salary));
+               .ForMember(dest => dest.WorkerSalary, opt => opt.MapFrom(src => src.Salary));
         });
+
         _mapper = new Mapper(config);
     }
 

TheSoftBedProject/SoftBedDatabase/Implementations/WorkerStorageContract.cs

@@ -118,7 +118,6 @@ internal class WorkerStorageContract : IWorkerStorageContract
         try
         {
             var element = GetWorkerById(id) ?? throw new ElementNotFoundException(id);
-            element.IsDeleted = true;
             _dbContext.SaveChanges();
         }
         catch (ElementNotFoundException)
@@ -133,5 +132,5 @@ internal class WorkerStorageContract : IWorkerStorageContract
         }
     }
 
-    private Worker? GetWorkerById(string id) => _dbContext.Workers.FirstOrDefault(x => x.Id == id && !x.IsDeleted);
+    private Worker? GetWorkerById(string id) => _dbContext.Workers.FirstOrDefault(x => x.Id == id);
 }

TheSoftBedProject/SoftBedDatabase/Models/Worker.cs

@@ -14,8 +14,6 @@ internal class Worker
 
     public DateTime EmploymentDate { get; set; }
 
-    public bool IsDeleted { get; set; }
-
     [ForeignKey("WorkerId")]
     public List<Salary>? Salaries { get; set; }
 

TheSoftBedProject/SoftBedDatabase/SoftBedDatabase.csproj

@@ -16,4 +16,9 @@
     <ProjectReference Include="..\SoftBedContracts\SoftBedContracts.csproj" />
   </ItemGroup>
 
+    <ItemGroup>
+		<InternalsVisibleTo Include="SoftBedTests" />
+		<InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+	</ItemGroup>
+
 </Project>

TheSoftBedProject/SoftBedDatabase/SoftBedDbContext.cs

@@ -1,6 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using SoftBedContracts.Infrastructure;
 using SoftBedDatabase.Models;
+using System;
 
 namespace SoftBedDatabase;
 
@@ -18,6 +19,8 @@ internal class SoftBedDbContext(IConfigurationDatabase configurationDatabase) :
     {
         base.OnModelCreating(modelBuilder);
 
+        modelBuilder.Entity<WorkPiece>().HasIndex(x => x.Size).IsUnique();
+
         modelBuilder.Entity<Post>()
             .HasIndex(e => new { e.PostName, e.IsActual })
             .IsUnique()

TheSoftBedProject/SoftBedTests/DataModelsTests/FurnitureHistoryDataModelTests.cs

@@ -7,7 +7,7 @@ namespace SoftBedTests.DataModelsTests;
 internal class FurnitureHistoryDataModelTests
 {
     [Test]
-    public void ProductIdIsNullOrEmptyTest()
+    public void FurnitureIdIsNullOrEmptyTest()
     {
         var furniture = CreateDataModel(null, 10);
         Assert.That(() => furniture.Validate(), Throws.TypeOf<ValidationException>());
@@ -16,7 +16,7 @@ internal class FurnitureHistoryDataModelTests
     }
 
     [Test]
-    public void ProductIdIsNotGuidTest()
+    public void FurnitureIdIsNotGuidTest()
     {
         var furniture = CreateDataModel("id", 10);
         Assert.That(() => furniture.Validate(), Throws.TypeOf<ValidationException>());

TheSoftBedProject/SoftBedTests/DataModelsTests/WorkPieceDataModelTests.cs

@@ -47,7 +47,7 @@ internal class WorkPieceDataModelTests
     }
 
     [Test]
-    public void ProductsIsNullOrEmptyTest()
+    public void FurnituresIsNullOrEmptyTest()
     {
         var workPiece = CreateDataModel(Guid.NewGuid().ToString(), "size", 0);
         Assert.That(() => workPiece.Validate(), Throws.TypeOf<ValidationException>());

TheSoftBedProject/SoftBedTests/Infrastructure/ConfigurationDatabaseTest.cs

@@ -0,0 +1,8 @@
+using SoftBedContracts.Infrastructure;
+
+namespace SoftBedTests.Infrastructure;
+
+internal class ConfigurationDatabaseTest : IConfigurationDatabase
+{
+	public string ConnectionString => "Host=localhost;Port=5432;Username=postgres;Password=Xaliullov05;Database=SoftBedTests";
+}

TheSoftBedProject/SoftBedTests/SoftBedTests.csproj

@@ -21,6 +21,7 @@
   <ItemGroup>
     <ProjectReference Include="..\SoftBedBusinessLogic\SoftBedBusinessLogic.csproj" />
     <ProjectReference Include="..\SoftBedContracts\SoftBedContracts.csproj" />
+    <ProjectReference Include="..\SoftBedDatabase\SoftBedDatabase.csproj" />
   </ItemGroup>
 
   <ItemGroup>

TheSoftBedProject/SoftBedTests/StoragesContracts/BaseStorageContractTest.cs

@@ -0,0 +1,25 @@
+using SoftBedDatabase;
+using SoftBedTests.Infrastructure;
+
+namespace SoftBedTests.StoragesContracts;
+
+internal abstract class BaseStorageContractTest
+{
+	protected SoftBedDbContext SoftBedDbContext { get; private set; }
+
+	[OneTimeSetUp]
+	public void OneTimeSetUp()
+	{
+        SoftBedDbContext = new SoftBedDbContext(new ConfigurationDatabaseTest());
+
+        SoftBedDbContext.Database.EnsureDeleted();
+        SoftBedDbContext.Database.EnsureCreated();
+	}
+
+	[OneTimeTearDown]
+	public void OneTimeTearDown()
+	{
+        SoftBedDbContext.Database.EnsureDeleted();
+        SoftBedDbContext.Dispose();
+	}
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/CollectStorageContractTests.cs

@@ -0,0 +1,162 @@
+using Microsoft.EntityFrameworkCore;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedContracts.StoragesContracts;
+using SoftBedDatabase.Models;
+
+namespace SoftBedTests.StoragesContracts;
+
+internal class CollectStorageContractTests : BaseStorageContractTest
+{
+    private CollectStorageContract _collectStorageContract;
+    private Worker _worker;
+    private Furniture _furniture;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _collectStorageContract = new CollectStorageContract(SoftBedDbContext);
+        _worker = InsertWorkerToDatabaseAndReturn();
+        _furniture = InsertFurnitureToDatabaseAndReturn();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Furnitures\" CASCADE;");
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Collects\" CASCADE;");
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var collect = InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        var list = _collectStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(), collect);
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _collectStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetList_ByWorker_Test()
+    {
+        var worker = InsertWorkerToDatabaseAndReturn("Other worker");
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        var list = _collectStorageContract.GetList(workerId: _worker.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        Assert.That(list.All(x => x.WorkerId == _worker.Id));
+    }
+
+    [Test]
+    public void Try_GetList_ByFurniture_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn("Other furniture");
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        var list = _collectStorageContract.GetList(furnitureId: _furniture.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        Assert.That(list.All(x => x.FurnitureId == _furniture.Id));
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var collect = InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        AssertElement(_collectStorageContract.GetElementById(collect.Id), collect);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertCollectsToDatabaseAndReturn(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        Assert.That(() => _collectStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var collect = CreateModel(Guid.NewGuid().ToString(), _worker.Id, _furniture.Id, 5);
+        _collectStorageContract.AddElement(collect);
+        AssertElement(GetCollectsFromDatabaseById(collect.Id), collect);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var id = Guid.NewGuid().ToString(); 
+        var collect = CreateModel(id, _worker.Id, _furniture.Id, 5);
+        InsertCollectsToDatabaseAndReturn(id, _worker.Id, _furniture.Id, 5);
+        Assert.That(() => _collectStorageContract.AddElement(collect), Throws.TypeOf<StorageException>());
+    }
+
+
+    private Worker InsertWorkerToDatabaseAndReturn(string workerFIO = "fio")
+    {
+        var worker = new Worker() { Id = Guid.NewGuid().ToString(), PostId = Guid.NewGuid().ToString(), FIO = workerFIO};
+        SoftBedDbContext.Workers.Add(worker);
+        SoftBedDbContext.SaveChanges();
+        return worker;
+    }
+
+    private Furniture InsertFurnitureToDatabaseAndReturn(string furnitureName = "furniture", int price = 5)
+    {
+        var furniture = new Furniture() { Id = Guid.NewGuid().ToString(), FurnitureName = furnitureName, Price = price };
+        SoftBedDbContext.Furnitures.Add(furniture);
+        SoftBedDbContext.SaveChanges();
+        return furniture;
+    }
+
+    private Collect InsertCollectsToDatabaseAndReturn(string id, string workerId, string furnitureId, double sum)
+    {
+        var collect = new Collect() { Id = id, WorkerId = workerId, FurnitureId = furnitureId, Sum = sum };
+        SoftBedDbContext.Collects.Add(collect);
+        SoftBedDbContext.SaveChanges();
+        return collect;
+    }
+
+    private static void AssertElement(CollectDataModel? actual, Collect expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.FurnitureId, Is.EqualTo(expected.FurnitureId));
+            Assert.That(actual.Sum, Is.EqualTo(expected.Sum));
+        });
+    }
+
+    private static CollectDataModel CreateModel(string id, string workerId, string furnitureId, double sum)
+    {
+        return new(id,workerId, furnitureId, sum);
+    }
+
+    private Collect? GetCollectsFromDatabaseById(string id) =>
+        SoftBedDbContext.Collects.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Collect? actual, CollectDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.FurnitureId, Is.EqualTo(expected.FurnitureId));
+            Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+            Assert.That(actual.Sum, Is.EqualTo(expected.Sum));
+        });
+    }
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/FurnitureStorageContractTests.cs

@@ -0,0 +1,241 @@
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedDatabase.Implementations;
+using SoftBedDatabase.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace SoftBedTests.StoragesContracts;
+
+[TestFixture]
+internal class FurnitureStorageContractTests : BaseStorageContractTest
+{
+
+    private FurnitureStorageContract _furnitureStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _furnitureStorageContract = new FurnitureStorageContract(SoftBedDbContext);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Furnitures\" CASCADE;");
+    }
+
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _furnitureStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetHistoryByFurnitureId_WhenHaveRecords_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 20, DateTime.UtcNow.AddDays(-1));
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 30, DateTime.UtcNow.AddMinutes(-10));
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 40, DateTime.UtcNow.AddDays(1));
+        var list = _furnitureStorageContract.GetHistoryByFurnitureId(furniture.Id);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+    }
+
+    [Test]
+    public void Try_GetHistoryByFurnitureId_WhenNoRecords_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 20, DateTime.UtcNow.AddDays(-1));
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 30, DateTime.UtcNow.AddMinutes(-10));
+        InsertFurnitureHistoryToDatabaseAndReturn(furniture.Id, 40, DateTime.UtcNow.AddDays(1));
+        var list = _furnitureStorageContract.GetHistoryByFurnitureId(Guid.NewGuid().ToString());
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(0));
+    }
+
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _furnitureStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenRecordHasDeleted_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.GetElementById(furniture.Id), Is.Null);
+    }
+
+
+
+    [Test]
+    public void Try_GetElementByName_WhenNoRecord_Test()
+    {
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _furnitureStorageContract.GetElementByName("name"), Is.Null);
+    }
+
+    [Test]
+    public void Try_GetElementByName_WhenRecordHasDeleted_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.GetElementById(furniture.FurnitureName), Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), isDeleted: false);
+        _furnitureStorageContract.AddElement(furniture);
+        AssertElement(GetFurnitureFromDatabaseById(furniture.Id), furniture);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenIsDeletedIsTrue_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.AddElement(furniture), Throws.Nothing);
+        AssertElement(GetFurnitureFromDatabaseById(furniture.Id), CreateModel(furniture.Id, isDeleted: false));
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString());
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, furnitureName: "name unique");
+        Assert.That(() => _furnitureStorageContract.AddElement(furniture), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), furnitureName: furniture.FurnitureName, isDeleted: false);
+        Assert.That(() => _furnitureStorageContract.AddElement(furniture), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), furnitureName: furniture.FurnitureName, isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.AddElement(furniture), Throws.Nothing);
+    }
+
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), isDeleted: false);
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, isDeleted: false);
+        _furnitureStorageContract.UpdElement(furniture);
+        AssertElement(GetFurnitureFromDatabaseById(furniture.Id), furniture);
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenIsDeletedIsTrue_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), isDeleted: true);
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, isDeleted: false);
+        _furnitureStorageContract.UpdElement(furniture);
+        AssertElement(GetFurnitureFromDatabaseById(furniture.Id), CreateModel(furniture.Id, isDeleted: false));
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _furnitureStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, furnitureName: "name");
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), furnitureName: furniture.FurnitureName);
+        Assert.That(() => _furnitureStorageContract.UpdElement(furniture), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString(), "name unique", isDeleted: false);
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, furnitureName: "name");
+        InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), furnitureName: furniture.FurnitureName, isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.UpdElement(furniture), Throws.Nothing);
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenRecordWasDeleted_Test()
+    {
+        var furniture = CreateModel(Guid.NewGuid().ToString());
+        InsertFurnitureToDatabaseAndReturn(furniture.Id, isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.UpdElement(furniture), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: false);
+        _furnitureStorageContract.DelElement(furniture.Id);
+        var element = GetFurnitureFromDatabaseById(furniture.Id);
+        Assert.Multiple(() =>
+        {
+            Assert.That(element, Is.Not.Null);
+            Assert.That(element!.IsDeleted);
+        });
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _furnitureStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_DelElement_WhenRecordWasDeleted_Test()
+    {
+        var furniture = InsertFurnitureToDatabaseAndReturn(Guid.NewGuid().ToString(), isDeleted: true);
+        Assert.That(() => _furnitureStorageContract.DelElement(furniture.Id), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private Furniture InsertFurnitureToDatabaseAndReturn(string id, string furnitureName = "test", FurnitureType furnitureType = FurnitureType.FoldingFurniture, double price = 1, bool isDeleted = false)
+    {
+        var furniture = new Furniture() { Id = id, FurnitureName = furnitureName, FurnitureType = furnitureType, Price = price, IsDeleted = isDeleted };
+        SoftBedDbContext.Furnitures.Add(furniture);
+        SoftBedDbContext.SaveChanges();
+        return furniture;
+    }
+
+    private FurnitureHistory InsertFurnitureHistoryToDatabaseAndReturn(string furnitureId, double price, DateTime changeDate)
+    {
+        var furnitureHistory = new FurnitureHistory() { Id = Guid.NewGuid().ToString(), FurnitureId = furnitureId, OldPrice = price, ChangeDate = changeDate };
+        SoftBedDbContext.FurnitureHistories.Add(furnitureHistory);
+        SoftBedDbContext.SaveChanges();
+        return furnitureHistory;
+    }
+
+    private static FurnitureDataModel CreateModel(string id, string furnitureName = "test", FurnitureType furnitureType = FurnitureType.UpholsteredFurniture, double price = 1, bool isDeleted = false)
+        => new(id, furnitureName, furnitureType, price, isDeleted, []);
+
+    private Furniture? GetFurnitureFromDatabaseById(string id) => SoftBedDbContext.Furnitures.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(Furniture? actual, FurnitureDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.FurnitureName, Is.EqualTo(expected.FurnitureName));
+            Assert.That(actual.FurnitureType, Is.EqualTo(expected.FurnitureType));
+            Assert.That(actual.Price, Is.EqualTo(expected.Price));
+            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
+        });
+    }
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/PostStorageContractTests.cs

@@ -0,0 +1,317 @@
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Enums;
+using SoftBedContracts.Exceptions;
+using SoftBedDatabase.Implementations;
+using SoftBedDatabase.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace SoftBedTests.StoragesContracts;
+
+[TestFixture]
+internal class PostStorageContractTests : BaseStorageContractTest
+{
+	private PostStorageContract _postStorageContract;
+
+	[SetUp]
+	public void SetUp()
+	{
+		_postStorageContract = new PostStorageContract(SoftBedDbContext);
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Posts\" CASCADE;");
+	}
+
+	[Test]
+	public void Try_GetList_WhenHaveRecords_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2");
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3");
+		var list = _postStorageContract.GetList();
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(3));
+		AssertElement(list.First(x => x.Id == post.PostId), post);
+	}
+
+	[Test]
+	public void Try_GetList_WhenNoRecords_Test()
+	{
+		var list = _postStorageContract.GetList();
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.Empty);
+	}
+
+	[Test]
+	public void Try_GetList_OnlyActual_Test()
+	{
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isActual: true);
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isActual: false);
+		var list = _postStorageContract.GetList(onlyActual: true);
+		Assert.That(list, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(list, Has.Count.EqualTo(2));
+			Assert.That(!list.Any(x => !x.IsActual));
+		});
+	}
+
+	[Test]
+	public void Try_GetList_IncludeNoActual_Test()
+	{
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", isActual: true);
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", isActual: false);
+		var list = _postStorageContract.GetList(onlyActual: false);
+		Assert.That(list, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(list, Has.Count.EqualTo(3));
+			Assert.That(list.Count(x => x.IsActual), Is.EqualTo(2));
+			Assert.That(list.Count(x => !x.IsActual), Is.EqualTo(1));
+		});
+	}
+
+	[Test]
+	public void Try_GetPostWithHistory_WhenHaveRecords_Test()
+	{
+		var postId = Guid.NewGuid().ToString();
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
+		InsertPostToDatabaseAndReturn(postId, "name 2", isActual: true);
+		InsertPostToDatabaseAndReturn(postId, "name 2", isActual: false);
+		var list = _postStorageContract.GetPostWithHistory(postId);
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(2));
+	}
+
+	[Test]
+	public void Try_GetPostWithHistory_WhenNoRecords_Test()
+	{
+		var postId = Guid.NewGuid().ToString();
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", isActual: true);
+		InsertPostToDatabaseAndReturn(postId, "name 2", isActual: true);
+		InsertPostToDatabaseAndReturn(postId, "name 2", isActual: false);
+		var list = _postStorageContract.GetPostWithHistory(Guid.NewGuid().ToString());
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(0));
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenHaveRecord_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
+		AssertElement(_postStorageContract.GetElementById(post.PostId), post);
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenNoRecord_Test()
+	{
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
+		Assert.That(() => _postStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenRecordHasDeleted_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+		Assert.That(() => _postStorageContract.GetElementById(post.PostId), Is.Null);
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenTrySearchById_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
+		Assert.That(() => _postStorageContract.GetElementById(post.Id), Is.Null);
+	}
+
+	[Test]
+	public void Try_GetElementByName_WhenHaveRecord_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
+		AssertElement(_postStorageContract.GetElementByName(post.PostName), post);
+	}
+
+	[Test]
+	public void Try_GetElementByName_WhenNoRecord_Test()
+	{
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString());
+		Assert.That(() => _postStorageContract.GetElementByName("name"), Is.Null);
+	}
+
+	[Test]
+	public void Try_GetElementByName_WhenRecordHasDeleted_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+		Assert.That(() => _postStorageContract.GetElementById(post.PostName), Is.Null);
+	}
+
+	[Test]
+	public void Try_AddElement_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), isActual: true);
+		_postStorageContract.AddElement(post);
+		AssertElement(GetPostFromDatabaseByPostId(post.Id), post);
+	}
+
+	[Test]
+	public void Try_AddElement_WhenActualIsFalse_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), isActual: false);
+		Assert.That(() => _postStorageContract.AddElement(post), Throws.Nothing);
+		AssertElement(GetPostFromDatabaseByPostId(post.Id), CreateModel(post.Id, isActual: true));
+	}
+
+	[Test]
+	public void Try_AddElement_WhenHaveRecordWithSameName_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), "name unique", isActual: true);
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), postName: post.PostName, isActual: true);
+		Assert.That(() => _postStorageContract.AddElement(post), Throws.TypeOf<ElementExistsException>());
+	}
+
+	[Test]
+	public void Try_AddElement_WhenHaveRecordWithSamePostIdAndActualIsTrue_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), isActual: true);
+		InsertPostToDatabaseAndReturn(post.Id, isActual: true);
+		Assert.That(() => _postStorageContract.AddElement(post), Throws.TypeOf<ElementExistsException>());
+	}
+
+	[Test]
+	public void Try_UpdElement_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString());
+		InsertPostToDatabaseAndReturn(post.Id, isActual: true);
+		_postStorageContract.UpdElement(post);
+		var posts = SoftBedDbContext.Posts.Where(x => x.PostId == post.Id).OrderByDescending(x => x.ChangeDate);
+		Assert.That(posts.Count(), Is.EqualTo(2));
+		AssertElement(posts.First(), CreateModel(post.Id, isActual: true));
+		AssertElement(posts.Last(), CreateModel(post.Id, isActual: false));
+	}
+
+	[Test]
+	public void Try_UpdElement_WhenActualIsFalse_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), isActual: false);
+		InsertPostToDatabaseAndReturn(post.Id, isActual: true);
+		_postStorageContract.UpdElement(post);
+		AssertElement(GetPostFromDatabaseByPostId(post.Id), CreateModel(post.Id, isActual: true));
+	}
+
+	[Test]
+	public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+	{
+		Assert.That(() => _postStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+	}
+
+	[Test]
+	public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString(), "New Name");
+		InsertPostToDatabaseAndReturn(post.Id, postName: "name");
+		InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), postName: post.PostName);
+		Assert.That(() => _postStorageContract.UpdElement(post), Throws.TypeOf<ElementExistsException>());
+	}
+
+	[Test]
+	public void Try_UpdElement_WhenRecordWasDeleted_Test()
+	{
+		var post = CreateModel(Guid.NewGuid().ToString());
+		InsertPostToDatabaseAndReturn(post.Id, isActual: false);
+		Assert.That(() => _postStorageContract.UpdElement(post), Throws.TypeOf<ElementDeletedException>());
+	}
+
+	[Test]
+	public void Try_DelElement_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+		_postStorageContract.DelElement(post.PostId);
+		var element = GetPostFromDatabaseByPostId(post.PostId);
+		Assert.Multiple(() =>
+		{
+			Assert.That(element, Is.Not.Null);
+			Assert.That(!element!.IsActual);
+		});
+	}
+
+	[Test]
+	public void Try_DelElement_WhenNoRecordWithThisId_Test()
+	{
+		Assert.That(() => _postStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+	}
+
+	[Test]
+	public void Try_DelElement_WhenRecordWasDeleted_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+		Assert.That(() => _postStorageContract.DelElement(post.PostId), Throws.TypeOf<ElementDeletedException>());
+	}
+
+	[Test]
+	public void Try_ResElement_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: false);
+		_postStorageContract.ResElement(post.PostId);
+		var element = GetPostFromDatabaseByPostId(post.PostId);
+		Assert.Multiple(() =>
+		{
+			Assert.That(element, Is.Not.Null);
+			Assert.That(element!.IsActual);
+		});
+	}
+
+	[Test]
+	public void Try_ResElement_WhenNoRecordWithThisId_Test()
+	{
+		Assert.That(() => _postStorageContract.ResElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+	}
+
+	[Test]
+	public void Try_ResElement_WhenRecordNotWasDeleted_Test()
+	{
+		var post = InsertPostToDatabaseAndReturn(Guid.NewGuid().ToString(), isActual: true);
+		Assert.That(() => _postStorageContract.ResElement(post.PostId), Throws.Nothing);
+	}
+
+	private Post InsertPostToDatabaseAndReturn(string id, string postName = "test", PostType postType = PostType.Assembler, double salary = 10, bool isActual = true, DateTime? changeDate = null)
+	{
+		var post = new Post() { Id = Guid.NewGuid().ToString(), PostId = id, PostName = postName, PostType = postType, Salary = salary, IsActual = isActual, ChangeDate = changeDate ?? DateTime.UtcNow };
+		SoftBedDbContext.Posts.Add(post);
+		SoftBedDbContext.SaveChanges();
+		return post;
+	}
+
+	private static void AssertElement(PostDataModel? actual, Post expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.Id, Is.EqualTo(expected.PostId));
+			Assert.That(actual.PostName, Is.EqualTo(expected.PostName));
+			Assert.That(actual.PostType, Is.EqualTo(expected.PostType));
+			Assert.That(actual.Salary, Is.EqualTo(expected.Salary));
+			Assert.That(actual.IsActual, Is.EqualTo(expected.IsActual));
+		});
+	}
+
+	private static PostDataModel CreateModel(string postId, string postName = "test", PostType postType = PostType.Assembler, double salary = 10, bool isActual = false, DateTime? changeDate = null)
+		=> new(postId, postName, postType, salary, isActual, changeDate ?? DateTime.UtcNow);
+
+	private Post? GetPostFromDatabaseByPostId(string id) => SoftBedDbContext.Posts.Where(x => x.PostId == id).OrderByDescending(x => x.ChangeDate).FirstOrDefault();
+
+	private static void AssertElement(Post? actual, PostDataModel expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.PostId, Is.EqualTo(expected.Id));
+			Assert.That(actual.PostName, Is.EqualTo(expected.PostName));
+			Assert.That(actual.PostType, Is.EqualTo(expected.PostType));
+			Assert.That(actual.Salary, Is.EqualTo(expected.Salary));
+			Assert.That(actual.IsActual, Is.EqualTo(expected.IsActual));
+		});
+	}
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/SalaryStorageContractTests.cs

@@ -0,0 +1,149 @@
+using SoftBedContracts.DataModels;
+using SoftBedDatabase.Implementations;
+using SoftBedDatabase.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace SoftBedTests.StoragesContracts;
+
+[TestFixture]
+internal class SalaryStorageContractTests : BaseStorageContractTest
+{
+	private SalaryStorageContract _salaryStorageContract;
+	private Worker _worker;
+
+	[SetUp]
+	public void SetUp()
+	{
+		_salaryStorageContract = new SalaryStorageContract(SoftBedDbContext);
+		_worker = InsertWorkerToDatabaseAndReturn();
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Salaries\" CASCADE;");
+		SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
+	}
+
+	[Test]
+	public void Try_GetList_WhenHaveRecords_Test()
+	{
+		var salary = InsertSalaryToDatabaseAndReturn(_worker.Id, workerSalary: 100);
+		InsertSalaryToDatabaseAndReturn(_worker.Id);
+		InsertSalaryToDatabaseAndReturn(_worker.Id);
+		var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(3));
+		AssertElement(list.First(), salary);
+	}
+
+	[Test]
+	public void Try_GetList_WhenNoRecords_Test()
+	{
+		var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow.AddDays(10));
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.Empty);
+	}
+
+	[Test]
+	public void Try_GetList_OnlyInDatePeriod_Test()
+	{
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+		var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1));
+		Assert.That(list, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(list, Has.Count.EqualTo(2));
+		});
+	}
+
+	[Test]
+	public void Try_GetList_ByWorker_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn("name 2");
+		InsertSalaryToDatabaseAndReturn(_worker.Id);
+		InsertSalaryToDatabaseAndReturn(_worker.Id);
+		InsertSalaryToDatabaseAndReturn(worker.Id);
+		var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
+		Assert.That(list, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(list, Has.Count.EqualTo(2));
+			Assert.That(list.All(x => x.WorkerId == _worker.Id));
+		});
+	}
+
+	[Test]
+	public void Try_GetList_ByWorkerOnlyInDatePeriod_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn("name 2");
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+		InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(-1).AddMinutes(5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+		InsertSalaryToDatabaseAndReturn(worker.Id, salaryDate: DateTime.UtcNow.AddDays(1).AddMinutes(-5));
+		InsertSalaryToDatabaseAndReturn(_worker.Id, salaryDate: DateTime.UtcNow.AddDays(-2));
+		var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddDays(1), _worker.Id);
+		Assert.That(list, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(list, Has.Count.EqualTo(2));
+			Assert.That(list.All(x => x.WorkerId == _worker.Id));
+		});
+	}
+
+	[Test]
+	public void Try_AddElement_Test()
+	{
+		var salary = CreateModel(_worker.Id);
+		_salaryStorageContract.AddElement(salary);
+		AssertElement(GetSalaryFromDatabaseByWorkerId(_worker.Id), salary);
+	}
+
+    private Worker InsertWorkerToDatabaseAndReturn(string workerFIO = "fio")
+    {
+        var worker = new Worker() { Id = Guid.NewGuid().ToString(), PostId = Guid.NewGuid().ToString(), FIO = workerFIO };
+        SoftBedDbContext.Workers.Add(worker);
+        SoftBedDbContext.SaveChanges();
+        return worker;
+    }
+
+
+    private Salary InsertSalaryToDatabaseAndReturn(string workerId, double workerSalary = 1, DateTime? salaryDate = null)
+	{
+		var salary = new Salary() { WorkerId = workerId, WorkerSalary = workerSalary, SalaryDate = salaryDate ?? DateTime.UtcNow };
+		SoftBedDbContext.Salaries.Add(salary);
+		SoftBedDbContext.SaveChanges();
+		return salary;
+	}
+
+	private static void AssertElement(SalaryDataModel? actual, Salary expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+			Assert.That(actual.Salary, Is.EqualTo(expected.WorkerSalary));
+		});
+	}
+
+	private static SalaryDataModel CreateModel(string workerId, double workerSalary = 1, DateTime? salaryDate = null)
+		=> new(workerId, salaryDate ?? DateTime.UtcNow, workerSalary);
+
+	private Salary? GetSalaryFromDatabaseByWorkerId(string id) => SoftBedDbContext.Salaries.FirstOrDefault(x => x.WorkerId == id);
+
+	private static void AssertElement(Salary? actual, SalaryDataModel expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.WorkerId, Is.EqualTo(expected.WorkerId));
+			Assert.That(actual.WorkerSalary, Is.EqualTo(expected.Salary));
+		});
+	}
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/WorkPieceStorageContractTests.cs

@@ -0,0 +1,173 @@
+using Microsoft.EntityFrameworkCore;
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedDatabase.Implementations;
+using SoftBedDatabase.Models;
+using System;
+
+namespace SoftBedTests.StoragesContracts;
+
+[TestFixture]
+internal class WorkPieceStorageContractTests : BaseStorageContractTest
+{
+    private WorkPieceStorageContract _workPieceStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _workPieceStorageContract = new WorkPieceStorageContract(SoftBedDbContext);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Furnitures\" CASCADE;");
+        SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"WorkPieces\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var workPiece = InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString(), size: "10x10");
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString(), size: "100x100");
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString(), size: "1000x1000");
+        var list = _workPieceStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(3));
+        AssertElement(list.First(x => x.Id == workPiece.Id), workPiece);
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _workPieceStorageContract.GetList();
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var workPiece = InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_workPieceStorageContract.GetElementById(workPiece.Id), workPiece);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _workPieceStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+
+    [Test]
+    public void Try_GetElementBySize_WhenHaveRecord_Test()
+    {
+        var workPiece = InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString());
+        AssertElement(_workPieceStorageContract.GetElementBySize(workPiece.Size), workPiece);
+    }
+
+    [Test]
+    public void Try_GetElementBySize_WhenNoRecord_Test()
+    {
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString());
+        Assert.That(() => _workPieceStorageContract.GetElementBySize("600x600"), Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var workPiece = CreateModel(Guid.NewGuid().ToString());
+        _workPieceStorageContract.AddElement(workPiece);
+        AssertElement(GetWorkPieceFromDatabase(workPiece.Id), workPiece);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+    {
+        var workPiece = CreateModel(Guid.NewGuid().ToString(),"10x10", 500);
+        InsertWorkPieceToDatabaseAndReturn(workPiece.Id);
+        Assert.That(() => _workPieceStorageContract.AddElement(workPiece), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_AddElement_WhenHaveRecordWithSameSize_Test()
+    {
+        var workPiece = CreateModel(Guid.NewGuid().ToString(), "10x10", 500);
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString(), size: workPiece.Size);
+        Assert.That(() => _workPieceStorageContract.AddElement(workPiece), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var workPiece = CreateModel(Guid.NewGuid().ToString(), "10x10", 500);
+        InsertWorkPieceToDatabaseAndReturn(workPiece.Id);
+        _workPieceStorageContract.UpdElement(workPiece);
+        AssertElement(GetWorkPieceFromDatabase(workPiece.Id), workPiece);
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _workPieceStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenHaveRecordWithSameSize_Test()
+    {
+        var workPiece = CreateModel(Guid.NewGuid().ToString(), "10x10", 500);
+        InsertWorkPieceToDatabaseAndReturn(workPiece.Id, size: "+100x100");
+        InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString(), size: workPiece.Size);
+        Assert.That(() => _workPieceStorageContract.UpdElement(workPiece), Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var workPiece = InsertWorkPieceToDatabaseAndReturn(Guid.NewGuid().ToString());
+        _workPieceStorageContract.DelElement(workPiece.Id);
+        var element = GetWorkPieceFromDatabase(workPiece.Id);
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _workPieceStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private WorkPiece InsertWorkPieceToDatabaseAndReturn(string id, string size = "500x500", double weight = 20)
+    {
+        var workPiece = new WorkPiece() { Id = id, Size = size, Weight = weight };
+        SoftBedDbContext.WorkPieces.Add(workPiece);
+        SoftBedDbContext.SaveChanges();
+        return workPiece;
+    }
+
+    private static void AssertElement(WorkPieceDataModel? actual, WorkPiece expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Size, Is.EqualTo(expected.Size));
+            Assert.That(actual.Weight, Is.EqualTo(expected.Weight));
+        });
+    }
+
+    private static WorkPieceDataModel CreateModel(string id, string size = "50x50", double weight = 10)
+    => new(id, size, weight);
+
+    private WorkPiece? GetWorkPieceFromDatabase(string id) => SoftBedDbContext.WorkPieces.FirstOrDefault(x => x.Id == id);
+
+    private static void AssertElement(WorkPiece? actual, WorkPieceDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Size, Is.EqualTo(expected.Size));
+            Assert.That(actual.Weight, Is.EqualTo(expected.Weight));
+        });
+    }
+}

TheSoftBedProject/SoftBedTests/StoragesContracts/WorkerStorageContractTests.cs

@@ -0,0 +1,207 @@
+using SoftBedContracts.DataModels;
+using SoftBedContracts.Exceptions;
+using SoftBedDatabase.Implementations;
+using SoftBedDatabase.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace SoftBedTests.StoragesContracts;
+
+[TestFixture]
+internal class WorkerStorageContractTests : BaseStorageContractTest
+{
+	private WorkerStorageContract _workerStorageContract;
+
+	[SetUp]
+	public void SetUp()
+	{
+		_workerStorageContract = new WorkerStorageContract(SoftBedDbContext);
+	}
+
+	[TearDown]
+	public void TearDown()
+	{
+		SoftBedDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
+	}
+
+	[Test]
+	public void Try_GetList_WhenHaveRecords_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1");
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2");
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3");
+		var list = _workerStorageContract.GetList();
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(3));
+		AssertElement(list.First(), worker);
+	}
+
+	[Test]
+	public void Try_GetList_WhenNoRecords_Test()
+	{
+		var list = _workerStorageContract.GetList();
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Is.Empty);
+	}
+
+	[Test]
+	public void Try_GetList_ByPostId_Test()
+	{
+		var postId = Guid.NewGuid().ToString();
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", postId);
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", postId);
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3");
+		var list = _workerStorageContract.GetList(postId: postId);
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(2));
+		Assert.That(list.All(x => x.PostId == postId));
+	}
+
+	[Test]
+	public void Try_GetList_ByBirthDate_Test()
+	{
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", birthDate: DateTime.UtcNow.AddYears(-25));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", birthDate: DateTime.UtcNow.AddYears(-21));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", birthDate: DateTime.UtcNow.AddYears(-20));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-19));
+		var list = _workerStorageContract.GetList(fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1), toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1));
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(2));
+	}
+
+	[Test]
+	public void Try_GetList_ByEmploymentDate_Test()
+	{
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", employmentDate: DateTime.UtcNow.AddDays(-2));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", employmentDate: DateTime.UtcNow.AddDays(-1));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", employmentDate: DateTime.UtcNow.AddDays(1));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", employmentDate: DateTime.UtcNow.AddDays(2));
+		var list = _workerStorageContract.GetList(fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(2));
+	}
+
+	[Test]
+	public void Try_GetList_ByAllParameters_Test()
+	{
+		var postId = Guid.NewGuid().ToString();
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 1", postId, birthDate: DateTime.UtcNow.AddYears(-25), employmentDate: DateTime.UtcNow.AddDays(-2));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 2", postId, birthDate: DateTime.UtcNow.AddYears(-22), employmentDate: DateTime.UtcNow.AddDays(-1));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 3", postId, birthDate: DateTime.UtcNow.AddYears(-21), employmentDate: DateTime.UtcNow.AddDays(-1));
+		InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString(), "fio 4", birthDate: DateTime.UtcNow.AddYears(-20), employmentDate: DateTime.UtcNow.AddDays(1));
+		var list = _workerStorageContract.GetList(postId: postId, fromBirthDate: DateTime.UtcNow.AddYears(-21).AddMinutes(-1), toBirthDate: DateTime.UtcNow.AddYears(-20).AddMinutes(1), fromEmploymentDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-1), toEmploymentDate: DateTime.UtcNow.AddDays(1).AddMinutes(1));
+		Assert.That(list, Is.Not.Null);
+		Assert.That(list, Has.Count.EqualTo(1));
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenHaveRecord_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+		AssertElement(_workerStorageContract.GetElementById(worker.Id), worker);
+	}
+
+	[Test]
+	public void Try_GetElementById_WhenNoRecord_Test()
+	{
+		Assert.That(() => _workerStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+	}
+
+	[Test]
+	public void Try_GetElementByFIO_WhenHaveRecord_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+		AssertElement(_workerStorageContract.GetElementByFIO(worker.FIO), worker);
+	}
+
+	[Test]
+	public void Try_GetElementByFIO_WhenNoRecord_Test()
+	{
+		Assert.That(() => _workerStorageContract.GetElementByFIO("New Fio"), Is.Null);
+	}
+
+	[Test]
+	public void Try_AddElement_Test()
+	{
+		var worker = CreateModel(Guid.NewGuid().ToString());
+		_workerStorageContract.AddElement(worker);
+		AssertElement(GetWorkerFromDatabase(worker.Id), worker);
+	}
+
+	[Test]
+	public void Try_AddElement_WhenHaveRecordWithSameId_Test()
+	{
+		var worker = CreateModel(Guid.NewGuid().ToString());
+		InsertWorkerToDatabaseAndReturn(worker.Id);
+		Assert.That(() => _workerStorageContract.AddElement(worker), Throws.TypeOf<ElementExistsException>());
+	}
+
+	[Test]
+	public void Try_UpdElement_Test()
+	{
+		var worker = CreateModel(Guid.NewGuid().ToString(), "New Fio");
+		InsertWorkerToDatabaseAndReturn(worker.Id);
+		_workerStorageContract.UpdElement(worker);
+		AssertElement(GetWorkerFromDatabase(worker.Id), worker);
+	}
+
+	[Test]
+	public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+	{
+		Assert.That(() => _workerStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
+	}
+
+	[Test]
+	public void Try_DelElement_Test()
+	{
+		var worker = InsertWorkerToDatabaseAndReturn(Guid.NewGuid().ToString());
+		_workerStorageContract.DelElement(worker.Id);
+		var element = GetWorkerFromDatabase(worker.Id);
+		Assert.That(element, Is.Not.Null);
+	}
+
+	[Test]
+	public void Try_DelElement_WhenNoRecordWithThisId_Test()
+	{
+		Assert.That(() => _workerStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
+	}
+
+
+	private Worker InsertWorkerToDatabaseAndReturn(string id, string fio = "test", string? postId = null, DateTime? birthDate = null, DateTime? employmentDate = null, bool isDeleted = false)
+	{
+		var worker = new Worker() { Id = id, FIO = fio, PostId = postId ?? Guid.NewGuid().ToString(), BirthDate = birthDate ?? DateTime.UtcNow.AddYears(-20), EmploymentDate = employmentDate ?? DateTime.UtcNow };
+		SoftBedDbContext.Workers.Add(worker);
+		SoftBedDbContext.SaveChanges();
+		return worker;
+	}
+
+	private static void AssertElement(WorkerDataModel? actual, Worker expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.Id, Is.EqualTo(expected.Id));
+			Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
+			Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
+			Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
+			Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
+		});
+	}
+
+	private static WorkerDataModel CreateModel(string id, string fio = "fio", string? postId = null, DateTime? birthDate = null, DateTime? employmentDate = null, bool isDeleted = false) =>
+		new(id, fio, postId ?? Guid.NewGuid().ToString(), birthDate ?? DateTime.UtcNow.AddYears(-20), employmentDate ?? DateTime.UtcNow);
+
+	private Worker? GetWorkerFromDatabase(string id) => SoftBedDbContext.Workers.FirstOrDefault(x => x.Id == id);
+
+	private static void AssertElement(Worker? actual, WorkerDataModel expected)
+	{
+		Assert.That(actual, Is.Not.Null);
+		Assert.Multiple(() =>
+		{
+			Assert.That(actual.Id, Is.EqualTo(expected.Id));
+			Assert.That(actual.PostId, Is.EqualTo(expected.PostId));
+			Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
+			Assert.That(actual.BirthDate, Is.EqualTo(expected.BirthDate));
+			Assert.That(actual.EmploymentDate, Is.EqualTo(expected.EmploymentDate));
+		});
+	}
+}