RegressionTestHelper.cs

using System.Runtime.CompilerServices;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace LcmCrdt.Tests.Data;

public class RegressionTestHelper(string projectName) : IAsyncLifetime
{
    private IHost _host = null!;
    private AsyncServiceScope _asyncScope;
    //unique db path per instance, so CurrentProjectService doesn't think a db has already run migrations
    private readonly CrdtProject _crdtProject = new(projectName, $"{projectName}-{Guid.NewGuid():N}.sqlite");
    public IServiceProvider Services => _asyncScope.ServiceProvider;

    private async Task InitDbFromScripts(RegressionVersion version)
    {
        var initialSqlFile = GetFilePath($"Scripts/{version}.sql");
        var projectsService = _asyncScope.ServiceProvider.GetRequiredService<CurrentProjectService>();
        projectsService.SetupProjectContextForNewDb(_crdtProject);
        await using var lcmCrdtDbContext = await _asyncScope.ServiceProvider.GetRequiredService<IDbContextFactory<LcmCrdtDbContext>>().CreateDbContextAsync();
        var sql = await File.ReadAllTextAsync(initialSqlFile);
        var dbConnection = lcmCrdtDbContext.Database.GetDbConnection();
        await dbConnection.OpenAsync();
        var dbCommand = dbConnection.CreateCommand();
        // Make virtual tables immediately useable (included here so we don't have to update future sql dumps)
        // see: https://sqlite.org/forum/info/b68bc59ddd4aeca38d44823611fa931a671158403e4af522105bf2ba21a96327
        var resetSchema = "PRAGMA writable_schema=RESET;";
        dbCommand.CommandText = $"{sql}\n{resetSchema}";
        await dbCommand.ExecuteNonQueryAsync();

        //need to close the connection, otherwise the collations won't get created, they would normally be created on open or save, so we're closing so they get created when EF opens the connection.
        await dbConnection.CloseAsync();

        await lcmCrdtDbContext.Database.MigrateAsync();

        await projectsService.RefreshProjectData();
    }

    public Task InitializeAsync()
    {
        return InitializeAsync(RegressionVersion.v2);
    }

    public async Task InitializeAsync(RegressionVersion version, bool withDataMigrations = false)
    {
        var builder = Host.CreateEmptyApplicationBuilder(null);
        builder.Services.AddTestLcmCrdtClient();
        _host = builder.Build();
        var services = _host.Services;
        _asyncScope = services.CreateAsyncScope();
        await InitDbFromScripts(version);

        // Data migrations are already on their way out. It doesn't really make sense for all tests to run them,
        // which would change a bunch of verified project snapshots.
        // When data migrations are removed (#2350), we should run this code unconditionally
        // at the end of InitDbFromScripts (instead of the current db-migration and refresh-project-data approach)
        // Because that's closer to the prod code.
        if (withDataMigrations)
        {
            await Services.GetRequiredService<CurrentProjectService>().SetupProjectContext(_crdtProject);
        }
    }

    public async Task DisposeAsync()
    {
        await _asyncScope.DisposeAsync();
        if (_host is IAsyncDisposable asyncDisposable) await asyncDisposable.DisposeAsync();
        else
        {
            _host.Dispose();
        }

        if (File.Exists(_crdtProject.DbPath))
        {
            using var connection = new SqliteConnection($"Data Source={_crdtProject.DbPath}");
            SqliteConnection.ClearPool(connection);
            File.Delete(_crdtProject.DbPath);
        }
    }

    private static string GetFilePath(string name, [CallerFilePath] string sourceFile = "")
    {
        return Path.Combine(
            Path.GetDirectoryName(sourceFile) ??
            throw new InvalidOperationException("Could not get directory of source file"),
            name);
    }

    public enum RegressionVersion
    {
        v1,
        v2,
    }
}