Check/MagicCarpetProject/MagicCarpetTests/WebApiControllersTests/SuppliesControllerTests.cs

using MagicCarpetContracts.BindingModels;
using MagicCarpetContracts.DataModels;
using MagicCarpetContracts.Enums;
using MagicCarpetContracts.ViewModels;
using MagicCarpetDatabase.Models;
using MagicCarpetTests.Infrastructure;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace MagicCarpetTests.WebApiControllersTests;

[TestFixture]
internal class SuppliesControllerTests : BaseWebApiControllerTest
{
    private string _componentId;

    [SetUp]
    public void SetUp()
    {
        _componentId = MagicCarpetDbContext.InsertTourToDatabaseAndReturn().Id;
    }

    [TearDown]
    public void TearDown()
    {
        MagicCarpetDbContext.RemoveToursFromDatabase();
        MagicCarpetDbContext.RemoveSuppliesFromDatabase();
    }

    [Test]
    public async Task GetAllWarehouses_WhenHaveRecords_ShouldSuccess_Test()
    {
        // Arrange
        var supply = MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        // Act
        var response = await HttpClient.GetAsync("/api/supplies");
        // Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SuppliesViewModel>>(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");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<AgencyViewModel>>(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()
    {
        //Arrange
        var supplies = MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/supplies/{supplies.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<SuppliesViewModel>(response), supplies);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        //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
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn(tours: [(_componentId, 5)]);
        var supplies = CreateModel(components: [(_componentId, 5)]);
        //Act
        var response = await HttpClient.PostAsync($"/api/supplies", MakeContent(supplies));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(MagicCarpetDbContext.GetSuppliesFromDatabaseById(supplies.Id!), supplies);
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/supplies", 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", 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 SuppliesViewModel { Id = "Id", TourType = TourType.None, Tours = [] };
        var suppliesWithTypeIncorrect = new SuppliesViewModel { Id = Guid.NewGuid().ToString(), TourType = TourType.None, Tours = [] };
        //Act
        var responseWithIdIncorrect = await HttpClient.PostAsync($"/api/supplies", MakeContent(suppliesIdIncorrect));
        var responseWithTypeIncorrect = await HttpClient.PostAsync($"/api/supplies", 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
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        var supplies = CreateModel(components: [(_componentId, 5)]);
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn(supplies.Id);
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies", MakeContent(supplies));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        MagicCarpetDbContext.ChangeTracker.Clear();
        AssertElement(MagicCarpetDbContext.GetSuppliesFromDatabaseById(supplies.Id!), supplies);
    }

    [Test]
    public async Task Put_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        var furniture = CreateModel();
        MagicCarpetDbContext.InsertSuppliesToDatabaseAndReturn();
        //Act
        var response = await HttpClient.PutAsync($"/api/supplies", MakeContent(furniture));
        //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", 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", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }


    private static SuppliesBindingModel CreateModel(string? id = null, TourType type = TourType.Ski, int count = 21, DateTime? date = null, List<(string, int)>? components = null)
    {
        var Supply = new SuppliesBindingModel() { Id = id ?? Guid.NewGuid().ToString(), TourType = type, Count = count, ProductuionDate = date ?? DateTime.UtcNow,Tours = [] };
        if (components is not null)
        {
            foreach (var elem in components)
            {
                Supply.Tours.Add(new TourSuppliesBindingModel { SuppliesId = Supply.Id, TourId = elem.Item1, Count = elem.Item2 });
            }
        }
        return Supply;
    }

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

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