PIbd-23_Kadyshev_M.I_TwoFromTheCasket/TwoFromTheCasketContratcs/TwoFromTheCasketTest/StoragesContractsTests/OrderStorageContractTests.cs

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using TwoFromTheCasketContratcs.DataModels;
using TwoFromTheCasketContratcs.Enums;
using TwoFromTheCasketContratcs.Exceptions;
using TwoFromTheCasketDatabase.Implementation;
using TwoFromTheCasketDatabase.Models;
using NUnit.Framework;
using TwoFromTheCasketContratcs.StorageContracts;

namespace TwoFromTheCasketTest.StoragesContractsTests
{
    [TestFixture]
    internal class OrderStorageContractTests : BaseStorageContractTest
    {
        private OrderStorageContract _orderStorageContract;

        [SetUp]
        public void SetUp()
        {
            _orderStorageContract = new OrderStorageContract(TwoFromTheCasketDbContext);
        }

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

        [Test]
        public void Try_GetList_WhenHaveRecords_Test()
        {
            var order = InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString());
            InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString());
            InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString());
            var list = _orderStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
            AssertElement(list.First(x => x.Id == order.Id), order);


        }

        [Test]
        public void Try_GetList_WhenNoRecords_Test()
        {
            var list = _orderStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.Empty);
        }
        [Test]
        public void Try_GetElementById_WhenHaveRecord_Test()
        {
            var service = InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_orderStorageContract.GetElementById(service.Id), service);
        }
        [Test]
        public void Try_GetElementByDate_WhenNoRecord_Test()
        {
            Assert.That(() => _orderStorageContract.GetElementByDate(DateTime.UtcNow), Is.Null);
        }
        [Test]
        public void Try_GetElementByDate_WhenHaveRecord_Test()
        {
            var order = InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString(), DateTime.UtcNow);
            InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString(), DateTime.UtcNow);
            Assert.That(order, Is.Not.Null);
        }
        [Test]
        public void Try_GetElementByStatus_WhenNoRecord_Test()
        {
            Assert.That(() => _orderStorageContract.GetElementByStatus(StatusType.None), Is.Null);
        }
        [Test]
        public void Try_GetElementByStatus_WhenHaveRecord_Test()
        {
            var order = InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.None);
            InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString(), DateTime.UtcNow, StatusType.None);
            Assert.That(order, Is.Not.Null);
        }

        [Test]
        public void Try_AddElement_Test()
        {
            var order = CreateModel(Guid.NewGuid().ToString());
            _orderStorageContract.AddElement(order);
            AssertElement(GetOrderFromDatabase(order.Id), order);
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameId_Test()
        {
            var order = CreateModel(Guid.NewGuid().ToString());
            InsertOrderToDatabaseAndReturn(order.Id);
            Assert.That(() => _orderStorageContract.AddElement(order), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_UpdElement_Test()
        {
            var order = CreateModel(Guid.NewGuid().ToString());
            InsertOrderToDatabaseAndReturn(order.Id);
            _orderStorageContract.UpdElement(order);
            AssertElement(GetOrderFromDatabase(order.Id), order);
        }
        [Test]
        public void Try_UpdElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _orderStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())),
                Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_DelElement_Test()
        {
            var order = InsertOrderToDatabaseAndReturn(Guid.NewGuid().ToString());

            
            _orderStorageContract.DelElement(order.Id);

            
            var element = GetOrderFromDatabase(order.Id);
            Assert.That(element, Is.Null);
        }
        [Test]
        public void Try_DelElement_WhenNoRecordWasDeleted_Test()
        {
            var order = CreateModel(Guid.NewGuid().ToString());
            Assert.That(() => _orderStorageContract.DelElement(order.Id), Throws.TypeOf<ElementNotFoundException>());
        }
        [Test]
        public void Try_DelElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _orderStorageContract.DelElement(Guid.NewGuid().ToString()),
                Throws.TypeOf<ElementNotFoundException>());
        }



        private Order InsertOrderToDatabaseAndReturn(string id, DateTime? date = null, StatusType? status = null, RoomType? roomType = null)
        {
            var order = new Order()
            {
               Id = id

            };
            TwoFromTheCasketDbContext.Orders.Add(order);
            TwoFromTheCasketDbContext.SaveChanges();
            return order;
        }

        private static void AssertElement(OrderDataModel? actual, Order expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.Status, Is.EqualTo(expected.Status));
                Assert.That(actual.Date, Is.EqualTo(expected.Date));
                Assert.That(actual.RoomType, Is.EqualTo(expected.RoomType));
                
            });
        }

        private static OrderDataModel CreateModel(string id, DateTime? date = null, StatusType? status = null, RoomType? roomType = null) =>
            new(id, date ?? DateTime.UtcNow, status ?? StatusType.None, roomType ?? RoomType.None);

        private Order? GetOrderFromDatabase(string id) => TwoFromTheCasketDbContext.Orders.FirstOrDefault(x => x.Id == id);

        private static void AssertElement(Order? actual, OrderDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.Status, Is.EqualTo(expected.Status));
                Assert.That(actual.Date, Is.EqualTo(expected.Date));
                Assert.That(actual.RoomType, Is.EqualTo(expected.RoomType));
            });
        }

    }
}