test(sql): reap >24h-old orphaned test databases at fixture startup (AdminUI + Configuration prefixes)

2026-08-17 05:37:22 -04:00
parent 9f09a62ad2
commit 8946644bb1
3 changed files with 460 additions and 22 deletions
@@ -1,3 +1,5 @@
+using System.Data.Common;
+using System.Globalization;
 using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore;
 using Xunit;
@@ -13,9 +15,17 @@ namespace ZB.MOM.WW.OtOpcUa.Configuration.Tests;
 /// </summary>
 public sealed class SchemaComplianceFixture : IDisposable
 {
+    /// <summary>The name prefix every Configuration test database carries; also the reaper's LIKE anchor.</summary>
+    internal const string TestDatabasePrefix = "OtOpcUaConfig_Test_";
+
    private const string DefaultServer = "10.100.0.35,14330";
    private const string DefaultSaPassword = "OtOpcUaDev_2026!";

+    /// <summary>How long a test database must have existed before the reaper considers it certainly orphaned.</summary>
+    private static readonly TimeSpan OrphanAge = TimeSpan.FromHours(24);
+
+    private static readonly Lazy<int> Reaper = new(RunReaper, LazyThreadSafetyMode.ExecutionAndPublication);
+
    /// <summary>Gets the name of the test database.</summary>
    public string DatabaseName { get; }
    /// <summary>Gets the connection string for the test database.</summary>
@@ -27,7 +37,13 @@ public sealed class SchemaComplianceFixture : IDisposable
        var server = Environment.GetEnvironmentVariable("OTOPCUA_CONFIG_TEST_SERVER") ?? DefaultServer;
        var saPassword = Environment.GetEnvironmentVariable("OTOPCUA_CONFIG_TEST_SA_PASSWORD") ?? DefaultSaPassword;

-        DatabaseName = $"OtOpcUaConfig_Test_{DateTime.UtcNow:yyyyMMddHHmmss}_{Guid.NewGuid():N}";
+        // A killed test process never reaches Dispose, so its database outlives the run. Reap the ones old
+        // enough to be certainly nobody's, once per process. This fixture has no reachability probe, so an
+        // unreachable server must leave behaviour exactly as it was: the reaper silently does nothing and
+        // Migrate() below throws as it always has.
+        _ = Reaper.Value;
+
+        DatabaseName = $"{TestDatabasePrefix}{DateTime.UtcNow:yyyyMMddHHmmss}_{Guid.NewGuid():N}";
        ConnectionString =
            $"Server={server};Database={DatabaseName};User Id=sa;Password={saPassword};TrustServerCertificate=True;Encrypt=False;";

@@ -48,6 +64,16 @@ public sealed class SchemaComplianceFixture : IDisposable
        return conn;
    }

+    private static int RunReaper()
+    {
+        var server = Environment.GetEnvironmentVariable("OTOPCUA_CONFIG_TEST_SERVER") ?? DefaultServer;
+        var saPassword = Environment.GetEnvironmentVariable("OTOPCUA_CONFIG_TEST_SA_PASSWORD") ?? DefaultSaPassword;
+        var master =
+            $"Server={server};Database=master;User Id=sa;Password={saPassword};TrustServerCertificate=True;Encrypt=False;";
+
+        return SqlTestDatabaseReaper.ReapOrphans(master, TestDatabasePrefix, DateTime.UtcNow - OrphanAge).Count;
+    }
+
    /// <summary>Disposes the fixture and drops the test database.</summary>
    public void Dispose()
    {
@@ -68,6 +94,156 @@ END";
    }
 }

+/// <summary>
+///     Drops test databases that a killed test process left behind on the <b>shared</b> SQL Server.
+/// </summary>
+/// <remarks>
+///     <para>
+///         <see cref="SchemaComplianceFixture"/> names its database
+///         <c>{prefix}{yyyyMMddHHmmss-UTC}_{guid:N}</c> and drops it in <c>Dispose</c> — which a
+///         <c>Ctrl-C</c>, a crashed runner or a killed container never reaches, so the database survives
+///         forever on an instance nobody gardens.
+///     </para>
+///     <para>
+///         This is <c>DROP DATABASE</c> against a server other people share, so the rules are deliberately
+///         narrow and every one of them is load-bearing:
+///     </para>
+///     <list type="bullet">
+///         <item>
+///             the <c>LIKE</c> is an <b>exact prefix</b> with <c>_</c> escaped (an unescaped <c>_</c> is a
+///             single-character wildcard in T-SQL) — never widen it;
+///         </item>
+///         <item>
+///             a name whose embedded timestamp does not parse is <b>left alone</b>, because an unparseable
+///             name is by definition not one this code created;
+///         </item>
+///         <item>
+///             only names <b>strictly older than the cutoff</b> are dropped. At 24 hours that is far beyond
+///             any run, so the reaper can never race a live sibling run on the same server; and
+///         </item>
+///         <item>
+///             nothing here ever throws. Unlike this project's <c>Dispose</c>, which deliberately lets a
+///             teardown failure surface, opportunistic housekeeping must never fail a green run.
+///         </item>
+///     </list>
+///     <para>
+///         Deliberately duplicated from the AdminUI.Tests copy rather than shared: the two suites have no
+///         common test-support assembly, and a new one purely for ~100 lines of best-effort housekeeping
+///         costs more than the duplication.
+///     </para>
+/// </remarks>
+internal static class SqlTestDatabaseReaper
+{
+    private const string TimestampFormat = "yyyyMMddHHmmss";
+
+    /// <summary>
+    ///     Drops every database matching <paramref name="prefix"/> whose embedded creation timestamp is
+    ///     strictly older than <paramref name="cutoffUtc"/>.
+    /// </summary>
+    /// <param name="masterConnectionString">A connection string pointed at <c>master</c>.</param>
+    /// <param name="prefix">The exact test-database name prefix, e.g. <c>OtOpcUaConfig_Test_</c>.</param>
+    /// <param name="cutoffUtc">Databases created strictly before this UTC instant are dropped.</param>
+    /// <returns>The names actually dropped; empty when there was nothing to reap or anything went wrong.</returns>
+    internal static IReadOnlyList<string> ReapOrphans(string masterConnectionString, string prefix, DateTime cutoffUtc)
+    {
+        var reaped = new List<string>();
+
+        try
+        {
+            foreach (var name in ListCandidates(masterConnectionString, prefix))
+            {
+                if (!TryParseCreatedUtc(name, prefix, out var createdUtc)) continue;
+                if (createdUtc >= cutoffUtc) continue;
+
+                try
+                {
+                    if (TryDropDatabase(masterConnectionString, name)) reaped.Add(name);
+                }
+                catch (Exception)
+                {
+                    // One stubborn database must not stop the sweep, nor fail the run that triggered it.
+                }
+            }
+        }
+        catch (Exception)
+        {
+            // Enumeration failed (server down, no permission). Reaping is opportunistic housekeeping.
+        }
+
+        if (reaped.Count > 0)
+        {
+            Console.WriteLine(
+                $"[sql-test-reaper] dropped {reaped.Count} orphaned test database(s) older than " +
+                $"{cutoffUtc:yyyy-MM-dd HH:mm:ss}Z: {string.Join(", ", reaped)}");
+        }
+
+        return reaped;
+    }
+
+    /// <summary>Drops the named database, swallowing database errors — reaping is best-effort.</summary>
+    /// <param name="masterConnectionString">A connection string pointed at <c>master</c>.</param>
+    /// <param name="databaseName">The database to drop.</param>
+    /// <returns><see langword="true"/> when the statement ran without error.</returns>
+    internal static bool TryDropDatabase(string masterConnectionString, string databaseName)
+    {
+        try
+        {
+            using var conn = new SqlConnection(masterConnectionString);
+            conn.Open();
+
+            using var cmd = conn.CreateCommand();
+            cmd.CommandText = $@"
+IF DB_ID(N'{databaseName}') IS NOT NULL
+BEGIN
+    ALTER DATABASE [{databaseName}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE;
+    DROP DATABASE [{databaseName}];
+END";
+            cmd.ExecuteNonQuery();
+            return true;
+        }
+        catch (DbException)
+        {
+            return false;
+        }
+    }
+
+    private static List<string> ListCandidates(string masterConnectionString, string prefix)
+    {
+        var names = new List<string>();
+
+        using var conn = new SqlConnection(masterConnectionString);
+        conn.Open();
+
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"SELECT name FROM sys.databases WHERE name LIKE @pattern ESCAPE '\'";
+        cmd.Parameters.Add(new SqlParameter("@pattern", prefix.Replace("_", @"\_", StringComparison.Ordinal) + "%"));
+
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read()) names.Add(reader.GetString(0));
+
+        return names;
+    }
+
+    private static bool TryParseCreatedUtc(string databaseName, string prefix, out DateTime createdUtc)
+    {
+        createdUtc = default;
+
+        if (!databaseName.StartsWith(prefix, StringComparison.Ordinal)) return false;
+
+        var rest = databaseName.AsSpan(prefix.Length);
+
+        // Expect exactly "<14-digit timestamp>_<guid>" — anything else is not a name this code minted.
+        if (rest.Length < TimestampFormat.Length + 1 || rest[TimestampFormat.Length] != '_') return false;
+
+        return DateTime.TryParseExact(
+            rest[..TimestampFormat.Length],
+            TimestampFormat,
+            CultureInfo.InvariantCulture,
+            DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal,
+            out createdUtc);
+    }
+}
+
 [CollectionDefinition(nameof(SchemaComplianceCollection))]
 public sealed class SchemaComplianceCollection : ICollectionFixture<SchemaComplianceFixture>
 {