Merge branch 'master' into fix/832-docker-dev-batch
This commit is contained in:
@@ -713,8 +713,6 @@ public abstract class ProcessedConformance : ConformanceBase
|
||||
[InlineData(HistoryAggregateType.StartBound)]
|
||||
[InlineData(HistoryAggregateType.EndBound)]
|
||||
[InlineData(HistoryAggregateType.DeltaBounds)]
|
||||
[InlineData(HistoryAggregateType.DurationGood)]
|
||||
[InlineData(HistoryAggregateType.DurationBad)]
|
||||
[InlineData(HistoryAggregateType.WorstQuality)]
|
||||
[InlineData(HistoryAggregateType.NumberOfTransitions)]
|
||||
[InlineData(HistoryAggregateType.AnnotationCount)]
|
||||
|
||||
@@ -11,7 +11,8 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Conformance;
|
||||
/// Uncertain time as Good (#796) as well as against the Part 13 oracle. Every expectation here is derived by hand from
|
||||
/// Part 13 (§5.4.3.31-34: DurationGood / DurationBad are the Good / Bad region time of the interval, PercentGood /
|
||||
/// PercentBad that time ÷ the interval; Uncertain regions count toward neither — Mantis 0006166 — and the time before
|
||||
/// the first sample is Bad, no data), and the oracle itself is checked against the same hand values.
|
||||
/// the first sample is Bad, no data), and the oracle itself is checked against the same hand values. Since #820 the SQL
|
||||
/// backends serve DurationGood / DurationBad (the same region times, in ms) and this suite asserts them directly.
|
||||
/// </summary>
|
||||
public abstract class QualityMixConformance : ConformanceBase
|
||||
{
|
||||
@@ -155,15 +156,52 @@ public abstract class QualityMixConformance : ConformanceBase
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DurationGood_and_DurationBad_are_refused_rather_than_answered_from_the_baseline_rule()
|
||||
public async Task DurationGood_and_DurationBad_over_a_Good_Uncertain_Bad_mix_are_the_Part_13_region_times()
|
||||
{
|
||||
// Part 13 DurationGood / DurationBad are not served by the SQL backends (#682 advertises 17 aggregates); they
|
||||
// must stay refused up front — never answered by a calculator that counts Uncertain time as Good.
|
||||
// #820: served on both SQL backends from the same region totals as PercentGood / PercentBad. Part 13
|
||||
// §5.4.3.31/32: the Good / Bad region time of the interval as an OPC UA Duration (milliseconds); Uncertain regions
|
||||
// count toward neither (Mantis 0006166) — never the 1.5.378.182 baseline rule that counts Uncertain time as Good.
|
||||
await B.SeedAsync("Q", Q);
|
||||
var src = B.CreateDataSource();
|
||||
foreach (var agg in new[] { HistoryAggregateType.DurationGood, HistoryAggregateType.DurationBad })
|
||||
(await Should.ThrowAsync<HistoryAggregateNotSupportedException>(
|
||||
() => src.ReadProcessedAsync("Q", At(0), At(80), Ten, agg, Ct))).Aggregate.ShouldBe(agg);
|
||||
src.SupportedAggregates.ShouldContain(HistoryAggregateType.DurationGood);
|
||||
src.SupportedAggregates.ShouldContain(HistoryAggregateType.DurationBad);
|
||||
var good = (await src.ReadProcessedAsync("Q", At(0), At(80), Ten, HistoryAggregateType.DurationGood, Ct)).Samples;
|
||||
var bad = (await src.ReadProcessedAsync("Q", At(0), At(80), Ten, HistoryAggregateType.DurationBad, Ct)).Samples;
|
||||
|
||||
ShouldBeClose(Values(good), QDurationGood.Select(d => d * 1000).ToArray(), "DurationGood");
|
||||
ShouldBeClose(Values(bad), QDurationBad.Select(d => d * 1000).ToArray(), "DurationBad");
|
||||
good.ShouldAllBe(x => x.Value is double);
|
||||
good.Select(x => x.StatusCode).ShouldAllBe(c => c == GoodCalc);
|
||||
bad.Select(x => x.StatusCode).ShouldAllBe(c => c == GoodCalc);
|
||||
good.Select(x => x.SourceTimestampUtc).ShouldBe(Enumerable.Range(0, 8).Select(i => (DateTime?)B.Round(At(i * 10))));
|
||||
|
||||
// Uncertain time is neither Good nor Bad: only I4 (no Uncertain region) adds up to the whole 10 s.
|
||||
Values(good).Zip(Values(bad), (g, b) => Math.Round(g + b, 6)).ShouldBe([7000d, 3000d, 0d, 0d, 10000d, 4000d, 3000d, 5000d]);
|
||||
|
||||
// DurationGood / DurationBad = PercentGood / PercentBad × interval ÷ 100, interval by interval.
|
||||
var pGood = (await src.ReadProcessedAsync("Q", At(0), At(80), Ten, HistoryAggregateType.PercentGood, Ct)).Samples;
|
||||
ShouldBeClose(Values(good), Values(pGood).Select(p => p * Ten.TotalMilliseconds / 100).ToArray(), "DurationGood vs PercentGood");
|
||||
|
||||
// The baseline (the live AggregateFilter calculator, #809) answers Q's DurationGood with the Uncertain time added.
|
||||
var baseline = SdkAggregateOracle.RunSdkAsIs(HistoryAggregateType.DurationGood, At(0), At(80), Ten,
|
||||
Q.Select(r => (r.T, r.V, r.Status)));
|
||||
ShouldBeClose(baseline.Select(r => Convert.ToDouble(r.Value)).ToArray(),
|
||||
QBaselinePercentGood.Select(p => p * 100).ToArray(), "baseline DurationGood (#809)");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DurationGood_and_DurationBad_over_partial_data_count_no_data_as_Bad_and_Uncertain_as_neither()
|
||||
{
|
||||
// #820 over QP: [0,20) 5 s no data (Bad), Uncertain 7 s, Good 8 s; [20,40) all Uncertain; outside the data BadNoData.
|
||||
await B.SeedAsync("QP", QP);
|
||||
var src = B.CreateDataSource();
|
||||
var good = (await src.ReadProcessedAsync("QP", At(-20), At(60), Twenty, HistoryAggregateType.DurationGood, Ct)).Samples;
|
||||
var bad = (await src.ReadProcessedAsync("QP", At(-20), At(60), Twenty, HistoryAggregateType.DurationBad, Ct)).Samples;
|
||||
good.Select(x => x.Value).ShouldBe([null, 8000d, 0d, null]);
|
||||
bad.Select(x => x.Value).ShouldBe([null, 5000d, 0d, null]);
|
||||
var statuses = new[] { NoDataCalc, GoodCalc | Partial, GoodCalc | Partial, NoDataCalc };
|
||||
good.Select(x => x.StatusCode).ShouldBe(statuses);
|
||||
bad.Select(x => x.StatusCode).ShouldBe(statuses);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
@@ -182,7 +220,8 @@ public abstract class QualityMixConformance : ConformanceBase
|
||||
await B.SeedAsync("Q", Q);
|
||||
await AssertMatchesOracle("Q", Rounded(Q), from, to, intervalS,
|
||||
[
|
||||
HistoryAggregateType.PercentGood, HistoryAggregateType.PercentBad, HistoryAggregateType.Count,
|
||||
HistoryAggregateType.PercentGood, HistoryAggregateType.PercentBad, HistoryAggregateType.DurationGood,
|
||||
HistoryAggregateType.DurationBad, HistoryAggregateType.Count,
|
||||
HistoryAggregateType.Average, HistoryAggregateType.TimeAverage, HistoryAggregateType.TimeAverage2,
|
||||
HistoryAggregateType.Total, HistoryAggregateType.Total2, HistoryAggregateType.Start, HistoryAggregateType.End,
|
||||
HistoryAggregateType.Delta, HistoryAggregateType.Interpolative,
|
||||
@@ -192,15 +231,18 @@ public abstract class QualityMixConformance : ConformanceBase
|
||||
[Theory]
|
||||
[InlineData(-20, 60, 20)]
|
||||
[InlineData(-20, 60, 10)]
|
||||
[InlineData(60, -20, 20)]
|
||||
[InlineData(60, -20, 10)]
|
||||
public async Task Processed_reads_over_partial_data_match_the_Part_13_oracle(double from, double to, double intervalS)
|
||||
{
|
||||
// QP's start-of-data and end-of-data intervals against the oracle. Left out, each a documented or pinned divergence:
|
||||
// QP's start-of-data and end-of-data intervals against the oracle, forward and reverse (#821). Left out, each a documented or pinned divergence:
|
||||
// TimeAverage2 / Total2 (the SDK's 1 ms end-of-data region), the min/max family (the SDK sets Partial on a Bad
|
||||
// result), and TimeAverage / Total (pinned by Time_weighted_values_over_partial_data_cover_only_the_data below).
|
||||
await B.SeedAsync("QP", QP);
|
||||
await AssertMatchesOracle("QP", Rounded(QP), from, to, intervalS,
|
||||
[
|
||||
HistoryAggregateType.PercentGood, HistoryAggregateType.PercentBad, HistoryAggregateType.Count,
|
||||
HistoryAggregateType.PercentGood, HistoryAggregateType.PercentBad, HistoryAggregateType.DurationGood,
|
||||
HistoryAggregateType.DurationBad, HistoryAggregateType.Count,
|
||||
HistoryAggregateType.Average, HistoryAggregateType.Start, HistoryAggregateType.End, HistoryAggregateType.Delta,
|
||||
HistoryAggregateType.Interpolative,
|
||||
]);
|
||||
@@ -229,6 +271,28 @@ public abstract class QualityMixConformance : ConformanceBase
|
||||
Convert.ToDouble(sdk.Value).ShouldBe(total + 25, 1e-6, "baseline divergence — if this moves, compare QP's TimeAverage/Total to the oracle");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Time_weighted_values_over_partial_data_cover_only_the_data_in_a_reverse_read()
|
||||
{
|
||||
// #821: the reverse-order variant of the late-start case above — (0,20] read 20 → 0. The same Part 13 integral and
|
||||
// average over the covered [5,20); Uncertain; NOT Partial (a reverse read keys start-of-data on the latest sample,
|
||||
// which is past the window — the SDK's rule, SdkAggregateParityTests); stamped with the later edge (#677). The
|
||||
// baseline's reverse answer carries the same +25 ramp divergence.
|
||||
await B.SeedAsync("QP", QP);
|
||||
var src = B.CreateDataSource();
|
||||
const double total = 73.5 + 88 + 32d / 13;
|
||||
var tot = (await src.ReadProcessedAsync("QP", At(20), At(0), Twenty, HistoryAggregateType.Total, Ct)).Samples.Single();
|
||||
((double)tot.Value!).ShouldBe(total, 1e-6);
|
||||
tot.StatusCode.ShouldBe(UncertainCalc);
|
||||
tot.SourceTimestampUtc.ShouldBe(B.Round(At(20)));
|
||||
var avg = (await src.ReadProcessedAsync("QP", At(20), At(0), Twenty, HistoryAggregateType.TimeAverage, Ct)).Samples.Single();
|
||||
((double)avg.Value!).ShouldBe(total / 15, 1e-6);
|
||||
avg.StatusCode.ShouldBe(UncertainCalc);
|
||||
|
||||
var sdk = SdkAggregateOracle.Run(HistoryAggregateType.Total, B.Round(At(20)), B.Round(At(0)), Twenty, Rounded(QP)).Single();
|
||||
Convert.ToDouble(sdk.Value).ShouldBe(total + 25, 1e-6, "baseline divergence (reverse) — #821");
|
||||
}
|
||||
|
||||
private async Task AssertMatchesOracle(string tag, (DateTime, HistorianValue, uint)[] rows, double from, double to,
|
||||
double intervalS, HistoryAggregateType[] aggregates)
|
||||
{
|
||||
|
||||
@@ -18,16 +18,16 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Conformance;
|
||||
/// <remarks>
|
||||
/// <para>Shared (source-linked) by <c>Sql.Common.Tests</c> and both SQL backends' integration suites.</para>
|
||||
/// <para>
|
||||
/// <b>PercentGood is the one aggregate not taken as-is (#796).</b> The 1.5.378.182 baseline changed
|
||||
/// <b>PercentGood (and, since #820, DurationGood) are the aggregates not taken as-is (#796).</b> The 1.5.378.182 baseline changed
|
||||
/// <c>StatusAggregateCalculator.ComputeDurationGoodBad</c> (1.5.378.106 and earlier counted Good regions only):
|
||||
/// with TreatUncertainAsBad = false it counts Uncertain regions as <b>Good</b> time (as Bad when true). Part 13
|
||||
/// keeps Uncertain out of both (§5.4.3.31 DurationGood counts Good regions; §5.4.3.33 PercentGood =
|
||||
/// DurationGood ÷ interval; Mantis 0006166, closed "no change required": an all-Uncertain interval is
|
||||
/// PercentGood 0 <i>and</i> PercentBad 0), and so does ours. <see cref="Run"/> therefore answers PercentGood
|
||||
/// through <see cref="Part13PercentGoodCalculator"/>: the SAME baseline calculator, region machinery (simple
|
||||
/// (and DurationGood) through <see cref="Part13GoodCalculator"/>: the SAME baseline calculator, region machinery (simple
|
||||
/// bounds, end-of-data 1 ms region, status and Partial bits) and server-default configuration, counting only
|
||||
/// Good regions — exactly what the pre-.182 oracle computed. PercentBad still counts Bad regions only (unchanged
|
||||
/// by .182) and is compared as-is. <see cref="RunSdkAsIs"/> runs the baseline untouched, for the test that pins
|
||||
/// Good regions — exactly what the pre-.182 oracle computed. PercentBad / DurationBad still count Bad regions only
|
||||
/// (unchanged by .182) and are compared as-is. <see cref="RunSdkAsIs"/> runs the baseline untouched, for the test that pins
|
||||
/// the divergence.
|
||||
/// </para>
|
||||
/// <para>
|
||||
@@ -55,7 +55,7 @@ public static class SdkAggregateOracle
|
||||
|
||||
/// <summary>
|
||||
/// Runs the Part 13 oracle for <paramref name="aggregate"/> over <paramref name="samples"/>: the baseline calculator,
|
||||
/// except PercentGood, which counts Good regions only (see the remarks, #796).
|
||||
/// except PercentGood / DurationGood, which count Good regions only (see the remarks, #796/#820).
|
||||
/// </summary>
|
||||
/// <param name="aggregate">The aggregate.</param>
|
||||
/// <param name="start">Request start (later than <paramref name="end"/> for a reverse read).</param>
|
||||
@@ -65,9 +65,10 @@ public static class SdkAggregateOracle
|
||||
/// <returns>The oracle's processed values, in the order it returns them.</returns>
|
||||
public static IReadOnlyList<Result> Run(HistoryAggregateType aggregate, DateTime start, DateTime end, TimeSpan interval,
|
||||
IEnumerable<(DateTime Time, HistorianValue Value, uint Status)> samples) =>
|
||||
aggregate == HistoryAggregateType.PercentGood
|
||||
? RunCore(new LegacyCalculatorAdapter(new Part13PercentGoodCalculator(ObjectIds.AggregateFunction_PercentGood,
|
||||
start, end, interval.TotalMilliseconds, false, DefaultConfiguration, Telemetry)), start, end, samples)
|
||||
aggregate is HistoryAggregateType.PercentGood or HistoryAggregateType.DurationGood
|
||||
? RunCore(new LegacyCalculatorAdapter(new Part13GoodCalculator(AggregateId(aggregate),
|
||||
start, end, interval.TotalMilliseconds, false, DefaultConfiguration, Telemetry,
|
||||
usePercent: aggregate == HistoryAggregateType.PercentGood)), start, end, samples)
|
||||
: RunSdkAsIs(aggregate, start, end, interval, samples);
|
||||
|
||||
/// <summary>
|
||||
@@ -155,12 +156,14 @@ public static class SdkAggregateOracle
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The baseline <see cref="BaselineStatusAggregateCalculator"/> with PercentGood counting <b>Good</b> regions only — Part 13
|
||||
/// §5.4.3.31/§5.4.3.33, and the 1.5.378.106 rule. Everything else (bounds, regions, Partial, status) is the
|
||||
/// baseline's own code, run under the same configuration as PercentBad.
|
||||
/// The baseline <see cref="BaselineStatusAggregateCalculator"/> with PercentGood / DurationGood counting <b>Good</b>
|
||||
/// regions only — Part 13 §5.4.3.31/§5.4.3.33, and the 1.5.378.106 rule. Everything else (bounds, regions, Partial,
|
||||
/// status, the millisecond Duration unit) is the baseline's own code, run under the same configuration as
|
||||
/// PercentBad / DurationBad.
|
||||
/// </summary>
|
||||
private sealed class Part13PercentGoodCalculator(NodeId aggregateId, DateTime startTime, DateTime endTime,
|
||||
double processingInterval, bool stepped, AggregateConfiguration configuration, ITelemetryContext telemetry)
|
||||
private sealed class Part13GoodCalculator(NodeId aggregateId, DateTime startTime, DateTime endTime,
|
||||
double processingInterval, bool stepped, AggregateConfiguration configuration, ITelemetryContext telemetry,
|
||||
bool usePercent)
|
||||
: BaselineStatusAggregateCalculator(aggregateId, startTime, endTime, processingInterval, stepped, configuration, telemetry)
|
||||
{
|
||||
protected override LegacyDataValue ComputeValue(TimeSlice slice)
|
||||
@@ -178,7 +181,7 @@ public static class SdkAggregateOracle
|
||||
|
||||
var value = new LegacyDataValue
|
||||
{
|
||||
WrappedValue = ZB.MOM.WW.OtOpcUa.OpcUaServer.SdkValueBoundary.FromClr(good / total * 100),
|
||||
WrappedValue = ZB.MOM.WW.OtOpcUa.OpcUaServer.SdkValueBoundary.FromClr(usePercent ? good / total * 100 : good),
|
||||
SourceTimestamp = GetTimestamp(slice),
|
||||
ServerTimestamp = GetTimestamp(slice),
|
||||
};
|
||||
@@ -223,6 +226,8 @@ public static class SdkAggregateOracle
|
||||
HistoryAggregateType.Count => ObjectIds.AggregateFunction_Count,
|
||||
HistoryAggregateType.PercentGood => ObjectIds.AggregateFunction_PercentGood,
|
||||
HistoryAggregateType.PercentBad => ObjectIds.AggregateFunction_PercentBad,
|
||||
HistoryAggregateType.DurationGood => ObjectIds.AggregateFunction_DurationGood,
|
||||
HistoryAggregateType.DurationBad => ObjectIds.AggregateFunction_DurationBad,
|
||||
HistoryAggregateType.Start => ObjectIds.AggregateFunction_Start,
|
||||
HistoryAggregateType.End => ObjectIds.AggregateFunction_End,
|
||||
HistoryAggregateType.Delta => ObjectIds.AggregateFunction_Delta,
|
||||
|
||||
+17
@@ -54,6 +54,23 @@ public sealed class GalaxyDriverBrowserTests
|
||||
ex.Message.ShouldContain("ClientName");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#815: the browser runs on the admin node against an operator-chosen endpoint with no deploy, so it
|
||||
/// never gets the running driver's warn-only compatibility — a legacy ref (the old form default
|
||||
/// <c>env:MX_API_KEY</c>, a <c>file:</c> path, another subsystem's secret) is refused before any connect.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("env:MX_API_KEY")]
|
||||
[InlineData("file:appsettings.json")]
|
||||
[InlineData("secret:otopcua/historian/api-key")]
|
||||
public async Task OpenAsync_refuses_an_out_of_namespace_api_key_ref_with_no_warn_only_fallback(string reference)
|
||||
{
|
||||
var json = "{\"Gateway\":{\"Endpoint\":\"http://127.0.0.1:1\",\"ApiKeySecretRef\":\"" + reference
|
||||
+ "\"},\"MxAccess\":{\"ClientName\":\"X\"},\"Repository\":{},\"Reconnect\":{}}";
|
||||
await Should.ThrowAsync<ZB.MOM.WW.OtOpcUa.Core.Abstractions.CredentialReferenceException>(
|
||||
() => _sut.OpenAsync(json, TestContext.Current.CancellationToken));
|
||||
}
|
||||
|
||||
/// <summary>A JSON literal that deserializes to null must fail fast with a
|
||||
/// "deserialized to null" message — never a downstream NRE.</summary>
|
||||
[Fact]
|
||||
|
||||
+70
-41
@@ -1,14 +1,15 @@
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Config;
|
||||
using ZB.MOM.WW.Secrets.Abstractions;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Follow-up #2 + G-2a — pins the five resolution forms supported by
|
||||
/// <see cref="GalaxySecretRef.ResolveApiKeyAsync"/>: <c>env:NAME</c>, <c>file:PATH</c>,
|
||||
/// Follow-up #2 + G-2a + lmxopcua#815 — pins the resolution forms supported by
|
||||
/// <see cref="GalaxySecretRef.ResolveApiKeyAsync"/>: <c>env:OTOPCUA_GALAXY_NAME</c> (<c>file:</c> is refused),
|
||||
/// <c>dev:KEY</c>, <c>secret:NAME</c> (via the shared <see cref="ISecretResolver"/>), and
|
||||
/// the literal-string fallback. The <c>secret:</c> arm is fail-closed — an absent secret
|
||||
/// throws rather than leaking the ref string as the key. (The resolver was extracted from
|
||||
@@ -38,7 +39,7 @@ public sealed class GalaxyDriverApiKeyResolverTests
|
||||
[Fact]
|
||||
public async Task Env_prefix_resolves_to_environment_variable()
|
||||
{
|
||||
const string name = "OTOPCUA_TEST_GALAXY_API_KEY";
|
||||
const string name = "OTOPCUA_GALAXY_TEST_API_KEY";
|
||||
Environment.SetEnvironmentVariable(name, "key-from-env");
|
||||
try
|
||||
{
|
||||
@@ -55,41 +56,13 @@ public sealed class GalaxyDriverApiKeyResolverTests
|
||||
[Fact]
|
||||
public async Task Env_prefix_unset_variable_throws_with_descriptive_message()
|
||||
{
|
||||
const string name = "OTOPCUA_TEST_GALAXY_API_KEY_UNSET";
|
||||
const string name = "OTOPCUA_GALAXY_TEST_API_KEY_UNSET";
|
||||
Environment.SetEnvironmentVariable(name, null);
|
||||
|
||||
var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
|
||||
GalaxySecretRef.ResolveApiKeyAsync($"env:{name}", FakeResolver()));
|
||||
ex.Message.ShouldContain(name);
|
||||
ex.Message.ShouldContain("unset");
|
||||
}
|
||||
|
||||
/// <summary>Verifies that file: prefix resolves to trimmed file contents.</summary>
|
||||
[Fact]
|
||||
public async Task File_prefix_resolves_to_trimmed_file_contents()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), $"galaxy-key-{Guid.NewGuid():N}.txt");
|
||||
File.WriteAllText(path, " key-from-file \n");
|
||||
try
|
||||
{
|
||||
(await GalaxySecretRef.ResolveApiKeyAsync($"file:{path}", FakeResolver(), ct: TestContext.Current.CancellationToken))
|
||||
.ShouldBe("key-from-file");
|
||||
}
|
||||
finally
|
||||
{
|
||||
File.Delete(path);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Verifies that file: prefix with missing path throws.</summary>
|
||||
[Fact]
|
||||
public async Task File_prefix_missing_path_throws()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), $"does-not-exist-{Guid.NewGuid():N}.txt");
|
||||
var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
|
||||
GalaxySecretRef.ResolveApiKeyAsync($"file:{path}", FakeResolver()));
|
||||
ex.Message.ShouldContain(path);
|
||||
ex.Message.ShouldContain("doesn't exist");
|
||||
ex.Message.ShouldContain("not set");
|
||||
}
|
||||
|
||||
// ===== G-2a: secret: arm — resolves through the shared ISecretResolver, fail-closed =====
|
||||
@@ -161,7 +134,7 @@ public sealed class GalaxyDriverApiKeyResolverTests
|
||||
[Fact]
|
||||
public async Task Env_prefix_does_not_emit_literal_warning()
|
||||
{
|
||||
const string name = "OTOPCUA_TEST_GALAXY_API_KEY_NOWARN";
|
||||
const string name = "OTOPCUA_GALAXY_TEST_API_KEY_NOWARN";
|
||||
Environment.SetEnvironmentVariable(name, "v");
|
||||
try
|
||||
{
|
||||
@@ -211,21 +184,77 @@ public sealed class GalaxyDriverApiKeyResolverTests
|
||||
: null);
|
||||
}
|
||||
|
||||
/// <summary>Verifies that file: prefix with empty file throws.</summary>
|
||||
[Fact]
|
||||
public async Task File_prefix_empty_file_throws()
|
||||
// ===== lmxopcua#815: references are confined to the Galaxy namespace, checked before any read =====
|
||||
|
||||
/// <summary>
|
||||
/// An out-of-namespace reference — another subsystem's secret or process variable — throws, and neither the
|
||||
/// store nor the environment is consulted (the value is never read, so it can never be sent).
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("env:ConnectionStrings__ConfigDb")]
|
||||
[InlineData("env:ServerHistorian__ApiKey")]
|
||||
[InlineData("env:OTOPCUA_GALAXY_lower")]
|
||||
[InlineData("secret:otopcua/historian/api-key")]
|
||||
[InlineData("secret:OT-MESH-PSK-MAIN")]
|
||||
[InlineData("secret:galaxy/../otopcua/historian/api-key")]
|
||||
[InlineData("${secret:otopcua/apikeys/abc/galaxy-ack-password}")]
|
||||
[InlineData("SECRET:galaxy/inst1/apikey")]
|
||||
[InlineData("file:/tmp/any-file")]
|
||||
[InlineData("file:appsettings.json")]
|
||||
public async Task Out_of_namespace_reference_is_refused_without_reading_store_or_environment(string reference)
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), $"galaxy-key-empty-{Guid.NewGuid():N}.txt");
|
||||
File.WriteAllText(path, " \n ");
|
||||
var store = new CountingResolver();
|
||||
var envReads = 0;
|
||||
var ex = await Should.ThrowAsync<CredentialReferenceException>(() => GalaxySecretRef.ResolveApiKeyAsync(
|
||||
reference, store, ct: TestContext.Current.CancellationToken, environment: _ => { envReads++; return "LEAKED"; }));
|
||||
ex.Message.ShouldContain("secret:galaxy/<name>");
|
||||
ex.Message.ShouldContain("env:OTOPCUA_GALAXY_<NAME>");
|
||||
ex.Message.ShouldNotContain("LEAKED");
|
||||
store.Calls.ShouldBe(0);
|
||||
envReads.ShouldBe(0);
|
||||
}
|
||||
|
||||
/// <summary>The namespaced environment forms (incl. the legacy GALAXY_MXGW_ variable) resolve.</summary>
|
||||
[Theory]
|
||||
[InlineData("env:OTOPCUA_GALAXY_API_KEY", "OTOPCUA_GALAXY_API_KEY")]
|
||||
[InlineData("env:GALAXY_MXGW_API_KEY", "GALAXY_MXGW_API_KEY")]
|
||||
public async Task Namespaced_environment_reference_resolves(string reference, string variable)
|
||||
{
|
||||
var key = await GalaxySecretRef.ResolveApiKeyAsync(
|
||||
reference, FakeResolver(), ct: TestContext.Current.CancellationToken,
|
||||
environment: n => n == variable ? "the-key" : null);
|
||||
key.ShouldBe("the-key");
|
||||
}
|
||||
|
||||
/// <summary>A file reference is refused even when the file exists — its contents are never returned.</summary>
|
||||
[Fact]
|
||||
public async Task File_reference_is_refused_even_when_the_file_exists()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), $"galaxy-key-{Guid.NewGuid():N}.txt");
|
||||
File.WriteAllText(path, "key-from-file");
|
||||
try
|
||||
{
|
||||
var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
|
||||
var ex = await Should.ThrowAsync<CredentialReferenceException>(() =>
|
||||
GalaxySecretRef.ResolveApiKeyAsync($"file:{path}", FakeResolver()));
|
||||
ex.Message.ShouldContain("empty");
|
||||
ex.Message.ShouldNotContain("key-from-file");
|
||||
}
|
||||
finally
|
||||
{
|
||||
File.Delete(path);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Counts store lookups.</summary>
|
||||
private sealed class CountingResolver : ISecretResolver
|
||||
{
|
||||
/// <summary>Gets the number of lookups.</summary>
|
||||
public int Calls { get; private set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public Task<string?> GetAsync(SecretName name, CancellationToken ct)
|
||||
{
|
||||
Calls++;
|
||||
return Task.FromResult<string?>("LEAKED");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Config;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Runtime;
|
||||
using ZB.MOM.WW.Secrets.Abstractions;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#815 warn-only compatibility (deprecated): an ALREADY-DEPLOYED Galaxy driver whose config predates the
|
||||
/// namespaces — e.g. the old AdminUI form default <c>env:MX_API_KEY</c> — keeps resolving it on init and on every
|
||||
/// gateway reconnect (<c>ReopenAsync</c> → <c>BuildClientOptionsAsync</c>), warning rate-limited and surfacing it
|
||||
/// on the diagnostics bag; while the admin-node paths (browser) stay hard-fail.
|
||||
/// </summary>
|
||||
public sealed class GalaxyDriverLegacyCredentialTests
|
||||
{
|
||||
private const string LegacyVariable = "MX_API_KEY_815_TEST";
|
||||
|
||||
private static GalaxyDriverOptions Opts(string apiKeyRef, string? ackRef = null) => new(
|
||||
new GalaxyGatewayOptions("https://mxgw.test:5001", apiKeyRef),
|
||||
new GalaxyMxAccessOptions("Compat815"),
|
||||
new GalaxyRepositoryOptions(WatchDeployEvents: false),
|
||||
new GalaxyReconnectOptions())
|
||||
{
|
||||
AlarmAck = ackRef is null ? new GalaxyAlarmAckOptions() : new GalaxyAlarmAckOptions("ack-svc", null, ackRef),
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public async Task A_running_driver_with_a_legacy_env_ref_resolves_on_init_and_every_reconnect_and_warns_once()
|
||||
{
|
||||
Environment.SetEnvironmentVariable(LegacyVariable, "the-real-key");
|
||||
try
|
||||
{
|
||||
var logger = new CaptureLogger();
|
||||
var driver = new GalaxyDriver("gx-legacy", Opts($"env:{LegacyVariable}"), new NullResolver(), logger);
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
|
||||
// InitializeAsync and each ReopenAsync (gateway reconnect) build the client options through this one method.
|
||||
(await driver.BuildClientOptionsAsync(Opts($"env:{LegacyVariable}").Gateway, ct)).ApiKey.ShouldBe("the-real-key");
|
||||
(await driver.BuildClientOptionsAsync(Opts($"env:{LegacyVariable}").Gateway, ct)).ApiKey.ShouldBe("the-real-key");
|
||||
(await driver.BuildClientOptionsAsync(Opts($"env:{LegacyVariable}").Gateway, ct)).ApiKey.ShouldBe("the-real-key");
|
||||
|
||||
var warnings = logger.Entries.Where(e => e.Level == LogLevel.Warning && e.Message.Contains("lmxopcua#815")).ToList();
|
||||
warnings.Count.ShouldBe(1); // rate-limited: one per field per hour, not one per reconnect
|
||||
warnings[0].Message.ShouldContain("Gateway.ApiKeySecretRef");
|
||||
warnings[0].Message.ShouldContain("env:OTOPCUA_GALAXY_<NAME>");
|
||||
warnings[0].Message.ShouldNotContain("the-real-key");
|
||||
|
||||
var diagnostics = ((IDriverDiagnostics)driver).GetDiagnostics();
|
||||
diagnostics.Keys.ShouldContain(LegacyCredentialReferenceTracker.DiagnosticsKeyPrefix + "Gateway.ApiKeySecretRef");
|
||||
diagnostics.Values.ShouldAllBe(v => !v.Contains("the-real-key"));
|
||||
DriverDiagnostics.Bound(diagnostics).Values.ShouldAllBe(v => v.Length <= DriverDiagnostics.MaxValueLength);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Environment.SetEnvironmentVariable(LegacyVariable, null);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_running_driver_keeps_the_old_case_insensitive_and_file_semantics()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), $"gx-815-{Guid.NewGuid():N}.txt");
|
||||
File.WriteAllText(path, " key-from-file \n");
|
||||
try
|
||||
{
|
||||
var driver = new GalaxyDriver("gx-legacy-file", Opts($"file:{path}"), new NullResolver());
|
||||
(await driver.BuildClientOptionsAsync(Opts($"file:{path}").Gateway, TestContext.Current.CancellationToken))
|
||||
.ApiKey.ShouldBe("key-from-file");
|
||||
((IDriverDiagnostics)driver).GetDiagnostics().ShouldNotBeEmpty();
|
||||
}
|
||||
finally
|
||||
{
|
||||
File.Delete(path);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_namespaced_ref_resolves_without_a_compatibility_warning()
|
||||
{
|
||||
var logger = new CaptureLogger();
|
||||
var driver = new GalaxyDriver("gx-ok", Opts("dev:k"), new NullResolver(), logger);
|
||||
(await driver.BuildClientOptionsAsync(Opts("dev:k").Gateway, TestContext.Current.CancellationToken)).ApiKey.ShouldBe("k");
|
||||
logger.Entries.ShouldNotContain(e => e.Message.Contains("lmxopcua#815"));
|
||||
((IDriverDiagnostics)driver).GetDiagnostics().ShouldBeEmpty();
|
||||
}
|
||||
|
||||
/// <summary>The same legacy ref through the admin-node browser path (no tracker) is refused before any read.</summary>
|
||||
[Fact]
|
||||
public async Task The_same_ref_without_a_tracker_is_refused()
|
||||
{
|
||||
var reads = 0;
|
||||
await Should.ThrowAsync<CredentialReferenceException>(() => GalaxySecretRef.ResolveApiKeyAsync(
|
||||
"env:MX_API_KEY", new NullResolver(), ct: TestContext.Current.CancellationToken,
|
||||
environment: _ => { reads++; return "the-real-key"; }));
|
||||
reads.ShouldBe(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task The_running_ack_fallback_keeps_a_legacy_ref_and_warns()
|
||||
{
|
||||
var warnings = new List<string>();
|
||||
var tracker = new LegacyCredentialReferenceTracker(DriverCredentialPolicy.GalaxyScope, "gx", warnings.Add);
|
||||
var resolver = new GalaxyAckCredentialResolver(
|
||||
"gx", new GalaxyAlarmAckOptions("ack-svc", null, "env:LEGACY_ACK_PW"), new NullResolver(), new CaptureLogger(),
|
||||
n => n == "LEGACY_ACK_PW" ? "pw" : null, tracker);
|
||||
|
||||
(await resolver.ResolveAsync(null, TestContext.Current.CancellationToken)).Credential.ShouldNotBeNull().Password.ShouldBe("pw");
|
||||
warnings.ShouldHaveSingleItem().ShouldContain("AlarmAck.FallbackPasswordSecretRef");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void The_tracker_re_warns_after_the_interval()
|
||||
{
|
||||
var now = new DateTime(2026, 11, 11, 0, 0, 0, DateTimeKind.Utc);
|
||||
var warnings = new List<string>();
|
||||
var tracker = new LegacyCredentialReferenceTracker(DriverCredentialPolicy.GalaxyScope, "gx", warnings.Add, () => now);
|
||||
tracker.Report("F");
|
||||
tracker.Report("F");
|
||||
now += LegacyCredentialReferenceTracker.WarnInterval;
|
||||
tracker.Report("F");
|
||||
tracker.Report("G");
|
||||
warnings.Count.ShouldBe(3);
|
||||
}
|
||||
|
||||
private sealed class NullResolver : ISecretResolver
|
||||
{
|
||||
public Task<string?> GetAsync(SecretName name, CancellationToken ct) => Task.FromResult<string?>(null);
|
||||
}
|
||||
|
||||
private sealed class CaptureLogger : ILogger<GalaxyDriver>
|
||||
{
|
||||
public List<(LogLevel Level, string Message)> Entries { get; } = new();
|
||||
|
||||
public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
|
||||
|
||||
public bool IsEnabled(LogLevel logLevel) => true;
|
||||
|
||||
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
|
||||
{
|
||||
lock (Entries) Entries.Add((logLevel, formatter(state, exception)));
|
||||
}
|
||||
}
|
||||
}
|
||||
+42
@@ -300,6 +300,48 @@ public sealed class GalaxyAckCredentialTests
|
||||
.Password.ShouldBe(FallbackPassword);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#815: the fallback password is sent to the operator-authored gateway endpoint, so a reference
|
||||
/// outside the Galaxy namespace is refused — the store/environment value is never read, never sent.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("secret:otopcua/apikeys/0a1b/galaxy-ack-password")]
|
||||
[InlineData("${secret:otopcua/historian/api-key}")]
|
||||
[InlineData("env:ConnectionStrings__ConfigDb")]
|
||||
[InlineData("file:appsettings.json")]
|
||||
public async Task Resolver_refuses_a_fallback_reference_outside_the_galaxy_namespace(string reference)
|
||||
{
|
||||
const string Stolen = "stolen-value";
|
||||
var secrets = new DictSecretResolver
|
||||
{
|
||||
["otopcua/apikeys/0a1b/galaxy-ack-password"] = Stolen,
|
||||
["otopcua/historian/api-key"] = Stolen,
|
||||
};
|
||||
var envReads = 0;
|
||||
var logger = new CapturingLogger();
|
||||
var resolver = new GalaxyAckCredentialResolver(
|
||||
"drv", new GalaxyAlarmAckOptions("ack-svc", null, reference), secrets, logger,
|
||||
_ => { envReads++; return Stolen; });
|
||||
|
||||
var result = await resolver.ResolveAsync(null, CancellationToken.None);
|
||||
|
||||
result.Credential.ShouldBeNull();
|
||||
result.RefusalReason.ShouldNotBeNull().ShouldNotContain(Stolen);
|
||||
logger.AllText.ShouldNotContain(Stolen);
|
||||
envReads.ShouldBe(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolver_resolves_a_namespaced_environment_fallback()
|
||||
{
|
||||
var resolver = new GalaxyAckCredentialResolver(
|
||||
"drv", new GalaxyAlarmAckOptions("ack-svc", null, "env:OTOPCUA_GALAXY_ACK_PASSWORD"), new DictSecretResolver(),
|
||||
new CapturingLogger(), n => n == "OTOPCUA_GALAXY_ACK_PASSWORD" ? FallbackPassword : null);
|
||||
|
||||
(await resolver.ResolveAsync(null, CancellationToken.None)).Credential.ShouldNotBeNull()
|
||||
.Password.ShouldBe(FallbackPassword);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolver_secret_store_fault_is_a_refusal_not_a_throw()
|
||||
{
|
||||
|
||||
@@ -0,0 +1,384 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Text;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Heidenhain.Lsv2;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.Heidenhain.Tests.Simulator;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Heidenhain.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#831: controller alarms as native Part 9 conditions (<c>ALARM:</c> selectors + the <c>alarm</c> object),
|
||||
/// local-only acknowledgement (nothing sent to the control), quality-only annotation of a failed walk, and the
|
||||
/// identity-change rediscovery signal — against the in-process LSV2 simulator and the captured iTNC 530 alarm reply.
|
||||
/// </summary>
|
||||
[Trait("Category", "Unit")]
|
||||
public sealed class HeidenhainAlarmTests
|
||||
{
|
||||
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
||||
|
||||
private const string Alarm = """, "alarm": {"alarmType": "AlarmCondition", "severity": 800}""";
|
||||
|
||||
private static RawTagEntry AlarmTag(string selector, string name, bool withAlarm = true) =>
|
||||
new($"Plant/H/dev1/{name}",
|
||||
$$"""{"address": "ALARM:{{selector}}", "dataType": "Boolean"{{(withAlarm ? Alarm : "")}}}""", false, "dev1");
|
||||
|
||||
// ---- selector grammar ----
|
||||
|
||||
[Theory]
|
||||
[InlineData("*", "*")]
|
||||
[InlineData("other", "OTHER")]
|
||||
[InlineData("class=7", "CLASS=7")]
|
||||
[InlineData("NUMBER=-5..-1/class=7", "CLASS=7/NUMBER=-5..-1")]
|
||||
[InlineData("GROUP=4/NUMBER=100..199", "GROUP=4/NUMBER=100..199")]
|
||||
public void Selector_grammar_accepts_and_canonicalises(string body, string canonical)
|
||||
{
|
||||
HeidenhainAlarmSelector.TryParse(body, out var s, out var error).ShouldBeTrue(error);
|
||||
s!.Canonical.ShouldBe(canonical);
|
||||
HeidenhainAddress.TryParse("ALARM:" + body, out var a, out _).ShouldBeTrue();
|
||||
a!.Kind.ShouldBe(HeidenhainAddressKind.Alarm);
|
||||
a.Text.ShouldBe("ALARM:" + canonical);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData("CLASS")]
|
||||
[InlineData("CLASS=x")]
|
||||
[InlineData("CLASS=70000")]
|
||||
[InlineData("CLASS=-1")]
|
||||
[InlineData("NUMBER=5..1")]
|
||||
[InlineData("CLASS=1/CLASS=2")]
|
||||
[InlineData("TYPE=1")]
|
||||
[InlineData("NUMBER=3000000000")]
|
||||
public void Selector_grammar_refuses(string body)
|
||||
{
|
||||
HeidenhainAlarmSelector.TryParse(body, out _, out var error).ShouldBeFalse();
|
||||
error.ShouldNotBeNullOrEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Selector_matching_and_negative_numbers()
|
||||
{
|
||||
HeidenhainAlarmSelector.TryParse("CLASS=7/NUMBER=-1", out var s, out _).ShouldBeTrue();
|
||||
s!.Matches(7, 4, -1).ShouldBeTrue();
|
||||
s.Matches(7, 4, 1).ShouldBeFalse();
|
||||
s.Matches(6, 4, -1).ShouldBeFalse();
|
||||
}
|
||||
|
||||
// ---- TagConfig pairing ----
|
||||
|
||||
[Fact]
|
||||
public void An_alarm_selector_and_the_alarm_object_only_work_together()
|
||||
{
|
||||
HeidenhainTagDefinitionFactory.TryFromTagConfig("p", "d", AlarmTag("*", "a").TagConfig, out var def, out var error).ShouldBeTrue(error);
|
||||
def!.IsAlarmCondition.ShouldBeTrue();
|
||||
def.DataType.ShouldBe(DriverDataType.Boolean);
|
||||
def.Alarm!.Severity.ShouldBe(800);
|
||||
def.Group.ShouldBe(HeidenhainPollGroup.Alarm);
|
||||
HeidenhainTagRules.ExpectedTagDataType(AlarmTag("*", "a").TagConfig).ShouldBe("Boolean");
|
||||
|
||||
HeidenhainTagDefinitionFactory.TryFromTagConfig("p", "d", AlarmTag("*", "a", withAlarm: false).TagConfig, out _, out error).ShouldBeFalse();
|
||||
error!.ShouldContain("alarm");
|
||||
HeidenhainTagDefinitionFactory.TryFromTagConfig("p", "d", """{"address":"Status/ExecutionState","alarm":{}}""", out _, out error).ShouldBeFalse();
|
||||
error!.ShouldContain("not an ALARM: selector");
|
||||
HeidenhainTagDefinitionFactory.TryFromTagConfig("p", "d", """{"address":"ALARM:*","dataType":"Int32","alarm":{}}""", out _, out _).ShouldBeFalse();
|
||||
HeidenhainTagDefinitionFactory.TryFromTagConfig("p", "d", """{"address":"ALARM:*","isArray":true,"alarm":{}}""", out _, out _).ShouldBeFalse();
|
||||
HeidenhainTagDefinitionFactory.Inspect(AlarmTag("*", "a").TagConfig).ShouldBeEmpty();
|
||||
}
|
||||
|
||||
// ---- pure transition rules ----
|
||||
|
||||
private static HeidenhainAlarmTag Tag(string selector, int? severity = null) =>
|
||||
new("Plant/H/dev1/a", "h:1", Parse(selector), severity);
|
||||
|
||||
private static HeidenhainAlarmSelector Parse(string body)
|
||||
{
|
||||
HeidenhainAlarmSelector.TryParse(body, out var s, out _).ShouldBeTrue();
|
||||
return s!;
|
||||
}
|
||||
|
||||
private static readonly IAlarmSubscriptionHandle H = new HeidenhainAlarmSubscriptionHandle(1);
|
||||
|
||||
[Fact]
|
||||
public void Transitions_raise_retrigger_clear_and_ignore_reordering()
|
||||
{
|
||||
var tag = Tag("*", 900);
|
||||
var a = new Lsv2Alarm(7, 4, -1, "Run test of cutout channels");
|
||||
var b = new Lsv2Alarm(3, 1, 100, "Coolant low");
|
||||
var all = new[] { tag.Selector };
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
var (e1, t1) = HeidenhainAlarmRules.Transition(null, HeidenhainAlarmRules.Evaluate(tag.Selector, [a], all), tag, H, now);
|
||||
e1!.Kind.ShouldBe(AlarmTransitionKind.Raise);
|
||||
e1.ConditionId.ShouldBe(tag.RawPath);
|
||||
e1.OpcUaSeverity.ShouldBe(900);
|
||||
e1.Severity.ShouldBe(AlarmSeverity.Critical);
|
||||
e1.Message.ShouldBe("-1 Run test of cutout channels (class 7, group 4)");
|
||||
|
||||
// unchanged → nothing
|
||||
HeidenhainAlarmRules.Transition(t1, HeidenhainAlarmRules.Evaluate(tag.Selector, [a], all), tag, H, now).Event.ShouldBeNull();
|
||||
|
||||
// a new alarm (it also becomes the displayed one) → Retrigger
|
||||
var (e2, t2) = HeidenhainAlarmRules.Transition(t1, HeidenhainAlarmRules.Evaluate(tag.Selector, [a, b], all), tag, H, now);
|
||||
e2!.Kind.ShouldBe(AlarmTransitionKind.Retrigger);
|
||||
e2.Message.ShouldBe("100 Coolant low (class 3, group 1) [+1 more]");
|
||||
|
||||
// the same set in another wire order → nothing (deterministic display order)
|
||||
HeidenhainAlarmRules.Transition(t2, HeidenhainAlarmRules.Evaluate(tag.Selector, [b, a], all), tag, H, now).Event.ShouldBeNull();
|
||||
|
||||
// the displayed alarm leaves while another remains → Retrigger with the next one down
|
||||
var (e3, t3) = HeidenhainAlarmRules.Transition(t2, HeidenhainAlarmRules.Evaluate(tag.Selector, [a], all), tag, H, now);
|
||||
e3!.Kind.ShouldBe(AlarmTransitionKind.Retrigger);
|
||||
|
||||
var (e4, _) = HeidenhainAlarmRules.Transition(t3, [], tag, H, now);
|
||||
e4!.Kind.ShouldBe(AlarmTransitionKind.Clear);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Other_is_what_no_filter_on_the_control_claims_and_severity_defaults_to_high()
|
||||
{
|
||||
var a = new Lsv2Alarm(7, 4, -1, "x");
|
||||
var b = new Lsv2Alarm(3, 1, 100, "y");
|
||||
var selectors = new[] { Parse("CLASS=7"), Parse("*"), Parse("OTHER") };
|
||||
HeidenhainAlarmRules.Evaluate(Parse("OTHER"), [a, b], selectors).Select(k => k.Number).ShouldBe(new[] { 100 });
|
||||
HeidenhainAlarmRules.Evaluate(Parse("*"), [a, b], selectors).Count.ShouldBe(2);
|
||||
var (e, _) = HeidenhainAlarmRules.Transition(null, HeidenhainAlarmRules.Evaluate(Parse("OTHER"), [a, b], selectors),
|
||||
Tag("OTHER"), H, DateTime.UtcNow);
|
||||
e!.Severity.ShouldBe(AlarmSeverity.High);
|
||||
e.OpcUaSeverity.ShouldBeNull();
|
||||
}
|
||||
|
||||
// ---- end to end against the simulator ----
|
||||
|
||||
/// <summary>A control whose active-alarm list can be changed between walks (27 = first, 28 = next, 57 = end).</summary>
|
||||
private sealed class AlarmList
|
||||
{
|
||||
private volatile byte[][] _records = [];
|
||||
private int _cursor;
|
||||
public void Set(params byte[][] records) => _records = records;
|
||||
|
||||
public void Install(SimulatedControl c)
|
||||
{
|
||||
c.Runtime[27] = () => { _cursor = 0; return Next(); };
|
||||
c.Runtime[28] = Next;
|
||||
}
|
||||
|
||||
private SimReply Next()
|
||||
{
|
||||
var r = _records;
|
||||
return _cursor < r.Length ? SimReply.Ok("S_RI", r[_cursor++]) : SimReply.Refuse(57);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The captured iTNC 530 reply (Java fixture <c>hermle49.27</c>): class 7, group 4, number -1.</summary>
|
||||
private static byte[] Golden() => SimReply.FromFixture(Fixtures.Load("itnc530-inspect.properties")["hermle49.27"]).Payload!;
|
||||
|
||||
private static byte[] Record(int cls, int group, int number, string text)
|
||||
{
|
||||
var t = Encoding.Latin1.GetBytes(text + "\0");
|
||||
var b = new byte[8 + t.Length];
|
||||
BinaryPrimitives.WriteUInt16BigEndian(b, (ushort)cls);
|
||||
BinaryPrimitives.WriteUInt16BigEndian(b.AsSpan(2), (ushort)group);
|
||||
BinaryPrimitives.WriteInt32BigEndian(b.AsSpan(4), number);
|
||||
t.CopyTo(b, 8);
|
||||
return b;
|
||||
}
|
||||
|
||||
private static HeidenhainDriverOptions Options(int port, params RawTagEntry[] tags) => new()
|
||||
{
|
||||
Devices = [new HeidenhainDeviceOptions { Host = "127.0.0.1", Port = port, DeviceName = "dev1" }],
|
||||
RawTags = tags,
|
||||
TimeoutMs = 500,
|
||||
Polling = new HeidenhainPollingOptions { StatusMs = 100, CustomMs = 100, SlowMs = 300, AlarmMs = 100 },
|
||||
Reconnect = new HeidenhainReconnectOptions { InitialDelayMs = 100, MaxDelayMs = 200 },
|
||||
};
|
||||
|
||||
private static HeidenhainDriver Create(HeidenhainDriverOptions o) =>
|
||||
new(o, "hh-1", null, new HeidenhainCredentials(null), null, null);
|
||||
|
||||
private static async Task WaitUntil(Func<bool> condition, int timeoutMs = 5000)
|
||||
{
|
||||
var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
|
||||
while (!condition())
|
||||
{
|
||||
if (DateTime.UtcNow > deadline) throw new TimeoutException("condition not reached");
|
||||
await Task.Delay(20, Ct);
|
||||
}
|
||||
}
|
||||
|
||||
private static readonly string[] ReadOnlyCommands = ["A_LG", "R_VR", "R_PR", "R_RI", "R_MB", "R_DP"];
|
||||
|
||||
[Fact]
|
||||
public async Task Golden_controller_alarm_raises_and_clears_conditions_with_only_allowlisted_reads()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
var list = new AlarmList();
|
||||
list.Install(control);
|
||||
list.Set(Golden());
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var any = AlarmTag("*", "Any");
|
||||
var cls7 = AlarmTag("CLASS=7", "Class7");
|
||||
var cls1 = AlarmTag("CLASS=1", "Class1");
|
||||
var other = AlarmTag("OTHER", "Other");
|
||||
await using var d = Create(Options(sim.Port, any, cls7, cls1, other));
|
||||
var events = new ConcurrentQueue<AlarmEventArgs>();
|
||||
d.OnAlarmEvent += (_, e) => events.Enqueue(e);
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
|
||||
(await d.ReadAsync([any.RawPath], Ct))[0].StatusCode.ShouldBe(HeidenhainStatus.BadNotSupported); // a condition, not a value
|
||||
await d.SubscribeAlarmsAsync([any.RawPath, cls7.RawPath, cls1.RawPath, other.RawPath], Ct);
|
||||
await WaitUntil(() => events.Count(e => e.Kind == AlarmTransitionKind.Raise) >= 2);
|
||||
await Task.Delay(400, Ct); // several more walks: an unchanged list re-raises nothing
|
||||
var raises = events.Where(e => e.Kind == AlarmTransitionKind.Raise).ToList();
|
||||
raises.Select(e => e.ConditionId).Order().ShouldBe(new[] { any.RawPath, cls7.RawPath }.Order());
|
||||
raises.ShouldAllBe(e => e.Message == "-1 Run test of cutout channels (class 7, group 4)" && e.OpcUaSeverity == 800
|
||||
&& e.SourceNodeId == $"127.0.0.1:{sim.Port}");
|
||||
events.Count.ShouldBe(2);
|
||||
|
||||
list.Set();
|
||||
await WaitUntil(() => events.Count(e => e.Kind == AlarmTransitionKind.Clear) == 2);
|
||||
list.Set(Record(1, 2, 3, "Other alarm"), Golden());
|
||||
await WaitUntil(() => events.Any(e => e.ConditionId == cls1.RawPath && e.Kind == AlarmTransitionKind.Raise));
|
||||
await WaitUntil(() => events.Count(e => e.Kind == AlarmTransitionKind.Raise) == 5); // Any, Class7, Class1 again/new
|
||||
events.ShouldNotContain(e => e.ConditionId == other.RawPath); // every alarm is claimed by a CLASS filter
|
||||
|
||||
// Read-only: only the allowlisted read set ever reached the wire, and every alarm walk is R_RI 27/28.
|
||||
control.Violations.ShouldBeEmpty();
|
||||
sim.Requests.Select(r => r.Command).Distinct().ShouldBeSubsetOf(ReadOnlyCommands);
|
||||
sim.Requests.Where(r => r.Command == "R_RI").Select(r => r.Selector).Distinct().Order().ShouldBe(new[] { 27, 28 });
|
||||
d.GetHealth().State.ShouldBe(DriverState.Healthy);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Acknowledge_is_local_only_and_never_touches_the_control()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var any = AlarmTag("*", "Any");
|
||||
await using var d = Create(Options(sim.Port, any));
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
await d.AcknowledgeAsync([new AlarmAcknowledgeRequest($"127.0.0.1:{sim.Port}", any.RawPath, "seen", "op")], Ct);
|
||||
await Task.Delay(200, Ct);
|
||||
sim.Connections.ShouldBe(0); // no session was opened, so nothing at all was sent
|
||||
sim.Requests.ShouldBeEmpty();
|
||||
|
||||
// And with a live session: the request log grows only by the poll's own allowlisted reads.
|
||||
var list = new AlarmList();
|
||||
list.Install(control);
|
||||
list.Set(Golden());
|
||||
await d.SubscribeAlarmsAsync([any.RawPath], Ct);
|
||||
await WaitUntil(() => sim.Requests.Count(r => r.Command == "R_RI") >= 4);
|
||||
await d.AcknowledgeAsync([new AlarmAcknowledgeRequest($"127.0.0.1:{sim.Port}", any.RawPath, "seen", "op")], Ct);
|
||||
await Task.Delay(200, Ct);
|
||||
sim.Requests.Select(r => r.Command).Distinct().ShouldBeSubsetOf(ReadOnlyCommands);
|
||||
control.Violations.ShouldBeEmpty();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Comms_loss_annotates_quality_once_and_recovery_never_re_raises_an_active_condition()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
var list = new AlarmList();
|
||||
list.Install(control);
|
||||
list.Set(Golden());
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var any = AlarmTag("*", "Any");
|
||||
await using var d = Create(Options(sim.Port, any));
|
||||
var events = new ConcurrentQueue<AlarmEventArgs>();
|
||||
d.OnAlarmEvent += (_, e) => events.Enqueue(e);
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
await d.SubscribeAlarmsAsync([any.RawPath], Ct);
|
||||
await WaitUntil(() => events.Any(e => e.Kind == AlarmTransitionKind.Raise));
|
||||
|
||||
sim.GoOffline();
|
||||
await WaitUntil(() => events.Any(e => e.QualityStatusCode == HeidenhainStatus.BadNoCommunication));
|
||||
await WaitUntil(() => d.GetHealth().State == DriverState.Degraded);
|
||||
await Task.Delay(500, Ct); // several failed reconnects: still ONE annotation
|
||||
events.Count(e => e.IsQualityOnly && e.QualityStatusCode == HeidenhainStatus.BadNoCommunication).ShouldBe(1);
|
||||
|
||||
sim.GoOnline();
|
||||
await WaitUntil(() => events.Any(e => e.IsQualityOnly && e.QualityStatusCode == HeidenhainStatus.Good), 8000);
|
||||
await Task.Delay(400, Ct);
|
||||
events.Count(e => e.Kind == AlarmTransitionKind.Raise).ShouldBe(1); // the same alarm is still active: no re-raise (no un-ack)
|
||||
events.ShouldNotContain(e => e.Kind == AlarmTransitionKind.Retrigger || e.Kind == AlarmTransitionKind.Clear);
|
||||
d.GetHealth().State.ShouldBe(DriverState.Healthy);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_refused_alarm_walk_is_quality_only_and_does_not_degrade_health()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
control.Runtime[27] = () => SimReply.Refuse(49); // access denied
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var any = AlarmTag("*", "Any");
|
||||
await using var d = Create(Options(sim.Port, any));
|
||||
var events = new ConcurrentQueue<AlarmEventArgs>();
|
||||
d.OnAlarmEvent += (_, e) => events.Enqueue(e);
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
await d.SubscribeAlarmsAsync([any.RawPath], Ct);
|
||||
await WaitUntil(() => events.Any(e => e.QualityStatusCode == HeidenhainStatus.BadUserAccessDenied));
|
||||
await Task.Delay(400, Ct);
|
||||
events.ShouldAllBe(e => e.IsQualityOnly);
|
||||
events.Count.ShouldBe(1);
|
||||
d.GetHealth().State.ShouldBe(DriverState.Healthy);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Alarm_events_are_recorded_only_while_a_handler_listens()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
var list = new AlarmList();
|
||||
list.Install(control);
|
||||
list.Set(Golden());
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var any = AlarmTag("*", "Any");
|
||||
await using var d = Create(Options(sim.Port, any));
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
await d.SubscribeAlarmsAsync([any.RawPath], Ct);
|
||||
await WaitUntil(() => sim.Requests.Count(r => r.Command == "R_RI" && r.Selector == 27) >= 3);
|
||||
|
||||
var events = new ConcurrentQueue<AlarmEventArgs>();
|
||||
d.OnAlarmEvent += (_, e) => events.Enqueue(e);
|
||||
await WaitUntil(() => events.Any(e => e.Kind == AlarmTransitionKind.Raise)); // nothing was "told" while detached
|
||||
}
|
||||
|
||||
// ---- rediscovery ----
|
||||
|
||||
[Fact]
|
||||
public async Task A_reconnect_with_a_different_identity_raises_rediscovery_once()
|
||||
{
|
||||
var control = new SimulatedControl();
|
||||
control.Runtime[23] = () => SimulatedControl.U16(4);
|
||||
await using var sim = Lsv2Simulator.WithControl(control);
|
||||
var tag = TestTags.Raw("Status/ExecutionState");
|
||||
await using var d = Create(Options(sim.Port, tag));
|
||||
var raised = new ConcurrentQueue<RediscoveryEventArgs>();
|
||||
d.OnRediscoveryNeeded += (_, e) => raised.Enqueue(e);
|
||||
await d.InitializeAsync("{}", Ct);
|
||||
await d.SubscribeAsync([tag.RawPath], TimeSpan.FromMilliseconds(100), Ct);
|
||||
await WaitUntil(() => d.GetHostStatuses().Single().State == HostState.Running);
|
||||
var connections = sim.Connections;
|
||||
|
||||
// Same identity across a reconnect: baseline only, nothing raised.
|
||||
sim.GoOffline();
|
||||
await WaitUntil(() => d.GetHealth().State == DriverState.Degraded);
|
||||
sim.GoOnline();
|
||||
await WaitUntil(() => sim.Connections > connections && d.GetHealth().State == DriverState.Healthy, 8000);
|
||||
raised.ShouldBeEmpty();
|
||||
|
||||
// NC software update while it was away.
|
||||
control.Version = Encoding.Latin1.GetBytes("iTNC 530\0NC 340490 08\0PLC\0OPT\0");
|
||||
connections = sim.Connections;
|
||||
sim.GoOffline();
|
||||
await WaitUntil(() => d.GetHealth().State == DriverState.Degraded);
|
||||
sim.GoOnline();
|
||||
await WaitUntil(() => !raised.IsEmpty, 8000);
|
||||
await Task.Delay(300, Ct);
|
||||
raised.Count.ShouldBe(1);
|
||||
raised.Single().Reason.ShouldContain("340490 04");
|
||||
raised.Single().Reason.ShouldContain("340490 08");
|
||||
control.Violations.ShouldBeEmpty();
|
||||
}
|
||||
}
|
||||
@@ -151,13 +151,26 @@ public sealed class HeidenhainDriverTests
|
||||
|
||||
sim.GoOffline();
|
||||
// EVERY remote leaf — fast status, slow identity/alarms and custom PLC — goes Bad at once.
|
||||
await WaitUntil(() => tags.Take(5).All(t => rec.Last(t.RawPath)?.StatusCode == HeidenhainStatus.BadNoCommunication));
|
||||
rec.Last(tags[5].RawPath)!.Value.ShouldBe("CommunicationLost");
|
||||
// The invalidation is ONE pass over the device's tags (in authored order, capability last), delivered to this
|
||||
// thread's recorder as it runs — so wait for the WHOLE pass to land (the capability's CommunicationLost is
|
||||
// its last publication) before asserting on any of it. Asserting the capability the instant the five value
|
||||
// tags read Bad raced the pass's final publish (1/40 on 5bbe1e3c: "Supported").
|
||||
await WaitUntil(() => tags.Take(5).All(t => rec.Last(t.RawPath)?.StatusCode == HeidenhainStatus.BadNoCommunication)
|
||||
&& rec.Last(tags[5].RawPath)?.Value is "CommunicationLost");
|
||||
rec.Last(tags[5].RawPath)!.StatusCode.ShouldBe(HeidenhainStatus.Good);
|
||||
// ...and it is one pass: no remote value published Good again after its outage invalidation.
|
||||
foreach (var t in tags.Take(5))
|
||||
{
|
||||
var seq = rec.For(t.RawPath).Select(s => s.StatusCode).ToList();
|
||||
seq.Skip(seq.LastIndexOf(HeidenhainStatus.BadNoCommunication)).ShouldAllBe(s => s == HeidenhainStatus.BadNoCommunication);
|
||||
}
|
||||
|
||||
(await d.ReadAsync([tags[2].RawPath], Ct))[0].StatusCode.ShouldBe(HeidenhainStatus.BadNoCommunication);
|
||||
await WaitUntil(() => d.GetHealth().State == DriverState.Degraded);
|
||||
// Degraded holds through every reconnect attempt (Backoff AND Connecting carry the last error), but the host
|
||||
// status reads Stopped only in Backoff and Unknown while a reconnect attempt is in flight — so wait for the
|
||||
// Backoff phase rather than sample whichever phase the loop happens to be in.
|
||||
await WaitUntil(() => d.GetHealth().State == DriverState.Degraded && d.GetHostStatuses().Single().State == HostState.Stopped);
|
||||
d.GetHealth().LastError.ShouldNotBeNullOrEmpty();
|
||||
d.GetHostStatuses().Single().State.ShouldBe(HostState.Stopped);
|
||||
hostEvents.ShouldContain(e => e.NewState == HostState.Stopped);
|
||||
var frozen = d.GetHealth().LastSuccessfulRead;
|
||||
await Task.Delay(500, Ct);
|
||||
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
# QuestDB historian integration-test fixture (#822) — the QuestDB backend's shared, always-available instance.
|
||||
#
|
||||
# Deployed on the shared Docker host (see infra/README.md §1) as /opt/otopcua-questdb:
|
||||
#
|
||||
# rsync -av tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.QuestDb.IntegrationTests/Docker/ \
|
||||
# dohertj2@10.100.0.35:/opt/otopcua-questdb/
|
||||
# ssh dohertj2@10.100.0.35 'cd /opt/otopcua-questdb && docker compose up -d'
|
||||
#
|
||||
# Endpoint (HISTORIAN_QUESTDB_TEST_CONNECTION):
|
||||
# Host=10.100.0.35;Port=8812;Username=admin;Password=quest;Database=qdb;ServerCompatibilityMode=NoTypeLoading
|
||||
# Web console: http://10.100.0.35:19000 (host :9000 is taken on the Docker host).
|
||||
#
|
||||
# admin/quest is QuestDB's stock default — a throwaway dev fixture credential, not a secret. The tests isolate by a
|
||||
# unique table prefix per test class and drop their tables on dispose, so the instance can be shared by concurrent runs.
|
||||
#
|
||||
# Image pinned as in docker-dev/docker-compose.questdb.yml (questdb/questdb:10.0.1, the #666 T0 spike's version; ≥ 8.2.3
|
||||
# for table TTL). cairo.ttl.use.wall.clock stays at its default (true) — the historian relies on it (#674.1).
|
||||
services:
|
||||
questdb:
|
||||
image: questdb/questdb:10.0.1
|
||||
container_name: otopcua-questdb
|
||||
restart: unless-stopped
|
||||
# Every lmxopcua fixture container carries this so the shared Docker host stays
|
||||
# discoverable with `docker ps --filter label=project=lmxopcua`.
|
||||
labels:
|
||||
project: lmxopcua
|
||||
ports:
|
||||
- "8812:8812" # PG wire (the historian backend + tests)
|
||||
- "19000:9000" # web console / REST
|
||||
volumes:
|
||||
- otopcua-questdb-fixture-data:/var/lib/questdb
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "curl -fs http://localhost:9003/status || exit 1"]
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 12
|
||||
volumes:
|
||||
otopcua-questdb-fixture-data:
|
||||
name: otopcua-questdb-fixture-data
|
||||
labels:
|
||||
project: lmxopcua
|
||||
+9
-7
@@ -10,21 +10,23 @@ public sealed class ProcessedReadTests
|
||||
[Fact]
|
||||
public void Every_enum_member_is_either_served_or_refused()
|
||||
{
|
||||
// Seventeen served (#671 added TimeAverage, TimeAverage2, Interpolative and Total2, and moved Total to the
|
||||
// time-weighted family; #680 moved PercentGood/PercentBad there too — they are duration-based); anything appended to
|
||||
// the enum later falls to the refusal (total default).
|
||||
Enum.GetValues<HistoryAggregateType>().Count(a => AggregateFamilies.FamilyOf(a) is not null).ShouldBe(17);
|
||||
// Nineteen served (#671 added TimeAverage, TimeAverage2, Interpolative and Total2, and moved Total to the
|
||||
// time-weighted family; #680 moved PercentGood/PercentBad there too — they are duration-based; #820 added
|
||||
// DurationGood/DurationBad, the same region time); anything appended to the enum later falls to the refusal
|
||||
// (total default).
|
||||
Enum.GetValues<HistoryAggregateType>().Count(a => AggregateFamilies.FamilyOf(a) is not null).ShouldBe(19);
|
||||
Enum.GetValues<HistoryAggregateType>().Where(a => AggregateFamilies.FamilyOf(a) == AggregateFamily.TimeWeighted)
|
||||
.ShouldBe([HistoryAggregateType.Total, HistoryAggregateType.Interpolative, HistoryAggregateType.TimeAverage,
|
||||
HistoryAggregateType.PercentGood, HistoryAggregateType.PercentBad, HistoryAggregateType.TimeAverage2,
|
||||
HistoryAggregateType.Total2]);
|
||||
HistoryAggregateType.DurationGood, HistoryAggregateType.DurationBad, HistoryAggregateType.PercentGood,
|
||||
HistoryAggregateType.PercentBad, HistoryAggregateType.TimeAverage2, HistoryAggregateType.Total2],
|
||||
ignoreOrder: true);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Served_is_exactly_the_members_with_a_family()
|
||||
{
|
||||
// #682: the advertised set and the dispatch are one definition — a member is served iff it has a family.
|
||||
AggregateFamilies.Served.Count.ShouldBe(17);
|
||||
AggregateFamilies.Served.Count.ShouldBe(19);
|
||||
foreach (var a in Enum.GetValues<HistoryAggregateType>())
|
||||
AggregateFamilies.Served.Contains(a).ShouldBe(AggregateFamilies.FamilyOf(a) is not null, a.ToString());
|
||||
}
|
||||
|
||||
+98
-4
@@ -213,7 +213,8 @@ public sealed class SdkAggregateParityTests
|
||||
/// <summary>
|
||||
/// Applies the documented divergences listed on the class (other than truncation): strips the Calculated bit from our
|
||||
/// <c>BadNoData</c>; maps our generic-Bad TimeAverage2/Total2 outage interval to the SDK's <c>BadNoData</c>; takes the
|
||||
/// SDK's value for the end-of-data interval of TimeAverage2/Total2/PercentGood/PercentBad (its 1 ms artifact).
|
||||
/// SDK's value for the end-of-data interval of TimeAverage2/Total2/PercentGood/PercentBad/DurationGood/DurationBad
|
||||
/// (its 1 ms artifact).
|
||||
/// </summary>
|
||||
private static IReadOnlyList<DataValueSnapshot> MaskDocumented(HistoryAggregateType agg, IReadOnlyList<DataValueSnapshot> ours,
|
||||
IReadOnlyList<SdkAggregateOracle.Result> sdk, double from, double to, double intervalS, StoredSample[] data)
|
||||
@@ -225,7 +226,8 @@ public sealed class SdkAggregateParityTests
|
||||
var dataEnds = endsInWindow && data.Single(x => x.TimeUtc.Ticks == last).IsUsable;
|
||||
var outageEnds = endsInWindow && !dataEnds;
|
||||
var boolean = data.Any(x => x.Value.Kind == HistorianValueKind.Boolean);
|
||||
var percent = agg is HistoryAggregateType.PercentGood or HistoryAggregateType.PercentBad;
|
||||
var percent = agg is HistoryAggregateType.PercentGood or HistoryAggregateType.PercentBad
|
||||
or HistoryAggregateType.DurationGood or HistoryAggregateType.DurationBad;
|
||||
for (long i = 0; i < plan.BucketCount; i++)
|
||||
{
|
||||
var k = (int)(plan.Reversed ? plan.BucketCount - 1 - i : i);
|
||||
@@ -244,7 +246,7 @@ public sealed class SdkAggregateParityTests
|
||||
&& code == HistorianStatusCodes.Good
|
||||
&& (sdk[k].StatusCode & StatusBits.CodeBitsMask) == HistorianStatusCodes.UncertainDataSubNormal)
|
||||
list[k] = list[k] with { StatusCode = (list[k].StatusCode & ~StatusBits.CodeBitsMask) | HistorianStatusCodes.UncertainDataSubNormal };
|
||||
if (dataEnds && (twoVariant || agg is HistoryAggregateType.PercentGood or HistoryAggregateType.PercentBad)
|
||||
if (dataEnds && (twoVariant || percent)
|
||||
&& last >= plan.LowerTicks(i) && last < plan.UpperTicks(i) && sdk[k].Value is not null)
|
||||
list[k] = list[k] with { Value = sdk[k].Value };
|
||||
// An outage marker as the last sample: ours runs the outage to the window end (no end-of-data Partial on the
|
||||
@@ -290,7 +292,7 @@ public sealed class SdkAggregateParityTests
|
||||
{
|
||||
HistoryAggregateType.TimeAverage, HistoryAggregateType.TimeAverage2, HistoryAggregateType.Total,
|
||||
HistoryAggregateType.Total2, HistoryAggregateType.Interpolative, HistoryAggregateType.PercentGood,
|
||||
HistoryAggregateType.PercentBad,
|
||||
HistoryAggregateType.PercentBad, HistoryAggregateType.DurationGood, HistoryAggregateType.DurationBad,
|
||||
})
|
||||
foreach (var (name, data) in new[]
|
||||
{
|
||||
@@ -473,6 +475,98 @@ public sealed class SdkAggregateParityTests
|
||||
(100 - Pct(AsIs(HistoryAggregateType.PercentBad, 0, 20, data, cfg))).ShouldBe(50d, 1e-9);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #821: data that starts inside [0, 20) at +5 with an <b>Uncertain</b> first sample — the #810 QualityMix tag QP:
|
||||
/// Uncertain 10 at +5, Good 11 at +12, Uncertain 12 at +25, nothing after.
|
||||
/// </summary>
|
||||
private static readonly StoredSample[] UncertainFirstLateStart =
|
||||
[
|
||||
S(5, HistorianValue.FromDouble(10), Uncertain),
|
||||
S(12, HistorianValue.FromDouble(11), Good),
|
||||
S(25, HistorianValue.FromDouble(12), Uncertain),
|
||||
];
|
||||
|
||||
/// <summary>The <see cref="UncertainFirstLateStart"/> control: the same data with a <b>Good</b> first sample.</summary>
|
||||
private static readonly StoredSample[] GoodFirstLateStart =
|
||||
[S(5, HistorianValue.FromDouble(10), Good), .. UncertainFirstLateStart[1..]];
|
||||
|
||||
/// <summary>
|
||||
/// Runs SDK 2.0.1's OWN stock calculator (<see cref="Opc.Ua.Server.Aggregators"/>, not the frozen 1.5.378.182 copy
|
||||
/// the server registers) under the server-default configuration — for the #809/#821 facts only.
|
||||
/// </summary>
|
||||
private static List<(double? Value, uint Status)> Stock201(HistoryAggregateType agg, double from, double to,
|
||||
StoredSample[] data)
|
||||
{
|
||||
var id = agg switch
|
||||
{
|
||||
HistoryAggregateType.Total => Opc.Ua.ObjectIds.AggregateFunction_Total,
|
||||
HistoryAggregateType.TimeAverage => Opc.Ua.ObjectIds.AggregateFunction_TimeAverage,
|
||||
HistoryAggregateType.DurationGood => Opc.Ua.ObjectIds.AggregateFunction_DurationGood,
|
||||
HistoryAggregateType.PercentGood => Opc.Ua.ObjectIds.AggregateFunction_PercentGood,
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(agg)),
|
||||
};
|
||||
var calc = Opc.Ua.Server.Aggregators.CreateStandardCalculator(id, At(from), At(to),
|
||||
(At(to) - At(from)).Duration().TotalMilliseconds, false, SdkAggregateOracle.DefaultConfiguration,
|
||||
Opc.Ua.DefaultTelemetry.Create(_ => { }))!;
|
||||
var ordered = data.OrderBy(s => s.TimeUtc).ToList();
|
||||
if (to < from) ordered.Reverse();
|
||||
foreach (var s in ordered)
|
||||
calc.QueueRawValue(new Opc.Ua.DataValue(Opc.Ua.Variant.From(s.Value.Number), s.Status, s.TimeUtc, s.TimeUtc));
|
||||
var results = new List<(double?, uint)>();
|
||||
while (calc.TryGetProcessedValue(true, out var dv))
|
||||
results.Add((dv.WrappedValue.TryGetValue(out double d) ? d : null, dv.StatusCode.Code));
|
||||
return results;
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0, 20)]
|
||||
[InlineData(20, 0)]
|
||||
public void An_Uncertain_first_sample_in_a_late_start_interval_makes_the_SDK_integrate_the_time_before_the_data(
|
||||
double from, double to)
|
||||
{
|
||||
// #821, pinned divergence (pending the #809/#821 owner decision — this test records, it does not choose).
|
||||
// Part 13 §5.4.3.3/§5.4.3.8: the interpolated-bounding signal is defined from the first sample only — 10 → 11 over
|
||||
// [5,12) (73.5) and 11 → 11 + 8/13 over [12,20) (4·(22 + 8/13)) ⇒ Total 163.96…, TimeAverage = Total ÷ 15 s.
|
||||
const double part13Total = 73.5 + 88 + 32d / 13;
|
||||
Pct(Ours(HistoryAggregateType.Total, from, to, 0, UncertainFirstLateStart)).ShouldBe(part13Total, 1e-9);
|
||||
Pct(Ours(HistoryAggregateType.TimeAverage, from, to, 0, UncertainFirstLateStart)).ShouldBe(part13Total / 15, 1e-9);
|
||||
|
||||
// The frozen 1.5.378.182 calculators — exactly what the server registers for live AggregateFilter items
|
||||
// (CompatibilityAggregateFactory; Sdk2AggregateCompatibilityTests proves the runtime manager serves the same code)
|
||||
// — integrate the uncovered [0,5) as a ramp 0 → 10 (+25) and divide TimeAverage by the WHOLE 20 s interval.
|
||||
Pct(AsIs(HistoryAggregateType.Total, from, to, UncertainFirstLateStart)).ShouldBe(part13Total + 25, 1e-9);
|
||||
Pct(AsIs(HistoryAggregateType.TimeAverage, from, to, UncertainFirstLateStart)).ShouldBe((part13Total + 25) / 20, 1e-9);
|
||||
// SDK 2.0.1's own stock calculators answer the same: the upgrade did not change this.
|
||||
Stock201(HistoryAggregateType.Total, from, to, UncertainFirstLateStart).Single().Value!.Value
|
||||
.ShouldBe(part13Total + 25, 1e-9);
|
||||
Stock201(HistoryAggregateType.TimeAverage, from, to, UncertainFirstLateStart).Single().Value!.Value
|
||||
.ShouldBe((part13Total + 25) / 20, 1e-9);
|
||||
// Status agrees everywhere (Uncertain — an Uncertain value is used and the interval is not fully covered).
|
||||
(AsIs(HistoryAggregateType.Total, from, to, UncertainFirstLateStart).Single().StatusCode & StatusBits.CodeBitsMask)
|
||||
.ShouldBe(HistorianStatusCodes.UncertainDataSubNormal);
|
||||
(Ours(HistoryAggregateType.Total, from, to, 0, UncertainFirstLateStart).Single().StatusCode & StatusBits.CodeBitsMask)
|
||||
.ShouldBe(HistorianStatusCodes.UncertainDataSubNormal);
|
||||
|
||||
// Control: the SAME data with a Good first sample — all three agree on the Part 13 answer, so the trigger is the
|
||||
// Uncertain first sample, not the late start.
|
||||
foreach (var agg in new[] { HistoryAggregateType.Total, HistoryAggregateType.TimeAverage })
|
||||
{
|
||||
var expected = agg == HistoryAggregateType.Total ? part13Total : part13Total / 15;
|
||||
Pct(Ours(agg, from, to, 0, GoodFirstLateStart)).ShouldBe(expected, 1e-9);
|
||||
Pct(AsIs(agg, from, to, GoodFirstLateStart)).ShouldBe(expected, 1e-9);
|
||||
Stock201(agg, from, to, GoodFirstLateStart).Single().Value!.Value.ShouldBe(expected, 1e-9);
|
||||
}
|
||||
|
||||
// #809 on the same input: DurationGood / PercentGood — Part 13 (ours) and stock SDK 2.0.1 count Good regions only
|
||||
// ([12,20) = 8 s); the frozen live calculators also count the Uncertain [5,12) as Good (15 s).
|
||||
Pct(Ours(HistoryAggregateType.DurationGood, from, to, 0, UncertainFirstLateStart)).ShouldBe(8_000d, 1e-9);
|
||||
Stock201(HistoryAggregateType.DurationGood, from, to, UncertainFirstLateStart).Single().Value!.Value.ShouldBe(8_000d, 1e-9);
|
||||
Pct(AsIs(HistoryAggregateType.DurationGood, from, to, UncertainFirstLateStart)).ShouldBe(15_000d, 1e-9);
|
||||
Pct(Ours(HistoryAggregateType.PercentGood, from, to, 0, UncertainFirstLateStart)).ShouldBe(40d, 1e-9);
|
||||
Stock201(HistoryAggregateType.PercentGood, from, to, UncertainFirstLateStart).Single().Value!.Value.ShouldBe(40d, 1e-9);
|
||||
Pct(AsIs(HistoryAggregateType.PercentGood, from, to, UncertainFirstLateStart)).ShouldBe(75d, 1e-9);
|
||||
}
|
||||
|
||||
/// <summary>#684: Good 10 / 30 with an Uncertain value BELOW the Good minimum (+4) and one ABOVE the maximum (+6).</summary>
|
||||
private static readonly StoredSample[] UncertainBeyond =
|
||||
[
|
||||
|
||||
+27
@@ -274,6 +274,33 @@ public sealed class TimeWeightedAggregatorTests
|
||||
bad.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalcPartial, NoDataCalc]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Duration_aggregates_are_the_percent_regions_in_milliseconds()
|
||||
{
|
||||
// #820: DurationGood / DurationBad are the same Good / Bad region time as PercentGood / PercentBad, as an OPC UA
|
||||
// Duration (ms, the SDK's unit), with the same statuses and Partial bits — tag A over [0,80) at 20 s.
|
||||
var good = Run(HistoryAggregateType.DurationGood, 0, 80, 20, A);
|
||||
Values(good, 20_000, 10_000, 20_000, null);
|
||||
good.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalcPartial, NoDataCalc]);
|
||||
good.Where(x => x.Value is not null).ShouldAllBe(x => x.Value is double);
|
||||
var bad = Run(HistoryAggregateType.DurationBad, 0, 80, 20, A);
|
||||
Values(bad, 0, 10_000, 0, null);
|
||||
bad.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalcPartial, NoDataCalc]);
|
||||
|
||||
// Uncertain time counts toward neither (Mantis 0006166): −3 G, +4 outage, +6 U, +12 G, +30 G over [0,20) at 10 s ⇒
|
||||
// B0 [0,4) Uncertain (bound into the outage), [4,6) Bad, [6,10) Uncertain; B1 [10,12) Uncertain, [12,20) Good.
|
||||
StoredSample[] s =
|
||||
[
|
||||
S(-3, HistorianValue.FromDouble(10), Good), S(4, HistorianValue.Empty, BadNoCommunication),
|
||||
S(6, HistorianValue.FromDouble(30), Uncertain), S(12, HistorianValue.FromDouble(3), Good),
|
||||
S(30, HistorianValue.FromDouble(3), Good),
|
||||
];
|
||||
Values(Run(HistoryAggregateType.DurationGood, 0, 20, 10, s), 0, 8_000);
|
||||
Values(Run(HistoryAggregateType.DurationBad, 0, 20, 10, s), 2_000, 0);
|
||||
// A truncated interval measures its own (shorter) span: [10,15) holds [10,12) Uncertain + [12,15) Good.
|
||||
Values(Run(HistoryAggregateType.DurationGood, 0, 15, 10, s), 0, 3_000);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void With_no_end_bound_the_last_region_runs_to_the_interval_end()
|
||||
{
|
||||
|
||||
+161
-30
@@ -1,5 +1,6 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Security.Cryptography.X509Certificates;
|
||||
using Opc.Ua;
|
||||
using Opc.Ua.Client;
|
||||
using Shouldly;
|
||||
@@ -20,27 +21,54 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Browser.IntegrationTests;
|
||||
/// # or locally / in CI (scripts/ci/integration-fixtures.sh starts the same shape as otopcua-ci-opcplc-nat):
|
||||
/// docker run -d --rm --name otopcua-806-nat --hostname otopcua-806-nat-parity -p 32781:50000 \
|
||||
/// mcr.microsoft.com/iotedge/opc-plc:2.14.10 --pn=50000 --ph=otopcua-806-nat-parity.invalid --autoaccept --ut
|
||||
/// OPCUA_NAT_ENDPOINT=opc.tcp://127.0.0.1:32781 dotnet test --filter Fixture=opc-plc-nat
|
||||
/// docker exec otopcua-806-nat bash -c 'cat /app/pki/own/certs/*.der' > /tmp/nat.der # public cert only
|
||||
/// OPCUA_NAT_ENDPOINT=opc.tcp://127.0.0.1:32781 OPCUA_NAT_SERVER_CERT=/tmp/nat.der dotnet test --filter Fixture=opc-plc-nat
|
||||
/// </code>
|
||||
/// Skipped unless <c>OPCUA_NAT_ENDPOINT</c> is set and accepts TCP. Every test first proves the premise (the
|
||||
/// advertised URL is NOT the configured host:port, and its host does not resolve here), so a fixture that
|
||||
/// advertises a reachable address cannot make these pass vacuously. Before the fix the positive cases failed with
|
||||
/// <c>SocketException: nodename nor servname provided, or not known</c>.
|
||||
/// <para><b>Secure cases (#813/#816/#818).</b> Every browse here runs on a THROWAWAY browse PKI (the browser's
|
||||
/// internal PKI-root seam), never the operator's <c>adminui-browse-pki</c>. The refusal case trusts nothing. The
|
||||
/// positive and host-name cases trust the fixture's PUBLIC certificate — from <c>OPCUA_NAT_SERVER_CERT</c> (a DER or
|
||||
/// PEM file; what CI exports after copying it out of its throwaway container) or else the committed
|
||||
/// <c>Docker/nat/opc-plc-nat-server.der</c> (the shared-host stack's certificate, stable since #818 put its PKI on a
|
||||
/// volume) — and SKIP when the committed certificate is not the one the server presents, so they can never pass
|
||||
/// against a different server.</para>
|
||||
/// </summary>
|
||||
[Trait("Category", "Integration"), Trait("Fixture", "opc-plc-nat")]
|
||||
public sealed class NatPublishedEndpointBrowseTests
|
||||
public sealed class NatPublishedEndpointBrowseTests : IDisposable
|
||||
{
|
||||
private const string EnvVar = "OPCUA_NAT_ENDPOINT";
|
||||
private const string CertEnvVar = "OPCUA_NAT_SERVER_CERT";
|
||||
private const string CommittedCertFile = "opc-plc-nat-server.der";
|
||||
|
||||
private readonly string _pkiRoot = Path.Combine(Path.GetTempPath(), "otopcua-nat-pki-" + Guid.NewGuid().ToString("N"));
|
||||
|
||||
private static string? Endpoint => Environment.GetEnvironmentVariable(EnvVar) is { Length: > 0 } e ? e : null;
|
||||
|
||||
private static string Json(string endpoint, string policy = "None", string mode = "None") => $$"""
|
||||
{
|
||||
"EndpointUrl":"{{endpoint}}",
|
||||
"SecurityPolicy":"{{policy}}","SecurityMode":"{{mode}}","AuthType":"Anonymous",
|
||||
"SessionTimeout":"00:01:00","Timeout":"00:00:10","PerEndpointConnectTimeout":"00:00:10"
|
||||
}
|
||||
""";
|
||||
/// <inheritdoc />
|
||||
public void Dispose()
|
||||
{
|
||||
try { Directory.Delete(_pkiRoot, recursive: true); } catch { /* best-effort temp cleanup */ }
|
||||
}
|
||||
|
||||
/// <summary>A browser on this test's throwaway PKI.</summary>
|
||||
private OpcUaClientDriverBrowser Browser() => new(_pkiRoot);
|
||||
|
||||
private static string Json(string endpoint, string policy = "None", string mode = "None", bool? validateHostName = null)
|
||||
{
|
||||
var certValidation = validateHostName is { } v
|
||||
? $$""","CertificateValidation":{"ValidateServerHostName":{{(v ? "true" : "false")}}}"""
|
||||
: "";
|
||||
return $$"""
|
||||
{
|
||||
"EndpointUrl":"{{endpoint}}",
|
||||
"SecurityPolicy":"{{policy}}","SecurityMode":"{{mode}}","AuthType":"Anonymous",
|
||||
"SessionTimeout":"00:01:00","Timeout":"00:00:10","PerEndpointConnectTimeout":"00:00:10"{{certValidation}}
|
||||
}
|
||||
""";
|
||||
}
|
||||
|
||||
private static string RequireFixture()
|
||||
{
|
||||
@@ -60,8 +88,11 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
return endpoint;
|
||||
}
|
||||
|
||||
/// <summary>The premise: the server advertises a host:port other than the configured one, and that host is unresolvable.</summary>
|
||||
private static async Task AssertAdvertisesUnreachableAddressAsync(string endpoint, CancellationToken ct)
|
||||
/// <summary>
|
||||
/// The premise: the server advertises a host:port other than the configured one, and that host is unresolvable.
|
||||
/// Returns the DER certificate the server presents on its secure endpoint.
|
||||
/// </summary>
|
||||
private static async Task<byte[]> AssertAdvertisesUnreachableAddressAsync(string endpoint, CancellationToken ct)
|
||||
{
|
||||
var appConfig = new ApplicationConfiguration(DefaultTelemetry.Create(_ => { }))
|
||||
{
|
||||
@@ -84,6 +115,61 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
await Should.ThrowAsync<SocketException>(() => Dns.GetHostAddressesAsync(advertised.Host, ct),
|
||||
$"advertised host '{advertised.Host}' must be unresolvable from here, or this test proves nothing");
|
||||
}
|
||||
|
||||
return endpoints.First(e => e.SecurityPolicyUri == SecurityPolicies.Basic256Sha256).ServerCertificate.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Trust the fixture's public certificate in this test's throwaway PKI, or SKIP when no certificate for THIS
|
||||
/// server is available (see the class remarks). An explicit <c>OPCUA_NAT_SERVER_CERT</c> that does not match
|
||||
/// FAILS: it names the certificate the operator meant, so a mismatch is a fixture problem worth seeing.
|
||||
/// </summary>
|
||||
/// <param name="presentedDer">The certificate the server presents (from its GetEndpoints answer).</param>
|
||||
private void TrustFixtureCertificate(byte[] presentedDer)
|
||||
{
|
||||
using var presented = X509CertificateLoader.LoadCertificate(presentedDer);
|
||||
X509Certificate2 trusted;
|
||||
if (Environment.GetEnvironmentVariable(CertEnvVar) is { Length: > 0 } path)
|
||||
{
|
||||
trusted = LoadPublicCertificate(path);
|
||||
trusted.Thumbprint.ShouldBe(presented.Thumbprint,
|
||||
$"{CertEnvVar}={path} is not the certificate the NAT fixture presents");
|
||||
}
|
||||
else
|
||||
{
|
||||
var committed = Path.Combine(AppContext.BaseDirectory, CommittedCertFile);
|
||||
if (!File.Exists(committed))
|
||||
Assert.Skip($"{CommittedCertFile} is not deployed next to the tests and {CertEnvVar} is unset.");
|
||||
trusted = LoadPublicCertificate(committed);
|
||||
if (trusted.Thumbprint != presented.Thumbprint)
|
||||
Assert.Skip($"the committed {CommittedCertFile} ({trusted.Thumbprint}) is not this fixture's certificate " +
|
||||
$"({presented.Thumbprint}, expires {presented.NotAfter:yyyy-MM-dd}); set {CertEnvVar} or " +
|
||||
"refresh the committed copy (see Docker/nat/docker-compose.yml).");
|
||||
}
|
||||
|
||||
using (trusted)
|
||||
{
|
||||
trusted.HasPrivateKey.ShouldBeFalse("only a PUBLIC certificate is ever trusted from a file");
|
||||
var certs = Path.Combine(_pkiRoot, "trusted", "certs");
|
||||
Directory.CreateDirectory(certs);
|
||||
File.WriteAllBytes(Path.Combine(certs, "opc-plc-nat.der"), trusted.RawData);
|
||||
}
|
||||
}
|
||||
|
||||
private static X509Certificate2 LoadPublicCertificate(string path)
|
||||
{
|
||||
var bytes = File.ReadAllBytes(path);
|
||||
var text = System.Text.Encoding.ASCII.GetString(bytes);
|
||||
return text.Contains("-----BEGIN CERTIFICATE-----", StringComparison.Ordinal)
|
||||
? X509Certificate2.CreateFromPem(text)
|
||||
: X509CertificateLoader.LoadCertificate(bytes);
|
||||
}
|
||||
|
||||
private static StatusCode? FindStatus(Exception? ex)
|
||||
{
|
||||
for (; ex is not null; ex = ex.InnerException)
|
||||
if (ex is ServiceResultException sre) return sre.StatusCode;
|
||||
return null;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -93,7 +179,7 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
await AssertAdvertisesUnreachableAddressAsync(endpoint, ct);
|
||||
|
||||
await using var session = await new OpcUaClientDriverBrowser().OpenAsync(Json(endpoint), ct);
|
||||
await using var session = await Browser().OpenAsync(Json(endpoint), ct);
|
||||
var roots = await session.RootAsync(ct);
|
||||
roots.Count.ShouldBeGreaterThan(0);
|
||||
|
||||
@@ -104,6 +190,21 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
children.Count.ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Review of #816: with the host-name check ON, an unsecured browse still opens although the NAT certificate (sent
|
||||
/// in the GetEndpoints reply even for the None endpoint) names another host — the check never runs on None.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Host_name_validation_does_not_apply_to_a_None_browse()
|
||||
{
|
||||
var endpoint = RequireFixture();
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
await AssertAdvertisesUnreachableAddressAsync(endpoint, ct);
|
||||
|
||||
await using var session = await Browser().OpenAsync(Json(endpoint, validateHostName: true), ct);
|
||||
(await session.RootAsync(ct)).Count.ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Unreachable_configured_endpoint_still_fails_cleanly()
|
||||
{
|
||||
@@ -111,7 +212,7 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
// A closed loopback port: the rewrite must not invent a reachable address; the open fails promptly.
|
||||
var sw = System.Diagnostics.Stopwatch.StartNew();
|
||||
await Should.ThrowAsync<Exception>(() => new OpcUaClientDriverBrowser().OpenAsync(Json("opc.tcp://127.0.0.1:1"), ct));
|
||||
await Should.ThrowAsync<Exception>(() => Browser().OpenAsync(Json("opc.tcp://127.0.0.1:1"), ct));
|
||||
sw.Elapsed.ShouldBeLessThan(TimeSpan.FromSeconds(30));
|
||||
}
|
||||
|
||||
@@ -122,29 +223,59 @@ public sealed class NatPublishedEndpointBrowseTests
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
await AssertAdvertisesUnreachableAddressAsync(endpoint, ct);
|
||||
|
||||
// Basic256Sha256/SignAndEncrypt through the published port. The browse PKI never auto-accepts, so unless the
|
||||
// operator trusted this fixture's certificate in the browse PKI (then set OPCUA_NAT_SERVER_CERT_TRUSTED=1) the
|
||||
// open must be refused on the certificate — which proves the session reached the SERVER (no DNS failure on the
|
||||
// advertised host) and that the rewrite did not relax trust.
|
||||
var trusted = Environment.GetEnvironmentVariable("OPCUA_NAT_SERVER_CERT_TRUSTED") == "1";
|
||||
var json = Json(endpoint, "Basic256Sha256", "SignAndEncrypt");
|
||||
if (trusted)
|
||||
{
|
||||
await using var session = await new OpcUaClientDriverBrowser().OpenAsync(json, ct);
|
||||
(await session.RootAsync(ct)).Count.ShouldBeGreaterThan(0);
|
||||
return;
|
||||
}
|
||||
|
||||
// Basic256Sha256/SignAndEncrypt through the published port, on a browse PKI that trusts NOTHING (the browse
|
||||
// never auto-accepts): the open must be refused on the certificate — which proves the session reached the
|
||||
// SERVER (no DNS failure on the advertised host) and that the rewrite did not relax trust.
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await using var session = await new OpcUaClientDriverBrowser().OpenAsync(json, ct);
|
||||
await using var session = await Browser().OpenAsync(Json(endpoint, "Basic256Sha256", "SignAndEncrypt"), ct);
|
||||
});
|
||||
TestContext.Current.TestOutputHelper?.WriteLine($"secure open refused: {ex.GetType().Name}: {ex.Message}");
|
||||
ex.ShouldNotBeOfType<SocketException>($"must not fail on DNS for the advertised host: {ex}");
|
||||
var sre = ex as ServiceResultException ?? ex.InnerException as ServiceResultException;
|
||||
sre.ShouldNotBeNull($"expected a certificate refusal, got {ex.GetType().Name}: {ex.Message}");
|
||||
sre.StatusCode.ShouldBeOneOf(
|
||||
var status = FindStatus(ex);
|
||||
status.ShouldNotBeNull($"expected a certificate refusal, got {ex.GetType().Name}: {ex.Message}");
|
||||
status.Value.ShouldBeOneOf(
|
||||
StatusCodes.BadCertificateUntrusted, StatusCodes.BadSecurityChecksFailed,
|
||||
StatusCodes.BadCertificateChainIncomplete);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #818 — the positive secure case, runnable in CI. #816 — with the host-name check unset (the default) or
|
||||
/// explicitly off, a trusted certificate is accepted although it names <c>*-nat-private.invalid</c> and the
|
||||
/// browse dialled the published address: the NAT opt-out.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData(null)]
|
||||
[InlineData(false)]
|
||||
public async Task Secure_browse_with_the_fixture_certificate_trusted_succeeds_without_a_host_name_check(bool? validate)
|
||||
{
|
||||
var endpoint = RequireFixture();
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
TrustFixtureCertificate(await AssertAdvertisesUnreachableAddressAsync(endpoint, ct));
|
||||
|
||||
await using var session = await Browser().OpenAsync(
|
||||
Json(endpoint, "Basic256Sha256", "SignAndEncrypt", validate), ct);
|
||||
(await session.RootAsync(ct)).Count.ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #816 — with the host-name check on, the SAME trusted certificate is refused, and the host checked is the one
|
||||
/// the operator configured (the published address), not the server-advertised private name the certificate lists.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Host_name_validation_checks_the_configured_host_and_refuses_the_NAT_certificate()
|
||||
{
|
||||
var endpoint = RequireFixture();
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
TrustFixtureCertificate(await AssertAdvertisesUnreachableAddressAsync(endpoint, ct));
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await using var session = await Browser().OpenAsync(
|
||||
Json(endpoint, "Basic256Sha256", "SignAndEncrypt", validateHostName: true), ct);
|
||||
});
|
||||
TestContext.Current.TestOutputHelper?.WriteLine($"secure open refused: {ex.GetType().Name}: {ex.Message}");
|
||||
FindStatus(ex).ShouldBe(StatusCodes.BadCertificateHostNameInvalid, $"expected a host-name refusal, got {ex}");
|
||||
ex.ToString().ShouldContain($"'{new Uri(endpoint).IdnHost}'");
|
||||
}
|
||||
}
|
||||
|
||||
+7
@@ -24,4 +24,11 @@
|
||||
<ProjectReference Include="..\..\..\src\Core\ZB.MOM.WW.OtOpcUa.Commons\ZB.MOM.WW.OtOpcUa.Commons.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<!-- #818: the shared-host NAT fixture's PUBLIC server certificate (its PKI is on a persistent volume), trusted by
|
||||
NatPublishedEndpointBrowseTests in a throwaway browse PKI. Never a private key. -->
|
||||
<None Include="..\ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.IntegrationTests\Docker\nat\opc-plc-nat-server.der"
|
||||
Link="opc-plc-nat-server.der" CopyToOutputDirectory="PreserveNewest" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
|
||||
+3
-3
@@ -56,11 +56,11 @@ public sealed class OpcUaClientBrowserCertificateAuthTests
|
||||
{
|
||||
AuthType = OpcUaAuthType.Certificate,
|
||||
UserCertificatePath = path,
|
||||
UserCertificatePassword = "secret:opcua/browse-cert",
|
||||
UserCertificatePassword = "secret:opcuaclient/browse-cert",
|
||||
};
|
||||
|
||||
var identity = await OpcUaClientDriverBrowser.BuildBrowseUserIdentityAsync(
|
||||
opts, new OneSecret("opcua/browse-cert", "s3cret-pw"), TestContext.Current.CancellationToken);
|
||||
opts, new OneSecret("opcuaclient/browse-cert", "s3cret-pw"), TestContext.Current.CancellationToken);
|
||||
|
||||
identity.TokenType.ShouldBe(UserTokenType.Certificate);
|
||||
}
|
||||
@@ -78,7 +78,7 @@ public sealed class OpcUaClientBrowserCertificateAuthTests
|
||||
{
|
||||
AuthType = OpcUaAuthType.Username,
|
||||
Username = "op",
|
||||
Password = "secret:opcua/pw",
|
||||
Password = "secret:opcuaclient/pw",
|
||||
};
|
||||
|
||||
var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
|
||||
|
||||
+4
-2
@@ -10,7 +10,8 @@ here since opc-plc ships pre-containerized.
|
||||
| File | Purpose |
|
||||
|---|---|
|
||||
| [`docker-compose.yml`](docker-compose.yml) | Service definition for `otopcua-opc-plc` — image pin, port map, command flags. |
|
||||
| [`nat/docker-compose.yml`](nat/docker-compose.yml) | `otopcua-opc-plc-nat` — a SEPARATE stack (`/opt/otopcua-opcuaclient-nat` on the shared host): opc-plc advertising a private `.invalid` host on internal port 50000, published on 50010. For `NatPublishedEndpointBrowseTests` (`OPCUA_NAT_ENDPOINT=opc.tcp://10.100.0.35:50010`, #806/#813); see the compose file's header. |
|
||||
| [`nat/docker-compose.yml`](nat/docker-compose.yml) | `otopcua-opc-plc-nat` — a SEPARATE stack (`/opt/otopcua-opcuaclient-nat` on the shared host): opc-plc advertising a private `.invalid` host on internal port 50000, published on 50010. For `NatPublishedEndpointBrowseTests` (`OPCUA_NAT_ENDPOINT=opc.tcp://10.100.0.35:50010`, #806/#813); see the compose file's header. Its PKI is on a volume (#818). |
|
||||
| [`nat/opc-plc-nat-server.der`](nat/opc-plc-nat-server.der) | The NAT stack's **public** server certificate (no key), trusted by the positive secure / host-name NAT tests in a throwaway browse PKI. Refresh it when the stack's certificate is rolled (`docker compose down -v`); expires 2027-11-10. |
|
||||
| (this file) | How to run it. |
|
||||
|
||||
## Install
|
||||
@@ -34,7 +35,8 @@ docker compose up
|
||||
```
|
||||
|
||||
First run pulls the image (~250 MB). Startup takes ~5-10 seconds; the
|
||||
healthcheck in the compose file surfaces ready state in `docker ps`.
|
||||
healthcheck in the compose file surfaces ready state in `docker ps` (a bash `/dev/tcp` probe —
|
||||
the image has no `netstat`, which kept the old check permanently "unhealthy", #817).
|
||||
|
||||
To run detached (CI pattern):
|
||||
|
||||
|
||||
+3
-1
@@ -38,7 +38,9 @@ services:
|
||||
# opc-plc doesn't expose an HTTP health endpoint by default; use a TCP
|
||||
# probe via a shell the base image ships with. The fixture does its own
|
||||
# TCP probe but healthcheck surfaces status in `docker ps` for humans.
|
||||
test: ["CMD-SHELL", "netstat -an | grep -q ':50000.*LISTEN' || exit 1"]
|
||||
# #817: bash's /dev/tcp, NOT netstat — the image ships no netstat, so the old
|
||||
# `netstat -an | grep` check left the container permanently "unhealthy" (same fix as nat/, 27302314).
|
||||
test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/50000"]
|
||||
interval: 5s
|
||||
timeout: 2s
|
||||
retries: 10
|
||||
|
||||
+21
-2
@@ -20,6 +20,16 @@
|
||||
# ssh dohertj2@10.100.0.35 'cd /opt/otopcua-opcuaclient-nat && docker compose up -d'
|
||||
# OPCUA_NAT_ENDPOINT=opc.tcp://10.100.0.35:50010 dotnet test \
|
||||
# tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Browser.IntegrationTests --filter Fixture=opc-plc-nat
|
||||
#
|
||||
# #818: the server's PKI (/app/pki — own cert + private key, and the client certs --aa accepted) lives in the
|
||||
# named volume `opc-plc-nat-pki`, so recreating the container keeps the SAME server certificate. Its PUBLIC half is
|
||||
# committed next to this file (opc-plc-nat-server.der) and the secure tests trust it in a throwaway browse PKI. The
|
||||
# private key never leaves the volume. To roll the certificate deliberately (e.g. at expiry, 2027-11-10):
|
||||
# ssh dohertj2@10.100.0.35 'cd /opt/otopcua-opcuaclient-nat && docker compose down -v && docker compose up -d'
|
||||
# ssh dohertj2@10.100.0.35 'docker exec otopcua-opc-plc-nat bash -c "cat /app/pki/own/certs/*.der"' \
|
||||
# > tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.IntegrationTests/Docker/nat/opc-plc-nat-server.der
|
||||
# (until the committed copy is refreshed the positive secure tests SKIP on a thumbprint mismatch — they never pass
|
||||
# against a certificate other than the committed one).
|
||||
services:
|
||||
opc-plc-nat:
|
||||
image: mcr.microsoft.com/iotedge/opc-plc:2.14.10
|
||||
@@ -40,11 +50,20 @@ services:
|
||||
# --aa: accept the browser's self-signed client cert. Trust in the OTHER direction (the browser trusting
|
||||
# this server's cert) is deliberately not automatic — that is what the secure test pins.
|
||||
- "--aa"
|
||||
volumes:
|
||||
- opc-plc-nat-pki:/app/pki
|
||||
# The image runs as uid 1654 ("app") and ships no /app/pki, so Docker creates the volume mount point root-owned
|
||||
# and opc-plc could not write its certificate there. A throwaway test simulator: run it as root rather than add a
|
||||
# chown init container.
|
||||
user: "0"
|
||||
healthcheck:
|
||||
# The image ships no netstat (the sibling ../docker-compose.yml healthcheck is permanently "unhealthy" for that
|
||||
# reason); bash's /dev/tcp is there.
|
||||
# The image ships no netstat (the sibling ../docker-compose.yml healthcheck was permanently "unhealthy" for that
|
||||
# reason until #817 switched it to this probe too); bash's /dev/tcp is there.
|
||||
test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/50000"]
|
||||
interval: 5s
|
||||
timeout: 2s
|
||||
retries: 10
|
||||
start_period: 10s
|
||||
|
||||
volumes:
|
||||
opc-plc-nat-pki:
|
||||
|
||||
BIN
Binary file not shown.
+129
@@ -0,0 +1,129 @@
|
||||
using Opc.Ua;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.IntegrationTests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #816 — does the driver check the server certificate's host name? Against the plain opc-plc fixture, whose
|
||||
/// certificate names only its container hostname (e.g. <c>DNS:1fc1de3fcb21</c>) while the driver dials the docker
|
||||
/// host's address, so a host check MUST fail if it runs at all.
|
||||
/// <para>Before #816 the driver called the SDK's 8-argument <c>DefaultSessionFactory.CreateAsync</c>, which hard-codes
|
||||
/// <c>checkDomain: false</c>: the mismatch was never noticed. Now <c>certificateValidation.validateServerHostName</c>
|
||||
/// decides; unset keeps the old behaviour.</para>
|
||||
/// <para>Each test trusts the server's certificate in a THROWAWAY PKI (the driver's <c>PkiRootOverride</c>) with
|
||||
/// auto-accept OFF — auto-accept also accepts a host-name mismatch and would hide the check. The certificate is
|
||||
/// taken from the server's own GetEndpoints answer: what is under test is the host check, not how trust was
|
||||
/// established.</para>
|
||||
/// </summary>
|
||||
[Collection(OpcPlcCollection.Name)]
|
||||
[Trait("Category", "Integration")]
|
||||
[Trait("Simulator", "opc-plc")]
|
||||
public sealed class ServerHostNameValidationTests(OpcPlcFixture sim) : IDisposable
|
||||
{
|
||||
private readonly string _pkiRoot = Path.Combine(Path.GetTempPath(), "otopcua-816-" + Guid.NewGuid().ToString("N"));
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Dispose()
|
||||
{
|
||||
try { Directory.Delete(_pkiRoot, recursive: true); } catch { /* best-effort temp cleanup */ }
|
||||
}
|
||||
|
||||
private OpcUaClientDriverOptions SecureOptions(bool? validateHostName) => OpcPlcProfile.BuildOptions(sim.EndpointUrl) with
|
||||
{
|
||||
SecurityPolicy = OpcUaSecurityPolicy.Basic256Sha256,
|
||||
SecurityMode = OpcUaSecurityMode.SignAndEncrypt,
|
||||
AutoAcceptCertificates = false,
|
||||
CertificateValidation = new OpcUaCertificateValidationOptions { ValidateServerHostName = validateHostName },
|
||||
};
|
||||
|
||||
/// <summary>Trust the fixture's server certificate (as advertised on its secure endpoint) in the throwaway PKI.</summary>
|
||||
private async Task TrustServerCertificateAsync(CancellationToken ct)
|
||||
{
|
||||
var appConfig = new ApplicationConfiguration(DefaultTelemetry.Create(_ => { }))
|
||||
{
|
||||
ApplicationName = "OtOpcUa #816 trust",
|
||||
ApplicationType = ApplicationType.Client,
|
||||
SecurityConfiguration = new SecurityConfiguration(),
|
||||
TransportQuotas = new TransportQuotas(),
|
||||
ClientConfiguration = new ClientConfiguration(),
|
||||
DisableHiResClock = true,
|
||||
};
|
||||
using var discovery = await DiscoveryClient.CreateAsync(appConfig, new Uri(sim.EndpointUrl), DiagnosticsMasks.None, ct);
|
||||
var endpoints = await discovery.GetEndpointsAsync(default, ct);
|
||||
var secure = endpoints.ToList().First(e => e.SecurityPolicyUri == SecurityPolicies.Basic256Sha256);
|
||||
var der = secure.ServerCertificate.ToArray();
|
||||
der.ShouldNotBeEmpty("the secure endpoint must carry the server certificate");
|
||||
|
||||
var certs = Path.Combine(_pkiRoot, "trusted", "certs");
|
||||
Directory.CreateDirectory(certs);
|
||||
await File.WriteAllBytesAsync(Path.Combine(certs, "opc-plc.der"), der, ct);
|
||||
}
|
||||
|
||||
private async Task<OpcUaClientDriver> InitializeAsync(bool? validateHostName, string id, CancellationToken ct)
|
||||
{
|
||||
var drv = new OpcUaClientDriver(SecureOptions(validateHostName), driverInstanceId: id) { PkiRootOverride = _pkiRoot };
|
||||
try
|
||||
{
|
||||
await drv.InitializeAsync("{}", ct);
|
||||
return drv;
|
||||
}
|
||||
catch
|
||||
{
|
||||
await drv.DisposeAsync();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(null)] // unset = the pre-#816 behaviour every existing deployment has
|
||||
[InlineData(false)] // the explicit NAT / IP-addressed opt-out
|
||||
public async Task Without_host_name_validation_a_trusted_certificate_for_another_host_connects(bool? validate)
|
||||
{
|
||||
if (sim.SkipReason is not null) Assert.Skip(sim.SkipReason);
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
await TrustServerCertificateAsync(ct);
|
||||
|
||||
await using var drv = await InitializeAsync(validate, $"opcua-816-off-{validate}", ct);
|
||||
var snapshots = await drv.ReadAsync([OpcPlcProfile.StepUpRef], ct);
|
||||
snapshots[0].StatusCode.ShouldBe(0u, "the secured session must read once the server certificate is trusted");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Review of #816 (reproduced live): SDK 2.0.1 also checks the host at channel creation, against the certificate
|
||||
/// in the GetEndpoints reply — which opc-plc sends on its None endpoint too — before any security-mode test. The
|
||||
/// driver must not pass checkDomain for a None session, or the flag refuses an unsecured connect.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task With_host_name_validation_on_a_None_session_still_connects()
|
||||
{
|
||||
if (sim.SkipReason is not null) Assert.Skip(sim.SkipReason);
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
var options = OpcPlcProfile.BuildOptions(sim.EndpointUrl) with
|
||||
{
|
||||
AutoAcceptCertificates = false,
|
||||
CertificateValidation = new OpcUaCertificateValidationOptions { ValidateServerHostName = true },
|
||||
};
|
||||
|
||||
await using var drv = new OpcUaClientDriver(options, driverInstanceId: "opcua-816-none") { PkiRootOverride = _pkiRoot };
|
||||
await drv.InitializeAsync("{}", ct);
|
||||
(await drv.ReadAsync([OpcPlcProfile.StepUpRef], ct))[0].StatusCode.ShouldBe(0u);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task With_host_name_validation_the_certificate_is_checked_against_the_configured_host()
|
||||
{
|
||||
if (sim.SkipReason is not null) Assert.Skip(sim.SkipReason);
|
||||
var ct = TestContext.Current.CancellationToken;
|
||||
await TrustServerCertificateAsync(ct);
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(() => InitializeAsync(true, "opcua-816-on", ct));
|
||||
TestContext.Current.TestOutputHelper?.WriteLine($"refused: {ex}");
|
||||
// The driver's failover aggregate keeps per-endpoint failures as text. The SDK message names the host it
|
||||
// checked: the CONFIGURED one (the endpoint URL was rewritten to it), not whatever the server advertised.
|
||||
var configuredHost = new Uri(sim.EndpointUrl).IdnHost;
|
||||
var text = ex.ToString();
|
||||
text.ShouldContain($"The domain '{configuredHost}' is not listed in the server certificate");
|
||||
text.ShouldContain("validateServerHostName=false", Case.Sensitive, "the refusal must name the opt-out");
|
||||
}
|
||||
}
|
||||
+37
@@ -94,6 +94,43 @@ public sealed class OpcUaClientEndpointRewriteTests
|
||||
.ShouldBe("opc.tcp://[fd00::1]:54840/OtOpcUa");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #819 — a configured IPv6 zone index survives the rewrite verbatim. .NET's <see cref="Uri"/> drops it from
|
||||
/// every re-serialisation (Host, Authority, AbsoluteUri, ToString), so before #819 a link-local endpoint came out
|
||||
/// zone-less and unroutable.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("opc.tcp://[fe80::1%eth0]:4841", "opc.tcp://[fe80::1%eth0]:4841/OtOpcUa")]
|
||||
[InlineData("opc.tcp://[fe80::1%4]:4841/", "opc.tcp://[fe80::1%4]:4841/OtOpcUa")]
|
||||
// RFC 6874's encoded delimiter is kept as written, not normalised: the session dials what GetEndpoints reached.
|
||||
[InlineData("opc.tcp://[fe80::1%25eth0]:4841", "opc.tcp://[fe80::1%25eth0]:4841/OtOpcUa")]
|
||||
// Port-less configured URL: the advertised port is kept, the zone still is.
|
||||
[InlineData("opc.tcp://[fe80::1%eth0]", "opc.tcp://[fe80::1%eth0]:4840/OtOpcUa")]
|
||||
public void An_IPv6_zone_index_on_the_configured_host_is_preserved(string configured, string expected)
|
||||
{
|
||||
OpcUaEndpointUrlRewriter.Rewrite("opc.tcp://internal-host:4840/OtOpcUa", configured).ShouldBe(expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_zone_index_reaches_the_host_the_SDK_dials()
|
||||
{
|
||||
// The SDK's TCP transport connects to new Uri(EndpointDescription.EndpointUrl).IdnHost (ConfiguredEndpoint
|
||||
// re-parses the string), so the zone must survive into that accessor — and the advertised path with it.
|
||||
var rewritten = OpcUaEndpointUrlRewriter.Rewrite(
|
||||
"opc.tcp://[fe80::9]:4840/Ua", "opc.tcp://[fe80::1%eth0]:4841");
|
||||
var endpoint = new ConfiguredEndpoint(null, new EndpointDescription { EndpointUrl = rewritten }, EndpointConfiguration.Create());
|
||||
endpoint.EndpointUrl!.IdnHost.ShouldBe("fe80::1%eth0");
|
||||
endpoint.EndpointUrl.Port.ShouldBe(4841);
|
||||
endpoint.EndpointUrl.AbsolutePath.ShouldBe("/Ua");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_zone_matching_no_op_returns_the_advertised_string_verbatim()
|
||||
{
|
||||
OpcUaEndpointUrlRewriter.Rewrite("opc.tcp://[fe80::1%eth0]:4840/Ua", "opc.tcp://[fe80::1%eth0]:4840/")
|
||||
.ShouldBe("opc.tcp://[fe80::1%eth0]:4840/Ua");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_IPv6_advertised_host_is_replaced_by_a_configured_name()
|
||||
{
|
||||
|
||||
+88
-4
@@ -1,5 +1,6 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
using ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient;
|
||||
using ZB.MOM.WW.Secrets.Abstractions;
|
||||
|
||||
@@ -16,9 +17,9 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Tests;
|
||||
/// </summary>
|
||||
public sealed class OpcUaClientSecretResolutionTests
|
||||
{
|
||||
private const string KnownPwName = "opcua/inst/password";
|
||||
private const string KnownPwName = "opcuaclient/inst/password";
|
||||
private const string KnownPwValue = "resolved-password-plaintext";
|
||||
private const string KnownCertPwName = "opcua/inst/cert-pw";
|
||||
private const string KnownCertPwName = "opcuaclient/inst/cert-pw";
|
||||
private const string KnownCertPwValue = "resolved-cert-pw-plaintext";
|
||||
|
||||
/// <summary>A fake resolver: returns known values for two known names, null otherwise.</summary>
|
||||
@@ -70,14 +71,97 @@ public sealed class OpcUaClientSecretResolutionTests
|
||||
[Fact]
|
||||
public async Task Unknown_secret_ref_is_fail_closed()
|
||||
{
|
||||
var options = new OpcUaClientDriverOptions { Password = "secret:opcua/inst/absent" };
|
||||
var options = new OpcUaClientDriverOptions { Password = "secret:opcuaclient/inst/absent" };
|
||||
|
||||
var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
|
||||
OpcUaClientSecretResolution.ResolveSecretRefsAsync(
|
||||
options, FakeResolver(), CancellationToken.None));
|
||||
|
||||
ex.Message.ShouldContain("Password");
|
||||
ex.Message.ShouldContain("opcua/inst/absent");
|
||||
ex.Message.ShouldContain("opcuaclient/inst/absent");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#815: the password is sent to the operator-authored endpoint, so a reference outside the
|
||||
/// OpcUaClient namespace throws BEFORE the store or the environment is read — it is never resolved, never sent.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("secret:otopcua/historian/api-key")]
|
||||
[InlineData("secret:galaxy/inst1/apikey")]
|
||||
[InlineData("secret:OT-MESH-PSK-MAIN")]
|
||||
[InlineData("env:ConnectionStrings__ConfigDb")]
|
||||
[InlineData("env:ServerHistorian__ApiKey")]
|
||||
[InlineData("Secret:opcuaclient/inst/password")]
|
||||
[InlineData("file:appsettings.json")]
|
||||
public async Task Out_of_namespace_reference_is_refused_without_reading(string reference)
|
||||
{
|
||||
var store = new CountingResolver();
|
||||
var envReads = 0;
|
||||
foreach (var options in new[]
|
||||
{
|
||||
new OpcUaClientDriverOptions { Password = reference },
|
||||
new OpcUaClientDriverOptions { UserCertificatePassword = reference },
|
||||
})
|
||||
{
|
||||
var ex = await Should.ThrowAsync<CredentialReferenceException>(() =>
|
||||
OpcUaUserIdentityFactory.ResolveSecretRefsAsync(
|
||||
options, store, CancellationToken.None, _ => { envReads++; return "LEAKED"; }));
|
||||
ex.Message.ShouldContain("secret:opcuaclient/<name>");
|
||||
ex.Message.ShouldNotContain("LEAKED");
|
||||
}
|
||||
|
||||
store.Calls.ShouldBe(0);
|
||||
envReads.ShouldBe(0);
|
||||
}
|
||||
|
||||
/// <summary>A namespaced environment reference resolves.</summary>
|
||||
[Fact]
|
||||
public async Task Namespaced_environment_reference_resolves()
|
||||
{
|
||||
var resolved = await OpcUaUserIdentityFactory.ResolveSecretRefsAsync(
|
||||
new OpcUaClientDriverOptions { Password = "env:OTOPCUA_OPCUACLIENT_PLANT_PW" }, FakeResolver(),
|
||||
CancellationToken.None, n => n == "OTOPCUA_OPCUACLIENT_PLANT_PW" ? "pw" : null);
|
||||
resolved.Password.ShouldBe("pw");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#815 warn-only compatibility (deprecated): the RUNNING driver's session open keeps the old semantics
|
||||
/// for an out-of-namespace value — a case-insensitive <c>secret:</c> resolves, anything else is a literal — and
|
||||
/// warns once; the browser (no tracker) refuses the same value (see the theory above).
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task The_running_driver_keeps_old_semantics_for_a_legacy_value_and_warns()
|
||||
{
|
||||
var warnings = new List<string>();
|
||||
var tracker = new LegacyCredentialReferenceTracker(DriverCredentialPolicy.OpcUaClientScope, "ouc", warnings.Add);
|
||||
var legacyOptions = new OpcUaClientDriverOptions
|
||||
{
|
||||
Password = $"SECRET:{KnownPwName}", // pre-#815: case-insensitive secret: resolved
|
||||
UserCertificatePassword = "env:NOT_A_REF", // pre-#815: only secret: resolved — a literal password
|
||||
};
|
||||
|
||||
for (var i = 0; i < 3; i++)
|
||||
{
|
||||
var resolved = await OpcUaClientSecretResolution.ResolveSecretRefsAsync(
|
||||
legacyOptions, FakeResolver(), CancellationToken.None, tracker);
|
||||
resolved.Password.ShouldBe(KnownPwValue);
|
||||
resolved.UserCertificatePassword.ShouldBe("env:NOT_A_REF");
|
||||
}
|
||||
|
||||
warnings.Count.ShouldBe(2); // one per field, rate-limited across the three session opens
|
||||
warnings.ShouldAllBe(w => !w.Contains(KnownPwValue));
|
||||
tracker.Diagnostics.Count.ShouldBe(2);
|
||||
}
|
||||
|
||||
private sealed class CountingResolver : ISecretResolver
|
||||
{
|
||||
public int Calls { get; private set; }
|
||||
|
||||
public Task<string?> GetAsync(SecretName name, CancellationToken ct)
|
||||
{
|
||||
Calls++;
|
||||
return Task.FromResult<string?>("LEAKED");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>A fake resolver: returns known values for two known names, null otherwise.</summary>
|
||||
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
using Opc.Ua;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Gitea #816 — <c>certificateValidation.validateServerHostName</c>. The wire behaviour (the SDK's checkDomain against
|
||||
/// the CONFIGURED host) is pinned against real servers by <c>ServerHostNameValidationTests</c> (driver, plain opc-plc)
|
||||
/// and <c>NatPublishedEndpointBrowseTests</c> (browser, NAT opc-plc); these pin the option contract.
|
||||
/// </summary>
|
||||
[Trait("Category", "Unit")]
|
||||
public sealed class OpcUaClientServerHostNameOptionTests
|
||||
{
|
||||
[Fact]
|
||||
public void Unset_resolves_to_off_so_existing_deployments_are_unchanged()
|
||||
{
|
||||
var o = new OpcUaClientDriverOptions();
|
||||
o.CertificateValidation.ValidateServerHostName.ShouldBeNull();
|
||||
o.CertificateValidation.EffectiveValidateServerHostName.ShouldBeFalse();
|
||||
OpcUaCertificateValidationOptions.DefaultValidateServerHostName.ShouldBeFalse();
|
||||
|
||||
OpcUaClientDriverFactoryExtensions.ParseOptions("d", """{"endpointUrl":"opc.tcp://x:1"}""")
|
||||
.CertificateValidation.EffectiveValidateServerHostName.ShouldBeFalse();
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("true", true)]
|
||||
[InlineData("false", false)]
|
||||
public void Factory_json_binds_the_explicit_choice(string json, bool expected)
|
||||
{
|
||||
var o = OpcUaClientDriverFactoryExtensions.ParseOptions("d",
|
||||
$$$"""{"endpointUrl":"opc.tcp://x:1","certificateValidation":{"validateServerHostName":{{{json}}}}}""");
|
||||
|
||||
o.CertificateValidation.ValidateServerHostName.ShouldBe(expected);
|
||||
o.CertificateValidation.EffectiveValidateServerHostName.ShouldBe(expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void The_effective_value_is_not_serialised_back()
|
||||
{
|
||||
var json = System.Text.Json.JsonSerializer.Serialize(new OpcUaCertificateValidationOptions());
|
||||
json.ShouldNotContain("Effective");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Review of #816: SDK 2.0.1 also checks the host in <c>DefaultSessionFactory.CreateChannelAsync</c>, against the
|
||||
/// GetEndpoints certificate and before any security-mode test, so checkDomain is never passed for a None endpoint.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData(MessageSecurityMode.None, true, false)]
|
||||
[InlineData(MessageSecurityMode.None, false, false)]
|
||||
[InlineData(MessageSecurityMode.Sign, true, true)]
|
||||
[InlineData(MessageSecurityMode.SignAndEncrypt, true, true)]
|
||||
[InlineData(MessageSecurityMode.SignAndEncrypt, false, false)]
|
||||
public void CheckDomain_is_passed_only_for_secured_endpoints(MessageSecurityMode mode, bool validate, bool expected)
|
||||
{
|
||||
OpcUaEndpointSelection.CheckDomainFor(new EndpointDescription { SecurityMode = mode }, validate).ShouldBe(expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_host_name_refusal_names_the_opt_out()
|
||||
{
|
||||
var hint = OpcUaClientDriver.HostNameRefusalHint(new ServiceResultException(
|
||||
StatusCodes.BadCertificateHostNameInvalid, "The domain '10.1.2.3' is not listed in the server certificate."));
|
||||
hint.ShouldContain("validateServerHostName=false");
|
||||
|
||||
OpcUaClientDriver.HostNameRefusalHint(new ServiceResultException(StatusCodes.BadCertificateUntrusted))
|
||||
.ShouldBeEmpty();
|
||||
OpcUaClientDriver.HostNameRefusalHint(new InvalidOperationException("x")).ShouldBeEmpty();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user