continuousimprovement/tests/Strata.ContinuousImprovement.Api.Test.Unit/Controllers/ClientWarehousesControllerTests.cs

using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Api.Controllers;
using Strata.ContinuousImprovement.Biz.ClientWarehouses;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Strata.ContinuousImprovement.Api.Test.Unit.Controllers
{
    [TestFixture, Category("Unit"), Category("Controller")]
    public class ClientWarehousesControllerTests
    {
        private readonly ClientWarehousesController _clientWarehouseController;
        private readonly Mock<IClientWarehouseService> _mockClientWarehouseService;

        public ClientWarehousesControllerTests()
        {
            _mockClientWarehouseService = new Mock<IClientWarehouseService>();
            _clientWarehouseController = new ClientWarehousesController(_mockClientWarehouseService.Object);
        }

        [Test]
        public async Task GetAll_ReturnsAllClientWarehouses()
        {
            // Arrange
            var warehouses = new List<ClientWarehouse>
            {
                new ClientWarehouse { DatabaseGuid = Guid.NewGuid() },
                new ClientWarehouse { DatabaseGuid = Guid.NewGuid() }
            };

            _mockClientWarehouseService
                .Setup(x => x.GetAll(It.IsAny<CancellationToken>()))
                .ReturnsAsync(warehouses);

            // Act
            var result = await _clientWarehouseController.GetClientWarehouses(CancellationToken.None);

            // Assert
            var okResult = result.Result.Should().BeOfType<OkObjectResult>().Subject;
            okResult.Value.Should().BeEquivalentTo(warehouses);
        }

        [Test]
        public async Task GetAll_ReturnsNoContent_IfNoneExists()
        {
            // Arrange
            var warehouses = new List<ClientWarehouse>();

            _mockClientWarehouseService
                .Setup(x => x.GetAll(It.IsAny<CancellationToken>()))
                .ReturnsAsync(warehouses);

            // Act
            var result = await _clientWarehouseController.GetClientWarehouses(CancellationToken.None);

            // Assert
            var okResult = result.Result.Should().BeOfType<NoContentResult>();
        }

        [Test]
        public async Task Add_ShouldReturnNewId()
        {
            // Arrange
            var clientWarehouse = new ClientWarehouse();
            _mockClientWarehouseService
                .Setup(s => s.Add(clientWarehouse, It.IsAny<CancellationToken>()))
                .ReturnsAsync(123);

            // Act
            var result = await _clientWarehouseController.AddClientWarehouse(clientWarehouse, CancellationToken.None);

            // Assert
            var okResult = result.Result.Should().BeOfType<CreatedAtActionResult>().Subject;
            okResult.Value.Should().Be(123);
        }

        [Test]
        public async Task Delete_ShouldReturn_NoContent()
        {
            // Arrange
            var clientId = Guid.NewGuid();

            _mockClientWarehouseService
                .Setup(s => s.Delete(clientId, It.IsAny<CancellationToken>()))
                .ReturnsAsync(true);

            // Act
            var result = await _clientWarehouseController.DeleteClientWarehouse(clientId, CancellationToken.None);
            // Assert
            result.Should().BeOfType<NoContentResult>();
        }
    }
}