PIbd-22_Alkin_D.V_WildPlumDelivery/WildPlumProject/WildPlumTests/StoragesContractsTests/WarehouseStorageContractTests.cs

using WildPlumDatabase.Implementations;
using WildPlumDatabase;
using Microsoft.EntityFrameworkCore;
using WildPlumContracts.DataModels;
using WildPlumDatabase.Models;
using WildPlumContracts.Exceptions;

namespace WildPlumTests.StoragesContractsTests;

[TestFixture]
internal class WarehouseStorageContractTests : BaseStorageContractTests
{
    private WarehouseStorageContract _productStorageContract;

    [SetUp]
    public void SetUp()
    {
        _productStorageContract = new WarehouseStorageContract(WildPlumDbContext);
    }
    [TearDown]
    public void TearDown()
    {
        WildPlumDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE; ");
    }

    [Test]
    public void Try_GetList_WhenHaveRecords_Test()
    {
        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1", location: "loc3");
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2", location: "loc3");
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3", location: "loc3");
        var list = _productStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
        AssertElement(list.First(x => x.Id == product.Id), product);
    }
    [Test]
    public void Try_GetList_WhenNoRecords_Test()
    {
        var list = _productStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.Empty);
    }

    [Test]
    public void Try_GetElementByName_WhenHaveRecord_Test()
    {
        var product =
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
        AssertElement(_productStorageContract.GetElementByName(product.Name), product);
    }
    [Test]
    public void Try_GetElementByName_WhenNoRecord_Test()
    {
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString());
        Assert.That(() => _productStorageContract.GetElementByName("name"), Is.Null);
    }
    [Test]
    public void Try_AddElement_Test()
    {
        var product = CreateModel(Guid.NewGuid().ToString(), "name2", "loc2");
        _productStorageContract.AddElement(product);
        AssertElement(GetProductFromDatabaseById(product.Id), product);
    }
    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
    {
        var product = CreateModel(Guid.NewGuid().ToString());
        InsertProductToDatabaseAndReturn(product.Id, name: "name unique", location: "loc2");
        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
    }
    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
    {
        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), name: product.Name);
        Assert.That(() => _productStorageContract.AddElement(product), Throws.TypeOf<ElementExistsException>());
    }
    [Test]
    public void Try_UpdElement_Test()
    {
        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
        InsertProductToDatabaseAndReturn(product.Id, "name unique", location: "loc2");
        _productStorageContract.UpdElement(product);
        AssertElement(GetProductFromDatabaseById(product.Id), product);
    }
    [Test]
    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
    {
        Assert.That(() => _productStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
    }
    [Test]
    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
    {
        var product = CreateModel(Guid.NewGuid().ToString(), "name unique", location: "loc2");
        InsertProductToDatabaseAndReturn(product.Id, name: "name", location: "loc3");
        InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), name: product.Name, location: "loc4");
        Assert.That(() => _productStorageContract.UpdElement(product),
        Throws.TypeOf<ElementExistsException>());
    }
    [Test]
    public void Try_DelElement_Test()
    {
        var product = InsertProductToDatabaseAndReturn(Guid.NewGuid().ToString(), "name unique", location: "loc2");
        _productStorageContract.DelElement(product.Id);
        var element = GetProductFromDatabaseById(product.Id);
        Assert.That(element, Is.Null);
    }

    [Test]
    public void Try_DelElement_WhenNoRecordWithThisId_Test()
    {
        Assert.That(() => _productStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
    }


    private Warehouse InsertProductToDatabaseAndReturn(string id, string name = "test", string location = "loc1")
    {
        var product = new Warehouse()
        {
            Id = id,
            Name = name,
            Location = location
        };
        WildPlumDbContext.Warehouses.Add(product);
        WildPlumDbContext.SaveChanges();
        return product;
    }
    
    private static void AssertElement(WarehouseDataModel? actual, Warehouse expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.Name, Is.EqualTo(expected.Name));
        });
    }

    private static WarehouseDataModel CreateModel(string id, string name = "test", string location = "loc1")
    => new(id, name, location);

    private Warehouse? GetProductFromDatabaseById(string id) => WildPlumDbContext.Warehouses.FirstOrDefault(x => x.Id == id);

    private static void AssertElement(Warehouse? actual, WarehouseDataModel
    expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.Name, Is.EqualTo(expected.Name));
        });
    }
}