Merge R2-11 TagConfig consolidation (arch-review round 2) [PR #434]

Findings 01/C-1, 01/P-1 (single TagConfigIntent.Parse in Commons, 4 copies delegate, parse-once) + 05 CONV-2/UNDER-1/UNDER-6 (shared strict TagConfigJson readers, per-driver Inspect() + writable key, FOCAS capability pre-flight, Modbus probe timeoutMs, deploy-gate Warn|Error). Phase C runtime-strict flip deferred. T22/T24 deferred. Auto-merged AddressSpaceApplier.cs + DriverHostActor.cs with R2-04/R2-10; verified OpcUaServer.Tests 286/286 + Runtime.Tests 396/396. Build clean.
2026-07-13 11:29:32 -04:00
parent d62b140ccd 7c7d383da6
commit 1a698cbb97
74 changed files with 2228 additions and 682 deletions
@@ -0,0 +1,50 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.AbCip;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip.Tests;
+
+/// <summary>R2-11 (05/CONV-2) strictness surface for the AbCip equipment-tag parser: lenient runtime freeze,
+/// <c>Inspect</c> reports the typo, and the already-honoured <c>writable</c> key stays bit-identical through
+/// the shared reader swap.</summary>
+public sealed class AbCipEquipmentTagParserStrictnessTests
+{
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_DInt()
+    {
+        AbCipEquipmentTagParser.TryParse("{\"tagPath\":\"Motor.Speed\",\"dataType\":\"DIntt\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(AbCipDataType.DInt);
+    }
+
+    [Fact]
+    public void Inspect_reports_typo_dataType()
+    {
+        var warnings = AbCipEquipmentTagParser.Inspect("{\"tagPath\":\"Motor.Speed\",\"dataType\":\"DIntt\"}");
+        warnings.ShouldHaveSingleItem();
+        warnings[0].ShouldContain("DIntt");
+        warnings[0].ShouldContain("dataType");
+    }
+
+    [Fact]
+    public void Inspect_clean_config_has_no_warnings()
+    {
+        AbCipEquipmentTagParser.Inspect("{\"tagPath\":\"Motor.Speed\",\"dataType\":\"DInt\"}").ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Writable_false_is_honoured_bit_identical()
+    {
+        AbCipEquipmentTagParser.TryParse("{\"tagPath\":\"Motor.Speed\",\"dataType\":\"DInt\",\"writable\":false}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_absent_defaults_to_true()
+    {
+        AbCipEquipmentTagParser.TryParse("{\"tagPath\":\"Motor.Speed\",\"dataType\":\"DInt\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeTrue();
+    }
+}
@@ -0,0 +1,49 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.AbLegacy;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Tests;
+
+/// <summary>R2-11 (05/CONV-2) strictness surface for the AbLegacy equipment-tag parser: lenient runtime
+/// freeze, <c>Inspect</c> reports the typo, and the <c>writable</c> key is honoured (default true).</summary>
+public sealed class AbLegacyEquipmentTagParserStrictnessTests
+{
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_Int()
+    {
+        AbLegacyEquipmentTagParser.TryParse("{\"address\":\"N7:0\",\"dataType\":\"Intt\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(AbLegacyDataType.Int);
+    }
+
+    [Fact]
+    public void Inspect_reports_typo_dataType()
+    {
+        var warnings = AbLegacyEquipmentTagParser.Inspect("{\"address\":\"N7:0\",\"dataType\":\"Intt\"}");
+        warnings.ShouldHaveSingleItem();
+        warnings[0].ShouldContain("Intt");
+        warnings[0].ShouldContain("dataType");
+    }
+
+    [Fact]
+    public void Inspect_clean_config_has_no_warnings()
+    {
+        AbLegacyEquipmentTagParser.Inspect("{\"address\":\"N7:0\",\"dataType\":\"Int\"}").ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Writable_false_is_honoured()
+    {
+        AbLegacyEquipmentTagParser.TryParse("{\"address\":\"N7:0\",\"dataType\":\"Int\",\"writable\":false}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_absent_defaults_to_true()
+    {
+        AbLegacyEquipmentTagParser.TryParse("{\"address\":\"N7:0\",\"dataType\":\"Int\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeTrue();
+    }
+}
@@ -0,0 +1,61 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.FOCAS;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests;
+
+/// <summary>
+///     R2-11 (05/UNDER-6): an equipment-tag reference whose address violates the device series'
+///     capability matrix must fail to RESOLVE (surfacing <c>BadNodeIdUnknown</c>) — the same pre-flight
+///     authored tags get at <c>InitializeAsync</c> — instead of reaching the wire and failing later with a
+///     wire error. A capability-valid equipment tag still resolves + reads.
+/// </summary>
+[Trait("Category", "Unit")]
+public sealed class FocasEquipmentTagCapabilityGateTests
+{
+    private const string Host = "focas://10.0.0.5:8193";
+
+    private static FocasDriver NewDriver() => new(new FocasDriverOptions
+    {
+        // Series 16i: macro range 0..999 — MACRO:9500 is out of range.
+        Devices = [new FocasDeviceOptions(Host, Series: FocasCncSeries.Sixteen_i)],
+        Probe = new FocasProbeOptions { Enabled = false },
+    }, "drv-1", new FakeFocasClientFactory());
+
+    private static string EquipTag(string address) =>
+        $"{{\"address\":\"{address}\",\"dataType\":\"Int32\",\"deviceHostAddress\":\"{Host}\"}}";
+
+    [Fact]
+    public async Task Capability_violating_equipment_tag_does_not_resolve()
+    {
+        var drv = NewDriver();
+        await drv.InitializeAsync("{}", CancellationToken.None);
+
+        var results = await drv.ReadAsync([EquipTag("MACRO:9500")], CancellationToken.None);
+
+        results.Single().StatusCode.ShouldBe(FocasStatusMapper.BadNodeIdUnknown);
+    }
+
+    [Fact]
+    public async Task Capability_valid_equipment_tag_resolves_and_reads()
+    {
+        var drv = NewDriver();
+        await drv.InitializeAsync("{}", CancellationToken.None);
+
+        var results = await drv.ReadAsync([EquipTag("MACRO:100")], CancellationToken.None);
+
+        results.Single().StatusCode.ShouldNotBe(FocasStatusMapper.BadNodeIdUnknown);
+    }
+
+    [Fact]
+    public async Task Equipment_tag_for_unknown_device_does_not_resolve()
+    {
+        var drv = NewDriver();
+        await drv.InitializeAsync("{}", CancellationToken.None);
+
+        var badDevice = "{\"address\":\"MACRO:100\",\"dataType\":\"Int32\",\"deviceHostAddress\":\"focas://10.9.9.9:8193\"}";
+        var results = await drv.ReadAsync([badDevice], CancellationToken.None);
+
+        results.Single().StatusCode.ShouldBe(FocasStatusMapper.BadNodeIdUnknown);
+    }
+}
@@ -0,0 +1,57 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.FOCAS;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests;
+
+/// <summary>
+///     R2-11 (05/CONV-2 + 05/UNDER-1) strictness surface for the FOCAS equipment-tag parser: lenient
+///     runtime freeze on <c>dataType</c>, forced read-only (<c>Writable == false</c> regardless of any
+///     authored <c>writable:true</c>), and <c>Inspect</c> reporting the typo + the write-request.
+/// </summary>
+public sealed class FocasEquipmentTagParserStrictnessTests
+{
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_Int32()
+    {
+        FocasEquipmentTagParser.TryParse("{\"address\":\"D0100\",\"dataType\":\"Int322\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(FocasDataType.Int32);
+    }
+
+    [Fact]
+    public void Writable_is_always_false_even_when_requested_true()
+    {
+        FocasEquipmentTagParser.TryParse("{\"address\":\"D0100\",\"dataType\":\"Int32\",\"writable\":true}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_is_false_when_absent()
+    {
+        FocasEquipmentTagParser.TryParse("{\"address\":\"D0100\",\"dataType\":\"Int32\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Inspect_warns_on_writable_true_request()
+    {
+        var warnings = FocasEquipmentTagParser.Inspect("{\"address\":\"D0100\",\"dataType\":\"Int32\",\"writable\":true}");
+        warnings.ShouldContain(w => w.Contains("read-only") && w.Contains("writable"));
+    }
+
+    [Fact]
+    public void Inspect_reports_typo_dataType()
+    {
+        var warnings = FocasEquipmentTagParser.Inspect("{\"address\":\"D0100\",\"dataType\":\"Int322\"}");
+        warnings.ShouldContain(w => w.Contains("Int322") && w.Contains("dataType"));
+    }
+
+    [Fact]
+    public void Inspect_clean_read_only_config_has_no_warnings()
+    {
+        FocasEquipmentTagParser.Inspect("{\"address\":\"D0100\",\"dataType\":\"Int32\"}").ShouldBeEmpty();
+    }
+}
@@ -0,0 +1,56 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.Modbus;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus.Tests;
+
+/// <summary>
+///     R2-11 (05/CONV-2): the Modbus probe parses the SAME factory DTO shape the driver factory parses, so
+///     <c>timeoutMs</c> binds identically instead of being silently dropped (it never bound to the runtime
+///     <c>ModbusDriverOptions.Timeout</c> TimeSpan). The OpcUaClient probe/factory parse-parity rule.
+/// </summary>
+public sealed class ModbusDriverProbeParityTests
+{
+    [Fact]
+    public void Config_timeoutMs_binds_as_the_effective_probe_timeout()
+    {
+        var (target, error) = ModbusDriverProbe.TryParseProbeTarget(
+            "{\"host\":\"10.0.0.5\",\"port\":502,\"unitId\":3,\"timeoutMs\":250}",
+            fallbackTimeout: TimeSpan.FromSeconds(5));
+
+        error.ShouldBeNull();
+        target.ShouldNotBeNull();
+        target!.Value.Host.ShouldBe("10.0.0.5");
+        target.Value.Port.ShouldBe(502);
+        target.Value.UnitId.ShouldBe((byte)3);
+        target.Value.Timeout.ShouldBe(TimeSpan.FromMilliseconds(250));
+    }
+
+    [Fact]
+    public void Absent_timeoutMs_falls_back_to_the_caller_timeout()
+    {
+        var (target, _) = ModbusDriverProbe.TryParseProbeTarget(
+            "{\"host\":\"10.0.0.5\",\"port\":502}", fallbackTimeout: TimeSpan.FromSeconds(5));
+
+        target!.Value.Timeout.ShouldBe(TimeSpan.FromSeconds(5));
+        target.Value.UnitId.ShouldBe((byte)1);   // DTO default
+    }
+
+    [Fact]
+    public void Missing_host_is_an_error()
+    {
+        var (target, error) = ModbusDriverProbe.TryParseProbeTarget(
+            "{\"port\":0}", fallbackTimeout: TimeSpan.FromSeconds(5));
+        target.ShouldBeNull();
+        error.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public void Invalid_json_is_an_error()
+    {
+        var (target, error) = ModbusDriverProbe.TryParseProbeTarget(
+            "not valid json {{", fallbackTimeout: TimeSpan.FromSeconds(5));
+        target.ShouldBeNull();
+        error.ShouldContain("invalid");
+    }
+}
@@ -0,0 +1,71 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.Modbus;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus.Tests;
+
+/// <summary>
+///     R2-11 (05/CONV-2) strictness surface for the Modbus equipment-tag parser: the runtime stays lenient
+///     (freeze), the new <c>Inspect</c> reports the silently-defaulted typo, and the <c>writable</c> key is
+///     now honoured (default true).
+/// </summary>
+public sealed class ModbusEquipmentTagParserStrictnessTests
+{
+    // ---- Phase-A behaviour freeze: a typo'd enum still silently defaults ----
+
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_Int16()
+    {
+        ModbusEquipmentTagParser.TryParse(
+            "{\"region\":\"HoldingRegisters\",\"address\":1,\"dataType\":\"Intt16\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(ModbusDataType.Int16);
+    }
+
+    // ---- Inspect reports the typo ----
+
+    [Fact]
+    public void Inspect_reports_typo_dataType_with_field_and_valid_values()
+    {
+        var warnings = ModbusEquipmentTagParser.Inspect(
+            "{\"region\":\"HoldingRegisters\",\"address\":1,\"dataType\":\"Intt16\"}");
+        warnings.ShouldHaveSingleItem();
+        warnings[0].ShouldContain("Intt16");
+        warnings[0].ShouldContain("dataType");
+        warnings[0].ShouldContain("Int16");
+    }
+
+    [Fact]
+    public void Inspect_clean_config_has_no_warnings()
+    {
+        ModbusEquipmentTagParser.Inspect(
+            "{\"region\":\"HoldingRegisters\",\"address\":1,\"dataType\":\"Int16\"}")
+            .ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Inspect_malformed_json_warns_unresolvable()
+    {
+        ModbusEquipmentTagParser.Inspect("{not json").ShouldHaveSingleItem();
+    }
+
+    // ---- writable now honoured ----
+
+    [Fact]
+    public void Writable_false_is_honoured()
+    {
+        ModbusEquipmentTagParser.TryParse(
+            "{\"region\":\"HoldingRegisters\",\"address\":1,\"dataType\":\"Int16\",\"writable\":false}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_absent_defaults_to_true()
+    {
+        ModbusEquipmentTagParser.TryParse(
+            "{\"region\":\"HoldingRegisters\",\"address\":1,\"dataType\":\"Int16\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeTrue();
+    }
+}
@@ -0,0 +1,49 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.S7;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.S7.Tests;
+
+/// <summary>R2-11 (05/CONV-2) strictness surface for the S7 equipment-tag parser: lenient runtime freeze,
+/// <c>Inspect</c> reports the typo, and the <c>writable</c> key is honoured (default true).</summary>
+public sealed class S7EquipmentTagParserStrictnessTests
+{
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_Int16()
+    {
+        S7EquipmentTagParser.TryParse("{\"address\":\"DB1.DBW0\",\"dataType\":\"Intt16\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(S7DataType.Int16);
+    }
+
+    [Fact]
+    public void Inspect_reports_typo_dataType()
+    {
+        var warnings = S7EquipmentTagParser.Inspect("{\"address\":\"DB1.DBW0\",\"dataType\":\"Intt16\"}");
+        warnings.ShouldHaveSingleItem();
+        warnings[0].ShouldContain("Intt16");
+        warnings[0].ShouldContain("dataType");
+    }
+
+    [Fact]
+    public void Inspect_clean_config_has_no_warnings()
+    {
+        S7EquipmentTagParser.Inspect("{\"address\":\"DB1.DBW0\",\"dataType\":\"Int16\"}").ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Writable_false_is_honoured()
+    {
+        S7EquipmentTagParser.TryParse("{\"address\":\"DB1.DBW0\",\"dataType\":\"Int16\",\"writable\":false}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_absent_defaults_to_true()
+    {
+        S7EquipmentTagParser.TryParse("{\"address\":\"DB1.DBW0\",\"dataType\":\"Int16\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeTrue();
+    }
+}
@@ -0,0 +1,49 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Tests;
+
+/// <summary>R2-11 (05/CONV-2) strictness surface for the TwinCAT equipment-tag parser: lenient runtime
+/// freeze, <c>Inspect</c> reports the typo, and the <c>writable</c> key is honoured (default true).</summary>
+public sealed class TwinCATEquipmentTagParserStrictnessTests
+{
+    [Fact]
+    public void Freeze_typo_dataType_still_defaults_to_DInt()
+    {
+        TwinCATEquipmentTagParser.TryParse("{\"symbolPath\":\"MAIN.x\",\"dataType\":\"DIntt\"}", out var def)
+            .ShouldBeTrue();
+        def.DataType.ShouldBe(TwinCATDataType.DInt);
+    }
+
+    [Fact]
+    public void Inspect_reports_typo_dataType()
+    {
+        var warnings = TwinCATEquipmentTagParser.Inspect("{\"symbolPath\":\"MAIN.x\",\"dataType\":\"DIntt\"}");
+        warnings.ShouldHaveSingleItem();
+        warnings[0].ShouldContain("DIntt");
+        warnings[0].ShouldContain("dataType");
+    }
+
+    [Fact]
+    public void Inspect_clean_config_has_no_warnings()
+    {
+        TwinCATEquipmentTagParser.Inspect("{\"symbolPath\":\"MAIN.x\",\"dataType\":\"DInt\"}").ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Writable_false_is_honoured()
+    {
+        TwinCATEquipmentTagParser.TryParse("{\"symbolPath\":\"MAIN.x\",\"dataType\":\"DInt\",\"writable\":false}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void Writable_absent_defaults_to_true()
+    {
+        TwinCATEquipmentTagParser.TryParse("{\"symbolPath\":\"MAIN.x\",\"dataType\":\"DInt\"}", out var def)
+            .ShouldBeTrue();
+        def.Writable.ShouldBeTrue();
+    }
+}