fix(tagconfig): close the four #551 residuals — accept-gate-first Inspect, three authoring rules, CSV/service gate, doc sweep
Gitea #551. 1. CSV import ran no driver-typed config gate. Its typed columns were always strictly parsed, but the free-form TagConfigJson column reached the database unread, so a CSV could author a tag the driver rejects — one that deploys green and reads BadNodeIdUnknown forever. RawTagCsvMapper.Parse now names the offending row in the staged review grid, and RawTreeService enforces the same gate on CreateTag/UpdateTag/ImportTags: a form cannot be the guarantee (the API and any future caller reach none of them, and this repo has no bUnit). A rejected import row is an ERROR — the batch inserts nothing and the row is named — never a skip. Note the brief's premise that manual entry rides ImportTagsAsync is wrong: RawManualTagEntryModal commits row-by-row via CreateTagAsync, which is why the gate had to land on all three write paths. 2/3. The seven pre-#549 Inspect methods ran a hand-list of DescribeInvalidEnum checks, so every rejection cause not on the list was invisible. They are now ACCEPT-GATE-FIRST (the MTConnect/Sql/OpcUaClient/Calculation shape): ask the driver's own reader for the verdict, then explain the refusal, with a catch-all so "the parse rejects but Inspect said nothing" is unreachable. That closes S7's absent dataType, AbCip members[], Modbus stringByteOrder and the type-dependent guards, plus causes the issue did not name (absent region/address/tagPath/symbolPath/topic, TwinCAT Structure, MQTT's Sparkplug tuple). FOCAS and MQTT keep advisories about ACCEPTED blobs, so they diagnose rather than return empty. Authoring half: ModbusTagConfigModel gains stringByteOrder; AbCipTagConfigModel asks the new AbCipTagDefinitionFactory.DescribeInvalidMember; S7TagConfigModel captures whether the SOURCE blob declared dataType and asks S7TagDefinitionFactory.DataTypeKey/DeclaresDataType. One authority per rule. 4. Doc sweep: the six factory Inspect summaries, EquipmentTagConfigInspector's class remarks and AdminOperationsActor's comment all claimed invalid enums are "silently defaulted by the lenient runtime" — false since R2-11 Phase C made the runtime reads strict. They describe rejections now.
This commit is contained in:
Joseph Doherty
@@ -0,0 +1,100 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551 item 3: <see cref="AbCipTagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> — it
|
||||
/// asks <see cref="AbCipTagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a
|
||||
/// refusal. See <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter,
|
||||
/// never silent) are pinned.
|
||||
/// <para>
|
||||
/// AbCip's uncovered surface was the declared-UDT <c>members</c> array: the mapper rejects the WHOLE
|
||||
/// tag for one member with no <c>name</c> or a typo'd <c>dataType</c>, but neither this gate nor the
|
||||
/// AdminUI editor (which emits only <c>tagPath</c>/<c>dataType</c>/<c>writable</c> and carries
|
||||
/// <c>members</c> through its preserved key bag) ever looked.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class AbCipInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/abcip/dev1/T1";
|
||||
|
||||
/// <summary>Blobs the mapper ACCEPTS — the gate must say nothing about any of them.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
"""{"tagPath":"Program:Main.Speed","dataType":"DInt"}""",
|
||||
"""{"tagPath":"Speed"}""",
|
||||
"""{"tagPath":"Motor","dataType":"Structure","members":[{"name":"Run","dataType":"Bool"}]}""",
|
||||
// members present but not an ARRAY is ignored by the mapper, so it must be ignored here too.
|
||||
"""{"tagPath":"Speed","members":{"name":"Run"}}""",
|
||||
"""{"tagPath":"Speed","members":[]}""",
|
||||
// A member's writable / writeIdempotent / array keys are all optional.
|
||||
"""{"tagPath":"Motor","members":[{"name":"Run"}]}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"dataType":"DInt"}""", // no tagPath
|
||||
"""{"tagPath":"","dataType":"DInt"}""", // blank tagPath
|
||||
"""{"tagPath":123}""", // tagPath not a string
|
||||
"""{"tagPath":"Speed","dataType":"DIntt"}""", // typo'd top-level dataType
|
||||
"""{"tagPath":"Motor","members":[{"dataType":"Bool"}]}""", // member with no name
|
||||
"""{"tagPath":"Motor","members":[{"name":" ","dataType":"Bool"}]}""", // member with a blank name
|
||||
"""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Booll"}]}""", // typo'd member dataType
|
||||
"""{"tagPath":"Motor","members":["Run"]}""", // member not an object
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
AbCipTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
AbCipTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
AbCipTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
AbCipTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_absent_tagPath_is_named()
|
||||
=> AbCipTagDefinitionFactory.Inspect("""{"dataType":"DInt"}""")
|
||||
.ShouldContain(w => w.Contains("'tagPath'"));
|
||||
|
||||
[Fact]
|
||||
public void A_typo_in_a_member_dataType_is_named_with_its_index()
|
||||
=> AbCipTagDefinitionFactory.Inspect(
|
||||
"""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Bool"},{"name":"Speed","dataType":"Reall"}]}""")
|
||||
.ShouldContain(w => w.Contains("members[1]") && w.Contains("Reall"));
|
||||
|
||||
[Fact]
|
||||
public void A_member_with_no_name_is_named_with_its_index()
|
||||
=> AbCipTagDefinitionFactory.Inspect("""{"tagPath":"Motor","members":[{"dataType":"Bool"}]}""")
|
||||
.ShouldContain(w => w.Contains("members[0]") && w.Contains("name"));
|
||||
|
||||
// ---- DescribeInvalidMember is the shared authority the AdminUI model asks (one rule, two doors) ----
|
||||
|
||||
[Theory]
|
||||
[InlineData("""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Bool"}]}""", false)]
|
||||
[InlineData("""{"tagPath":"Motor"}""", false)]
|
||||
[InlineData("""{"tagPath":"Motor","members":[]}""", false)]
|
||||
[InlineData("""{"tagPath":"Motor","members":{"name":"Run"}}""", false)]
|
||||
[InlineData("not json at all", false)]
|
||||
[InlineData("""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Booll"}]}""", true)]
|
||||
[InlineData("""{"tagPath":"Motor","members":[{"dataType":"Bool"}]}""", true)]
|
||||
public void DescribeInvalidMember_over_a_string_matches_the_mapper(string tagConfig, bool expectWarning)
|
||||
=> (AbCipTagDefinitionFactory.DescribeInvalidMember(tagConfig) is not null).ShouldBe(expectWarning);
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> AbCipTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> AbCipTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551: <see cref="AbLegacyTagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> — it asks
|
||||
/// <see cref="AbLegacyTagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a refusal.
|
||||
/// See <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter, never
|
||||
/// silent) are pinned.
|
||||
/// </summary>
|
||||
public sealed class AbLegacyInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/ablegacy/dev1/T1";
|
||||
|
||||
/// <summary>Blobs the mapper ACCEPTS — the gate must say nothing about any of them.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
"""{"address":"N7:0","dataType":"Int"}""",
|
||||
"""{"address":"B3:1/2"}""",
|
||||
"""{"address":"F8:5","dataType":"Float","isArray":true,"arrayLength":10}""",
|
||||
// An over-long array is CLAMPED by the mapper, not rejected — so the gate must stay silent, even
|
||||
// though the AdminUI model refuses it (the un-clamped length also sets OPC UA ArrayDimensions).
|
||||
"""{"address":"F8:5","dataType":"Float","isArray":true,"arrayLength":9999}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"dataType":"Int"}""", // no address
|
||||
"""{"address":"","dataType":"Int"}""", // blank address
|
||||
"""{"address":7,"dataType":"Int"}""", // address not a string
|
||||
"""{"address":"N7:0","dataType":"Intt"}""", // typo'd dataType
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
AbLegacyTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
AbLegacyTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
AbLegacyTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
AbLegacyTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_absent_address_is_named()
|
||||
=> AbLegacyTagDefinitionFactory.Inspect("""{"dataType":"Int"}""")
|
||||
.ShouldContain(w => w.Contains("'address'"));
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> AbLegacyTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> AbLegacyTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551: <see cref="FocasTagDefinitionFactory.Inspect"/> gained an accept gate for its
|
||||
/// <b>rejection</b> diagnosis — see <c>ModbusInspectAcceptGateTests</c>'s remarks for why both
|
||||
/// directions are pinned.
|
||||
/// <para>
|
||||
/// FOCAS is the one factory that deliberately does NOT return empty on accept: two of its warnings
|
||||
/// are <b>advisories</b> about blobs the mapper ACCEPTS but the driver still cannot serve as
|
||||
/// authored — an unparseable FOCAS address (#540, dropped at the driver's own init) and an authored
|
||||
/// <c>writable:true</c> (the wire is read-only). Folding FOCAS into the plain "accept ⇒ empty"
|
||||
/// shape would have silently deleted both, so they are pinned here alongside the new rejections.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class FocasInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/focas/dev1/T1";
|
||||
|
||||
/// <summary>Blobs the mapper ACCEPTS <b>and</b> that carry no advisory — the gate must be silent.</summary>
|
||||
public static TheoryData<string> CleanAndAccepted() =>
|
||||
[
|
||||
"""{"address":"R100","dataType":"Int32"}""",
|
||||
"""{"address":"X0.0","dataType":"Bit"}""",
|
||||
"""{"address":"PARAM:1020"}""",
|
||||
"""{"address":"FIXED:Identity/SeriesNumber","dataType":"String"}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"dataType":"Int32"}""", // no address
|
||||
"""{"address":"","dataType":"Int32"}""", // blank address
|
||||
"""{"address":100}""", // address not a string
|
||||
"""{"address":"R100","dataType":"Intt32"}""", // typo'd dataType
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(CleanAndAccepted))]
|
||||
public void A_clean_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
FocasTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
FocasTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
FocasTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
FocasTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_absent_address_is_named()
|
||||
=> FocasTagDefinitionFactory.Inspect("""{"dataType":"Int32"}""")
|
||||
.ShouldContain(w => w.Contains("'address'"));
|
||||
|
||||
// ---- The two advisories the accept gate must NOT swallow ----
|
||||
|
||||
[Fact]
|
||||
public void An_unparseable_address_still_warns_even_though_the_mapper_accepts_it()
|
||||
{
|
||||
const string Blob = """{"address":"not-an-address","dataType":"Int32"}""";
|
||||
FocasTagDefinitionFactory.FromTagConfig(Blob, RawPath, out _).ShouldBeTrue("the mapper accepts any non-blank address");
|
||||
FocasTagDefinitionFactory.Inspect(Blob).ShouldContain(w => w.Contains("not parseable"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_authored_writable_still_warns_even_though_the_mapper_accepts_it()
|
||||
{
|
||||
const string Blob = """{"address":"R100","dataType":"Int32","writable":true}""";
|
||||
FocasTagDefinitionFactory.FromTagConfig(Blob, RawPath, out _).ShouldBeTrue("the mapper accepts writable:true");
|
||||
FocasTagDefinitionFactory.Inspect(Blob).ShouldContain(w => w.Contains("read-only"));
|
||||
}
|
||||
|
||||
/// <summary>A rejected blob still gets its advisories — the two diagnoses are independent.</summary>
|
||||
[Fact]
|
||||
public void A_rejected_config_reports_the_rejection_and_the_advisory_together()
|
||||
{
|
||||
var warnings = FocasTagDefinitionFactory.Inspect(
|
||||
"""{"address":"not-an-address","dataType":"Intt32","writable":true}""");
|
||||
|
||||
warnings.ShouldContain(w => w.Contains("dataType"));
|
||||
warnings.ShouldContain(w => w.Contains("not parseable"));
|
||||
warnings.ShouldContain(w => w.Contains("read-only"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> FocasTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> FocasTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551 items 2/3: <see cref="ModbusTagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> —
|
||||
/// it asks <see cref="ModbusTagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a
|
||||
/// refusal.
|
||||
/// <para>
|
||||
/// Two properties, and they pull in opposite directions, which is why both are pinned here. The
|
||||
/// gate must never be <b>stricter</b> than the mapper (a warning can be promoted to a blocking
|
||||
/// deploy error by <c>TagConfigValidationMode.Error</c>, so a warning on a blob the driver serves
|
||||
/// would refuse a working config); and it must never be <b>silent</b> on a blob the mapper refuses
|
||||
/// (that tag deploys green and then reads <c>BadNodeIdUnknown</c> forever). The previous hand-list
|
||||
/// of enum checks satisfied the first and failed the second for every cause not on the list —
|
||||
/// an absent <c>region</c>, a bad <c>address</c>, <c>stringByteOrder</c>, and the two
|
||||
/// type-dependent guards.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class ModbusInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/modbus/dev1/T1";
|
||||
private const string Clean = """{"region":"HoldingRegisters","address":1,"dataType":"Int16"}""";
|
||||
|
||||
/// <summary>Every blob below is one the mapper ACCEPTS, so the gate must say nothing about it.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
Clean,
|
||||
"""{"region":"Coils","address":0,"dataType":"Bool"}""",
|
||||
"""{"region":"HoldingRegisters","address":65535,"dataType":"String","stringLength":10,"stringByteOrder":"LowByteFirst"}""",
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"BitInRegister","bitIndex":15}""",
|
||||
// The byte/ushort NARROWING is part of the mapper's rule: bitIndex 256 truncates to bit 0 and is
|
||||
// ACCEPTED. A gate that described the un-narrowed value would refuse a tag the driver serves.
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"BitInRegister","bitIndex":256}""",
|
||||
// A non-string enum token reads as ABSENT, not invalid — the mapper accepts it as the default.
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":3}""",
|
||||
];
|
||||
|
||||
/// <summary>Every blob below is one the mapper REJECTS, so the gate must produce at least one warning.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"address":1,"dataType":"Int16"}""", // no region
|
||||
"""{"region":"HoldingRegisters","dataType":"Int16"}""", // no address
|
||||
"""{"region":"HoldingRegisters","address":-1,"dataType":"Int16"}""", // address < 0
|
||||
"""{"region":"HoldingRegisters","address":65536,"dataType":"Int16"}""", // address > ushort
|
||||
"""{"region":"HoldingRegisters","address":"1","dataType":"Int16"}""", // address not a number
|
||||
"""{"region":"HoldingRegisterz","address":1,"dataType":"Int16"}""", // typo'd region
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"Intt16"}""", // typo'd dataType
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"Int16","byteOrder":"Bigg"}""", // typo'd byteOrder
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"Nope"}""", // typo'd stringByteOrder
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"String"}""", // String with no length
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"BitInRegister","bitIndex":16}""", // bit out of range
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
ModbusTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
ModbusTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
ModbusTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
ModbusTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
// ---- The specific causes the issue named, each with a message that points at the right key ----
|
||||
|
||||
[Fact]
|
||||
public void An_absent_region_is_named()
|
||||
=> ModbusTagDefinitionFactory.Inspect("""{"address":1,"dataType":"Int16"}""")
|
||||
.ShouldContain(w => w.Contains("'region'"));
|
||||
|
||||
[Fact]
|
||||
public void An_out_of_range_address_is_named()
|
||||
=> ModbusTagDefinitionFactory.Inspect("""{"region":"Coils","address":70000,"dataType":"Int16"}""")
|
||||
.ShouldContain(w => w.Contains("'address'"));
|
||||
|
||||
/// <summary>Gitea #551 item 3: read strictly by the mapper since R2-11, checked by nothing until now.</summary>
|
||||
[Fact]
|
||||
public void A_typo_in_stringByteOrder_is_named()
|
||||
=> ModbusTagDefinitionFactory.Inspect(
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"HighByteFrist"}""")
|
||||
.ShouldContain(w => w.Contains("stringByteOrder") && w.Contains("HighByteFrist"));
|
||||
|
||||
[Fact]
|
||||
public void A_String_tag_with_no_stringLength_is_named()
|
||||
=> ModbusTagDefinitionFactory.Inspect("""{"region":"HoldingRegisters","address":1,"dataType":"String"}""")
|
||||
.ShouldContain(w => w.Contains("stringLength"));
|
||||
|
||||
[Fact]
|
||||
public void A_BitInRegister_tag_with_a_bit_over_15_is_named()
|
||||
=> ModbusTagDefinitionFactory.Inspect(
|
||||
"""{"region":"HoldingRegisters","address":1,"dataType":"BitInRegister","bitIndex":16}""")
|
||||
.ShouldContain(w => w.Contains("bitIndex"));
|
||||
|
||||
// ---- Framing rules preserved from the pre-#551 shape ----
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> ModbusTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
/// <summary>
|
||||
/// The pre-existing framing convention, deliberately left alone by #551 and shared by all eleven
|
||||
/// inspectors: a reference that does not START with <c>{</c> is not an equipment-tag TagConfig at
|
||||
/// all, so it draws nothing — even though the mapper would refuse it. Widening this is a separate
|
||||
/// decision about what a TagConfig IS, not about how a refusal is explained.
|
||||
/// </summary>
|
||||
/// <param name="reference">The non-object reference.</param>
|
||||
[Theory]
|
||||
[InlineData("just a string")]
|
||||
[InlineData("[1,2,3]")]
|
||||
[InlineData("42")]
|
||||
public void A_non_object_reference_draws_nothing_because_it_is_not_a_TagConfig(string reference)
|
||||
{
|
||||
ModbusTagDefinitionFactory.FromTagConfig(reference, RawPath, out _).ShouldBeFalse();
|
||||
ModbusTagDefinitionFactory.Inspect(reference).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> ModbusTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Mqtt.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551: <see cref="MqttTagDefinitionFactory.Inspect"/> gained an accept gate — see
|
||||
/// <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter, never silent)
|
||||
/// are pinned.
|
||||
/// <para>
|
||||
/// MQTT's gate is the <b>UNION</b> of its two mappers, because <c>Inspect</c> is handed a blob with
|
||||
/// no mode: the driver's <c>MqttMode</c> decides whether
|
||||
/// <see cref="MqttTagDefinitionFactory.FromTagConfig"/> or
|
||||
/// <see cref="MqttTagDefinitionFactory.FromSparkplugTagConfig"/> reads it, and nothing on a tag row
|
||||
/// says which. Gating on the Plain mapper alone would warn that every correctly-authored Sparkplug
|
||||
/// tag has no topic — the falsification control below is exactly that case.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class MqttInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/mqtt/dev1/T1";
|
||||
|
||||
private static bool EitherModeAccepts(string tagConfig)
|
||||
=> MqttTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _)
|
||||
|| MqttTagDefinitionFactory.FromSparkplugTagConfig(tagConfig, RawPath, out _);
|
||||
|
||||
/// <summary>Blobs at least one mapper ACCEPTS, with no wildcard advisory — the gate must be silent.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
"""{"topic":"plant/line1/temp"}""",
|
||||
"""{"topic":"plant/line1/temp","payloadFormat":"Json","dataType":"Float64","qos":1}""",
|
||||
// Sparkplug: no topic at all, and that is CORRECT — the control this whole union exists for.
|
||||
"""{"groupId":"OtOpcUaSim","edgeNodeId":"EdgeA","metricName":"Temp"}""",
|
||||
"""{"groupId":"OtOpcUaSim","edgeNodeId":"EdgeA","deviceId":"Filler1","metricName":"Node Control/Rebirth"}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs NEITHER mapper accepts — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"{}", // no address of either shape
|
||||
"""{"payloadFormat":"Json","dataType":"String"}""", // still no address
|
||||
"""{"groupId":"G","edgeNodeId":"E"}""", // incomplete Sparkplug tuple
|
||||
"""{"topic":"a/b","payloadFormat":"Jsonn"}""", // typo'd payloadFormat
|
||||
"""{"topic":"a/b","dataType":"Flooat64"}""", // typo'd dataType
|
||||
"""{"topic":"a/b","qos":5}""", // out-of-range qos
|
||||
"""{"groupId":"G","edgeNodeId":"E","metricName":"M","qos":"high"}""", // non-numeric qos, both modes
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_a_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
EitherModeAccepts(tagConfig).ShouldBeTrue("fixture must be accepted by at least one mode");
|
||||
MqttTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_neither_mapper_accepts_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
EitherModeAccepts(tagConfig).ShouldBeFalse("fixture must be rejected by both modes");
|
||||
MqttTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_blob_with_no_address_of_either_shape_names_both()
|
||||
{
|
||||
var warnings = MqttTagDefinitionFactory.Inspect("{}");
|
||||
warnings.ShouldContain(w => w.Contains("topic") && w.Contains("metricName"));
|
||||
}
|
||||
|
||||
/// <summary>The wildcard advisory is about an ACCEPTED blob, so the accept gate must not swallow it.</summary>
|
||||
[Fact]
|
||||
public void A_wildcard_topic_still_warns_even_though_the_mapper_accepts_it()
|
||||
{
|
||||
const string Blob = """{"topic":"plant/+/temp"}""";
|
||||
MqttTagDefinitionFactory.FromTagConfig(Blob, RawPath, out _).ShouldBeTrue("a wildcard topic is accepted on purpose");
|
||||
MqttTagDefinitionFactory.Inspect(Blob).ShouldContain(w => w.Contains("wildcard"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> MqttTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> MqttTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.S7.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551 item 2: <see cref="S7TagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> — it asks
|
||||
/// <see cref="S7TagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a refusal. See
|
||||
/// <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter, never silent)
|
||||
/// are pinned.
|
||||
/// <para>
|
||||
/// S7 carries the fleet's one unique rule: the reader REQUIRES the <c>dataType</c> key to be
|
||||
/// present. A blob with only an <c>address</c> therefore deploys green and reads
|
||||
/// <c>BadNodeIdUnknown</c> forever — and neither this gate nor the AdminUI model said a word about
|
||||
/// it until #551.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class S7InspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/s7/dev1/T1";
|
||||
|
||||
/// <summary>Blobs the mapper ACCEPTS — the gate must say nothing about any of them.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
"""{"address":"DB1.DBW0","dataType":"Int16"}""",
|
||||
"""{"address":"M0.0","dataType":"Bool"}""",
|
||||
"""{"address":"DB1.DBB0","dataType":"String","stringLength":254}""",
|
||||
// stringLength is irrelevant to a non-String tag, so an out-of-range remnant is ACCEPTED.
|
||||
"""{"address":"DB1.DBW0","dataType":"Int16","stringLength":9999}""",
|
||||
// A non-string dataType token satisfies the PRESENCE rule and then reads as absent ⇒ Int16.
|
||||
"""{"address":"DB1.DBW0","dataType":7}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"dataType":"Int16"}""", // no address
|
||||
"""{"address":"","dataType":"Int16"}""", // blank address
|
||||
"""{"address":123,"dataType":"Int16"}""", // address not a string
|
||||
"""{"address":"DB1.DBW0"}""", // no dataType key at all (#551)
|
||||
"""{"address":"DB1.DBW0","dataType":"Intt16"}""", // typo'd dataType
|
||||
"""{"address":"DB1.DBB0","dataType":"String","stringLength":255}""", // over the 254 S7 limit
|
||||
"""{"address":"DB1.DBB0","dataType":"String","stringLength":-1}""", // negative length
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
S7TagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
S7TagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
S7TagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
S7TagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
/// <summary>The headline case: present-and-typo'd was reported; ABSENT was not (Gitea #551 item 2).</summary>
|
||||
[Fact]
|
||||
public void An_absent_dataType_is_named()
|
||||
=> S7TagDefinitionFactory.Inspect("""{"address":"DB1.DBW0"}""")
|
||||
.ShouldContain(w => w.Contains("no 'dataType'"));
|
||||
|
||||
[Fact]
|
||||
public void An_absent_address_is_named()
|
||||
=> S7TagDefinitionFactory.Inspect("""{"dataType":"Int16"}""")
|
||||
.ShouldContain(w => w.Contains("'address'"));
|
||||
|
||||
[Fact]
|
||||
public void An_out_of_range_string_length_is_named()
|
||||
=> S7TagDefinitionFactory.Inspect("""{"address":"DB1.DBB0","dataType":"String","stringLength":255}""")
|
||||
.ShouldContain(w => w.Contains("stringLength"));
|
||||
|
||||
// ---- DeclaresDataType is the shared authority the AdminUI model asks (one rule, two doors) ----
|
||||
|
||||
[Theory]
|
||||
[InlineData("""{"dataType":"Int16"}""", true)]
|
||||
[InlineData("""{"dataType":7}""", true)] // presence is judged on the KEY, not the value
|
||||
[InlineData("""{"dataType":null}""", true)]
|
||||
[InlineData("""{"address":"DB1.DBW0"}""", false)]
|
||||
public void DeclaresDataType_judges_the_key_not_the_value(string tagConfig, bool expected)
|
||||
{
|
||||
using var doc = System.Text.Json.JsonDocument.Parse(tagConfig);
|
||||
S7TagDefinitionFactory.DeclaresDataType(doc.RootElement).ShouldBe(expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> S7TagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> S7TagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551: <see cref="TwinCATTagDefinitionFactory.Inspect"/> is <b>accept-gate-first</b> — it asks
|
||||
/// <see cref="TwinCATTagDefinitionFactory.FromTagConfig"/> for the verdict and only explains a refusal.
|
||||
/// See <c>ModbusInspectAcceptGateTests</c>'s remarks for why both directions (never stricter, never
|
||||
/// silent) are pinned. TwinCAT's uncovered rejections were an absent <c>symbolPath</c> and the
|
||||
/// unsupported <c>Structure</c> data type — a VALID enum name that the mapper still refuses.
|
||||
/// </summary>
|
||||
public sealed class TwinCATInspectAcceptGateTests
|
||||
{
|
||||
private const string RawPath = "cell/twincat/dev1/T1";
|
||||
|
||||
/// <summary>Blobs the mapper ACCEPTS — the gate must say nothing about any of them.</summary>
|
||||
public static TheoryData<string> Accepted() =>
|
||||
[
|
||||
"""{"symbolPath":"MAIN.bStart","dataType":"Bool"}""",
|
||||
"""{"symbolPath":"MAIN.nCount"}""",
|
||||
"""{"symbolPath":"MAIN.aData","dataType":"DInt","isArray":true,"arrayLength":8}""",
|
||||
// A stale arrayLength behind a cleared isArray is scalar, not a rejection.
|
||||
"""{"symbolPath":"MAIN.nCount","dataType":"DInt","arrayLength":8}""",
|
||||
];
|
||||
|
||||
/// <summary>Blobs the mapper REJECTS — the gate must produce at least one warning for each.</summary>
|
||||
public static TheoryData<string> Rejected() =>
|
||||
[
|
||||
"""{"dataType":"Bool"}""", // no symbolPath
|
||||
"""{"symbolPath":"","dataType":"Bool"}""", // blank symbolPath
|
||||
"""{"symbolPath":42}""", // symbolPath not a string
|
||||
"""{"symbolPath":"MAIN.x","dataType":"Booll"}""", // typo'd dataType
|
||||
"""{"symbolPath":"MAIN.udt","dataType":"Structure"}""", // valid NAME the driver still refuses
|
||||
];
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Accepted))]
|
||||
public void A_config_the_mapper_accepts_draws_no_warning(string tagConfig)
|
||||
{
|
||||
TwinCATTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeTrue("fixture must be accepted");
|
||||
TwinCATTagDefinitionFactory.Inspect(tagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Rejected))]
|
||||
public void A_config_the_mapper_rejects_is_never_passed_over_in_silence(string tagConfig)
|
||||
{
|
||||
TwinCATTagDefinitionFactory.FromTagConfig(tagConfig, RawPath, out _).ShouldBeFalse("fixture must be rejected");
|
||||
TwinCATTagDefinitionFactory.Inspect(tagConfig).ShouldNotBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_absent_symbolPath_is_named()
|
||||
=> TwinCATTagDefinitionFactory.Inspect("""{"dataType":"Bool"}""")
|
||||
.ShouldContain(w => w.Contains("'symbolPath'"));
|
||||
|
||||
/// <summary>A rejection an enum-spelling check can never see: the NAME parses, the driver still refuses.</summary>
|
||||
[Fact]
|
||||
public void A_Structure_typed_tag_is_named()
|
||||
=> TwinCATTagDefinitionFactory.Inspect("""{"symbolPath":"MAIN.udt","dataType":"Structure"}""")
|
||||
.ShouldContain(w => w.Contains("Structure"));
|
||||
|
||||
[Fact]
|
||||
public void A_blank_reference_draws_nothing()
|
||||
=> TwinCATTagDefinitionFactory.Inspect(" ").ShouldBeEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Unparseable_json_names_the_json()
|
||||
=> TwinCATTagDefinitionFactory.Inspect("{oops").ShouldContain(w => w.Contains("not valid JSON"));
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.AdminUI.Uns;
|
||||
using ZB.MOM.WW.OtOpcUa.AdminUI.Uns.TagEditors;
|
||||
using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
|
||||
using ZB.MOM.WW.OtOpcUa.ControlPlane.AdminOperations;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.AbCip;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Modbus;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.S7;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #551 — the authoring half of the four residuals, and the seam that makes it a guarantee.
|
||||
/// <list type="number">
|
||||
/// <item>
|
||||
/// <b>The CSV import runs the driver-typed gate.</b> Its typed columns were always strictly
|
||||
/// parsed, but the free-form <c>TagConfigJson</c> column reached the database unread. It is
|
||||
/// checked twice on purpose: in <see cref="RawTagCsvMapper.Parse"/> so the staged review grid
|
||||
/// NAMES the offending row before commit, and in <see cref="RawTreeService.ImportTagsAsync"/>
|
||||
/// because a grid cannot cover the API or a future caller — and this repo has no bUnit, so a
|
||||
/// rule only a page enforces is a rule no test can reach. Deleting the service check leaves the
|
||||
/// mapper tests green and turns the service tests red; that asymmetry is the point.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// <b>A rejected row is an ERROR, not a skip.</b> The import is all-or-nothing: nothing is
|
||||
/// inserted and the row is named. "Skipped" would claim the tag is already present.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// <b>Modbus <c>stringByteOrder</c>, AbCip <c>members[].dataType</c> and the S7 absent
|
||||
/// <c>dataType</c></b> — three rules the runtime has always enforced that no authoring surface
|
||||
/// checked.
|
||||
/// </item>
|
||||
/// </list>
|
||||
/// Every rejection below is paired with an acceptance control, so a gate that simply refuses everything
|
||||
/// cannot pass this suite.
|
||||
/// </summary>
|
||||
[Trait("Category", "Unit")]
|
||||
public sealed class RawTagConfigGateTests
|
||||
{
|
||||
// A blob the S7 driver actually reads — RootDeviceId hangs off the seed's S7 driver.
|
||||
private const string GoodS7 = """{"address":"DB1.DBW0","dataType":"Int16"}""";
|
||||
|
||||
private static (RawTreeService Service, string DbName) Seeded()
|
||||
{
|
||||
var name = RawTreeTestDb.SeedFresh();
|
||||
return (new RawTreeService(RawTreeTestDb.Factory(name)), name);
|
||||
}
|
||||
|
||||
private static RawTagInput Tag(string name, string tagConfig) =>
|
||||
new(name, "Float", TagAccessLevel.Read, WriteIdempotent: false, PollGroupId: null, tagConfig);
|
||||
|
||||
// ------------------------------------------------------------------ 1. the AdminUI models (item 2/3)
|
||||
|
||||
/// <summary>Gitea #551 item 3: the runtime reads it strictly; nothing on the authoring side did.</summary>
|
||||
[Fact]
|
||||
public void Modbus_rejects_a_typo_in_stringByteOrder()
|
||||
=> ModbusTagConfigModel
|
||||
.FromJson("""{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"HighByteFrist"}""")
|
||||
.Validate()
|
||||
.ShouldNotBeNullOrEmpty();
|
||||
|
||||
[Fact]
|
||||
public void Modbus_accepts_a_correctly_spelled_stringByteOrder()
|
||||
=> ModbusTagConfigModel
|
||||
.FromJson("""{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"LowByteFirst"}""")
|
||||
.Validate()
|
||||
.ShouldBeNull();
|
||||
|
||||
/// <summary>Gitea #551 item 3: members ride the model's preserved key bag, unread until now.</summary>
|
||||
[Fact]
|
||||
public void AbCip_rejects_a_typo_in_a_member_dataType()
|
||||
=> AbCipTagConfigModel
|
||||
.FromJson("""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Booll"}]}""")
|
||||
.Validate()
|
||||
.ShouldNotBeNullOrEmpty();
|
||||
|
||||
[Fact]
|
||||
public void AbCip_rejects_a_member_with_no_name()
|
||||
=> AbCipTagConfigModel
|
||||
.FromJson("""{"tagPath":"Motor","members":[{"dataType":"Bool"}]}""")
|
||||
.Validate()
|
||||
.ShouldNotBeNullOrEmpty();
|
||||
|
||||
[Fact]
|
||||
public void AbCip_accepts_well_formed_members()
|
||||
=> AbCipTagConfigModel
|
||||
.FromJson("""{"tagPath":"Motor","members":[{"name":"Run","dataType":"Bool"},{"name":"Speed","dataType":"Real"}]}""")
|
||||
.Validate()
|
||||
.ShouldBeNull();
|
||||
|
||||
/// <summary>Gitea #551 item 2: S7 is the only driver whose reader requires the key to be PRESENT.</summary>
|
||||
[Fact]
|
||||
public void S7_rejects_a_config_carrying_no_dataType_key()
|
||||
=> S7TagConfigModel.FromJson("""{"address":"DB1.DBW0"}""").Validate().ShouldNotBeNullOrEmpty();
|
||||
|
||||
[Fact]
|
||||
public void S7_accepts_a_config_carrying_a_dataType_key()
|
||||
=> S7TagConfigModel.FromJson(GoodS7).Validate().ShouldBeNull();
|
||||
|
||||
/// <summary>
|
||||
/// The absent-key rule records a property of the SOURCE blob, so a model built by object initialiser
|
||||
/// — which is what <see cref="RawBrowseCommitMapper"/> does — must validate clean: its
|
||||
/// <c>ToJson()</c> writes the key from the typed field. Getting this backwards would refuse every
|
||||
/// browse-committed S7 tag.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void S7_accepts_a_model_that_was_built_rather_than_loaded()
|
||||
=> new S7TagConfigModel { Address = "DB1.DBW0" }.Validate().ShouldBeNull();
|
||||
|
||||
/// <summary>A load→save through the editor always emits the key, so the round-trip stays authorable.</summary>
|
||||
[Fact]
|
||||
public void S7_round_trip_through_the_model_repairs_a_key_less_blob()
|
||||
{
|
||||
var model = S7TagConfigModel.FromJson("""{"address":"DB1.DBW0"}""");
|
||||
model.Validate().ShouldNotBeNullOrEmpty();
|
||||
|
||||
S7TagConfigModel.FromJson(model.ToJson()).Validate().ShouldBeNull();
|
||||
}
|
||||
|
||||
// ------------------------------- 2. authoring ⇔ deploy-gate parity for the three new rules (item 2/3)
|
||||
|
||||
/// <summary>
|
||||
/// The pairing that matters: a blob the authoring gate refuses must draw a deploy warning, and a blob
|
||||
/// it accepts must draw none. Either direction alone is satisfiable by a broken gate — refuse
|
||||
/// everything, or refuse nothing.
|
||||
/// </summary>
|
||||
/// <param name="driverType">The driver type to dispatch both gates on.</param>
|
||||
/// <param name="tagConfig">The blob under test.</param>
|
||||
/// <param name="expectRejected">Whether both gates should refuse it.</param>
|
||||
[Theory]
|
||||
[InlineData(DriverTypeNames.Modbus, """{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"Nope"}""", true)]
|
||||
[InlineData(DriverTypeNames.Modbus, """{"region":"HoldingRegisters","address":1,"dataType":"Int16","stringByteOrder":"LowByteFirst"}""", false)]
|
||||
[InlineData(DriverTypeNames.AbCip, """{"tagPath":"Motor","members":[{"name":"Run","dataType":"Booll"}]}""", true)]
|
||||
[InlineData(DriverTypeNames.AbCip, """{"tagPath":"Motor","members":[{"name":"Run","dataType":"Bool"}]}""", false)]
|
||||
[InlineData(DriverTypeNames.S7, """{"address":"DB1.DBW0"}""", true)]
|
||||
[InlineData(DriverTypeNames.S7, """{"address":"DB1.DBW0","dataType":"Int16"}""", false)]
|
||||
public void Authoring_and_the_deploy_gate_agree(string driverType, string tagConfig, bool expectRejected)
|
||||
{
|
||||
var authoringError = TagConfigValidator.Validate(driverType, tagConfig);
|
||||
var deployWarnings = EquipmentTagConfigInspector.Inspect(driverType, tagConfig);
|
||||
|
||||
(authoringError is not null).ShouldBe(expectRejected, $"authoring verdict for {driverType}");
|
||||
(deployWarnings.Count > 0).ShouldBe(expectRejected, $"deploy verdict for {driverType}");
|
||||
}
|
||||
|
||||
// ---------------------------------------------- 3. the CSV review grid names the row (item 1, surface)
|
||||
|
||||
/// <summary>
|
||||
/// The gate runs on the FINAL assembled blob — the bytes that reach the database — so the fixture
|
||||
/// puts the offending value in a key the Modbus typed map does NOT own (<c>stringByteOrder</c>,
|
||||
/// #551 item 3). A key the map DOES own is round-tripped through
|
||||
/// <c>ModbusTagConfigModel.FromJson/ToJson</c> by <c>ApplyTypedColumns</c> and silently normalised
|
||||
/// to the model default before it can ever be judged — a separate, pre-existing defect noted with
|
||||
/// this work, not one this gate can see.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Csv_parse_marks_a_row_whose_TagConfigJson_the_driver_would_reject()
|
||||
{
|
||||
const string Csv = """
|
||||
Name,DataType,TagConfigJson
|
||||
good,Float,"{""region"":""HoldingRegisters"",""address"":1,""stringByteOrder"":""LowByteFirst""}"
|
||||
bad,Float,"{""region"":""HoldingRegisters"",""address"":1,""stringByteOrder"":""Nope""}"
|
||||
""";
|
||||
|
||||
var result = RawTagCsvMapper.Parse(DriverTypeNames.Modbus, Csv);
|
||||
|
||||
result.FatalError.ShouldBeNull();
|
||||
result.Rows.Count.ShouldBe(2);
|
||||
result.Rows[0].Ok.ShouldBeTrue("the clean row must still import");
|
||||
result.Rows[1].Ok.ShouldBeFalse();
|
||||
result.Rows[1].Error.ShouldNotBeNull();
|
||||
result.Rows[1].Error!.ShouldContain("Nope");
|
||||
result.CanCommit.ShouldBeFalse("the commit is blocked while any row is invalid");
|
||||
result.ToImportRows().Count.ShouldBe(1);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The acceptance control for the driver that has NO typed CSV map, where the fallback cell reaches
|
||||
/// the database verbatim — the shape the gate most needed to cover.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Csv_parse_judges_a_map_less_drivers_fallback_cell_verbatim()
|
||||
{
|
||||
const string Good = """
|
||||
Name,DataType,TagConfigJson
|
||||
ok,Double,"{""nodeId"":""ns=2;s=Line3.Temp""}"
|
||||
""";
|
||||
const string Bad = """
|
||||
Name,DataType,TagConfigJson
|
||||
broken,Double,"{""node_id"":""ns=2;s=Line3.Temp""}"
|
||||
""";
|
||||
|
||||
RawTagCsvMapper.Parse(DriverTypeNames.OpcUaClient, Good).CanCommit.ShouldBeTrue();
|
||||
|
||||
var bad = RawTagCsvMapper.Parse(DriverTypeNames.OpcUaClient, Bad);
|
||||
bad.CanCommit.ShouldBeFalse();
|
||||
bad.Rows[0].Error.ShouldNotBeNull();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Positive control for the half that already worked: a typed column's value has always been
|
||||
/// strictly parsed (a bad enum throws <c>FormatException</c> into the row's error), so this row was
|
||||
/// rejected before #551 too. It is here so a reader can tell which half of the CSV path was the gap.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Csv_parse_still_marks_a_row_whose_TYPED_column_is_unparseable()
|
||||
{
|
||||
const string Csv = """
|
||||
Name,DataType,Region,Address,ModbusDataType
|
||||
bad,Float,HoldingRegisters,1,Intt16
|
||||
""";
|
||||
|
||||
var result = RawTagCsvMapper.Parse(DriverTypeNames.Modbus, Csv);
|
||||
|
||||
result.Rows.Count.ShouldBe(1);
|
||||
result.Rows[0].Ok.ShouldBeFalse();
|
||||
}
|
||||
|
||||
// ------------------------------------- 4. the SERVICE is the guarantee (item 1, the enforcement point)
|
||||
|
||||
/// <summary>
|
||||
/// Called with rows the CSV mapper never saw — which is exactly the shape of an API caller. Delete
|
||||
/// the check in <c>ImportTagsAsync</c> and this goes red while every mapper test above stays green.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ImportTags_fails_the_whole_batch_and_names_the_row_with_a_rejected_config()
|
||||
{
|
||||
var (service, dbName) = Seeded();
|
||||
|
||||
var rows = new[]
|
||||
{
|
||||
new RawTagImportRow(null, Tag("good1", GoodS7)),
|
||||
new RawTagImportRow(null, Tag("bad", """{"address":"DB1.DBW0"}""")), // no dataType key ⇒ S7 rejects
|
||||
new RawTagImportRow(null, Tag("good2", GoodS7)),
|
||||
};
|
||||
|
||||
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
||||
|
||||
result.Inserted.ShouldBe(0);
|
||||
result.Errors.ShouldContain(e => e.Contains("Row 2") && e.Contains("TagConfig"));
|
||||
|
||||
// All-or-nothing: the two good rows are not quietly kept either.
|
||||
using var db = RawTreeTestDb.CreateNamed(dbName);
|
||||
db.Tags.Any(t => t.Name == "good1" || t.Name == "good2").ShouldBeFalse();
|
||||
}
|
||||
|
||||
/// <summary>The acceptance control — without it, a gate that refuses every import would pass.</summary>
|
||||
[Fact]
|
||||
public async Task ImportTags_still_imports_a_batch_the_driver_can_read()
|
||||
{
|
||||
var (service, _) = Seeded();
|
||||
|
||||
var result = await service.ImportTagsAsync(
|
||||
RawTreeTestDb.RootDeviceId,
|
||||
new[] { new RawTagImportRow(null, Tag("ok1", GoodS7)), new RawTagImportRow(null, Tag("ok2", GoodS7)) });
|
||||
|
||||
result.Errors.ShouldBeEmpty();
|
||||
result.Inserted.ShouldBe(2);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Manual entry commits row-by-row through <c>CreateTagAsync</c>, NOT through
|
||||
/// <c>ImportTagsAsync</c> — so the gate has to live on that path too, or the "enforce in the
|
||||
/// service" claim covers only the CSV modal.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task CreateTag_refuses_a_config_the_driver_would_reject()
|
||||
{
|
||||
var (service, _) = Seeded();
|
||||
|
||||
var bad = await service.CreateTagAsync(
|
||||
RawTreeTestDb.RootDeviceId, null, Tag("newTag", """{"address":"DB1.DBW0"}"""));
|
||||
|
||||
bad.Ok.ShouldBeFalse();
|
||||
bad.Error.ShouldNotBeNull();
|
||||
bad.Error.ShouldContain("TagConfig");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CreateTag_accepts_a_config_the_driver_can_read()
|
||||
{
|
||||
var (service, _) = Seeded();
|
||||
|
||||
(await service.CreateTagAsync(RawTreeTestDb.RootDeviceId, null, Tag("newTag", GoodS7)))
|
||||
.Ok.ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateTag_refuses_a_config_the_driver_would_reject()
|
||||
{
|
||||
var (service, dbName) = Seeded();
|
||||
byte[] rowVersion;
|
||||
using (var db = RawTreeTestDb.CreateNamed(dbName))
|
||||
{
|
||||
rowVersion = db.Tags.Single(t => t.TagId == RawTreeTestDb.ReferencedTagId).RowVersion;
|
||||
}
|
||||
|
||||
var bad = await service.UpdateTagAsync(
|
||||
RawTreeTestDb.ReferencedTagId, Tag("temperature", """{"address":"DB1.DBW0"}"""), rowVersion);
|
||||
|
||||
bad.Ok.ShouldBeFalse();
|
||||
bad.Error.ShouldNotBeNull();
|
||||
bad.Error.ShouldContain("TagConfig");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A driver type with no typed model (Galaxy) validates to null in the modals, so the service must
|
||||
/// not invent a rule for it either — otherwise adding this gate would make Galaxy tags unauthorable.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void An_unmapped_driver_type_is_left_alone()
|
||||
{
|
||||
TagConfigValidator.Validate(DriverTypeNames.Galaxy, """{"FullName":"Reactor_001.Temp"}""").ShouldBeNull();
|
||||
TagConfigValidator.Validate(DriverTypeNames.Galaxy, "{}").ShouldBeNull();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Every blob <see cref="RawBrowseCommitMapper.BuildTagConfig"/> emits for a browsable driver must
|
||||
/// survive the gate the commit now passes through — otherwise browse-commit would author rows the
|
||||
/// import refuses.
|
||||
/// </summary>
|
||||
/// <param name="driverType">The browsable driver type.</param>
|
||||
[Theory]
|
||||
[InlineData(DriverTypeNames.S7)]
|
||||
[InlineData(DriverTypeNames.AbCip)]
|
||||
[InlineData(DriverTypeNames.AbLegacy)]
|
||||
[InlineData(DriverTypeNames.TwinCAT)]
|
||||
[InlineData(DriverTypeNames.OpcUaClient)]
|
||||
[InlineData(DriverTypeNames.Galaxy)]
|
||||
public void A_browse_committed_config_passes_the_gate(string driverType)
|
||||
{
|
||||
var tagConfig = RawBrowseCommitMapper.BuildTagConfig(driverType, "SomeAddress");
|
||||
|
||||
TagConfigValidator.Validate(driverType, tagConfig).ShouldBeNull(
|
||||
$"browse-commit for {driverType} must not author a config the import refuses");
|
||||
}
|
||||
|
||||
/// <summary>Sanity: the enums the three new rules read are the driver's own, not a local copy.</summary>
|
||||
[Fact]
|
||||
public void The_new_rules_read_the_drivers_own_enums()
|
||||
{
|
||||
Enum.GetNames<ModbusStringByteOrder>().ShouldContain("LowByteFirst");
|
||||
Enum.GetNames<AbCipDataType>().ShouldContain("Bool");
|
||||
Enum.GetNames<S7DataType>().ShouldContain("Int16");
|
||||
Enum.GetNames<TwinCATDataType>().ShouldContain("Structure");
|
||||
}
|
||||
}
|
||||
@@ -34,6 +34,19 @@ public sealed class RawTreeServiceWaveBTests
|
||||
private static RawTagInput Tag(string name, string dataType = "Float", string tagConfig = "{}") =>
|
||||
new(name, dataType, TagAccessLevel.ReadWrite, WriteIdempotent: false, PollGroupId: null, tagConfig);
|
||||
|
||||
/// <summary>
|
||||
/// A tag input whose <c>TagConfig</c> the <b>S7</b> driver would actually read — <c>RootDeviceId</c>
|
||||
/// hangs off the seed's S7 driver, and since Gitea #551 the service runs the driver-typed
|
||||
/// <c>TagConfigValidator</c> on every tag it writes. S7 requires BOTH an <c>address</c> and a
|
||||
/// present <c>dataType</c> key, so the bare <c>{}</c> the sibling helper defaults to is a config the
|
||||
/// driver rejects and the service now refuses. The Modbus-device tests keep <c>{}</c>: Modbus reads
|
||||
/// only enums out of the blob and accepts an empty one.
|
||||
/// </summary>
|
||||
/// <param name="name">The tag name.</param>
|
||||
/// <returns>The import-ready tag input.</returns>
|
||||
private static RawTagInput S7Tag(string name) =>
|
||||
Tag(name, tagConfig: """{"address":"DB1.DBW0","dataType":"Int16"}""");
|
||||
|
||||
// -------------------------------------------------------------------------------- CreateTag (WP4)
|
||||
|
||||
[Fact]
|
||||
@@ -181,9 +194,9 @@ public sealed class RawTreeServiceWaveBTests
|
||||
|
||||
var rows = new[]
|
||||
{
|
||||
new RawTagImportRow("Line/A", Tag("t1")),
|
||||
new RawTagImportRow("Line/A", Tag("t2")), // reuses Line + Line/A
|
||||
new RawTagImportRow("Line/B", Tag("t3")), // reuses Line, new B
|
||||
new RawTagImportRow("Line/A", S7Tag("t1")),
|
||||
new RawTagImportRow("Line/A", S7Tag("t2")), // reuses Line + Line/A
|
||||
new RawTagImportRow("Line/B", S7Tag("t3")), // reuses Line, new B
|
||||
};
|
||||
|
||||
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
||||
@@ -207,7 +220,7 @@ public sealed class RawTreeServiceWaveBTests
|
||||
var (service, dbName) = Seeded();
|
||||
|
||||
var result = await service.ImportTagsAsync(
|
||||
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, Tag("rootTag")) });
|
||||
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, S7Tag("rootTag")) });
|
||||
|
||||
result.Inserted.ShouldBe(1);
|
||||
using var db = RawTreeTestDb.CreateNamed(dbName);
|
||||
@@ -221,9 +234,9 @@ public sealed class RawTreeServiceWaveBTests
|
||||
|
||||
var rows = new[]
|
||||
{
|
||||
new RawTagImportRow("Grp", Tag("good1")),
|
||||
new RawTagImportRow("Grp", S7Tag("good1")),
|
||||
new RawTagImportRow("Grp", Tag("bad", tagConfig: "{oops")), // malformed JSON ⇒ error
|
||||
new RawTagImportRow("Grp", Tag("good2")),
|
||||
new RawTagImportRow("Grp", S7Tag("good2")),
|
||||
};
|
||||
|
||||
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
||||
@@ -245,8 +258,8 @@ public sealed class RawTreeServiceWaveBTests
|
||||
|
||||
var rows = new[]
|
||||
{
|
||||
new RawTagImportRow("Grp", Tag("dup")),
|
||||
new RawTagImportRow("Grp", Tag("dup")), // same path + name within the batch
|
||||
new RawTagImportRow("Grp", S7Tag("dup")),
|
||||
new RawTagImportRow("Grp", S7Tag("dup")), // same path + name within the batch
|
||||
};
|
||||
|
||||
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
||||
@@ -262,7 +275,7 @@ public sealed class RawTreeServiceWaveBTests
|
||||
|
||||
// "temperature" already sits at the device root of RootDevice.
|
||||
var result = await service.ImportTagsAsync(
|
||||
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, Tag("temperature")) });
|
||||
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, S7Tag("temperature")) });
|
||||
|
||||
result.Inserted.ShouldBe(0);
|
||||
result.Errors.ShouldContain(e => e.Contains("already exists"));
|
||||
|
||||
@@ -42,9 +42,15 @@ public sealed class TagConfigValidatorTests
|
||||
public void OpcUaClient_with_node_id_is_valid()
|
||||
=> TagConfigValidator.Validate("OpcUaClient", """{"nodeId":"ns=2;s=Line3.Temp"}""").ShouldBeNull();
|
||||
|
||||
// Gitea #551 item 2: S7 is the one driver whose reader REQUIRES the dataType key to be present, so a
|
||||
// blob carrying only an address is one the driver skips — this used to assert it was valid.
|
||||
[Fact]
|
||||
public void S7_with_address_is_valid()
|
||||
=> TagConfigValidator.Validate("S7", """{"address":"DB1.DBW0"}""").ShouldBeNull();
|
||||
public void S7_with_address_and_data_type_is_valid()
|
||||
=> TagConfigValidator.Validate("S7", """{"address":"DB1.DBW0","dataType":"Int16"}""").ShouldBeNull();
|
||||
|
||||
[Fact]
|
||||
public void S7_with_address_but_no_data_type_is_rejected()
|
||||
=> TagConfigValidator.Validate("S7", """{"address":"DB1.DBW0"}""").ShouldNotBeNullOrEmpty();
|
||||
|
||||
[Fact]
|
||||
public void AbCip_with_tag_path_is_valid()
|
||||
|
||||
Reference in New Issue
Block a user