PIbd-22_Pyzhov_E.A_TheSquirrel/SquirrelContract/SquirrelTests/WebApiControllersTests/SupplyControllerTests.cs

using SquirrelContract.BindingModels;
using SquirrelContract.Enums;
using SquirrelContract.ViewModels;
using SquirrelDatabase.Models;
using SquirrelTests.Infrastructure;
using System.Net;

namespace SquirrelTests.WebApiControllersTests;

[TestFixture]
internal class SupplyControllerTests : BaseWebApiControllerTest
{
    private string _cocktailId;

    [SetUp]
    public void SetUp()
    {
        _cocktailId = SquirrelDbContext.InsertCocktailToDatabaseAndReturn().Id;
    }

    [TearDown]
    public void TearDown()
    {
        SquirrelDbContext.RemoveCocktailsFromDatabase();
        SquirrelDbContext.RemoveSuppliesFromDatabase();
        SquirrelDbContext.RemoveWarehousesFromDatabase();
    }

    [Test]
    public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
    {
        // Arrange
        var supply = SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktails: [(_cocktailId, 10)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktails: [(_cocktailId, 10)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktails: [(_cocktailId, 10)]);
        // Act
        var response = await HttpClient.GetAsync($"/api/supplies/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        // Assert
        var data = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(3));
        });
        AssertElement(data.First(x => x.Id == supply.Id), supply);
    }

    [Test]
    public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(0));
        });
    }

    [Test]
    public async Task GetList_ByPeriod_ShouldSuccess_Test()
    {
        //Arrange
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), supplyDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), cocktails: [(_cocktailId, 1)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), supplyDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), cocktails: [(_cocktailId, 1)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), supplyDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), cocktails: [(_cocktailId, 1)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), supplyDate: DateTime.UtcNow.AddDays(1).AddMinutes(3), cocktails: [(_cocktailId, 1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(2));
        });
    }

    [Test]
    public async Task GetList_ByCocktailId_ShouldSuccess_Test()
    {
        //Arrange
        var cocktail = SquirrelDbContext.InsertCocktailToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktailName: "name1");
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(cocktails: [(_cocktailId, 5)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(cocktails: [(_cocktailId, 1), (cocktail.Id, 4)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(cocktails: [(cocktail.Id, 1)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(cocktails: [(cocktail.Id, 1), (_cocktailId, 1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/getcocktailrecords?id={_cocktailId}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(3));
            Assert.That(data.All(x => x.Cocktails.Any(y => y.CocktailId == _cocktailId)));
        });
    }

    [Test]
    public async Task GetList_ByCocktailId_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        var cocktail = SquirrelDbContext.InsertCocktailToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktailName: "Other cocktail");
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(cocktails: [(_cocktailId, 1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/getcocktailrecords?id={cocktail.Id}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
    }


    [Test]
    public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var supplies = SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString());
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/getcomponentbydata/{supplies.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<SupplyViewModel>(response), supplies);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString());
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Post_ShouldSuccess_Test()
    {
        //Arrange
        SquirrelDbContext.InsertWarehouseToDatabaseAndReturn();
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString(), cocktails: [(_cocktailId, 5)]);
        var supplies = CreateModel(cocktails: [(_cocktailId, 5)]);
        //Act
        var response = await HttpClient.PostAsync($"/api/supplies/register", MakeContent(supplies));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(SquirrelDbContext.GetSuppliesFromDatabaseById(supplies.Id!), supplies);
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/supplies/register", MakeContent(string.Empty));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/supplies/register", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var suppliesIdIncorrect = new SupplyViewModel { Id = "Id", Cocktails = [] };
        var suppliesWithTypeIncorrect = new SupplyViewModel { Id = Guid.NewGuid().ToString(), Cocktails = [] };
        //Act
        var responseWithIdIncorrect = await HttpClient.PostAsync($"/api/supplies/register", MakeContent(suppliesIdIncorrect));
        var responseWithTypeIncorrect = await HttpClient.PostAsync($"/api/supplies/register", MakeContent(suppliesWithTypeIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
            Assert.That(responseWithTypeIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Type is incorrect");
        });
    }

    [Test]
    public async Task Put_ShouldSuccess_Test()
    {
        //Arrange
        SquirrelDbContext.InsertWarehouseToDatabaseAndReturn();
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn();
        var supplies = CreateModel(cocktails: [(_cocktailId, 5)]);
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(supplies.Id);
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies/changeinfo", MakeContent(supplies));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        SquirrelDbContext.ChangeTracker.Clear();
        AssertElement(SquirrelDbContext.GetSuppliesFromDatabaseById(supplies.Id!), supplies);
    }

    [Test]
    public async Task Put_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        var sale = CreateModel();
        SquirrelDbContext.InsertSupplyToDatabaseAndReturn(Guid.NewGuid().ToString());
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies/changeinfo", MakeContent(sale));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies/changeinfo", MakeContent(string.Empty));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies/changeinfo", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }


    private static SupplyBindingModel CreateModel(string? id = null, DateTime? date = null, List<(string, int)>? cocktails = null)
    {
        var Supply = new SupplyBindingModel() { Id = id ?? Guid.NewGuid().ToString(), SupplyDate = date ?? DateTime.UtcNow, Cocktails = [] };
        if (cocktails is not null)
        {
            foreach (var elem in cocktails)
            {
                Supply.Cocktails.Add(new SupplyCocktailBindingModel { SupplyId = Supply.Id, CocktailId = elem.Item1, Count = elem.Item2 });
            }
        }
        return Supply;
    }

    private static void AssertElement(SupplyViewModel? actual, Supply expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.SupplyDate.Date, Is.EqualTo(expected.SupplyDate.Date));
        });
        if (expected.Cocktails is not null)
        {
            Assert.That(actual.Cocktails, Is.Not.Null);
            Assert.That(actual.Cocktails, Has.Count.EqualTo(expected.Cocktails.Count));
            for (int i = 0; i < actual.Cocktails.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.Cocktails[i].SupplyId, Is.EqualTo(expected.Cocktails[i].SupplyId));
                    Assert.That(actual.Cocktails[i].Count, Is.EqualTo(expected.Cocktails[i].Count));
                });
            }
        }
        else
        {
            Assert.That(actual.Cocktails, Is.Null);
        }
    }

    private static void AssertElement(Supply? actual, SupplyBindingModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.SupplyDate.Date, Is.EqualTo(expected.SupplyDate.Date));
        });
        if (expected.Cocktails is not null)
        {
            Assert.That(actual.Cocktails, Is.Not.Null);
            Assert.That(actual.Cocktails, Has.Count.EqualTo(expected.Cocktails.Count));
            for (int i = 0; i < actual.Cocktails.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.Cocktails[i].SupplyId, Is.EqualTo(expected.Cocktails[i].SupplyId));
                    Assert.That(actual.Cocktails[i].Count, Is.EqualTo(expected.Cocktails[i].Count));
                });
            }
        }
        else
        {
            Assert.That(actual.Cocktails, Is.Null);
        }
    }
}