fix(historian): SQL quality contract, long-name refusal, info-bit masking, AtTime-after-now, bootstrap hardening

- I-1: an Empty sample is always Bad. The writer stores a non-Bad NaN/Inf as Empty+BadOutOfRange and any other non-Bad Empty as BadNoData; the updater refuses a non-Bad Empty with BadInvalidArgument; reads clamp a legacy non-Bad Empty row to BadNoData (Raw and AtTime). - Tag/source names over 400 chars are refused, never truncated: writer per-tag failure, updater BadInvalidArgument, reads not-found, events none. - HistorianInfoBits masks the historian bits before setting one. - AtTime past now, stepped from the last sample => UncertainDataSubNormal. - Bootstrapper: logger, 5 s negative cache, ClearPool + Warning when sp_releaseapplock fails. - Provider builds its shared state lazily (an invalid Schema no longer throws at Resolve); Kinds is a FrozenSet; Gateway reuses the recorder's DefaultSupportedKinds. - Cleanup: SqlHistorianDataTypes in its own file (updater dup removed), dead Invalidate and unused status consts deleted, named severity masks, alarm writer brace. Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe
2026-10-09 14:16:31 -04:00
parent fc57eefca6
commit 821763a09d
20 changed files with 611 additions and 126 deletions
@@ -32,6 +32,36 @@ public sealed class SqlServerHistorianProviderTests
        p.CreateUpdater(sp).ShouldBeOfType<SqlServerHistorianDataUpdater>();
    }

+    [Fact]
+    public void Supported_kinds_are_a_frozen_set() =>
+        Make().SupportedKinds.ShouldBeAssignableTo<System.Collections.Frozen.FrozenSet<HistorianValueKind>>();
+
+    /// <summary>
+    ///     An invalid schema must not fail provider construction (the host resolves the provider even when no
+    ///     consumer is enabled); it surfaces only when a seam is actually built.
+    /// </summary>
+    [Fact]
+    public void An_invalid_schema_fails_only_when_a_seam_is_built()
+    {
+        var p = new SqlServerHistorianProvider(new SqlServerHistorianOptions { ConnectionString = "x", Schema = "bad;schema" });
+        p.Name.ShouldBe("SqlServer");
+        Should.Throw<ArgumentException>(() => p.CreateDataSource(new NullSp()));
+    }
+
+    [Fact]
+    public void Every_seam_shares_one_connection_bootstrapper_and_catalog()
+    {
+        var sp = new NullSp();
+        var p = Make();
+        var a = (SqlServerHistorianDataSource)p.CreateDataSource(sp);
+        var b = (SqlServerHistorianDataSource)p.CreateDataSource(sp);
+        Field(a, "_bootstrap").ShouldBeSameAs(Field(b, "_bootstrap"));
+        Field(a, "_catalog").ShouldBeSameAs(Field(b, "_catalog"));
+    }
+
+    private static object? Field(object o, string name) =>
+        o.GetType().GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!.GetValue(o);
+
    private sealed class NullSp : IServiceProvider
    {
        public object? GetService(Type serviceType) => null;
@@ -22,6 +22,23 @@ public sealed class StatusCodeOracleTests
        ((uint)Opc.Ua.AggregateBits.Interpolated).ShouldBe(HistorianInfoBits.HistorianInterpolated);
    }

+    /// <summary>
+    ///     A stored status that already carries a historian bit (a sample written via HistoryUpdate with the Calculated
+    ///     bit, say) must come back with ONE historian bit, never both: the existing pair is masked off first. The SDK
+    ///     agrees — <c>SetAggregateBits</c> replaces, it does not OR.
+    /// </summary>
+    [Fact]
+    public void Setting_one_historian_bit_clears_the_other()
+    {
+        var calculatedUncertain = SqlHistorianStatusCodes.UncertainDataSubNormal | 0x400u | HistorianInfoBits.HistorianCalculated;
+        var interpolated = HistorianInfoBits.WithInterpolated(calculatedUncertain);
+        interpolated.ShouldBe(SqlHistorianStatusCodes.UncertainDataSubNormal | 0x400u | HistorianInfoBits.HistorianInterpolated);
+        new Opc.Ua.StatusCode(interpolated).AggregateBits.ShouldBe(Opc.Ua.AggregateBits.Interpolated);
+
+        var interpolatedGood = 0x400u | HistorianInfoBits.HistorianInterpolated;
+        HistorianInfoBits.WithCalculated(interpolatedGood).ShouldBe(0x400u | HistorianInfoBits.HistorianCalculated);
+    }
+
    [Fact]
    public void Info_type_is_data_value() =>
        HistorianInfoBits.InfoTypeDataValue.ShouldBe(0x400u);
@@ -9,18 +9,32 @@ public sealed class ValueWriterPrepareTests
    private static readonly DateTime T = new(2026, 10, 9, 1, 2, 3, DateTimeKind.Utc);

    [Fact]
-    public void Non_finite_doubles_become_Empty_keeping_status()
+    public void Non_finite_doubles_become_Empty_and_are_forced_Bad()
    {
-        const uint status = 0x40000000u;
+        const uint uncertain = 0x40000000u;
+        const uint badNoCommunication = 0x80310000u;
        var rows = SqlServerHistorianValueWriter.Prepare(
        [
-            new(T, HistorianValue.FromDouble(double.NaN), status),
+            new(T, HistorianValue.FromDouble(double.NaN), uncertain),
            new(T.AddTicks(1), HistorianValue.FromDouble(double.PositiveInfinity), 0),
-            new(T.AddTicks(2), HistorianValue.FromDouble(double.NegativeInfinity), 0),
+            new(T.AddTicks(2), HistorianValue.FromDouble(double.NegativeInfinity), badNoCommunication),
            new(T.AddTicks(3), HistorianValue.FromDouble(1.5), 0),
        ], () => T);
        rows.Select(r => r.Value.Kind).ShouldBe([HistorianValueKind.Empty, HistorianValueKind.Empty, HistorianValueKind.Empty, HistorianValueKind.Double]);
-        rows[0].StatusCode.ShouldBe(status);
+        rows.Select(r => r.StatusCode).ShouldBe([SqlHistorianStatusCodes.BadOutOfRange, SqlHistorianStatusCodes.BadOutOfRange,
+            badNoCommunication, 0u]);
+    }
+
+    [Fact]
+    public void A_non_bad_Empty_is_stored_BadNoData_and_a_bad_Empty_keeps_its_code()
+    {
+        var rows = SqlServerHistorianValueWriter.Prepare(
+        [
+            new(T, HistorianValue.Empty, 0),
+            new(T.AddTicks(1), HistorianValue.Empty, 0x40A40000u),
+            new(T.AddTicks(2), HistorianValue.Empty, 0x80310000u),
+        ], () => T);
+        rows.Select(r => r.StatusCode).ShouldBe([SqlHistorianStatusCodes.BadNoData, SqlHistorianStatusCodes.BadNoData, 0x80310000u]);
    }

    [Fact]