Check/MagicCarpetProject/MagicCarpetTests/StoragesContracts/SaleStorageContractTests.cs

using MagicCarpetContracts.DataModels;
using MagicCarpetContracts.Enums;
using MagicCarpetContracts.Exceptions;
using MagicCarpetDatabase.Implementations;
using MagicCarpetDatabase.Models;
using Microsoft.EntityFrameworkCore;
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 SaleStorageContractTests : BaseStorageContractTest
{
    private SaleStorageContract _saleStorageContract;
    private Client _client;
    private Employee _employee;
    private Tour _tour;

    [SetUp]
    public void SetUp()
    {
        _saleStorageContract = new SaleStorageContract(MagicCarpetDbContext);;
        _client = InsertClientToDatabaseAndReturn();
        _employee = InsertEmployeeToDatabaseAndReturn();
        _tour = InsertTourToDatabaseAndReturn();
    }

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

    [Test]
    public void Try_GetList_WhenHaveRecords_Test()
    {
        var sale = InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 5)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, tours: [(_tour.Id, 10)]);
        var list = _saleStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
        AssertElement(list.First(x => x.Id == sale.Id), sale);
    }

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

    [Test]
    public void Try_GetList_ByPeriod_Test()
    {
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(3), tours: [(_tour.Id, 1)]);
        var list = _saleStorageContract.GetList(startDate: DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1));
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(2));
    }

    [Test]
    public void Try_GetList_ByEmployeeId_Test()
    {
        var employee = InsertEmployeeToDatabaseAndReturn("Other employee");
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(employee.Id, null, tours: [(_tour.Id, 1)]);
        var list = _saleStorageContract.GetList(employeeId: _employee.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(2));
        Assert.That(list.All(x => x.EmployeeId == _employee.Id));
    }

    [Test]
    public void Try_GetList_ByClientId_Test()
    {
        var client = InsertClientToDatabaseAndReturn("Other fio", "+8-888-888-88-88");
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, client.Id, tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, tours: [(_tour.Id, 1)]);
        var list = _saleStorageContract.GetList(clientId: _client.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(2));
        Assert.That(list.All(x => x.ClientId == _client.Id));
    }

    [Test]
    public void Try_GetList_ByTourId_Test()
    {
        var tour = InsertTourToDatabaseAndReturn("Other name");
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 5)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1), (tour.Id, 4)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, tours: [(tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, null, tours: [(tour.Id, 1), (_tour.Id, 1)]);
        var list = _saleStorageContract.GetList(tourId: _tour.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
        Assert.That(list.All(x => x.Tours.Any(y => y.TourId == _tour.Id)));
    }

    [Test]
    public void Try_GetList_ByAllParameters_Test()
    {
        var employee = InsertEmployeeToDatabaseAndReturn("Other employee");
        var client = InsertClientToDatabaseAndReturn("Other fio", "+8-888-888-88-88");
        var tour = InsertTourToDatabaseAndReturn("Other name");
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(employee.Id, null, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), tours: [(tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, client.Id, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), tours: [(_tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), tours: [(tour.Id, 1)]);
        InsertSaleToDatabaseAndReturn(employee.Id, null, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), tours: [(_tour.Id, 1)]);
        var list = _saleStorageContract.GetList(startDate: DateTime.UtcNow.AddDays(-1), endDate: DateTime.UtcNow.AddDays(1), employeeId: _employee.Id, clientId: _client.Id, tourId: tour.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(1));
    }

    [Test]
    public void Try_GetElementById_WhenHaveRecord_Test()
    {
        var sale = InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        AssertElement(_saleStorageContract.GetElementById(sale.Id), sale);
    }

    [Test]
    public void Try_GetElementById_WhenNoRecord_Test()
    {
        InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)]);
        Assert.That(() => _saleStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
    }

    [Test]
    public void Try_GetElementById_WhenRecordHasCanceled_Test()
    {
        var sale = InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)], isCancel: true);
        AssertElement(_saleStorageContract.GetElementById(sale.Id), sale);
    }

    [Test]
    public void Try_AddElement_Test()
    {
        var sale = CreateModel(Guid.NewGuid().ToString(), _employee.Id, _client.Id, 1, DiscountType.RegularCustomer, 1, false, [_tour.Id]);
        _saleStorageContract.AddElement(sale);
        AssertElement(GetSaleFromDatabaseById(sale.Id), sale);
    }

    [Test]
    public void Try_AddElement_WhenIsDeletedIsTrue_Test()
    {
        var sale = CreateModel(Guid.NewGuid().ToString(), _employee.Id, _client.Id, 1, DiscountType.RegularCustomer, 1, true, [_tour.Id]);
        Assert.That(() => _saleStorageContract.AddElement(sale), Throws.Nothing);
        AssertElement(GetSaleFromDatabaseById(sale.Id), CreateModel(sale.Id, _employee.Id, _client.Id, 1, DiscountType.RegularCustomer, 1, false, [_tour.Id]));
    }

    [Test]
    public void Try_DelElement_Test()
    {
        var sale = InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)], isCancel: false);
        _saleStorageContract.DelElement(sale.Id);
        var element = GetSaleFromDatabaseById(sale.Id);
        Assert.Multiple(() =>
        {
            Assert.That(element, Is.Not.Null);
            Assert.That(element!.IsCancel);
        });
    }

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

    [Test]
    public void Try_DelElement_WhenRecordWasCanceled_Test()
    {
        var sale = InsertSaleToDatabaseAndReturn(_employee.Id, _client.Id, tours: [(_tour.Id, 1)], isCancel: true);
        Assert.That(() => _saleStorageContract.DelElement(sale.Id), Throws.TypeOf<ElementDeletedException>());
    }

    private Client InsertClientToDatabaseAndReturn(string fio = "test", string phoneNumber = "+7-777-777-77-77")
    {
        var client = new Client() { Id = Guid.NewGuid().ToString(), FIO = fio, PhoneNumber = phoneNumber, DiscountSize = 10 };
        MagicCarpetDbContext.Clients.Add(client);
        MagicCarpetDbContext.SaveChanges();
        return client;
    }

    private Employee InsertEmployeeToDatabaseAndReturn(string fio = "test")
    {
        var employee = new Employee() { Id = Guid.NewGuid().ToString(), FIO = fio, PostId = Guid.NewGuid().ToString() };
        MagicCarpetDbContext.Employees.Add(employee);
        MagicCarpetDbContext.SaveChanges();
        return employee;
    }

    private Tour InsertTourToDatabaseAndReturn(string tourName = "test", TourType tourType = TourType.Beach, double price = 1, bool isDeleted = false)
    {
        var tour = new Tour() { Id = Guid.NewGuid().ToString(), TourName = tourName, Type = tourType, Price = price };
        MagicCarpetDbContext.Tours.Add(tour);
        MagicCarpetDbContext.SaveChanges();
        return tour;
    }

    private Sale InsertSaleToDatabaseAndReturn(string employeeId, string? clientId, DateTime? saleDate = null, double sum = 1, DiscountType discountType = DiscountType.OnSale, double discount = 0, bool isCancel = false, List<(string, int)>? tours = null)
    {
        var sale = new Sale() { EmployeeId = employeeId, ClientId = clientId, SaleDate = saleDate ?? DateTime.UtcNow, Sum = sum, DiscountType = discountType, Discount = discount, IsCancel = isCancel, SaleTours = [] };
        if (tours is not null)
        {
            foreach (var elem in tours)
            {
                sale.SaleTours.Add(new SaleTour { TourId = elem.Item1, SaleId = sale.Id, Count = elem.Item2 });
            }
        }
        MagicCarpetDbContext.Sales.Add(sale);
        MagicCarpetDbContext.SaveChanges();
        return sale;
    }

    private static void AssertElement(SaleDataModel? actual, Sale expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.EmployeeId, Is.EqualTo(expected.EmployeeId));
            Assert.That(actual.ClientId, Is.EqualTo(expected.ClientId));
            Assert.That(actual.DiscountType, Is.EqualTo(expected.DiscountType));
            Assert.That(actual.Discount, Is.EqualTo(expected.Discount));
            Assert.That(actual.IsCancel, Is.EqualTo(expected.IsCancel));
        });

        if (expected.SaleTours is not null)
        {
            Assert.That(actual.Tours, Is.Not.Null);
            Assert.That(actual.Tours, Has.Count.EqualTo(expected.SaleTours.Count));
            for (int i = 0; i < actual.Tours.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.Tours[i].TourId, Is.EqualTo(expected.SaleTours[i].TourId));
                    Assert.That(actual.Tours[i].Count, Is.EqualTo(expected.SaleTours[i].Count));
                });
            }
        }
        else
        {
            Assert.That(actual.Tours, Is.Null);
        }
    }

    private static SaleDataModel CreateModel(string id, string employeeId, string? clientId, double sum, DiscountType discountType, double discount, bool isCancel, List<string> tourIds)
    {
        var tours = tourIds.Select(x => new SaleTourDataModel(id, x, 1)).ToList();
        return new(id, employeeId, clientId, sum, discountType, discount, isCancel, tours);
    }

    private Sale? GetSaleFromDatabaseById(string id) => MagicCarpetDbContext.Sales.Include(x => x.SaleTours).FirstOrDefault(x => x.Id == id);

    private static void AssertElement(Sale? actual, SaleDataModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.EmployeeId, Is.EqualTo(expected.EmployeeId));
            Assert.That(actual.ClientId, Is.EqualTo(expected.ClientId));
            Assert.That(actual.DiscountType, Is.EqualTo(expected.DiscountType));
            Assert.That(actual.Discount, Is.EqualTo(expected.Discount));
            Assert.That(actual.IsCancel, Is.EqualTo(expected.IsCancel));
        });

        if (expected.Tours is not null)
        {
            Assert.That(actual.SaleTours, Is.Not.Null);
            Assert.That(actual.SaleTours, Has.Count.EqualTo(expected.Tours.Count));
            for (int i = 0; i < actual.SaleTours.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.SaleTours[i].TourId, Is.EqualTo(expected.Tours[i].TourId));
                    Assert.That(actual.SaleTours[i].Count, Is.EqualTo(expected.Tours[i].Count));
                });
            }
        }
        else
        {
            Assert.That(actual.SaleTours, Is.Null);
        }
    }
}