persistence/Persistence.IntegrationTests/WebAppFactoryFixture.cs

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Persistence.API;
using Persistence.Database;
using Persistence.Database.Model;
using Persistence.Database.Postgres;
using Refit;
using RestSharp;
using System.Net.Http.Headers;
using System.Text.Json;

namespace Persistence.IntegrationTests;
public class WebAppFactoryFixture : WebApplicationFactory<Startup>
{
    private static readonly JsonSerializerOptions JsonSerializerOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        PropertyNameCaseInsensitive = true,
        //Converters = { new ValidationResultConverter() }
    };

    private static readonly RefitSettings RefitSettings = new(new SystemTextJsonContentSerializer(JsonSerializerOptions));

    private readonly string connectionString;
    private readonly KeyCloakUser keycloakTestUser;
    public readonly string KeycloakGetTokenUrl;

    public WebAppFactoryFixture()
    {
        var configuration = new ConfigurationBuilder()
           .AddJsonFile("appsettings.Tests.json")
           .Build();

        var dbConnection = configuration.GetSection("DbConnection").Get<DbConnection>()!;
        connectionString = dbConnection.GetConnectionString();

        keycloakTestUser = configuration.GetSection("KeycloakTestUser").Get<KeyCloakUser>()!;

        KeycloakGetTokenUrl = configuration.GetSection("KeycloakGetTokenUrl").Value!;
    }

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            var descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextOptions<PersistenceDbContext>));

            if (descriptor != null)
                services.Remove(descriptor);

            services.AddDbContext<PersistenceDbContext>(options =>
               options.UseNpgsql(connectionString));

            services.AddScoped<IPersistenceDbContext>(provider => provider.GetRequiredService<PersistenceDbContext>());

            var serviceProvider = services.BuildServiceProvider();

            using var scope = serviceProvider.CreateScope();
            var scopedServices = scope.ServiceProvider;
            var dbContext = scopedServices.GetRequiredService<PersistenceDbContext>();

            dbContext.Database.EnsureCreatedAndMigrated();
            dbContext.SaveChanges();
        });
    }

    public override async ValueTask DisposeAsync()
    {
        var dbContext = new PersistenceDbContext(
           new DbContextOptionsBuilder<PersistenceDbContext>()
              .UseNpgsql(connectionString)
              .Options);

        await dbContext.Database.EnsureDeletedAsync();
    }

    public T GetHttpClient<T>(string uriSuffix)
    {
        var httpClient = CreateClient();
        if (string.IsNullOrEmpty(uriSuffix))
            return RestService.For<T>(httpClient, RefitSettings);

        if (httpClient.BaseAddress is not null)
            httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);

        return RestService.For<T>(httpClient, RefitSettings);
    }

    public async Task<T> GetAuthorizedHttpClient<T>(string uriSuffix)
    {
        var httpClient = await GetAuthorizedHttpClient();
        if (string.IsNullOrEmpty(uriSuffix))
            return RestService.For<T>(httpClient, RefitSettings);

        if (httpClient.BaseAddress is not null)
            httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);

        return RestService.For<T>(httpClient, RefitSettings);
    }

    private async Task<HttpClient> GetAuthorizedHttpClient()
    {
        var httpClient = CreateClient();
        var token = await GetTokenAsync();
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

        return httpClient;
    }

    private async Task<string> GetTokenAsync()
    {
        var restClient = new RestClient();

        var request = new RestRequest(KeycloakGetTokenUrl, Method.Post);
        request.AddParameter("username", keycloakTestUser.Username);
        request.AddParameter("password", keycloakTestUser.Password);
        request.AddParameter("client_id", keycloakTestUser.ClientId);
        request.AddParameter("grant_type", keycloakTestUser.GrantType);

        var keyCloackResponse = await restClient.PostAsync(request);
        if (keyCloackResponse.IsSuccessful && !String.IsNullOrEmpty(keyCloackResponse.Content))
        {
            var token = JsonSerializer.Deserialize<JwtToken>(keyCloackResponse.Content)!;
            return token.AccessToken;
        }

        return String.Empty;
    }
}