PIBD24_BoikoM.S._Candyhouse/CandyHouseSolution/CandyHouseTests/StoragesContracts/PositionStorageContractTests.cs

using AutoMapper;
using CandyHouseBase.DataModels;
using CandyHouseBase.Exceptions;
using CandyHouseBase.Enums; // Add this for PositionType
using CandyHouseDataBase.Implementations;
using CandyHouseDataBase.Models;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System;
using System.Linq;

namespace CandyHouseTests.StoragesContracts
{
    [TestFixture]
    internal class PositionStorageContractTests : BaseStorageContractTest
    {
        private PositionStorageContract _positionStorageContract;

        [SetUp]
        public void SetUp()
        {
            _positionStorageContract = new PositionStorageContract(CandyHouseDbContext);
        }

        [TearDown]
        public void TearDown()
        {
            CandyHouseDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Positions\" CASCADE;");
        }

        [Test]
        public void Try_GetList_WhenHaveRecords_Test()
        {
            var position = InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Small, "Manager");
            InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Medium, "Clerk");
            InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Cool, "Supervisor",
                false); // Not actual

            var list = _positionStorageContract.GetList();

            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(2)); // Only actual positions
            AssertElement(list.First(x => x.Id == position.Id), position);
        }

        [Test]
        public void Try_GetList_WhenNoRecords_Test()
        {
            var list = _positionStorageContract.GetList();

            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.Empty);
        }

        [Test]
        public void Try_GetElementById_WhenHaveRecord_Test()
        {
            var position = InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Small, "Manager");
            Console.WriteLine($"Inserted PositionId: {position.PositionId}");
            Console.WriteLine($"Querying with id: {position.Id}");
            var result = _positionStorageContract.GetElementById(position.PositionId);
            Console.WriteLine($"Returned Id: {result.Id}");
            Console.WriteLine($"Position Id: {position.Id}");
            AssertElement(result, position);
            // Explicitly verify the Id matches PositionId
            Assert.That(result.Id, Is.EqualTo(position.Id),
                "PositionDataModel.Id should match Position.PositionId");
        }

        [Test]
        public void Try_GetElementById_WhenNoRecord_Test()
        {
            Assert.That(() => _positionStorageContract.GetElementById(Guid.NewGuid().ToString()),
                Throws.TypeOf<StorageException>());
        }

        [Test]
        public void Try_AddElement_Test()
        {
            var position = CreateModel(Guid.NewGuid().ToString(), PositionType.Medium, "Manager");

            _positionStorageContract.AddElement(position);
            AssertElement(GetPositionFromDatabase(position.Id), position);
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameTitle_Test()
        {
            var positionId = Guid.NewGuid().ToString();
            InsertPositionToDatabaseAndReturn(positionId, PositionType.Small, "Manager");
            var duplicatePosition = CreateModel(Guid.NewGuid().ToString(), PositionType.Medium, "Manager");

            Assert.That(() => _positionStorageContract.AddElement(duplicatePosition),
                Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_UpdateElement_WhenHaveRecord_Test()
        {
            var positionId = Guid.NewGuid().ToString();
            InsertPositionToDatabaseAndReturn(positionId, PositionType.Small, "Manager");
            var updatedPosition = CreateModel(positionId, PositionType.Cool, "Senior Manager");

            _positionStorageContract.UpdateElement(updatedPosition);

            var currentPosition = GetPositionFromDatabaseByPositionId(positionId, true);
            AssertElement(currentPosition, updatedPosition);
            var oldPosition = GetPositionFromDatabaseByPositionId(positionId, false);
            Assert.That(oldPosition, Is.Not.Null);
            Assert.That(oldPosition.IsActual, Is.False);
        }

        [Test]
        public void Try_UpdateElement_WhenNoRecord_Test()
        {
            var position = CreateModel(Guid.NewGuid().ToString(), PositionType.Medium, "Manager");

            Assert.That(() => _positionStorageContract.UpdateElement(position),
                Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_UpdateElement_WhenDuplicateTitleExists_Test()
        {
            var positionId1 = Guid.NewGuid().ToString();
            var positionId2 = Guid.NewGuid().ToString();
            InsertPositionToDatabaseAndReturn(positionId1, PositionType.Small, "Manager");
            InsertPositionToDatabaseAndReturn(positionId2, PositionType.Medium, "Senior Manager");
            var updatedPosition = CreateModel(positionId1, PositionType.Cool, "Senior Manager");

            Assert.That(() => _positionStorageContract.UpdateElement(updatedPosition),
                Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_DeleteElement_Test()
        {
            var position = InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Small, "Manager");

            _positionStorageContract.DeleteElement(position.PositionId);
            var deletedPosition = GetPositionFromDatabaseByPositionId(position.PositionId, true);
            Assert.That(deletedPosition, Is.Null);
            var historicalPosition = GetPositionFromDatabaseByPositionId(position.PositionId, false);
            Assert.That(historicalPosition, Is.Not.Null);
            Assert.That(historicalPosition.IsActual, Is.False);
        }

        [Test]
        public void Try_DeleteElement_WhenNoRecord_Test()
        {
            Assert.That(() => _positionStorageContract.DeleteElement(Guid.NewGuid().ToString()),
                Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_DeleteElement_WhenAlreadyNotActual_Test()
        {
            var position =
                InsertPositionToDatabaseAndReturn(Guid.NewGuid().ToString(), PositionType.Small, "Manager", false);

            Assert.That(() => _positionStorageContract.DeleteElement(position.PositionId),
                Throws.TypeOf<ElementDeletedException>());
        }

        private Position InsertPositionToDatabaseAndReturn(string positionId, PositionType type, string title,
            bool isActual = true)
        {
            var position = new Position
            {
                PositionId = positionId,
                Id = Guid.NewGuid().ToString(),
                Type = type,
                Title = title,
                IsActual = isActual,
                ChangeDate = DateTime.UtcNow
            };
            CandyHouseDbContext.Positions.Add(position);
            CandyHouseDbContext.SaveChanges();
            return position;
        }

        private static void AssertElement(PositionDataModel actual, Position expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.Type, Is.EqualTo(expected.Type));
                Assert.That(actual.Title, Is.EqualTo(expected.Title));
            });
        }

        private static void AssertElement(Position actual, PositionDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.PositionId, Is.EqualTo(expected.Id));
                Assert.That(actual.Type, Is.EqualTo(expected.Type));
                Assert.That(actual.Title, Is.EqualTo(expected.Title));
                Assert.That(actual.IsActual, Is.True); // Assumes we only check actual records
            });
        }

        private static PositionDataModel CreateModel(string id, PositionType type, string title)
        {
            return new PositionDataModel(id, type, title);
        }

        private Position GetPositionFromDatabase(string id)
        {
            return CandyHouseDbContext.Positions.FirstOrDefault(x => x.Id == id);
        }

        private Position GetPositionFromDatabaseByPositionId(string positionId, bool isActual)
        {
            return CandyHouseDbContext.Positions
                .Where(x => x.PositionId == positionId && x.IsActual == isActual)
                .OrderByDescending(x => x.ChangeDate)
                .FirstOrDefault();
        }
    }
}