refactor(tests): share engine and corpus-path constants across the report lanes

Folds duplicated engine names, corpus paths and schema-reading helpers in the
SQLite, MySQL and D1 report lanes into one definition per language. No behaviour change.

Author: dmealing

server/csharp/MetaObjects.IntegrationTests/Api/ApiContractReportConformanceTest.cs

@@ -40,18 +40,10 @@ public async Task Api_contract_report_generated(string scenarioPath)
     public async Task Api_contract_report_generated_on_sqlite(string scenarioPath)
     {
         var scenario = ApiContractScenarioLoader.LoadScenario(scenarioPath);
-        var file = Path.Combine(Path.GetTempPath(), $"mo-report-api-{Guid.NewGuid():N}.db");
-        try
-        {
-            await using var server = await ReportGeneratedServerFactory.StartSqliteAsync(file);
-            await server.ApplySeedAsync();
-            await RunAsync(scenario, server.BaseUrl);
-        }
-        finally
-        {
-            Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
-            if (File.Exists(file)) File.Delete(file);
-        }
+        using var db = new SqliteTempDatabase("mo-report-api-");
+        await using var server = await ReportGeneratedServerFactory.StartSqliteAsync(db.FilePath);
+        await server.ApplySeedAsync();
+        await RunAsync(scenario, server.BaseUrl);
     }
 
     // ...and over MySQL 8.4: the schema is report/schema.mysql.sql (the adopter's tables plus

server/csharp/MetaObjects.IntegrationTests/Api/ReportFixture.cs

@@ -16,10 +16,7 @@
 
 using System.Text.Json;        // JsonValueKind
 using System.Text.Json.Nodes;  // JsonNode / JsonObject / JsonArray
-using Microsoft.Data.Sqlite;
 using MetaObjects.IntegrationTests.Runner;
-using MySqlConnector;
-using Npgsql;
 
 namespace MetaObjects.IntegrationTests.Api;
 
@@ -28,32 +25,16 @@ internal static class ReportFixture
     /// <summary>The one top-level key of seed.json that is not a base table.</summary>
     private const string SeedReportsKey = "reports";
 
-    /// <summary>Execute the committed TypeScript-produced schema on a fresh container.</summary>
+    /// <summary>Execute the committed TypeScript-produced schema for this engine's artifact.</summary>
     public static async Task ProvisionSchemaAsync(string connString, ScenarioEngine engine = ScenarioEngine.Postgres)
     {
-        if (engine == ScenarioEngine.Sqlite)
+        var path = engine switch
         {
-            await using var lite = new SqliteConnection(connString);
-            await lite.OpenAsync();
-            await using var liteCmd = lite.CreateCommand();
-            liteCmd.CommandText = await File.ReadAllTextAsync(ApiContractCorpusPaths.ReportSchemaSqliteSql);
-            await liteCmd.ExecuteNonQueryAsync();
-            return;
-        }
-        if (engine == ScenarioEngine.MySql)
-        {
-            await using var my = new MySqlConnection(connString);
-            await my.OpenAsync();
-            await using var myCmd = my.CreateCommand();
-            myCmd.CommandText = await File.ReadAllTextAsync(ApiContractCorpusPaths.ReportSchemaMysqlSql);
-            await myCmd.ExecuteNonQueryAsync();
-            return;
-        }
-        await using var c = new NpgsqlConnection(connString);
-        await c.OpenAsync();
-        await using var cmd = c.CreateCommand();
-        cmd.CommandText = await File.ReadAllTextAsync(ApiContractCorpusPaths.ReportSchemaSql);
-        await cmd.ExecuteNonQueryAsync();
+            ScenarioEngine.Sqlite => ApiContractCorpusPaths.ReportSchemaSqliteSql,
+            ScenarioEngine.MySql => ApiContractCorpusPaths.ReportSchemaMysqlSql,
+            _ => ApiContractCorpusPaths.ReportSchemaSql,
+        };
+        await engine.ExecuteScriptAsync(connString, await File.ReadAllTextAsync(path));
     }
 
     /// <summary>
@@ -70,13 +51,7 @@ public static async Task ApplySeedAsync(string connString, string seedPath, Scen
         if (tables.Count == 0)
             throw new InvalidOperationException($"{seedPath}: no base-table rows to seed");
 
-        await using System.Data.Common.DbConnection c = engine switch
-        {
-            ScenarioEngine.Sqlite => new SqliteConnection(connString),
-            ScenarioEngine.MySql => new MySqlConnection(connString),
-            _ => new NpgsqlConnection(connString),
-        };
-        await c.OpenAsync();
+        await using var c = await engine.OpenConnectionAsync(connString);
 
         foreach (var (table, rowsNode) in tables)
         {
@@ -86,7 +61,7 @@ public static async Task ApplySeedAsync(string connString, string seedPath, Scen
             {
                 if (rowNode is not JsonObject row)
                     throw new InvalidOperationException($"{seedPath}: '{table}' has a row that is not an object");
-                var quote = engine == ScenarioEngine.MySql ? "`" : "\"";
+                var quote = engine.Quote();
                 var colList = string.Join(", ", row.Select(kv => quote + kv.Key + quote));
                 var valueList = string.Join(", ", row.Select(kv => SqlLiteral(seedPath, table, kv.Key, kv.Value)));
                 await using var ins = c.CreateCommand();

server/csharp/MetaObjects.IntegrationTests/Api/ReportGeneratedServerFactory.cs

@@ -228,12 +228,9 @@ private static void RegisterGeneratedDbContext(
                         && m.GetParameters().Length == 4)
             .MakeGenericMethod(dbContextType);
 
-        Action<DbContextOptionsBuilder> configure = engine switch
-        {
-            ScenarioEngine.Sqlite => opts => opts.UseSqlite(connString),
-            ScenarioEngine.MySql => opts => opts.UseMySql(connString, new MySqlServerVersion(new Version(8, 4, 0))),
-            _ => opts => opts.UseNpgsql(connString),
-        };
+        // Provider choice lives on the engine (ScenarioEngineExtensions.UseEngine) — the one
+        // MySqlServerVersion pin too, so the provider and the mysql:8.4 image cannot drift apart.
+        Action<DbContextOptionsBuilder> configure = opts => opts.UseEngine(engine, connString);
         addDbContext.Invoke(null, new object?[]
         {
             services, configure, ServiceLifetime.Scoped, ServiceLifetime.Scoped,

server/csharp/MetaObjects.IntegrationTests/QueryScenarioMySqlTests.cs

@@ -24,8 +24,5 @@ public async Task Report_scenario_on_mysql(string scenarioPath)
         await QueryScenarioRunner.RunMySqlAsync(scenario, mysql.ConnectionString);
     }
 
-    public static IEnumerable<object[]> Scenarios() =>
-        Directory.EnumerateFiles(CorpusPaths.QueriesDir, "report-*.yaml", SearchOption.TopDirectoryOnly)
-            .OrderBy(p => p, StringComparer.Ordinal)
-            .Select(p => new object[] { p });
+    public static IEnumerable<object[]> Scenarios() => CorpusPaths.ReportQueryScenarios();
 }

server/csharp/MetaObjects.IntegrationTests/QueryScenarioSqliteTests.cs

@@ -19,20 +19,9 @@ public sealed class QueryScenarioSqliteTests
     public async Task Report_scenario_on_sqlite(string scenarioPath)
     {
         var scenario = ScenarioLoader.LoadQuery(scenarioPath);
-        var file = Path.Combine(Path.GetTempPath(), $"mo-report-{Guid.NewGuid():N}.db");
-        try
-        {
-            await QueryScenarioRunner.RunSqliteAsync(scenario, file);
-        }
-        finally
-        {
-            Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
-            if (File.Exists(file)) File.Delete(file);
-        }
+        using var db = new SqliteTempDatabase("mo-report-");
+        await QueryScenarioRunner.RunSqliteAsync(scenario, db.FilePath);
     }
 
-    public static IEnumerable<object[]> Scenarios() =>
-        Directory.EnumerateFiles(CorpusPaths.QueriesDir, "report-*.yaml", SearchOption.TopDirectoryOnly)
-            .OrderBy(p => p, StringComparer.Ordinal)
-            .Select(p => new object[] { p });
+    public static IEnumerable<object[]> Scenarios() => CorpusPaths.ReportQueryScenarios();
 }

server/csharp/MetaObjects.IntegrationTests/Runner/CorpusPaths.cs

@@ -15,6 +15,16 @@ internal static class CorpusPaths
     public static readonly string CanonicalDir = Path.Combine(Corpus, "canonical");
     public static readonly string QueriesDir = Path.Combine(Corpus, "queries");
 
+    /// <summary>
+    /// The <c>report-*</c> query scenarios as xUnit member data — the only corpus subset whose
+    /// tables exist in the SQLite and MySQL schema artifacts. One home for the name predicate,
+    /// so a dialect-gated scenario cannot be silently skipped by one lane's enumeration.
+    /// </summary>
+    public static IEnumerable<object[]> ReportQueryScenarios() =>
+        Directory.EnumerateFiles(QueriesDir, "report-*.yaml", SearchOption.TopDirectoryOnly)
+            .OrderBy(p => p, StringComparer.Ordinal)
+            .Select(p => new object[] { p });
+
     /// <summary>
     /// The committed canonical Postgres schema artifact. TypeScript is the single
     /// producer of this DDL (base tables + projection views, literal column naming);

server/csharp/MetaObjects.IntegrationTests/Runner/QueryScenarioRunner.cs

@@ -21,8 +21,6 @@
 using MetaObjects.Loader;
 using MetaObjects.Meta;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Data.Sqlite;
-using MySqlConnector;
 using Npgsql;
 using Xunit.Sdk;
 using YamlDotNet.Core;
@@ -54,7 +52,7 @@ private static async Task RunAsync(QueryScenario scenario, ScenarioEngine engine
     {
         // Provision the schema from the committed canonical DDL — the single
         // TS-produced artifact every port executes. (No per-scenario synthesis.)
-        await ExecuteAsync(engine, connectionString, ReadCanonicalSchemaSql(engine));
+        await engine.ExecuteScriptAsync(connectionString, ReadCanonicalSchemaSql(engine));
 
         // Optional seed data (a per-engine `seed-data-engine` entry wins over `seed-data`).
         var seed = scenario.SeedFor(engine.Name());
@@ -64,17 +62,13 @@ private static async Task RunAsync(QueryScenario scenario, ScenarioEngine engine
             // identifier quote differs, so a Postgres-spelled seed is translated.
             if (engine == ScenarioEngine.MySql && !scenario.HasSeedFor(engine.Name()))
                 seed = MySqlSeed.FromPostgres(seed);
-            await ExecuteAsync(engine, connectionString, seed);
+            await engine.ExecuteScriptAsync(connectionString, seed);
         }
 
-        // Open a DbContext + run each query.
+        // Open a DbContext + run each query. (Provider choice: ScenarioEngineExtensions.UseEngine.)
         var builder = new DbContextOptionsBuilder<AppDbContext>();
-        var options = (engine switch
-        {
-            ScenarioEngine.Sqlite => builder.UseSqlite(connectionString),
-            ScenarioEngine.MySql => builder.UseMySql(connectionString, new MySqlServerVersion(new System.Version(8, 4, 0))),
-            _ => builder.UseNpgsql(connectionString),
-        }).Options;
+        builder.UseEngine(engine, connectionString);
+        var options = builder.Options;
         // Postgres runs the whole generated context; the other engines read the report views
         // through the view-only subset (see ReportViewsDbContext).
         await using AppDbContext db = engine == ScenarioEngine.Postgres
@@ -179,31 +173,6 @@ private static string ReadCanonicalSchemaSql(ScenarioEngine engine)
         return File.ReadAllText(path);
     }
 
-    private static async Task ExecuteAsync(ScenarioEngine engine, string connString, string sql)
-    {
-        if (engine == ScenarioEngine.Sqlite)
-        {
-            await using var lite = new SqliteConnection(connString);
-            await lite.OpenAsync();
-            await using var liteCmd = lite.CreateCommand();
-            liteCmd.CommandText = sql;
-            await liteCmd.ExecuteNonQueryAsync();
-            return;
-        }
-        if (engine == ScenarioEngine.MySql)
-        {
-            await using var my = new MySqlConnection(connString);
-            await my.OpenAsync();
-            await using var myCmd = new MySqlCommand(sql, my);
-            await myCmd.ExecuteNonQueryAsync();
-            return;
-        }
-        await using var conn = new NpgsqlConnection(connString);
-        await conn.OpenAsync();
-        await using var cmd = new NpgsqlCommand(sql, conn);
-        await cmd.ExecuteNonQueryAsync();
-    }
-
     // -----------------------------------------------------------------------
     // Result assertion (every comparison is JSON-canonical byte equality)
     // -----------------------------------------------------------------------

server/csharp/MetaObjects.IntegrationTests/Runner/ScenarioEngine.cs

@@ -1,8 +1,13 @@
 // ScenarioEngine — the database engine a query scenario runs against. Postgres is the
 // reference; SQLite and MySQL are the other engines the FR-044 report scenarios run on in C#.
 
+using System.Data.Common;
 using System.Text;
 using System.Text.RegularExpressions;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using MySqlConnector;
+using Npgsql;
 
 namespace MetaObjects.IntegrationTests.Runner;
 
@@ -13,6 +18,12 @@ public enum ScenarioEngine
     MySql,
 }
 
+/// <summary>
+/// The engine-keyed facts of the corpus lanes live HERE, not in per-caller switches: one
+/// provider choice, one connection factory, one script executor, one identifier quote. A
+/// fourth engine means one more arm in each of these switches (and the Postgres-default arm
+/// is a loud TODO there), not a hunt through the fixture, runner and server factory.
+/// </summary>
 public static class ScenarioEngineExtensions
 {
     /// <summary>The engine's name as the corpus spells it (the key of a <c>seed-data-engine</c> entry).</summary>
@@ -23,6 +34,44 @@ public static class ScenarioEngineExtensions
         ScenarioEngine.MySql => "mysql",
         _ => throw new ArgumentOutOfRangeException(nameof(engine), engine, null),
     };
+
+    /// <summary>The identifier quote seeds and inserts use: MySQL backticks, everything else the corpus' double quotes.</summary>
+    public static string Quote(this ScenarioEngine engine) =>
+        engine == ScenarioEngine.MySql ? "`" : "\"";
+
+    /// <summary>The server version Pomelo generates against. Keep in step with the mysql:8.4 image MySqlDatabase starts.</summary>
+    public static readonly Version MySqlProviderVersion = new(8, 4, 0);
+
+    /// <summary>Point this engine's EF Core provider at <paramref name="connString"/> (mutates and returns the builder).</summary>
+    public static DbContextOptionsBuilder UseEngine(this DbContextOptionsBuilder builder, ScenarioEngine engine, string connString) =>
+        engine switch
+        {
+            ScenarioEngine.Sqlite => builder.UseSqlite(connString),
+            ScenarioEngine.MySql => builder.UseMySql(connString, new MySqlServerVersion(MySqlProviderVersion)),
+            _ => builder.UseNpgsql(connString),
+        };
+
+    /// <summary>Open this engine's ADO.NET connection. Callers treat it as the provider-neutral <see cref="DbConnection"/>.</summary>
+    public static async Task<DbConnection> OpenConnectionAsync(this ScenarioEngine engine, string connString)
+    {
+        DbConnection conn = engine switch
+        {
+            ScenarioEngine.Sqlite => new SqliteConnection(connString),
+            ScenarioEngine.MySql => new MySqlConnection(connString),
+            _ => new NpgsqlConnection(connString),
+        };
+        await conn.OpenAsync();
+        return conn;
+    }
+
+    /// <summary>Execute one whole SQL script (schema artifact or seed) on a fresh connection of this engine.</summary>
+    public static async Task ExecuteScriptAsync(this ScenarioEngine engine, string connString, string sql)
+    {
+        await using var conn = await engine.OpenConnectionAsync(connString);
+        await using var cmd = conn.CreateCommand();
+        cmd.CommandText = sql;
+        await cmd.ExecuteNonQueryAsync();
+    }
 }
 
 public static partial class MySqlSeed

server/csharp/MetaObjects.IntegrationTests/Runner/SqliteTempDatabase.cs

@@ -0,0 +1,25 @@
+// SqliteTempDatabase — a throwaway SQLite file for one scenario, owned by the scenario.
+//
+// The teardown order IS the contract: Microsoft.Data.Sqlite pools connections, so the pools
+// must be cleared BEFORE the file is deleted — otherwise a pooled connection holds the file
+// and the next "fresh" scenario reads the previous scenario's rows. That step is easy to
+// forget in a copy-paste, so it lives once.
+
+using Microsoft.Data.Sqlite;
+
+namespace MetaObjects.IntegrationTests.Runner;
+
+internal sealed class SqliteTempDatabase : IDisposable
+{
+    /// <summary>Full path of the (not yet created) database file; the driver creates it on first use.</summary>
+    public string FilePath { get; }
+
+    public SqliteTempDatabase(string prefix) =>
+        FilePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), $"{prefix}{Guid.NewGuid():N}.db");
+
+    public void Dispose()
+    {
+        SqliteConnection.ClearAllPools();
+        if (System.IO.File.Exists(FilePath)) System.IO.File.Delete(FilePath);
+    }
+}

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt

@@ -92,15 +92,9 @@ object QueryScenarioRunner {
      * spelled for the engine. The Postgres `expect` blocks are asserted unchanged.
      */
     fun run(scenario: QueryScenario, baseUrl: String, username: String, password: String, engine: ScenarioEngine) {
-        // A MySQL DATETIME has no zone and the corpus stores UTC wall clocks: read and write them
-        // as UTC whatever the JVM zone is, so a report's instant column reads back as the same instant.
-        val jdbcUrl = if (engine == ScenarioEngine.MYSQL) {
-            baseUrl + (if ('?' in baseUrl) "&" else "?") + "connectionTimeZone=UTC&forceConnectionTimeZoneToSession=true"
-        } else if (engine == ScenarioEngine.SQLITE) {
-            // SQLite keeps an instant as the TEXT the view built (`...T03:00:00.000Z`); the driver
-            // parses a timestamp with this format, which reads that spelling back as the UTC instant.
-            baseUrl + (if ('?' in baseUrl) "&" else "?") + "date_string_format=yyyy-MM-dd'T'HH:mm:ss.SSSX"
-        } else baseUrl
+        // The engine appends its own session parameters (timezone / date-format policy) — see
+        // ScenarioEngine.jdbcUrl.
+        val jdbcUrl = engine.jdbcUrl(baseUrl)
         val db = Database.connect(jdbcUrl, user = username, password = password)
 
         val corpus = ScenarioLoader.findCorpusRoot()