pfm/PostFundManagement.Tests/SkorubaUserServiceIntegrationTests.cs

using PostFundManagement.Application.Extensions;
using PostFundManagement.Domain.Abstractions;
using PostFundManagement.Domain.Models.Security;
using PostFundManagement.Infrastructure.Database.Services;
using static PostFundManagement.Domain.Extensions.Constants;

namespace PostFundManagement.Tests;

public class SkorubaUserServiceGetUserRolesIntegrationTests
{
    private readonly ISkorubaUserService _skorubaService;
    private readonly IHttpClientFactory _httpClientFactory;

    public SkorubaUserServiceGetUserRolesIntegrationTests()
    {
        var services = new ServiceCollection();

        // Load configuration from environment and secrets
        var configuration = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json", optional: true)
            .AddUserSecrets(Assembly.GetExecutingAssembly(), optional: true)
            .AddEnvironmentVariables()
            .Build();

        services.AddSingleton(configuration);
        services.AddHttpClient();

        // Register the Skoruba HTTP client with the actual DI configuration
        services.AddSkorubaApiService(configuration)
            .AddRegisterServicesWithCaching(configuration)
            .AddEndpointAndServiceCaching(configuration)
            .AddSharedServices()
            .AddHashServices(configuration)
            .AddApplicationDbContext(configuration)
            .AddHttpContextAccessor()
            .AddTransient<ITenantContextService, TenantContextService>();

        var serviceProvider = services.BuildServiceProvider();
        _skorubaService = serviceProvider.GetRequiredService<ISkorubaUserService>();
        _httpClientFactory = serviceProvider.GetRequiredService<IHttpClientFactory>();
    }

    [DebugOnlyFact]
    public void HttpClientFactory_HasSkorubaHttpClientConfigured()
    {
        // Act
        var httpClient = _httpClientFactory.CreateClient(SkorubaHttpClient);

        // Assert
        Assert.NotNull(httpClient);
        Assert.NotNull(httpClient.BaseAddress);
    }

    [DebugOnlyFact]
    public async Task CreateUserAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var newUser = new CreateUserRequest
        {
            UserName = "testuser",
            Email = "testuser@example.com",
            EmailConfirmed = true,            
        };

        // Act
        var result = await _skorubaService.CreateUserAsync(newUser);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task DeleteUserAsync_MustSucced_WithErrorMessage()
    {
        // Arrange        
        var userId = Guid.Parse("3b001832-c78d-4705-9bc2-0f2f2ebb35b7");

        // Act
        var result = await _skorubaService.RemoveUserAsync(userId);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task LockoutUserAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");

        // Act
        var result = await _skorubaService.SetUserLockoutAsync(userId, true);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task UnlockUserAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");

        // Act
        var result = await _skorubaService.SetUserLockoutAsync(userId, false);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task GetUserRolesAsync_SendsProperlyFormattedRequest()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var page = 1;
        var pageSize = 25;

        // Act
        var result = await _skorubaService.GetUserRolesAsync(userId, page, pageSize);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task AddUserRoleAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var roleId = Guid.Parse("34b03edc-cda4-4380-b7a5-3310933b75ab"); // Contributor role ID

        // Act
        var result = await _skorubaService.AddRoleAsync(userId, roleId);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task RemoveUserRoleAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var roleId = Guid.Parse("34b03edc-cda4-4380-b7a5-3310933b75ab"); // Contributor role ID

        // Act
        var result = await _skorubaService.RemoveRoleAsync(userId, roleId);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task GetUserClaimAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var page = 1;
        var pageSize = 25;

        // Act
        var result = await _skorubaService.GetUserClaimsAsync(userId, page, pageSize);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task AddUserClaimAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var claimType = "test-claim";
        var claimValue = "test-value";

        // Act
        var result = await _skorubaService.AddClaimAsync(userId, claimType, claimValue);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task RemoveUserClaimAsync_MustSucced_WithErrorMessage()
    {
        // Arrange
        var userId = Guid.Parse("285df6e4-c0f9-4c7c-8da7-b3867ffe1880");
        var claimType = "test-claim";

        var userClaimsResult = await _skorubaService.GetUserClaimsAsync(userId);
        var matchingClaim = userClaimsResult.Value?.FirstOrDefault(c => c.ClaimType == claimType);

        Assert.NotNull(matchingClaim);

        // Act
        var result = await _skorubaService.RemoveClaimAsync(userId, matchingClaim!.ClaimId!.Value);

        // Assert     
        Assert.True(result.IsSuccess, result.Errors.FirstOrDefault()?.Message);
        Assert.Empty(result.Errors);
    }

    [DebugOnlyFact]
    public async Task GetUserRolesAsync_RespectsCancellationToken()
    {
        // Arrange
        var userId = Guid.NewGuid();
        var cts = new CancellationTokenSource();
        cts.Cancel();

        // Act & Assert
        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
        {
            await _skorubaService.GetUserRolesAsync(userId, cancellationToken: cts.Token);
        });
    }
}