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

using CandyHouseBase.DataModels;
using CandyHouseBase.Enums;
using CandyHouseBase.Exceptions;
using CandyHouseDataBase.Implementations;
using CandyHouseDataBase.Models;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System;
using System.Linq;

namespace CandyHouseTests.StoragesContracts
{
    [TestFixture]
    internal class OrderStorageContractTests : BaseStorageContractTest
    {
        private OrderStorageContract _orderStorageContract;
        private string _pekarId;
        private string _productId;
        private Position _position;

        [SetUp]
        public void SetUp()
        {
            _orderStorageContract = new OrderStorageContract(CandyHouseDbContext);
            _position = InsertPositionToDatabaseAndReturn();
            _pekarId = InsertPekarToDatabaseAndReturn(_position.Id).Id; // Insert a Pekar for foreign key
            _productId = InsertProductToDatabaseAndReturn().Id; // Insert a Product for foreign key
        }

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

        [Test]
        public void Try_GetOrders_WhenHaveRecords_Test()
        {
            var order1 = InsertOrderToDatabaseAndReturn("Customer1", DateTime.UtcNow);
            var order2 = InsertOrderToDatabaseAndReturn("Customer2", DateTime.UtcNow.AddDays(-1));

            var orders = _orderStorageContract.GetOrders();

            Assert.That(orders, Is.Not.Null);
            Assert.That(orders, Has.Count.EqualTo(2));
            AssertOrder(orders.First(o => o.Id == order1.Id), order1);
        }

        [Test]
        public void Try_GetOrders_WhenNoRecords_Test()
        {
            var orders = _orderStorageContract.GetOrders();

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

        [Test]
        public void Try_AddElement_ValidOrder_Test()
        {
            var order = CreateOrderModel(Guid.NewGuid().ToString(), "John Doe", DateTime.UtcNow, 100m, 10m);

            _orderStorageContract.AddElement(order);
            var dbOrder = GetOrderFromDatabaseById(order.Id);

            Assert.That(dbOrder, Is.Not.Null);
            AssertOrder(dbOrder, order);
        }

        [Test]
        public void Try_AddElement_DuplicatePekarIdAndOrderDate_Test()
        {
            var order1 = CreateOrderModel(Guid.NewGuid().ToString(), "John Doe", DateTime.UtcNow, 100m, 10m);
            _orderStorageContract.AddElement(order1);

            var order2 = CreateOrderModel(Guid.NewGuid().ToString(), "Jane Doe", order1.OrderDate, 200m, 20m);

            Assert.That(() => _orderStorageContract.AddElement(order2),
                Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_AddElement_InvalidOrder_Test()
        {
            var order = CreateOrderModel("", "John Doe", DateTime.UtcNow, -100m, 10m); // Invalid Id and TotalAmount

            Assert.That(() => _orderStorageContract.AddElement(order),
                Throws.TypeOf<ValidationException>());
        }

        [Test]
        public void Try_UpdateElement_ValidOrder_Test()
        {
            var originalOrder = InsertOrderToDatabaseAndReturn("Original Customer", DateTime.UtcNow);
            var updatedOrder = CreateOrderModel(originalOrder.Id, "Updated Customer", DateTime.UtcNow.AddHours(1), 200m,
                20m);

            _orderStorageContract.UpdateElement(updatedOrder);
            var dbOrder = GetOrderFromDatabaseById(updatedOrder.Id);

            Assert.That(dbOrder, Is.Not.Null);
            AssertOrder(dbOrder, updatedOrder);
        }

        [Test]
        public void Try_UpdateElement_NonExistentOrder_Test()
        {
            var order = CreateOrderModel(Guid.NewGuid().ToString(), "John Doe", DateTime.UtcNow, 100m, 10m);

            Assert.That(() => _orderStorageContract.UpdateElement(order),
                Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_UpdateElement_DuplicatePekarIdAndOrderDate_Test()
        {
            var order1 = InsertOrderToDatabaseAndReturn("Customer1", DateTime.UtcNow);
            var order2 = InsertOrderToDatabaseAndReturn("Customer2", DateTime.UtcNow.AddDays(1));
            var updatedOrder2 = CreateOrderModel(order2.Id, "Customer2 Updated", order1.OrderDate, 200m, 20m);

            Assert.That(() => _orderStorageContract.UpdateElement(updatedOrder2),
                Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_DeleteElement_ValidOrder_Test()
        {
            var order = InsertOrderToDatabaseAndReturn("John Doe", DateTime.UtcNow);

            _orderStorageContract.DeleteElement(CreateOrderModel(order.Id, order.CustomerName, order.OrderDate,
                order.TotalAmount, order.DiscountAmount));
            var dbOrder = GetOrderFromDatabaseById(order.Id);

            Assert.That(dbOrder, Is.Null);
        }

        [Test]
        public void Try_DeleteElement_NonExistentOrder_Test()
        {
            var order = CreateOrderModel(Guid.NewGuid().ToString(), "John Doe", DateTime.UtcNow, 100m, 10m);

            Assert.That(() => _orderStorageContract.DeleteElement(order),
                Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_GetElementById_ValidOrder_Test()
        {
            var order = InsertOrderToDatabaseAndReturn("John Doe", DateTime.UtcNow);

            var result = _orderStorageContract.GetElementById(order.Id);

            Assert.That(result, Is.Not.Null);
            AssertOrder(result, order);
        }

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

        // Helper Methods
        private Order InsertOrderToDatabaseAndReturn(string customerName, DateTime orderDate)
        {
            var order = new Order
            {
                Id = Guid.NewGuid().ToString(),
                CustomerName = customerName,
                OrderDate = orderDate,
                TotalAmount = 100m,
                DiscountAmount = 10m,
                ProductId = _productId,
                PekarId = _pekarId,
                StatusType = StatusType.Pending
            };
            CandyHouseDbContext.Orders.Add(order);
            CandyHouseDbContext.SaveChanges();
            return order;
        }

        private Pekar InsertPekarToDatabaseAndReturn(string positonId = null)
        {
            var pekar = new Pekar
            {
                Id = Guid.NewGuid().ToString(),
                FIO = "Test Pekar",
                PositionId = positonId, // Assuming a valid PositionId
                BonusCoefficient = 1.0m
            };
            CandyHouseDbContext.Pekars.Add(pekar);
            CandyHouseDbContext.SaveChanges();
            return pekar;
        }

        private Product InsertProductToDatabaseAndReturn()
        {
            var product = new Product
            {
                Id = Guid.NewGuid().ToString(),
                Name = "Test Product",
                Description = "Test Description",
                OldName = "Test Old Name",
                OldDescription = "Test Old Description"
            };
            CandyHouseDbContext.Products.Add(product);
            CandyHouseDbContext.SaveChanges();
            return product;
        }

        private Order GetOrderFromDatabaseById(string id)
        {
            return CandyHouseDbContext.Orders.FirstOrDefault(x => x.Id == id);
        }

        private OrderDataModel CreateOrderModel(string id, string customerName, DateTime orderDate, decimal totalAmount,
            decimal discountAmount)
        {
            return new OrderDataModel(id, customerName, orderDate, totalAmount, discountAmount, _productId, _pekarId,
                StatusType.Pending);
        }

        private static void AssertOrder(OrderDataModel actual, Order expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.CustomerName, Is.EqualTo(expected.CustomerName));
                Assert.That(actual.OrderDate, Is.EqualTo(expected.OrderDate));
                Assert.That(actual.TotalAmount, Is.EqualTo(expected.TotalAmount));
                Assert.That(actual.DiscountAmount, Is.EqualTo(expected.DiscountAmount));
                Assert.That(actual.ProductId, Is.EqualTo(expected.ProductId));
                Assert.That(actual.PekarId, Is.EqualTo(expected.PekarId));
                Assert.That(actual.StatusType, Is.EqualTo(expected.StatusType));
            });
        }

        private static void AssertOrder(Order actual, OrderDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.CustomerName, Is.EqualTo(expected.CustomerName));
                Assert.That(actual.OrderDate, Is.EqualTo(expected.OrderDate));
                Assert.That(actual.TotalAmount, Is.EqualTo(expected.TotalAmount));
                Assert.That(actual.DiscountAmount, Is.EqualTo(expected.DiscountAmount));
                Assert.That(actual.ProductId, Is.EqualTo(expected.ProductId));
                Assert.That(actual.PekarId, Is.EqualTo(expected.PekarId));
                Assert.That(actual.StatusType, Is.EqualTo(expected.StatusType));
            });
        }

        private Position InsertPositionToDatabaseAndReturn(string? positionId = null)
        {
            var position = new Position
            {
                Id = positionId ?? Guid.NewGuid().ToString(), // Unique ID for each record
                PositionId = positionId ?? Guid.NewGuid().ToString(), // Unique ID for each record
                Type = PositionType.Cool, // Assuming string; adjust if PositionType enum is used
                Title = "TestPosition",
                IsActual = true,
                ChangeDate = DateTime.UtcNow
            };
            CandyHouseDbContext.Positions.Add(position);
            CandyHouseDbContext.SaveChanges();
            return position;
        }
    }
}