feat(opcua): FB-7 surgical DataType/array-shape in-place tag writes
Widen the F10b surgical address-space path so a changed equipment tag whose only differences are DataType / IsArray / ArrayLength (on top of the existing Writable / Historizing) is applied IN PLACE on the live node instead of forcing a full RebuildAddressSpace that drops every client's subscriptions server-wide. ISurgicalAddressSpaceSink.UpdateTagAttributes gains (dataType, isArray, arrayLength); the DeferredAddressSpaceSink wrapper forwards all six args (the prod-inertness seam). OtOpcUaNodeManager swaps DataType + ValueRank + ArrayDimensions in place, and on a real shape change (a) resets the node to BadWaitingForInitialData so no stale wrong-typed value is exposed (closes the prior brief-value-type-mismatch objection) and (b) raises a Part 3 GeneralModelChangeEvent (verb=DataTypeChanged) so model-aware clients re-read the definition. A Writable/Historizing-only change leaves the shape untouched (no reset, no model event) — original behaviour preserved byte-for-byte. AddressSpaceApplier.TagDeltaIsSurgicalEligible adds the three shape fields to its whitelist; FullName/Name/DriverInstanceId/alarm differences still rebuild. Tests: new NodeManagerSurgicalShapeUpdateTests boots a real server to prove the in-place swap + value reset + the no-reset backward-compat path + the model-event builder; AddressSpaceApplierTests invert the two former DataType/IsArray-rebuild cases to surgical and assert the shape args land; DeferredAddressSpaceSinkTests assert the shape args forward. 273/273 OpcUaServer.Tests green; full solution builds.
This commit is contained in:
Joseph Doherty
@@ -616,10 +616,12 @@ public sealed class AddressSpaceApplierTests
|
||||
sink.RebuildCalls.ShouldBe(1);
|
||||
}
|
||||
|
||||
/// <summary>H1a — a deploy that ONLY changes an existing equipment tag (e.g. flips its dataType or
|
||||
/// Writable bit) must rebuild the address space. The planner diffs the tag into
|
||||
/// <c>ChangedEquipmentTags</c> with no Added/Removed of anything else; the applier must still drive
|
||||
/// exactly one rebuild so the running server drops the stale node and re-materialises it.</summary>
|
||||
/// <summary>H1a — a deploy that ONLY changes an existing equipment tag in a NON-surgical way (here the
|
||||
/// driver-side <c>FullName</c> re-routes to a different point) must rebuild the address space. The planner
|
||||
/// diffs the tag into <c>ChangedEquipmentTags</c> with no Added/Removed of anything else; the applier must
|
||||
/// still drive exactly one rebuild so the running server drops the stale node and re-materialises it.
|
||||
/// (Surgically-applicable tag changes — Writable/Historizing/DataType/array-shape — take the in-place path
|
||||
/// instead; those are covered by the F10b + FB-7 surgical tests.)</summary>
|
||||
[Fact]
|
||||
public void Changed_equipment_tags_only_trigger_rebuild()
|
||||
{
|
||||
@@ -628,9 +630,9 @@ public sealed class AddressSpaceApplierTests
|
||||
|
||||
var previous = CompositionWithTags(
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Float", FullName: "40001", Writable: false, Alarm: null));
|
||||
// Same tag id, but DataType + Writable flipped — the planner classifies this as a change.
|
||||
// Same tag id, but the driver-side FullName flipped — a non-surgical change, so the applier rebuilds.
|
||||
var next = CompositionWithTags(
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Int32", FullName: "40001", Writable: true, Alarm: null));
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Float", FullName: "40002", Writable: false, Alarm: null));
|
||||
|
||||
var plan = AddressSpacePlanner.Compute(previous, next);
|
||||
|
||||
@@ -815,9 +817,9 @@ public sealed class AddressSpaceApplierTests
|
||||
}
|
||||
|
||||
/// <summary>F10b — the skip is ONLY for a node-irrelevant vtag edit that is the SOLE change. A
|
||||
/// node-irrelevant Expression-only vtag edit MIXED with any other change (here a changed equipment
|
||||
/// tag) must still rebuild — the rebuild is forced by the OTHER change, and the running server gets
|
||||
/// its single rebuild as before.</summary>
|
||||
/// node-irrelevant Expression-only vtag edit MIXED with another NON-surgical change (here a changed
|
||||
/// equipment tag whose driver-side <c>FullName</c> re-routes) must still rebuild — the rebuild is forced
|
||||
/// by the OTHER change, and the running server gets its single rebuild as before.</summary>
|
||||
[Fact]
|
||||
public void Node_irrelevant_vtag_edit_mixed_with_another_change_still_rebuilds()
|
||||
{
|
||||
@@ -837,13 +839,13 @@ public sealed class AddressSpaceApplierTests
|
||||
Expression: "ctx.GetTag(\"a\") * 60", DependencyRefs: new[] { "a" }),
|
||||
},
|
||||
};
|
||||
// Expression-only vtag edit (node-irrelevant) AND a node-affecting tag DataType flip.
|
||||
// Expression-only vtag edit (node-irrelevant) AND a non-surgical tag change (FullName re-route).
|
||||
var next = new AddressSpaceComposition(
|
||||
Array.Empty<EquipmentNode>(), Array.Empty<DriverInstancePlan>(), Array.Empty<ScriptedAlarmPlan>())
|
||||
{
|
||||
EquipmentTags = new[]
|
||||
{
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Int32", FullName: "40001", Writable: false, Alarm: null),
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Float", FullName: "40002", Writable: false, Alarm: null),
|
||||
},
|
||||
EquipmentVirtualTags = new[]
|
||||
{
|
||||
@@ -1157,17 +1159,19 @@ public sealed class AddressSpaceApplierTests
|
||||
sink.SurgicalCalls.ShouldHaveSingleItem().Historian.ShouldBe("WW.New"); // override verbatim
|
||||
}
|
||||
|
||||
/// <summary>F10b safe-default — a tag delta whose <c>DataType</c> changed is NOT surgical-eligible (the
|
||||
/// node's value type would differ), so the applier must rebuild and make NO surgical call.</summary>
|
||||
/// <summary>FB-7 — a tag delta whose <c>DataType</c> changed is now surgical-eligible: the sink swaps the
|
||||
/// node's DataType in place (and raises a GeneralModelChangeEvent), so the applier SKIPS the rebuild and
|
||||
/// makes exactly one surgical call carrying the NEW DataType. Here Writable also flips, which the same
|
||||
/// in-place update applies. Subscriptions are preserved.</summary>
|
||||
[Fact]
|
||||
public void Changed_tag_data_type_change_rebuilds_and_no_surgical_call()
|
||||
public void Changed_tag_data_type_change_skips_rebuild_and_updates_in_place()
|
||||
{
|
||||
var sink = new RecordingSink();
|
||||
var applier = new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance);
|
||||
|
||||
var previous = CompositionWithTags(
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Float", FullName: "40001", Writable: false, Alarm: null));
|
||||
// DataType flips AND Writable flips — DataType is node-affecting, so this must rebuild.
|
||||
// DataType flips Float → Int32 AND Writable flips false → true — both are now surgically applied.
|
||||
var next = CompositionWithTags(
|
||||
new EquipmentTagPlan("tag-1", "eq-1", "drv", FolderPath: "", Name: "Speed", DataType: "Int32", FullName: "40001", Writable: true, Alarm: null));
|
||||
|
||||
@@ -1176,15 +1180,22 @@ public sealed class AddressSpaceApplierTests
|
||||
|
||||
var outcome = applier.Apply(plan);
|
||||
|
||||
outcome.RebuildCalled.ShouldBeTrue();
|
||||
sink.RebuildCalls.ShouldBe(1);
|
||||
sink.SurgicalCalls.ShouldBeEmpty();
|
||||
outcome.RebuildCalled.ShouldBeFalse();
|
||||
sink.RebuildCalls.ShouldBe(0); // NO rebuild — subscriptions preserved
|
||||
var call = sink.SurgicalCalls.ShouldHaveSingleItem();
|
||||
call.NodeId.ShouldBe(EquipmentNodeIds.Variable("eq-1", "", "Speed"));
|
||||
call.DataType.ShouldBe("Int32"); // the NEW DataType
|
||||
call.Writable.ShouldBeTrue(); // the NEW Writable, applied in the same call
|
||||
call.IsArray.ShouldBeFalse();
|
||||
outcome.ChangedNodes.ShouldBe(1);
|
||||
}
|
||||
|
||||
/// <summary>F10b safe-default — a tag delta whose <c>IsArray</c> flag changed is NOT surgical-eligible
|
||||
/// (array-ness drives ValueRank/ArrayDimensions on the node), so the applier rebuilds.</summary>
|
||||
/// <summary>FB-7 — a tag delta whose <c>IsArray</c> flag flips scalar → array is now surgical-eligible:
|
||||
/// the sink swaps ValueRank + ArrayDimensions in place, so the applier skips the rebuild and the surgical
|
||||
/// call carries the new array shape. An array tag is forced read-only (matching EnsureVariable), so the
|
||||
/// surgical Writable is false even though the tag stays non-writable here.</summary>
|
||||
[Fact]
|
||||
public void Changed_tag_is_array_change_rebuilds()
|
||||
public void Changed_tag_is_array_change_skips_rebuild_and_updates_in_place()
|
||||
{
|
||||
var sink = new RecordingSink();
|
||||
var applier = new AddressSpaceApplier(sink, NullLogger<AddressSpaceApplier>.Instance);
|
||||
@@ -1201,9 +1212,13 @@ public sealed class AddressSpaceApplierTests
|
||||
|
||||
var outcome = applier.Apply(plan);
|
||||
|
||||
outcome.RebuildCalled.ShouldBeTrue();
|
||||
sink.RebuildCalls.ShouldBe(1);
|
||||
sink.SurgicalCalls.ShouldBeEmpty();
|
||||
outcome.RebuildCalled.ShouldBeFalse();
|
||||
sink.RebuildCalls.ShouldBe(0);
|
||||
var call = sink.SurgicalCalls.ShouldHaveSingleItem();
|
||||
call.IsArray.ShouldBeTrue(); // the NEW array shape
|
||||
call.ArrayLength.ShouldBe(16u);
|
||||
call.DataType.ShouldBe("Int16"); // element type unchanged
|
||||
call.Writable.ShouldBeFalse(); // array tag forced read-only
|
||||
}
|
||||
|
||||
/// <summary>F10b safe-default — a tag delta whose driver-side <c>FullName</c> changed is NOT
|
||||
@@ -1499,10 +1514,10 @@ public sealed class AddressSpaceApplierTests
|
||||
|
||||
private sealed class RecordingSink : IOpcUaAddressSpaceSink, ISurgicalAddressSpaceSink
|
||||
{
|
||||
/// <summary>Gets the queue of surgical in-place tag-attribute update calls (F10b).</summary>
|
||||
public ConcurrentQueue<(string NodeId, bool Writable, string? Historian)> SurgicalQueue { get; } = new();
|
||||
/// <summary>Gets the queue of surgical in-place tag-attribute update calls (F10b + FB-7).</summary>
|
||||
public ConcurrentQueue<(string NodeId, bool Writable, string? Historian, string DataType, bool IsArray, uint? ArrayLength)> SurgicalQueue { get; } = new();
|
||||
/// <summary>Gets the list of recorded surgical in-place tag-attribute update calls.</summary>
|
||||
public List<(string NodeId, bool Writable, string? Historian)> SurgicalCalls => SurgicalQueue.ToList();
|
||||
public List<(string NodeId, bool Writable, string? Historian, string DataType, bool IsArray, uint? ArrayLength)> SurgicalCalls => SurgicalQueue.ToList();
|
||||
/// <summary>When false, <see cref="UpdateTagAttributes"/> reports the node missing (returns false),
|
||||
/// driving the applier's rebuild fallback. Defaults to true (node present, update succeeds).</summary>
|
||||
public bool SurgicalReturns { get; init; } = true;
|
||||
@@ -1511,9 +1526,12 @@ public sealed class AddressSpaceApplierTests
|
||||
/// <param name="variableNodeId">The variable node ID to update in place.</param>
|
||||
/// <param name="writable">The new Writable (AccessLevel) for the node.</param>
|
||||
/// <param name="historianTagname">The resolved historian tagname (null ⇒ not historized).</param>
|
||||
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname)
|
||||
/// <param name="dataType">The new OPC UA data type name to apply in place.</param>
|
||||
/// <param name="isArray">The new array-ness of the node.</param>
|
||||
/// <param name="arrayLength">The new 1-D array length when <paramref name="isArray"/> is true.</param>
|
||||
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname, string dataType, bool isArray, uint? arrayLength)
|
||||
{
|
||||
SurgicalQueue.Enqueue((variableNodeId, writable, historianTagname));
|
||||
SurgicalQueue.Enqueue((variableNodeId, writable, historianTagname, dataType, isArray, arrayLength));
|
||||
return SurgicalReturns;
|
||||
}
|
||||
|
||||
|
||||
@@ -94,13 +94,19 @@ public sealed class DeferredAddressSpaceSinkTests
|
||||
var inner = new SurgicalRecordingSink { Result = true };
|
||||
deferred.SetSink(inner);
|
||||
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: "MyTag.PV")
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: "MyTag.PV",
|
||||
dataType: "Int32", isArray: true, arrayLength: 8u)
|
||||
.ShouldBeTrue();
|
||||
|
||||
var call = inner.SurgicalCalls.ShouldHaveSingleItem();
|
||||
call.NodeId.ShouldBe("v-1");
|
||||
call.Writable.ShouldBeTrue();
|
||||
call.Historian.ShouldBe("MyTag.PV");
|
||||
// FB-7: the DataType/array-shape args must forward verbatim too — a partial forward would silently
|
||||
// drop the shape update on every driver-role host.
|
||||
call.DataType.ShouldBe("Int32");
|
||||
call.IsArray.ShouldBeTrue();
|
||||
call.ArrayLength.ShouldBe(8u);
|
||||
}
|
||||
|
||||
/// <summary>The surgical forward returns the inner's own result (false ⇒ node missing) so the caller
|
||||
@@ -111,7 +117,8 @@ public sealed class DeferredAddressSpaceSinkTests
|
||||
var deferred = new DeferredAddressSpaceSink();
|
||||
deferred.SetSink(new SurgicalRecordingSink { Result = false });
|
||||
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: false, historianTagname: null)
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: false, historianTagname: null,
|
||||
dataType: "Float", isArray: false, arrayLength: null)
|
||||
.ShouldBeFalse();
|
||||
}
|
||||
|
||||
@@ -122,11 +129,13 @@ public sealed class DeferredAddressSpaceSinkTests
|
||||
public void UpdateTagAttributes_returns_false_when_inner_is_not_surgical()
|
||||
{
|
||||
var deferred = new DeferredAddressSpaceSink(); // default inner = null sink (not surgical)
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: null)
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: null,
|
||||
dataType: "Float", isArray: false, arrayLength: null)
|
||||
.ShouldBeFalse();
|
||||
|
||||
deferred.SetSink(new RecordingSink()); // a non-surgical inner
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: null)
|
||||
((ISurgicalAddressSpaceSink)deferred).UpdateTagAttributes("v-1", writable: true, historianTagname: null,
|
||||
dataType: "Float", isArray: false, arrayLength: null)
|
||||
.ShouldBeFalse();
|
||||
}
|
||||
|
||||
@@ -175,13 +184,13 @@ public sealed class DeferredAddressSpaceSinkTests
|
||||
{
|
||||
/// <summary>Gets or sets the value <see cref="UpdateTagAttributes"/> returns.</summary>
|
||||
public bool Result { get; set; } = true;
|
||||
/// <summary>Gets the recorded surgical calls.</summary>
|
||||
public List<(string NodeId, bool Writable, string? Historian)> SurgicalCalls { get; } = new();
|
||||
/// <summary>Gets the recorded surgical calls (incl. the FB-7 DataType/array-shape args).</summary>
|
||||
public List<(string NodeId, bool Writable, string? Historian, string DataType, bool IsArray, uint? ArrayLength)> SurgicalCalls { get; } = new();
|
||||
|
||||
/// <inheritdoc />
|
||||
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname)
|
||||
public bool UpdateTagAttributes(string variableNodeId, bool writable, string? historianTagname, string dataType, bool isArray, uint? arrayLength)
|
||||
{
|
||||
SurgicalCalls.Add((variableNodeId, writable, historianTagname));
|
||||
SurgicalCalls.Add((variableNodeId, writable, historianTagname, dataType, isArray, arrayLength));
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
+222
@@ -0,0 +1,222 @@
|
||||
using Opc.Ua;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// FB-7 — the BEHAVIOURAL half of the surgical DataType/array-shape in-place write (the applier-level
|
||||
/// eligibility + dispatch decisions live in <see cref="AddressSpaceApplierTests"/>). Boots a real
|
||||
/// <see cref="OtOpcUaSdkServer"/> through <see cref="OpcUaApplicationHost"/> (the same harness
|
||||
/// <see cref="NodeManagerWriteRevertTests"/> uses) so <see cref="OtOpcUaNodeManager.UpdateTagAttributes"/>
|
||||
/// runs against a live node manager (real <c>Lock</c> + <c>SystemContext</c> + <c>Server</c>), and asserts:
|
||||
/// <list type="bullet">
|
||||
/// <item>a DataType / ValueRank / array-length change is applied IN PLACE on the existing node and
|
||||
/// RESETS its value to BadWaitingForInitialData (no stale wrong-typed value), while the node identity
|
||||
/// (and therefore client subscriptions) survive;</item>
|
||||
/// <item>a Writable / Historizing-only change (shape unchanged) does NOT reset the value — the
|
||||
/// original surgical behaviour is preserved byte-for-byte;</item>
|
||||
/// <item>the built <c>GeneralModelChangeEvent</c> carries Changes=[{Affected=node, Verb=DataTypeChanged}].</item>
|
||||
/// </list>
|
||||
/// <para>
|
||||
/// Coverage boundary (deliberate, mirrors <see cref="NodeManagerWriteRevertTests"/>): the model-change
|
||||
/// event is asserted via its <i>builder</i> (<see cref="OtOpcUaNodeManager.BuildNodeShapeChangedEvent"/>)
|
||||
/// in isolation, not its end-to-end <c>Server.ReportEvent</c> dispatch — observing that would require a
|
||||
/// subscribed event monitored-item. The single in-lock report call-site is covered by inspection.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class NodeManagerSurgicalShapeUpdateTests : IDisposable
|
||||
{
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
private readonly string _pkiRoot = Path.Combine(
|
||||
Path.GetTempPath(),
|
||||
$"otopcua-surgical-shape-{Guid.NewGuid():N}");
|
||||
|
||||
// ───────────────────────────── Shape swap (DataType / ValueRank / array length) ─────────────────────────────
|
||||
|
||||
/// <summary>A DataType change swaps the node's DataType in place and resets the value (the old Float value
|
||||
/// must not survive on a now-Int32 node); the node id is unchanged, so client subscriptions are preserved.</summary>
|
||||
[Fact]
|
||||
public async Task DataType_change_swaps_in_place_and_resets_value()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
nm.EnsureVariable("eq-1/sp", parentFolderNodeId: null, displayName: "Sp", dataType: "Float", writable: false);
|
||||
nm.WriteValue("eq-1/sp", 3.5f, OpcUaQuality.Good, DateTime.UtcNow);
|
||||
var node = nm.TryGetVariable("eq-1/sp")!;
|
||||
node.DataType.ShouldBe(DataTypeIds.Float); // arrange guard
|
||||
|
||||
var applied = nm.UpdateTagAttributes("eq-1/sp", writable: false, historianTagname: null,
|
||||
dataType: "Int32", isArray: false, arrayLength: null);
|
||||
|
||||
applied.ShouldBeTrue();
|
||||
node.DataType.ShouldBe(DataTypeIds.Int32); // swapped in place
|
||||
node.ValueRank.ShouldBe(ValueRanks.Scalar);
|
||||
node.Value.ShouldBeNull(); // stale Float value dropped
|
||||
node.StatusCode.ShouldBe((StatusCode)StatusCodes.BadWaitingForInitialData);
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
/// <summary>A scalar → array flip swaps ValueRank to OneDimension + ArrayDimensions=[len] in place and
|
||||
/// resets the value.</summary>
|
||||
[Fact]
|
||||
public async Task Scalar_to_array_flip_swaps_value_rank_and_resets_value()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
nm.EnsureVariable("eq-1/buf", parentFolderNodeId: null, displayName: "Buf", dataType: "Int16", writable: false);
|
||||
nm.WriteValue("eq-1/buf", (short)42, OpcUaQuality.Good, DateTime.UtcNow);
|
||||
var node = nm.TryGetVariable("eq-1/buf")!;
|
||||
node.ValueRank.ShouldBe(ValueRanks.Scalar); // arrange guard
|
||||
|
||||
var applied = nm.UpdateTagAttributes("eq-1/buf", writable: false, historianTagname: null,
|
||||
dataType: "Int16", isArray: true, arrayLength: 8u);
|
||||
|
||||
applied.ShouldBeTrue();
|
||||
node.ValueRank.ShouldBe(ValueRanks.OneDimension);
|
||||
node.ArrayDimensions.ShouldNotBeNull();
|
||||
node.ArrayDimensions[0].ShouldBe(8u);
|
||||
node.Value.ShouldBeNull(); // stale scalar value dropped
|
||||
node.StatusCode.ShouldBe((StatusCode)StatusCodes.BadWaitingForInitialData);
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
/// <summary>An array-to-array LENGTH change (rank stays OneDimension, only ArrayDimensions[0] differs) is
|
||||
/// still treated as a shape change — the dimension is updated and the (now wrong-length) value reset.</summary>
|
||||
[Fact]
|
||||
public async Task Array_length_change_swaps_dimension_and_resets_value()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
nm.EnsureVariable("eq-1/buf", parentFolderNodeId: null, displayName: "Buf", dataType: "Int16",
|
||||
writable: false, historianTagname: null, isArray: true, arrayLength: 4u);
|
||||
nm.WriteValue("eq-1/buf", new short[] { 1, 2, 3, 4 }, OpcUaQuality.Good, DateTime.UtcNow);
|
||||
var node = nm.TryGetVariable("eq-1/buf")!;
|
||||
node.ArrayDimensions![0].ShouldBe(4u); // arrange guard
|
||||
|
||||
var applied = nm.UpdateTagAttributes("eq-1/buf", writable: false, historianTagname: null,
|
||||
dataType: "Int16", isArray: true, arrayLength: 8u);
|
||||
|
||||
applied.ShouldBeTrue();
|
||||
node.ArrayDimensions[0].ShouldBe(8u);
|
||||
node.Value.ShouldBeNull();
|
||||
node.StatusCode.ShouldBe((StatusCode)StatusCodes.BadWaitingForInitialData);
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
// ───────────────────────────── Backward compatibility (shape unchanged) ─────────────────────────────
|
||||
|
||||
/// <summary>A Writable-only change (DataType + array-ness identical to the live node) must NOT reset the
|
||||
/// value — the original surgical behaviour stands. AccessLevel flips to ReadWrite; the prior Good value
|
||||
/// survives untouched.</summary>
|
||||
[Fact]
|
||||
public async Task Writable_only_change_keeps_value_and_does_not_reset()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
nm.EnsureVariable("eq-1/sp", parentFolderNodeId: null, displayName: "Sp", dataType: "Float", writable: false);
|
||||
nm.WriteValue("eq-1/sp", 7.0f, OpcUaQuality.Good, DateTime.UtcNow);
|
||||
var node = nm.TryGetVariable("eq-1/sp")!;
|
||||
|
||||
// Same DataType ("Float") + same scalar shape — only Writable flips false → true.
|
||||
var applied = nm.UpdateTagAttributes("eq-1/sp", writable: true, historianTagname: null,
|
||||
dataType: "Float", isArray: false, arrayLength: null);
|
||||
|
||||
applied.ShouldBeTrue();
|
||||
node.Value.ShouldBe(7.0f); // value preserved (NOT reset)
|
||||
node.StatusCode.ShouldBe((StatusCode)StatusCodes.Good); // status preserved
|
||||
node.DataType.ShouldBe(DataTypeIds.Float);
|
||||
// ReadWrite ⇒ CurrentRead | CurrentWrite.
|
||||
node.AccessLevel.ShouldBe((byte)(AccessLevels.CurrentRead | AccessLevels.CurrentWrite));
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
/// <summary>An unknown node id (rebuilt/removed in the interim) returns false so the caller falls back to a
|
||||
/// full rebuild; it must not throw.</summary>
|
||||
[Fact]
|
||||
public async Task Missing_node_returns_false()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
bool result = true;
|
||||
Should.NotThrow(() => result = nm.UpdateTagAttributes("eq-1/gone", writable: false, historianTagname: null,
|
||||
dataType: "Int32", isArray: false, arrayLength: null));
|
||||
result.ShouldBeFalse();
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
// ───────────────────────────── GeneralModelChangeEvent builder ─────────────────────────────
|
||||
|
||||
/// <summary>The built model-change event announces the affected node with verb DataTypeChanged and the
|
||||
/// node's TypeDefinition as AffectedType — what model-aware clients consume to re-read the definition.</summary>
|
||||
[Fact]
|
||||
public async Task Built_model_change_event_reflects_the_affected_node()
|
||||
{
|
||||
var (host, server) = await BootAsync();
|
||||
var nm = server.NodeManager!;
|
||||
|
||||
nm.EnsureVariable("eq-1/sp", parentFolderNodeId: null, displayName: "Sp", dataType: "Float", writable: false);
|
||||
var node = nm.TryGetVariable("eq-1/sp")!;
|
||||
|
||||
var e = nm.BuildNodeShapeChangedEvent(node);
|
||||
|
||||
e.ShouldNotBeNull();
|
||||
e.Changes.ShouldNotBeNull();
|
||||
var changes = e.Changes.Value;
|
||||
changes.Length.ShouldBe(1);
|
||||
changes[0].Affected.ShouldBe(node.NodeId);
|
||||
changes[0].AffectedType.ShouldBe(VariableTypeIds.BaseDataVariableType);
|
||||
changes[0].Verb.ShouldBe((byte)ModelChangeStructureVerbMask.DataTypeChanged);
|
||||
|
||||
await host.DisposeAsync();
|
||||
}
|
||||
|
||||
private async Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync()
|
||||
{
|
||||
var host = new OpcUaApplicationHost(
|
||||
new OpcUaApplicationHostOptions
|
||||
{
|
||||
ApplicationName = "OtOpcUa.SurgicalShapeTest",
|
||||
ApplicationUri = $"urn:OtOpcUa.SurgicalShapeTest:{Guid.NewGuid():N}",
|
||||
OpcUaPort = AllocateFreePort(),
|
||||
PublicHostname = "localhost",
|
||||
PkiStoreRoot = _pkiRoot,
|
||||
},
|
||||
Microsoft.Extensions.Logging.Abstractions.NullLogger<OpcUaApplicationHost>.Instance);
|
||||
|
||||
var server = new OtOpcUaSdkServer();
|
||||
await host.StartAsync(server, Ct);
|
||||
return (host, server);
|
||||
}
|
||||
|
||||
private static int AllocateFreePort()
|
||||
{
|
||||
using var listener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
|
||||
listener.Stop();
|
||||
return port;
|
||||
}
|
||||
|
||||
/// <summary>Cleans up the PKI root directory.</summary>
|
||||
public void Dispose()
|
||||
{
|
||||
if (Directory.Exists(_pkiRoot))
|
||||
{
|
||||
try { Directory.Delete(_pkiRoot, recursive: true); }
|
||||
catch { /* best-effort cleanup */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user