BlazorApp/BlazorApp.Tests/Controllers/CustomerControllerTests.cs

using BlazorApp.Controllers;
using BlazorApp.Interfaces.Services;
using BlazorApp.Shared.Models;
using BlazorApp.Shared.Models.Pagination;
using Microsoft.AspNetCore.Mvc;
using Moq;

namespace BlazorApp.Tests.Controllers;

public class CustomerControllerTests
{
    private readonly Mock<ICustomerService> _mockService;
    private readonly CustomerController _controller;

    public CustomerControllerTests()
    {
        _mockService = new Mock<ICustomerService>();
        _controller = new CustomerController(_mockService.Object);
    }

    [Fact]
    public async Task Query_OK()
    {
        var customers = new PaginatedResult<Customer>
        {
            TotalCount = 1,
            Results = new List<Customer>() { new Customer { Id = "blabla", CompanyName = "blabla" } }
        };
        _mockService.Setup(s => s.Query(It.IsAny<Shared.Queries.CustomerQuery>())).ReturnsAsync(customers);

        var actionResult = await _controller.Query(new Shared.Queries.CustomerQuery());

        var okResult = Assert.IsType<OkObjectResult>(actionResult.Result);

        var returnResult = Assert.IsType<PaginatedResult<Customer>>(okResult.Value);

        Assert.Single(returnResult.Results);
        Assert.Equal(1, returnResult.TotalCount);
        _mockService.Verify(s => s.Query(It.IsAny<Shared.Queries.CustomerQuery>()), Times.Once);
    }

    [Fact]
    public async Task Get_OK()
    {
        var customer = new Customer
        {
            Id = "blabla",
            CompanyName = "blabla"
        };
        _mockService.Setup(s => s.Get(It.IsAny<string>())).ReturnsAsync(customer);

        var actionResult = await _controller.Get("blabla");

        var okResult = Assert.IsType<OkObjectResult>(actionResult.Result);

        var returnResult = Assert.IsType<Customer>(okResult.Value);

        Assert.NotNull(returnResult);
        _mockService.Verify(s => s.Get("blabla"), Times.Once);
    }

    [Fact]
    public async Task Delete_ReturnsNoContent()
    {
        _mockService.Setup(s => s.Delete(It.IsAny<string>())).Returns(Task.CompletedTask);

        var actionResult = await _controller.Delete("blabla");

        Assert.IsType<NoContentResult>(actionResult);
        _mockService.Verify(s => s.Delete("blabla"), Times.Once);
    }

    [Fact]
    public async Task Save_ReturnsNoContent()
    {
        var customer = new Customer
        {
            Id = "blabla",
            CompanyName = "blabla"
        };
        _mockService.Setup(s => s.Save(It.IsAny<Customer>())).Returns(Task.CompletedTask);

        var actionResult = await _controller.Save(customer);

        Assert.IsType<NoContentResult>(actionResult);
        _mockService.Verify(s => s.Save(customer), Times.Once);
    }

    [Fact]
    public async Task Update_ReturnsNoContent()
    {
        var customer = new Customer
        {
            Id = "blabla",
            CompanyName = "blabla"
        };
        _mockService.Setup(s => s.Update(It.IsAny<Customer>())).Returns(Task.CompletedTask);

        var actionResult = await _controller.Update(customer);

        Assert.IsType<NoContentResult>(actionResult);
        _mockService.Verify(s => s.Update(customer), Times.Once);
    }
}