Check/MagicCarpetProject/MagicCarpetTests/StoragesContractsTests/TourStorageContractTests.cs

using MagicCarpetContracts.DataModels;
using MagicCarpetContracts.Enums;
using MagicCarpetContracts.Exceptions;
using MagicCarpetDatabase.Implementations;
using MagicCarpetDatabase.Models;
using Microsoft.EntityFrameworkCore;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static NUnit.Framework.Internal.OSPlatform;

namespace MagicCarpetTests.StoragesContracts;

[TestFixture]
internal class TourStorageContractTests : BaseStorageContractTest
{
    private TourStorageContract _tourStorageContract;

    [SetUp]
    public void SetUp()
    {
        _tourStorageContract = new TourStorageContract(MagicCarpetDbContext);
    }

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

    [Test]
    public void Try_GetList_WhenHaveRecords_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2");
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3");
        var list = _tourStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
        AssertElement(list.First(x => x.Id == tour.Id), tour);
    }

    [Test]
    public void Try_GetList_WhenNoRecords_Test()
    {
        var list = _tourStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.Empty);
    }

    [Test]
    public void Try_GetHistoryByTourId_WhenHaveRecords_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 20, DateTime.UtcNow.AddDays(-1));
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 30, DateTime.UtcNow.AddMinutes(-10));
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 40, DateTime.UtcNow.AddDays(1));
        var list = _tourStorageContract.GetHistoryByTourId(tour.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
    }

    [Test]
    public void Try_GetHistoryByTourId_WhenNoRecords_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 20, DateTime.UtcNow.AddDays(-1));
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 30, DateTime.UtcNow.AddMinutes(-10));
        InsertTourHistoryToDatabaseAndReturn(tour.Id, 40, DateTime.UtcNow.AddDays(1));
        var list = _tourStorageContract.GetHistoryByTourId(Guid.NewGuid().ToString());
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
    }

    [Test]
    public void Try_GetElementById_WhenHaveRecord_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString());
        AssertElement(_tourStorageContract.GetElementById(tour.Id), tour);
    }

    [Test]
    public void Try_GetElementById_WhenNoRecord_Test()
    {
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString());
        Assert.That(() => _tourStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
    }

    [Test]
    public void Try_GetElementByName_WhenHaveRecord_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString());
        AssertElement(_tourStorageContract.GetElementByName(tour.TourName), tour);
    }

    [Test]
    public void Try_GetElementByName_WhenNoRecord_Test()
    {
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString());
        Assert.That(() => _tourStorageContract.GetElementByName("name"), Is.Null);
    }

    [Test]
    public void Try_AddElement_Test()
    {
        var tour = CreateModel(Guid.NewGuid().ToString());
        _tourStorageContract.AddElement(tour);
        AssertElement(GetTourFromDatabaseById(tour.Id), tour);
    }

    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
    {
        var tour = CreateModel(Guid.NewGuid().ToString());
        InsertTourToDatabaseAndReturn(tour.Id, tourName: "name unique");
        Assert.That(() => _tourStorageContract.AddElement(tour), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
    {
        var tour = CreateModel(Guid.NewGuid().ToString(), "name unique");
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), tourName: tour.TourName);
        Assert.That(() => _tourStorageContract.AddElement(tour), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_UpdElement_Test()
    {
        var tour = CreateModel(Guid.NewGuid().ToString(), "new name", "country");
        InsertTourToDatabaseAndReturn(tour.Id);
        _tourStorageContract.UpdElement(tour);
        AssertElement(GetTourFromDatabaseById(tour.Id), tour);
    }

    [Test]
    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
    {
        Assert.That(() => _tourStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
    }

    [Test]
    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
    {
        var tour = CreateModel(Guid.NewGuid().ToString(), "name unique");
        InsertTourToDatabaseAndReturn(tour.Id, tourName: "name");
        InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString(), tourName: tour.TourName);
        Assert.That(() => _tourStorageContract.UpdElement(tour), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_DelElement_Test()
    {
        var tour = InsertTourToDatabaseAndReturn(Guid.NewGuid().ToString());
        _tourStorageContract.DelElement(tour.Id);
        var element = GetTourFromDatabaseById(tour.Id);
        Assert.That(element, Is.Null);
    }

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

    private Tour InsertTourToDatabaseAndReturn(string id, string tourName = "test", string tourCountry = "country", TourType tourType = TourType.Beach, double price = 1)
    {
        var tour = new Tour() { Id = id, TourName = tourName, TourCountry = tourCountry, Type = tourType, Price = price };
        MagicCarpetDbContext.Tours.Add(tour);
        MagicCarpetDbContext.SaveChanges();
        return tour;
    }

    private TourHistory InsertTourHistoryToDatabaseAndReturn(string tourId, double price, DateTime changeDate)
    {
        var tourHistory = new TourHistory() { Id = Guid.NewGuid().ToString(), TourId = tourId, OldPrice = price, ChangeDate = changeDate };
        MagicCarpetDbContext.TourHistories.Add(tourHistory);
        MagicCarpetDbContext.SaveChanges();
        return tourHistory;
    }

    private static void AssertElement(TourDataModel? actual, Tour expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.TourName, Is.EqualTo(expected.TourName));
            Assert.That(actual.TourCountry, Is.EqualTo(expected.TourCountry));
            Assert.That(actual.Type, Is.EqualTo(expected.Type));
            Assert.That(actual.Price, Is.EqualTo(expected.Price));
        });
    }

    private static TourDataModel CreateModel(string id, string tourName = "test", string tourCountry = "country", TourType type = TourType.Beach, double price = 1)
        => new(id, tourName, tourCountry, price, type);

    private Tour? GetTourFromDatabaseById(string id) => MagicCarpetDbContext.Tours.FirstOrDefault(x => x.Id == id);

    private static void AssertElement(Tour? actual, TourDataModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.TourName, Is.EqualTo(expected.TourName));
            Assert.That(actual.TourCountry, Is.EqualTo(expected.TourCountry));
            Assert.That(actual.Type, Is.EqualTo(expected.Type));
            Assert.That(actual.Price, Is.EqualTo(expected.Price));
        });
    }
}