Сделал половину тестов

2025-03-12 11:37:46 +04:00
parent 46f9d4a00f
commit d66619bfd2
11 changed files with 823 additions and 11 deletions
--- a/TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/ComplitedWorkDataModel.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/ComplitedWorkDataModel.cs
@@ -8,9 +8,10 @@ public class ComplitedWorkDataModel(string id, string workId, string roomId, Lis
    public string Id { get; private set; } = id;
    public string WorkId { get; private set; } = workId;
    public string RoomId { get; private set; } = roomId;
-    public DateTime Date { get; private set; } = DateTime.Now;
+    public DateTime Date { get; private set; } = DateTime.UtcNow;
    public List<WorkerComplitedWorkDataModel> Workers { get; private set; } = workers;

+
    public void Validate()
    {
        if (Id.IsEmpty())
--- a/TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/SalaryDataModel.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/SalaryDataModel.cs
@@ -9,7 +9,7 @@ public class SalaryDataModel(string id, string workerId, double sum) : IValidati
    public string Id { get; private set; } = id;
    public string WorkerId { get; private set; } = workerId;
    public double Sum { get; private set; } = sum;
-    public DateTime Date { get; private set; } = DateTime.Now;
+    public DateTime Date { get; private set; } = DateTime.UtcNow;

    public void Validate()
    {
--- a/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/ComplitedWorkStorageContract.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/ComplitedWorkStorageContract.cs
@@ -18,9 +18,17 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
        _dbContext = context;
        var conf = new MapperConfiguration(cfg =>
        {
+            cfg.CreateMap<ComplitedWork, ComplitedWorkDataModel>()
+                .ConstructUsing(src => new ComplitedWorkDataModel(
+                    src.Id,
+                    src.WorkId,
+                    src.RoomId,
+                    src.WorkersComplitedWorks
+                        .Select(wcw => new WorkerComplitedWorkDataModel(wcw.WorkerId, wcw.ComplitedWorkId, wcw.NumberOfWorkingHours))
+                        .ToList()
+                ));
+
            cfg.CreateMap<ComplitedWorkDataModel, ComplitedWork>();
-            cfg.CreateMap<ComplitedWork, ComplitedWorkDataModel>();
-            cfg.CreateMap<WorkerComplitedWork, WorkerComplitedWorkDataModel>();
        });
        _mapper = new Mapper(conf);
    }
@@ -73,9 +81,39 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
    {
        try
        {
-            _dbContext.ComplitedWorks.Add(_mapper.Map<ComplitedWork>(complitedWorkDataModel));
+            if (complitedWorkDataModel.Workers == null || complitedWorkDataModel.Workers.Count == 0)
+            {
+                throw new ValidationException("The value in the Workers must include workers");
+            }
+
+            if (!_dbContext.Rooms.Any(x => x.Id == complitedWorkDataModel.RoomId))
+            {
+                throw new ElementNotFoundException($"Room with ID {complitedWorkDataModel.RoomId} not found.");
+            }
+
+            var complitedWork = _mapper.Map<ComplitedWork>(complitedWorkDataModel);
+            _dbContext.ComplitedWorks.Add(complitedWork);
+
+            foreach (var worker in complitedWorkDataModel.Workers)
+            {
+                _dbContext.WorkerComplitedWorks.Add(new WorkerComplitedWork
+                {
+                    WorkerId = worker.WorkerId,
+                    ComplitedWorkId = complitedWork.Id,
+                    NumberOfWorkingHours = worker.NumberOfWorkingHours
+                });
+            }
+
            _dbContext.SaveChanges();
        }
+        catch (ValidationException)
+        {
+            throw;
+        }
+        catch (ElementNotFoundException)
+        {
+            throw;
+        }
        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "PK_ComplitedWorks" })
        {
            _dbContext.ChangeTracker.Clear();
@@ -88,6 +126,10 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
        }
    }

+
+
+
+
    public void DelElement(string id)
    {
        try
--- a/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/RoomHistoryStorageContract.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/RoomHistoryStorageContract.cs
@@ -61,8 +61,15 @@ public class RoomHistoryStorageContract : IRoomHistoryStorageContract
    {
        try
        {
-            _dbContext.RoomHistories.Add(_mapper.Map<RoomHistory>(roomHistoryDataModel));
+            var roomExists = _dbContext.Rooms.Any(x => x.Id == roomHistoryDataModel.RoomId);
+            if (!roomExists)
+                throw new ElementNotFoundException($"Room with Id {roomHistoryDataModel.RoomId} not found.");
+
+            var entity = _mapper.Map<RoomHistory>(roomHistoryDataModel);
+            _dbContext.RoomHistories.Add(entity);
            _dbContext.SaveChanges();
+
+            var savedEntity = _dbContext.RoomHistories.FirstOrDefault(x => x.Id == entity.Id);
        }
        catch (DbUpdateException ex)
        {
@@ -75,4 +82,5 @@ public class RoomHistoryStorageContract : IRoomHistoryStorageContract
            throw new StorageException(ex);
        }
    }
+
 }
--- a/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/SalaryStorageContract.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/SalaryStorageContract.cs
@@ -46,9 +46,20 @@ public class SalaryStorageContract : ISalaryStorageContract
    {
        try
        {
+            var workerExists = _dbContext.Workers.Any(x => x.Id == salaryDataModel.WorkerId);
+            if (!workerExists)
+            {
+                throw new ElementNotFoundException($"Worker with id {salaryDataModel.WorkerId} not found.");
+            }
+
            _dbContext.Salaries.Add(_mapper.Map<Salary>(salaryDataModel));
            _dbContext.SaveChanges();
        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
        catch (DbUpdateException ex)
        {
            _dbContext.ChangeTracker.Clear();
@@ -60,4 +71,5 @@ public class SalaryStorageContract : ISalaryStorageContract
            throw new StorageException(ex);
        }
    }
+
 }
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/Infrastructure/ConfigurationDatabaseTest.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/Infrastructure/ConfigurationDatabaseTest.cs
@@ -9,5 +9,5 @@ namespace TwoFromTheCasketTests.Infrastructure;

 public class ConfigurationDatabaseTest : IConfigurationDatabase
 {
-    public string ConnectionString => "Host=127.0.0.1;Port=5432;Database=Test;Username=postgres;Password=postgres;";
+    public string ConnectionString => "Host=localhost;Port=5432;Database=TwoFromTheCasketDb;Username=postgres;Password=1234";
 }
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/BaseStorageContractTest.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/BaseStorageContractTest.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketTests.Infrastructure;
+using TwoFromTheCasketDatabase;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+public abstract class BaseStorageContractTest
+{
+    protected TwoFromTheCasketDbContext TwoFromTheCasketDb { get; private set; }
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        TwoFromTheCasketDb = new TwoFromTheCasketDbContext(new
+            ConfigurationDatabaseTest());
+        TwoFromTheCasketDb.Database.EnsureDeleted();
+        TwoFromTheCasketDb.Database.EnsureCreated();
+    }
+    [OneTimeTearDown]
+    public void OneTimeTearDown()
+    {
+        TwoFromTheCasketDb.Database.EnsureDeleted();
+        TwoFromTheCasketDb.Dispose();
+    }
+}
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/ComplitedWorkStorageContractTests.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/ComplitedWorkStorageContractTests.cs
@@ -0,0 +1,300 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using System.Net;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Enums;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketDatabase.Implementations;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+[TestFixture]
+public class ComplitedWorkStorageContractTests : BaseStorageContractTest
+{
+    private ComplitedWorkStorageContract _complitedWorkStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _complitedWorkStorageContract = new ComplitedWorkStorageContract(TwoFromTheCasketDb);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"WorkerComplitedWorks\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"ComplitedWorks\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var complitedWork = InsertComplitedWorkToDatabase(Guid.NewGuid().ToString());
+        InsertComplitedWorkToDatabase(Guid.NewGuid().ToString());
+
+        var list = _complitedWorkStorageContract.GetList(null, null);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        AssertElement(list.First(x => x.Id == complitedWork.Id), complitedWork);
+    }
+
+    [Test]
+    public void Try_GetList_WithFilters_Test()
+    {
+        var workId = InsertWorkToDatabase(Guid.NewGuid().ToString()).Id; 
+        var complitedWork1 = InsertComplitedWorkToDatabase(Guid.NewGuid().ToString(), workId: workId);
+        InsertComplitedWorkToDatabase(Guid.NewGuid().ToString(), workId: Guid.NewGuid().ToString());
+
+        var list = _complitedWorkStorageContract.GetList(null, null, WorkId: workId);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+        AssertElement(list.First(), complitedWork1);
+    }
+
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _complitedWorkStorageContract.GetList(null, null);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var complitedWork = InsertComplitedWorkToDatabase(Guid.NewGuid().ToString());
+
+        var element = _complitedWorkStorageContract.GetElementById(complitedWork.Id);
+
+        AssertElement(element, complitedWork);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        var element = _complitedWorkStorageContract.GetElementById(Guid.NewGuid().ToString());
+
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString());
+        _complitedWorkStorageContract.AddElement(complitedWorkDataModel);
+
+        var element = GetComplitedWorkFromDatabase(complitedWorkDataModel.Id);
+        AssertElement(element, complitedWorkDataModel);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenElementExists_Test()
+    {
+        var complitedWork = InsertComplitedWorkToDatabase(Guid.NewGuid().ToString());
+
+        var duplicate = CreateComplitedWorkDataModel(complitedWork.Id);
+
+        Assert.That(() => _complitedWorkStorageContract.AddElement(duplicate),
+            Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_AddElement_WhenWorkersAreEmpty_Test()
+    {
+        var roomId = InsertRoomToDatabase(Guid.NewGuid().ToString()).Id;
+        var workId = InsertWorkToDatabase(Guid.NewGuid().ToString()).Id;
+
+        var complitedWorkDataModel = new ComplitedWorkDataModel(
+            Guid.NewGuid().ToString(),
+            workId,
+            roomId,
+            new List<WorkerComplitedWorkDataModel>()
+        );
+
+        Assert.That(() => _complitedWorkStorageContract.AddElement(complitedWorkDataModel),
+            Throws.TypeOf<ValidationException>());
+    }
+
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var complitedWork = InsertComplitedWorkToDatabase(Guid.NewGuid().ToString());
+
+        _complitedWorkStorageContract.DelElement(complitedWork.Id);
+
+        var element = GetComplitedWorkFromDatabase(complitedWork.Id);
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _complitedWorkStorageContract.DelElement(Guid.NewGuid().ToString()),
+            Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private ComplitedWork InsertComplitedWorkToDatabase(string id, string workId = null, string roomId = null)
+    {
+        roomId ??= InsertRoomToDatabase(Guid.NewGuid().ToString()).Id;
+        workId ??= InsertWorkToDatabase(Guid.NewGuid().ToString()).Id;
+
+        var workerId = InsertWorkerToDatabase(Guid.NewGuid().ToString()).Id;
+
+        var complitedWork = new ComplitedWork
+        {
+            Id = id,
+            WorkId = workId,
+            RoomId = roomId,
+            Date = DateTime.UtcNow
+        };
+
+        TwoFromTheCasketDb.ComplitedWorks.Add(complitedWork);
+        TwoFromTheCasketDb.SaveChanges();
+
+        var workerComplitedWork = new WorkerComplitedWork
+        {
+            WorkerId = workerId,
+            ComplitedWorkId = complitedWork.Id,
+            NumberOfWorkingHours = 8
+        };
+
+        TwoFromTheCasketDb.WorkerComplitedWorks.Add(workerComplitedWork);
+        TwoFromTheCasketDb.SaveChanges();
+
+        return complitedWork;
+    }
+
+
+
+
+    private ComplitedWorkDataModel CreateComplitedWorkDataModel(string id, string workId = null, string roomId = null)
+    {
+        roomId ??= InsertRoomToDatabase(Guid.NewGuid().ToString()).Id;
+        workId ??= InsertWorkToDatabase(Guid.NewGuid().ToString()).Id;
+
+        var workerId = InsertWorkerToDatabase(Guid.NewGuid().ToString()).Id;
+        var workerComplitedWork = new WorkerComplitedWorkDataModel(workerId, id, 8);
+
+        return new ComplitedWorkDataModel(
+            id,
+            workId,
+            roomId,
+            new List<WorkerComplitedWorkDataModel> { workerComplitedWork }
+        );
+    }
+
+
+
+    private ComplitedWork? GetComplitedWorkFromDatabase(string id) =>
+    TwoFromTheCasketDb.ComplitedWorks
+        .Include(x => x.WorkersComplitedWorks)
+        .FirstOrDefault(x => x.Id == id);
+
+
+    private static void AssertElement(ComplitedWorkDataModel? actual, ComplitedWork expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkId, Is.EqualTo(expected.WorkId));
+            Assert.That(actual.RoomId, Is.EqualTo(expected.RoomId));
+            Assert.That(actual.Date, Is.EqualTo(expected.Date).Within(1).Seconds);
+            Assert.That(actual.Workers, Has.Count.EqualTo(expected.WorkersComplitedWorks.Count));
+        });
+    }
+
+    private static void AssertElement(ComplitedWork? actual, ComplitedWorkDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null, "ComplitedWork не найден в базе после добавления"); // ✅ Проверка перед сравнением
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual!.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WorkId, Is.EqualTo(expected.WorkId));
+            Assert.That(actual.RoomId, Is.EqualTo(expected.RoomId));
+            Assert.That(actual.Date, Is.EqualTo(expected.Date).Within(1).Seconds);
+            Assert.That(actual.WorkersComplitedWorks.Count, Is.EqualTo(expected.Workers.Count));
+        });
+    }
+
+
+    private Room InsertRoomToDatabase(string id, string ownerFIO = "Иванов И.И.", string address = null)
+    {
+        address ??= $"ул. Пушкина, {new Random().Next(1, 1000)}";
+
+        var room = new Room
+        {
+            Id = id,
+            OwnerFIO = ownerFIO,
+            Address = address,
+            Space = 50,
+            Type = TypeRoom.Residential
+        };
+
+        TwoFromTheCasketDb.Rooms.Add(room);
+        TwoFromTheCasketDb.SaveChanges();
+        return room;
+    }
+
+
+    private Work InsertWorkToDatabase(string id, string description = "Test work")
+    {
+        var work = new Work
+        {
+            Id = id,
+            Type = TypeWork.Electrical,
+            Description = description,
+            Date = DateTime.UtcNow
+        };
+
+        TwoFromTheCasketDb.Works.Add(work);
+        TwoFromTheCasketDb.SaveChanges();
+        return work;
+    }
+
+    private Worker InsertWorkerToDatabase(string id, string fio = "Иванов И.И.")
+    {
+        var worker = new Worker
+        {
+            Id = id,
+            FIO = fio,
+            SpecializationId = InsertSpecializationToDatabase(Guid.NewGuid().ToString()).Id,
+            PhoneNumber = "+79101234567",
+            DateBirthDay = DateTime.UtcNow.AddYears(-30),
+            ValidFrom = DateTime.UtcNow,
+            IsCurrent = 1
+        };
+
+        TwoFromTheCasketDb.Workers.Add(worker);
+        TwoFromTheCasketDb.SaveChanges();
+        return worker;
+    }
+
+
+    private TwoFromTheCasketDatabase.Models.Specialization InsertSpecializationToDatabase(string id, string name = null, double salary = 50000)
+    {
+        name ??= $"Повар , {new Random().Next(1, 1000)}";
+        var specialization = new TwoFromTheCasketDatabase.Models.Specialization
+        {
+            Id = id,
+            SpecializationName = name,
+            Salary = salary,
+            IsActual = true,
+            ChangeDate = DateTime.UtcNow
+        };
+
+        TwoFromTheCasketDb.Specializations.Add(specialization);
+        TwoFromTheCasketDb.SaveChanges();
+        return specialization;
+    }
+
+
+
+}
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/RoomStorageContractTests.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/RoomStorageContractTests.cs
@@ -0,0 +1,244 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Enums;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketDatabase.Implementations;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+[TestFixture]
+public class RoomStorageContractTests : BaseStorageContractTest
+{
+    private RoomStorageContract _roomStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _roomStorageContract = new RoomStorageContract(TwoFromTheCasketDb);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"RoomHistories\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"ComplitedWorks\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Rooms\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var room = InsertRoomToDatabase(Guid.NewGuid().ToString(), "Иванов И.И.", "ул. Ленина, 10");
+        InsertRoomToDatabase(Guid.NewGuid().ToString(), "Петров П.П.", "ул. Кирова, 15");
+
+        var list = _roomStorageContract.GetList();
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        AssertElement(list.First(x => x.Id == room.Id), room);
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _roomStorageContract.GetList();
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetHistoryRoomId_WhenHaveRecords_Test()
+    {
+        var room = InsertRoomToDatabase(Guid.NewGuid().ToString());
+        InsertRoomHistoryToDatabase(Guid.NewGuid().ToString(), room.Id);
+        InsertRoomHistoryToDatabase(Guid.NewGuid().ToString(), room.Id);
+
+        var history = _roomStorageContract.GetHistoryRoomId(room.Id);
+
+        Assert.That(history, Is.Not.Null);
+        Assert.That(history, Has.Count.EqualTo(2));
+    }
+
+    [Test]
+    public void Try_GetHistoryRoomId_WhenNoRecords_Test()
+    {
+        var history = _roomStorageContract.GetHistoryRoomId(Guid.NewGuid().ToString());
+
+        Assert.That(history, Is.Not.Null);
+        Assert.That(history, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetListByOwner_WhenHaveRecords_Test()
+    {
+        var ownerFIO = "Иванов И.И.";
+        InsertRoomToDatabase(Guid.NewGuid().ToString(), ownerFIO);
+        InsertRoomToDatabase(Guid.NewGuid().ToString(), ownerFIO, "ул. Колотушкина");
+
+        var list = _roomStorageContract.GetListByOwner(ownerFIO);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+    }
+
+    [Test]
+    public void Try_GetListByOwner_WhenNoRecords_Test()
+    {
+        var list = _roomStorageContract.GetListByOwner("Несуществующий владелец");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetListByAddress_WhenHaveRecords_Test()
+    {
+        var address = "ул. Ленина, 10";
+        InsertRoomToDatabase(Guid.NewGuid().ToString(), "Иванов И.И.", address);
+
+        var list = _roomStorageContract.GetListByAddress(address);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public void Try_GetListByAddress_WhenNoRecords_Test()
+    {
+        var list = _roomStorageContract.GetListByAddress("Несуществующий адрес");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var room = InsertRoomToDatabase(Guid.NewGuid().ToString());
+        AssertElement(_roomStorageContract.GetElementById(room.Id), room);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        Assert.That(_roomStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var roomDataModel = CreateRoomDataModel(Guid.NewGuid().ToString(), "Сидоров А.А.", "ул. Лермонтова, 25");
+        _roomStorageContract.AddElement(roomDataModel);
+        AssertElement(GetRoomFromDatabase(roomDataModel.Id), roomDataModel);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenElementWithSameAddressExists_Test()
+    {
+        var roomDataModel = CreateRoomDataModel(Guid.NewGuid().ToString(), "Иванов И.И.", "ул. Некрасова, 33");
+        InsertRoomToDatabase(Guid.NewGuid().ToString(), address: roomDataModel.Address);
+
+        Assert.That(() => _roomStorageContract.AddElement(roomDataModel),
+            Throws.TypeOf<ElementExistsException>());
+    }
+
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var room = InsertRoomToDatabase(Guid.NewGuid().ToString(), "Иванов И.И.", "ул. Пушина, 1");
+        var updatedRoom = CreateRoomDataModel(room.Id, "Петров П.П.", "ул. Чехова, 22");
+
+        _roomStorageContract.UpdElement(updatedRoom);
+        AssertElement(GetRoomFromDatabase(updatedRoom.Id), updatedRoom);
+    }
+
+    [Test]
+    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
+    {
+        var updatedRoom = CreateRoomDataModel(Guid.NewGuid().ToString());
+        Assert.That(() => _roomStorageContract.UpdElement(updatedRoom),
+            Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var room = InsertRoomToDatabase(Guid.NewGuid().ToString());
+        _roomStorageContract.DelElement(room.Id);
+        Assert.That(GetRoomFromDatabase(room.Id), Is.Null);
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecordWithThisId_Test()
+    {
+        Assert.That(() => _roomStorageContract.DelElement(Guid.NewGuid().ToString()),
+            Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private Room InsertRoomToDatabase(string id, string ownerFIO = "Иванов И.И.", string address = "ул. Пушкина, 1")
+    {
+        var room = new Room
+        {
+            Id = id,
+            OwnerFIO = ownerFIO,
+            Address = address,
+            Space = 50,
+            Type = TypeRoom.Office
+        };
+
+        TwoFromTheCasketDb.Rooms.Add(room);
+        TwoFromTheCasketDb.SaveChanges();
+
+        return room;
+    }
+
+    private void InsertRoomHistoryToDatabase(string id, string roomId)
+    {
+        var history = new RoomHistory
+        {
+            Id = id,
+            RoomId = roomId,
+            OwnerFIO = "Иванов И.И.",
+            Type = TypeRoom.Office,
+            ChangeDate = DateTime.UtcNow
+        };
+
+        TwoFromTheCasketDb.RoomHistories.Add(history);
+        TwoFromTheCasketDb.SaveChanges();
+    }
+
+    private static void AssertElement(RoomDataModel? actual, Room expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.OwnerFIO, Is.EqualTo(expected.OwnerFIO));
+            Assert.That(actual.Address, Is.EqualTo(expected.Address));
+            Assert.That(actual.Space, Is.EqualTo(expected.Space));
+            Assert.That(actual.Type, Is.EqualTo(expected.Type));
+        });
+    }
+
+    private static void AssertElement(Room? actual, RoomDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.OwnerFIO, Is.EqualTo(expected.OwnerFIO));
+            Assert.That(actual.Address, Is.EqualTo(expected.Address));
+            Assert.That(actual.Space, Is.EqualTo(expected.Space));
+            Assert.That(actual.Type, Is.EqualTo(expected.Type));
+        });
+    }
+
+    private RoomDataModel CreateRoomDataModel(string id, string ownerFio = "Иванов И.И.", string address = "ул. Пушкина, 1") =>
+        new(id, ownerFio, address, 50, TypeRoom.Office);
+
+    private Room? GetRoomFromDatabase(string id) =>
+        TwoFromTheCasketDb.Rooms.FirstOrDefault(x => x.Id == id);
+}
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/SalaryStorageContract.cs
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/SalaryStorageContract.cs
@@ -0,0 +1,177 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketDatabase.Implementations;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+[TestFixture]
+public class SalaryStorageContractTests : BaseStorageContractTest
+{
+    private SalaryStorageContract _salaryStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _salaryStorageContract = new SalaryStorageContract(TwoFromTheCasketDb);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Salaries\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Workers\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+        var worker = InsertWorkerToDatabase(Guid.NewGuid().ToString());
+        var salary1 = InsertSalaryToDatabase(worker.Id, DateTime.UtcNow.AddDays(-5));
+        var salary2 = InsertSalaryToDatabase(worker.Id, DateTime.UtcNow);
+
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        AssertElement(list.First(x => x.Date == salary1.Date), salary1);
+        AssertElement(list.First(x => x.Date == salary2.Date), salary2);
+    }
+
+    [Test]
+    public void Try_GetList_WithWorkerId_Test()
+    {
+        var worker1 = InsertWorkerToDatabase(Guid.NewGuid().ToString());
+        var worker2 = InsertWorkerToDatabase(Guid.NewGuid().ToString());
+
+        var salary1 = InsertSalaryToDatabase(worker1.Id, DateTime.UtcNow);
+        InsertSalaryToDatabase(worker2.Id, DateTime.UtcNow);
+
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow, worker1.Id);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(1));
+        AssertElement(list.First(), salary1);
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var list = _salaryStorageContract.GetList(DateTime.UtcNow.AddDays(-10), DateTime.UtcNow);
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var worker = InsertWorkerToDatabase(Guid.NewGuid().ToString());
+        var salaryDataModel = CreateSalaryDataModel(worker.Id);
+
+        _salaryStorageContract.AddElement(salaryDataModel);
+
+        var element = GetSalaryFromDatabase(salaryDataModel.WorkerId, salaryDataModel.Date);
+        AssertElement(element, salaryDataModel);
+    }
+
+    [Test]
+    public void Try_AddElement_WhenWorkerNotExists_Test()
+    {
+        var salaryDataModel = CreateSalaryDataModel(Guid.NewGuid().ToString());
+
+        Assert.That(() => _salaryStorageContract.AddElement(salaryDataModel),
+            Throws.TypeOf<ElementNotFoundException>());
+    }
+
+    private Worker InsertWorkerToDatabase(string id, string fio = "Иванов И.И.")
+    {
+        var worker = new Worker
+        {
+            Id = id,
+            FIO = fio,
+            SpecializationId = InsertSpecializationToDatabase(Guid.NewGuid().ToString()).Id,
+            PhoneNumber = "+79101234567",
+            DateBirthDay = DateTime.UtcNow.AddYears(-30),
+            ValidFrom = DateTime.UtcNow,
+            IsCurrent = 1
+        };
+
+        TwoFromTheCasketDb.Workers.Add(worker);
+        TwoFromTheCasketDb.SaveChanges();
+        return worker;
+    }
+
+    private Salary InsertSalaryToDatabase(string workerId, DateTime date, double sum = 50000)
+    {
+        var salary = new Salary
+        {
+            Id = Guid.NewGuid().ToString(),
+            WorkerId = workerId,
+            Date = date,
+            Sum = sum
+        };
+
+        TwoFromTheCasketDb.Salaries.Add(salary);
+        TwoFromTheCasketDb.SaveChanges();
+        return salary;
+    }
+
+    private SalaryDataModel CreateSalaryDataModel(string workerId, double sum = 50000)
+    {
+        return new SalaryDataModel(
+            Guid.NewGuid().ToString(),
+            workerId,
+            sum
+        );
+    }
+
+    private Salary? GetSalaryFromDatabase(string workerId, DateTime date)
+    {
+        return TwoFromTheCasketDb.Salaries
+            .FirstOrDefault(x => x.WorkerId == workerId && x.Date == date);
+    }
+
+    private static void AssertElement(SalaryDataModel? actual, Salary 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.Date, Is.EqualTo(expected.Date).Within(1).Seconds);
+            Assert.That(actual.Sum, Is.EqualTo(expected.Sum));
+        });
+    }
+
+    private static void AssertElement(Salary? actual, SalaryDataModel 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.Date, Is.EqualTo(expected.Date).Within(1).Seconds);
+            Assert.That(actual.Sum, Is.EqualTo(expected.Sum));
+        });
+    }
+
+    private TwoFromTheCasketDatabase.Models.Specialization InsertSpecializationToDatabase(string id, string name = null, double salary = 50000)
+    {
+        name ??= $"Повар , {new Random().Next(1, 1000)}";
+        var specialization = new TwoFromTheCasketDatabase.Models.Specialization
+        {
+            Id = id,
+            SpecializationName = name,
+            Salary = salary,
+            IsActual = true,
+            ChangeDate = DateTime.UtcNow
+        };
+
+        TwoFromTheCasketDb.Specializations.Add(specialization);
+        TwoFromTheCasketDb.SaveChanges();
+        return specialization;
+    }
+}
--- a/TwoFromTheCasketContracts/TwoFromTheCasketTests/TwoFromTheCasketTests.csproj
+++ b/TwoFromTheCasketContracts/TwoFromTheCasketTests/TwoFromTheCasketTests.csproj
@@ -10,8 +10,10 @@

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

  <ItemGroup>
    <Using Include="NUnit.Framework" />
  </ItemGroup>

-  <ItemGroup>
-    <Folder Include="StorageContracts\" />
-  </ItemGroup>
-
 </Project>