shoc-backend/Api.SeaHavenIndustries.Tests/UserControllerTests.cs

using Api.SeaHavenIndustries.Controllers;
using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;
using System.Security.Claims;
using System.Text.Json;
using Xunit;

namespace Api.SeaHavenIndustries.Tests;

public class UserControllerTests
{
    private static string Json(object? value) =>
        JsonSerializer.Serialize(value, value?.GetType() ?? typeof(object));

    private static UserController NewController(Mock<IUserService> service, string? userId = null)
    {
        var controller = new UserController(service.Object, Mock.Of<ILogger<UserController>>());
        if (userId != null)
        {
            controller.ControllerContext = new ControllerContext
            {
                HttpContext = new DefaultHttpContext
                {
                    User = new ClaimsPrincipal(new ClaimsIdentity(new[]
                    {
                        new Claim(ClaimTypes.NameIdentifier, userId)
                    }, "Test"))
                }
            };
        }
        return controller;
    }

    [Fact]
    public async Task GetUsers_ReturnsServiceList()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.GetUsersAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<UserListRowDTO>
            {
                new() { Id = "1", Name = "A", Email = "a@x.com", RoleName = "Admin", Status = "Active", Date = "Jan 01 2026" }
            });

        var controller = NewController(service);

        var result = await controller.GetUsers(CancellationToken.None);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        ok.Value.Should().BeAssignableTo<IEnumerable<UserListRowDTO>>();
    }

    [Fact]
    public async Task AddUser_Success_ReturnsUpdatedSuccessfully()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.AddUserAsync(It.IsAny<AddUserRequestDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new AddUserOutcomeDTO { Success = true });

        var controller = NewController(service);

        var result = await controller.AddUser(new User_DTO { Name = "N", Email = "n@x.com", Role = "Admin" }, CancellationToken.None);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        var response = ok.Value.Should().BeOfType<DataResponse>().Subject;
        response.Status.Should().Be("200");
        response.Message.Should().Be("Updated Successfully");
    }

    [Fact]
    public async Task AddUser_Failure_ReturnsBadRequestWithServiceError()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.AddUserAsync(It.IsAny<AddUserRequestDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new AddUserOutcomeDTO { Success = false, Error = "boom" });

        var controller = NewController(service);

        var result = await controller.AddUser(new User_DTO(), CancellationToken.None);

        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
        var response = bad.Value.Should().BeOfType<Response>().Subject;
        response.Status.Should().Be("Error");
        response.Message.Should().Be("boom");
    }

    [Fact]
    public async Task EditUser_NotFound_ReturnsUserNotFoundMessage()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.EditUserAsync(It.IsAny<EditUserRequestDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(false);

        var controller = NewController(service);

        var result = await controller.EditUser(new EditUser_DTO { Id = "9" }, CancellationToken.None);

        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
        var response = bad.Value.Should().BeOfType<Response>().Subject;
        response.Message.Should().Be("User not found");
    }

    [Fact]
    public async Task EditUser_Found_ReturnsUpdatedSuccessfully()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.EditUserAsync(It.IsAny<EditUserRequestDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(true);

        var controller = NewController(service);

        var result = await controller.EditUser(new EditUser_DTO { Id = "9" }, CancellationToken.None);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        ok.Value.Should().BeOfType<DataResponse>();
    }

    [Fact]
    public async Task DeleteUser_NotFound_ReturnsIdNotMatchedMessage()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.DeleteUserAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(false);

        var controller = NewController(service);

        var result = await controller.DeleteUser(new EditUser_DTO { Id = "missing" }, CancellationToken.None);

        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
        var response = bad.Value.Should().BeOfType<Response>().Subject;
        response.Message.Should().Be("ID not matched!");
    }

    [Fact]
    public async Task DeleteUser_Found_DelegatesAndReturnsOk()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.DeleteUserAsync("5", It.IsAny<CancellationToken>())).ReturnsAsync(true);

        var controller = NewController(service);

        var result = await controller.DeleteUser(new EditUser_DTO { Id = "5" }, CancellationToken.None);

        result.Should().BeOfType<OkObjectResult>();
        service.Verify(s => s.DeleteUserAsync("5", It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task DeleteCurrentUser_UsesClaimUserId()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.DeleteCurrentUserAsync("77", It.IsAny<CancellationToken>())).Returns(Task.CompletedTask);

        var controller = NewController(service, "77");

        var result = await controller.DeleteCurrentUser(CancellationToken.None);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        ok.Value.Should().BeOfType<DataResponse>();
        service.Verify(s => s.DeleteCurrentUserAsync("77", It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task UserProfile_PreservesLowercaseAddedDateKey()
    {
        var service = new Mock<IUserService>();
        service.Setup(s => s.GetUserProfileAsync("77", It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<UserProfileRowDTO>
            {
                new() { Id = "77", Name = "Me", AddedDate = new DateTime(2026, 1, 1), Email = "me@x.com", Contact = "321" }
            });

        var controller = NewController(service, "77");

        var result = await controller.UserProfile(CancellationToken.None);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        var json = Json(ok.Value);
        json.Should().Contain("\"Id\":\"77\"");
        json.Should().Contain("\"Name\":\"Me\"");
        json.Should().Contain("\"addeddate\":\"");
        json.Should().Contain("\"Email\":\"me@x.com\"");
        json.Should().Contain("\"Contact\":\"321\"");
    }
}