PIBD24_BoikoM.S._Candyhouse/CandyHouseSolution/CandyHouseTests/WebApiControllersTests/IngredientControllerTests.cs

using CandyHouseBase.Contracts;
using CandyHouseTests.Infrastructure;
using System.Net;
using CandyHouseBase.Contracts.BindingModels;
using CandyHouseBase.Contracts.ViewModels;
using CandyHouseDataBase.Models;
using NUnit.Framework;

namespace CandyHouseTests.WebApiControllersTests;

[TestFixture]
internal class IngredientControllerTests : BaseWebApiControllerTest
{
    [TearDown]
    public void TearDown()
    {
        CandyHouseDbContext.RemoveIngredientsFromDatabase();
    }

    [Test]
    public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
    {
        //Arrange
        var ingredient = CandyHouseDbContext.InsertIngredientToDatabaseAndReturn(name: "Sugar");
        CandyHouseDbContext.InsertIngredientToDatabaseAndReturn(name: "Salt");
        
        //Act
        var response = await HttpClient.GetAsync("/api/ingredients");
        
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<IngredientViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(2));
        });
        AssertElement(data.First(x => x.Id == ingredient.Id), ingredient);
    }

    [Test]
    public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
    {
        var response = await HttpClient.GetAsync("/api/ingredients");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<IngredientViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(0));
        });
    }

    [Test]
    public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
    {
        var ingredient = CandyHouseDbContext.InsertIngredientToDatabaseAndReturn();
        var response = await HttpClient.GetAsync($"/api/ingredients/{ingredient.Id}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<IngredientViewModel>(response), ingredient);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        CandyHouseDbContext.InsertIngredientToDatabaseAndReturn();
        var response = await HttpClient.GetAsync($"/api/ingredients/{Guid.NewGuid()}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Post_ShouldSuccess_Test()
    {
        var model = new IngredientBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            Name = "Cocoa",
            Unit = "g",
            Cost = 100
        };
        var response = await HttpClient.PostAsync("/api/ingredients", MakeContent(model));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        
        var savedIngredient = CandyHouseDbContext.Ingredients.First(x => x.Id == model.Id);
        AssertElement(savedIngredient, model);
    }

    [Test]
    public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        var modelWithEmptyName = new IngredientBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            Name = "",
            Unit = "g",
            Cost = 1
        };

        var modelWithNegativeCost = new IngredientBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            Name = "Invalid",
            Unit = "g",
            Cost = -10
        };

        var response1 = await HttpClient.PostAsync("/api/ingredients", MakeContent(modelWithEmptyName));
        var response2 = await HttpClient.PostAsync("/api/ingredients", MakeContent(modelWithNegativeCost));

        Assert.Multiple(() =>
        {
            Assert.That(response1.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
            Assert.That(response2.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
        });
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        var response = await HttpClient.PostAsync("/api/ingredients", MakeContent(string.Empty));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }
    
    [Test]
    public async Task Put_ShouldUpdateIngredient_Test()
    {
        // Arrange
        var ingredient = CandyHouseDbContext.InsertIngredientToDatabaseAndReturn();
        var model = new IngredientBindingModel
        {
            Id = ingredient.Id,
            Name = "Updated Ingredient",
            Unit = "kg",
            Cost = 55.5m
        };
        
        // Act
        var response = await HttpClient.PutAsync("/api/ingredients", MakeContent(model));
        
        // Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        
        CandyHouseDbContext.ChangeTracker.Clear();
        var updatedIngredient = CandyHouseDbContext.Ingredients.First(x => x.Id == ingredient.Id);
        Assert.Multiple(() =>
        {
            Assert.That(updatedIngredient.Name, Is.EqualTo(model.Name));
            Assert.That(updatedIngredient.Unit, Is.EqualTo(model.Unit));
            Assert.That(updatedIngredient.Cost, Is.EqualTo(model.Cost));
        });
    }
    
    [Test]
    public async Task Put_WhenNoRecord_ShouldBadRequest_Test()
    {
        var model = new IngredientBindingModel
        {
            Id = Guid.NewGuid().ToString(),
            Name = "Nonexistent",
            Unit = "kg",
            Cost = 100m
        };
        
        var response = await HttpClient.PutAsync("/api/ingredients", MakeContent(model));
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }
    
    [Test]
    public async Task Delete_ShouldRemoveIngredient_Test()
    {
        // Arrange
        var ingredient = CandyHouseDbContext.InsertIngredientToDatabaseAndReturn();
        
        // Act
        var response = await HttpClient.DeleteAsync($"/api/ingredients/{ingredient.Id}");
        
        // Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        
        CandyHouseDbContext.ChangeTracker.Clear();
        var deletedIngredient = CandyHouseDbContext.Ingredients.FirstOrDefault(x => x.Id == ingredient.Id);
        Assert.That(deletedIngredient, Is.Null);
    }
    
    [Test]
    public async Task Delete_WhenNoRecord_ShouldBadRequest_Test()
    {
        var response = await HttpClient.DeleteAsync($"/api/ingredients/{Guid.NewGuid()}");
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }
    
    private void AssertElement(IngredientViewModel viewModel, Ingredient model)
    {
        Assert.Multiple(() =>
        {
            Assert.That(viewModel.Id, Is.EqualTo(model.Id));
            Assert.That(viewModel.Name, Is.EqualTo(model.Name));
            Assert.That(viewModel.Unit, Is.EqualTo(model.Unit));
            Assert.That((decimal)viewModel.Cost, Is.EqualTo(model.Cost));
        });
    }
    
    private void AssertElement(Ingredient model, IngredientBindingModel bindingModel)
    {
        Assert.Multiple(() =>
        {
            Assert.That(model.Id, Is.EqualTo(bindingModel.Id));
            Assert.That(model.Name, Is.EqualTo(bindingModel.Name));
            Assert.That(model.Unit, Is.EqualTo(bindingModel.Unit));
            Assert.That(model.Cost, Is.EqualTo((decimal)bindingModel.Cost));
        });
    }
}