Joseph Doherty
286 lines
12 KiB
C#
286 lines
12 KiB
C#
using Shouldly;
|
|
using Xunit;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
|
|
|
|
/// <summary>
|
|
/// R2-07 T1 — table-driven tests over <see cref="AddressSpaceChangeClassifier.Classify"/>. The
|
|
/// classifier is a pure function over an <see cref="AddressSpacePlan"/>: it names the delta class the
|
|
/// applier routes each plan through (Empty / AttributeOnly / PureAdd / PureRemove / AddRemoveMix /
|
|
/// Rebuild). First-match-wins per the plan's classification table, with the default-closed
|
|
/// Rebuild safety valve catching every node-affecting change.
|
|
/// </summary>
|
|
public sealed class AddressSpaceChangeClassifierTests
|
|
{
|
|
[Fact]
|
|
public void Empty_plan_classifies_as_Empty()
|
|
{
|
|
AddressSpaceChangeClassifier.Classify(Plan()).ShouldBe(AddressSpaceChangeKind.Empty);
|
|
}
|
|
|
|
// ----- single add class ⇒ PureAdd -----
|
|
|
|
[Fact]
|
|
public void Added_equipment_only_is_PureAdd()
|
|
{
|
|
var plan = Plan(addedEquipment: new[] { Eq("eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
[Fact]
|
|
public void Added_alarm_only_is_PureAdd()
|
|
{
|
|
var plan = Plan(addedAlarms: new[] { Alarm("alm-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
[Fact]
|
|
public void Added_equipment_tag_only_is_PureAdd()
|
|
{
|
|
var plan = Plan(addedTags: new[] { Tag("tag-1", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
[Fact]
|
|
public void Added_virtual_tag_only_is_PureAdd()
|
|
{
|
|
var plan = Plan(addedVtags: new[] { Vtag("vt-1", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
// ----- single remove class ⇒ PureRemove -----
|
|
|
|
[Fact]
|
|
public void Removed_equipment_only_is_PureRemove()
|
|
{
|
|
var plan = Plan(removedEquipment: new[] { Eq("eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureRemove);
|
|
}
|
|
|
|
[Fact]
|
|
public void Removed_alarm_only_is_PureRemove()
|
|
{
|
|
var plan = Plan(removedAlarms: new[] { Alarm("alm-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureRemove);
|
|
}
|
|
|
|
[Fact]
|
|
public void Removed_equipment_tag_only_is_PureRemove()
|
|
{
|
|
var plan = Plan(removedTags: new[] { Tag("tag-1", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureRemove);
|
|
}
|
|
|
|
[Fact]
|
|
public void Removed_virtual_tag_only_is_PureRemove()
|
|
{
|
|
var plan = Plan(removedVtags: new[] { Vtag("vt-1", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureRemove);
|
|
}
|
|
|
|
// ----- add AND remove ⇒ AddRemoveMix -----
|
|
|
|
[Fact]
|
|
public void Add_and_remove_is_AddRemoveMix()
|
|
{
|
|
var plan = Plan(addedTags: new[] { Tag("tag-1", "eq-1") }, removedTags: new[] { Tag("tag-2", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AddRemoveMix);
|
|
}
|
|
|
|
[Fact]
|
|
public void Add_equipment_and_remove_vtag_is_AddRemoveMix()
|
|
{
|
|
var plan = Plan(addedEquipment: new[] { Eq("eq-2") }, removedVtags: new[] { Vtag("vt-1", "eq-1") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AddRemoveMix);
|
|
}
|
|
|
|
// ----- node-affecting change ⇒ Rebuild -----
|
|
|
|
[Fact]
|
|
public void Changed_equipment_is_Rebuild()
|
|
{
|
|
var plan = Plan(changedEquipment: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentDelta(Eq("eq-1"), Eq("eq-1") with { DisplayName = "New" }),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.Rebuild);
|
|
}
|
|
|
|
[Fact]
|
|
public void Changed_alarm_is_Rebuild()
|
|
{
|
|
var plan = Plan(changedAlarms: new[]
|
|
{
|
|
new AddressSpacePlan.AlarmDelta(Alarm("alm-1"), Alarm("alm-1") with { MessageTemplate = "changed" }),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.Rebuild);
|
|
}
|
|
|
|
[Fact]
|
|
public void Non_surgical_changed_tag_is_Rebuild()
|
|
{
|
|
// FullName re-routes the node to a different driver point ⇒ NOT surgical-eligible ⇒ Rebuild.
|
|
var plan = Plan(changedTags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentTagDelta(
|
|
Tag("tag-1", "eq-1", fullName: "40001"),
|
|
Tag("tag-1", "eq-1", fullName: "40002")),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.Rebuild);
|
|
}
|
|
|
|
[Fact]
|
|
public void Node_relevant_changed_vtag_is_Rebuild()
|
|
{
|
|
// Name change re-derives the NodeId ⇒ node-relevant ⇒ Rebuild.
|
|
var plan = Plan(changedVtags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentVirtualTagDelta(
|
|
Vtag("vt-1", "eq-1", name: "A"),
|
|
Vtag("vt-1", "eq-1", name: "B")),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.Rebuild);
|
|
}
|
|
|
|
// ----- surgical-only / rename-only / driver-only ⇒ AttributeOnly -----
|
|
|
|
[Fact]
|
|
public void Surgical_eligible_changed_tag_only_is_AttributeOnly()
|
|
{
|
|
// Only Writable flips ⇒ surgical-eligible ⇒ AttributeOnly (no adds, no removes).
|
|
var plan = Plan(changedTags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentTagDelta(
|
|
Tag("tag-1", "eq-1", writable: false),
|
|
Tag("tag-1", "eq-1", writable: true)),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AttributeOnly);
|
|
}
|
|
|
|
[Fact]
|
|
public void Node_irrelevant_changed_vtag_only_is_AttributeOnly()
|
|
{
|
|
// Only Expression differs ⇒ node-irrelevant ⇒ AttributeOnly.
|
|
var plan = Plan(changedVtags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentVirtualTagDelta(
|
|
Vtag("vt-1", "eq-1", expression: "a"),
|
|
Vtag("vt-1", "eq-1", expression: "a * 2")),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AttributeOnly);
|
|
}
|
|
|
|
[Fact]
|
|
public void Folder_renames_only_is_AttributeOnly()
|
|
{
|
|
var plan = Plan(renamedFolders: new[] { new AddressSpacePlan.FolderRename("area-1", "New Area") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AttributeOnly);
|
|
}
|
|
|
|
[Fact]
|
|
public void Driver_only_deltas_are_AttributeOnly_node_inert()
|
|
{
|
|
// Driver adds/removes/changes never touch the address space — excluded from hasAdds/hasRemoves.
|
|
var plan = Plan(
|
|
addedDrivers: new[] { new DriverInstancePlan("d-1", "Modbus", "{}") },
|
|
removedDrivers: new[] { new DriverInstancePlan("d-2", "Modbus", "{}") },
|
|
changedDrivers: new[]
|
|
{
|
|
new AddressSpacePlan.DriverDelta(
|
|
new DriverInstancePlan("d-3", "Modbus", "{\"v\":1}"),
|
|
new DriverInstancePlan("d-3", "Modbus", "{\"v\":2}")),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.AttributeOnly);
|
|
}
|
|
|
|
// ----- mixed-with-surgical: adds still win over coincident surgical changes -----
|
|
|
|
[Fact]
|
|
public void Adds_with_coincident_surgical_change_is_PureAdd()
|
|
{
|
|
var plan = Plan(
|
|
addedTags: new[] { Tag("tag-new", "eq-1") },
|
|
changedTags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentTagDelta(
|
|
Tag("tag-1", "eq-1", writable: false),
|
|
Tag("tag-1", "eq-1", writable: true)),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
[Fact]
|
|
public void Adds_with_coincident_non_surgical_change_is_Rebuild()
|
|
{
|
|
// Rule 2 (node-affecting change) is evaluated BEFORE the add/remove split, so a non-surgical
|
|
// change forces Rebuild even alongside pure adds.
|
|
var plan = Plan(
|
|
addedTags: new[] { Tag("tag-new", "eq-1") },
|
|
changedTags: new[]
|
|
{
|
|
new AddressSpacePlan.EquipmentTagDelta(
|
|
Tag("tag-1", "eq-1", fullName: "40001"),
|
|
Tag("tag-1", "eq-1", fullName: "40002")),
|
|
});
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.Rebuild);
|
|
}
|
|
|
|
[Fact]
|
|
public void Adds_with_coincident_folder_rename_is_PureAdd()
|
|
{
|
|
var plan = Plan(
|
|
addedTags: new[] { Tag("tag-new", "eq-1") },
|
|
renamedFolders: new[] { new AddressSpacePlan.FolderRename("area-1", "New Area") });
|
|
AddressSpaceChangeClassifier.Classify(plan).ShouldBe(AddressSpaceChangeKind.PureAdd);
|
|
}
|
|
|
|
// ----- construction helpers -----
|
|
|
|
private static EquipmentNode Eq(string id) => new(id, id, "line-1");
|
|
|
|
private static ScriptedAlarmPlan Alarm(string id) => new(id, "eq-1", "scr-1", "msg");
|
|
|
|
private static EquipmentTagPlan Tag(string id, string equipmentId, string fullName = "40001", bool writable = false) =>
|
|
new(id, equipmentId, "drv", FolderPath: "", Name: "Speed", DataType: "Float", FullName: fullName, Writable: writable, Alarm: null);
|
|
|
|
private static EquipmentVirtualTagPlan Vtag(string id, string equipmentId, string name = "Efficiency", string expression = "ctx.GetTag(\"a\")") =>
|
|
new(id, equipmentId, FolderPath: "", Name: name, DataType: "Float64", Expression: expression, DependencyRefs: new[] { "a" });
|
|
|
|
private static AddressSpacePlan Plan(
|
|
IReadOnlyList<EquipmentNode>? addedEquipment = null,
|
|
IReadOnlyList<EquipmentNode>? removedEquipment = null,
|
|
IReadOnlyList<AddressSpacePlan.EquipmentDelta>? changedEquipment = null,
|
|
IReadOnlyList<DriverInstancePlan>? addedDrivers = null,
|
|
IReadOnlyList<DriverInstancePlan>? removedDrivers = null,
|
|
IReadOnlyList<AddressSpacePlan.DriverDelta>? changedDrivers = null,
|
|
IReadOnlyList<ScriptedAlarmPlan>? addedAlarms = null,
|
|
IReadOnlyList<ScriptedAlarmPlan>? removedAlarms = null,
|
|
IReadOnlyList<AddressSpacePlan.AlarmDelta>? changedAlarms = null,
|
|
IReadOnlyList<EquipmentTagPlan>? addedTags = null,
|
|
IReadOnlyList<EquipmentTagPlan>? removedTags = null,
|
|
IReadOnlyList<AddressSpacePlan.EquipmentTagDelta>? changedTags = null,
|
|
IReadOnlyList<EquipmentVirtualTagPlan>? addedVtags = null,
|
|
IReadOnlyList<EquipmentVirtualTagPlan>? removedVtags = null,
|
|
IReadOnlyList<AddressSpacePlan.EquipmentVirtualTagDelta>? changedVtags = null,
|
|
IReadOnlyList<AddressSpacePlan.FolderRename>? renamedFolders = null) =>
|
|
new(
|
|
addedEquipment ?? Array.Empty<EquipmentNode>(),
|
|
removedEquipment ?? Array.Empty<EquipmentNode>(),
|
|
changedEquipment ?? Array.Empty<AddressSpacePlan.EquipmentDelta>(),
|
|
addedDrivers ?? Array.Empty<DriverInstancePlan>(),
|
|
removedDrivers ?? Array.Empty<DriverInstancePlan>(),
|
|
changedDrivers ?? Array.Empty<AddressSpacePlan.DriverDelta>(),
|
|
addedAlarms ?? Array.Empty<ScriptedAlarmPlan>(),
|
|
removedAlarms ?? Array.Empty<ScriptedAlarmPlan>(),
|
|
changedAlarms ?? Array.Empty<AddressSpacePlan.AlarmDelta>())
|
|
{
|
|
AddedEquipmentTags = addedTags ?? Array.Empty<EquipmentTagPlan>(),
|
|
RemovedEquipmentTags = removedTags ?? Array.Empty<EquipmentTagPlan>(),
|
|
ChangedEquipmentTags = changedTags ?? Array.Empty<AddressSpacePlan.EquipmentTagDelta>(),
|
|
AddedEquipmentVirtualTags = addedVtags ?? Array.Empty<EquipmentVirtualTagPlan>(),
|
|
RemovedEquipmentVirtualTags = removedVtags ?? Array.Empty<EquipmentVirtualTagPlan>(),
|
|
ChangedEquipmentVirtualTags = changedVtags ?? Array.Empty<AddressSpacePlan.EquipmentVirtualTagDelta>(),
|
|
RenamedFolders = renamedFolders ?? Array.Empty<AddressSpacePlan.FolderRename>(),
|
|
};
|
|
}
|