mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-18 22:55:08 +08:00
Marc Schier
391 lines
16 KiB
C#
391 lines
16 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2026 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Options;
|
|
using NUnit.Framework;
|
|
using Opc.Ua.PubSub.Connections;
|
|
using Opc.Ua.PubSub.Encoding;
|
|
using Opc.Ua.PubSub.Transcoding;
|
|
using Opc.Ua.Tests;
|
|
using static Opc.Ua.PubSub.Tests.Transcoding.TranscodingTestUtilities;
|
|
|
|
namespace Opc.Ua.PubSub.Tests.Transcoding
|
|
{
|
|
/// <summary>
|
|
/// Tests for the declarative, reloadable transcoding configuration: the
|
|
/// route-to-descriptor factory, the change signature, the configuration
|
|
/// binding, and the reload coordinator's incremental reconfiguration.
|
|
/// </summary>
|
|
[TestFixture]
|
|
[Category("Unit")]
|
|
public class TranscodeConfigurationTests
|
|
{
|
|
private static TranscodeRouteOptions FullRoute()
|
|
{
|
|
return new TranscodeRouteOptions
|
|
{
|
|
Name = "r1",
|
|
Source = "src",
|
|
Target = "tgt",
|
|
TargetEncoding = TranscodeEncoding.Json,
|
|
Topic = "topic/x",
|
|
FieldEncoding = PubSubFieldEncoding.Variant,
|
|
JsonSingleMessage = true,
|
|
PreserveMetaDataVersion = false,
|
|
AllowInsecureCrossEncoding = true,
|
|
DropKeepAlive = true,
|
|
RenameFields = new Dictionary<string, string> { ["a"] = "b" },
|
|
SelectFields = ["b"],
|
|
PromoteFields = ["b"],
|
|
PromotedFieldPrefix = "p_",
|
|
KeepMessageTypes =
|
|
[
|
|
PubSubDataSetMessageType.KeyFrame
|
|
],
|
|
RemapIds = new TranscodeIdRemapOptions
|
|
{
|
|
PublisherIdNumber = 7,
|
|
WriterGroupId = 3,
|
|
DataSetClassId = "0f8fad5b-d9cb-469f-a165-70867728950e",
|
|
DataSetWriterIds = new Dictionary<ushort, ushort> { [1] = 2 }
|
|
}
|
|
};
|
|
}
|
|
|
|
[Test]
|
|
public void Factory_Create_BuildsDescriptor()
|
|
{
|
|
TranscodingBridgeDescriptor descriptor =
|
|
TranscodeRouteOptionsFactory.Create(FullRoute());
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(descriptor.SourceConnectionName, Is.EqualTo("src"));
|
|
Assert.That(descriptor.TargetConnectionName, Is.EqualTo("tgt"));
|
|
Assert.That(descriptor.AllowInsecureCrossEncoding, Is.True);
|
|
Assert.That(descriptor.Spec.TargetEncoding, Is.EqualTo(TranscodeEncoding.Json));
|
|
Assert.That(descriptor.Spec.TargetOptions.JsonSingleMessageMode, Is.True);
|
|
Assert.That(descriptor.Spec.TargetOptions.PreserveMetaDataVersion, Is.False);
|
|
Assert.That(descriptor.Spec.Promotion, Is.Not.Null);
|
|
Assert.That(descriptor.Spec.Promotion!.FieldNames.Count, Is.EqualTo(1));
|
|
Assert.That(descriptor.Spec.Promotion!.FieldNames[0], Is.EqualTo("b"));
|
|
Assert.That(descriptor.Spec.Promotion!.PropertyKeyPrefix, Is.EqualTo("p_"));
|
|
Assert.That(descriptor.Spec.Transforms.Count, Is.GreaterThanOrEqualTo(4));
|
|
Assert.That(descriptor.TopicSelector, Is.Not.Null);
|
|
Assert.That(
|
|
descriptor.TopicSelector!(new ReceivedNetworkMessage()),
|
|
Is.EqualTo("topic/x"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void Factory_Create_MissingFields_Throw()
|
|
{
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(
|
|
() => TranscodeRouteOptionsFactory.Create(
|
|
new TranscodeRouteOptions { Source = "s", Target = "t" }),
|
|
Throws.InvalidOperationException);
|
|
Assert.That(
|
|
() => TranscodeRouteOptionsFactory.Create(
|
|
new TranscodeRouteOptions { Name = "n", Target = "t" }),
|
|
Throws.InvalidOperationException);
|
|
Assert.That(
|
|
() => TranscodeRouteOptionsFactory.Create(
|
|
new TranscodeRouteOptions { Name = "n", Source = "s" }),
|
|
Throws.InvalidOperationException);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void Factory_ComputeSignature_DetectsChanges()
|
|
{
|
|
TranscodeRouteOptions a = FullRoute();
|
|
TranscodeRouteOptions b = FullRoute();
|
|
string signatureA = TranscodeRouteOptionsFactory.ComputeSignature(a);
|
|
string signatureB = TranscodeRouteOptionsFactory.ComputeSignature(b);
|
|
b.TargetEncoding = TranscodeEncoding.Uadp;
|
|
string signatureChanged = TranscodeRouteOptionsFactory.ComputeSignature(b);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(signatureA, Is.EqualTo(signatureB));
|
|
Assert.That(signatureChanged, Is.Not.EqualTo(signatureA));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void AddTranscoding_BindsRoutesFromConfiguration()
|
|
{
|
|
IConfiguration configuration = new ConfigurationBuilder()
|
|
.AddInMemoryCollection(new Dictionary<string, string?>
|
|
{
|
|
["Routes:0:Name"] = "r1",
|
|
["Routes:0:Source"] = "sub",
|
|
["Routes:0:Target"] = "pub",
|
|
["Routes:0:TargetEncoding"] = "Json",
|
|
["Routes:0:Topic"] = "t/1",
|
|
["Routes:0:PromoteFields:0"] = "Temperature",
|
|
["Routes:0:PromotedFieldPrefix"] = "opc_",
|
|
["Routes:0:RenameFields:a"] = "b",
|
|
["Routes:0:RemapIds:WriterGroupId"] = "5"
|
|
})
|
|
.Build();
|
|
|
|
var services = new ServiceCollection();
|
|
services.AddSingleton(NUnitTelemetryContext.Create());
|
|
services.AddLogging();
|
|
services.AddOpcUa().AddPubSub(pubsub => pubsub.AddTranscoding(configuration));
|
|
using ServiceProvider provider = services.BuildServiceProvider();
|
|
|
|
PubSubTranscodingOptions options = provider
|
|
.GetRequiredService<IOptionsMonitor<PubSubTranscodingOptions>>()
|
|
.CurrentValue;
|
|
|
|
Assert.That(options.Routes, Has.Count.EqualTo(1));
|
|
TranscodeRouteOptions route = options.Routes[0];
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(route.Name, Is.EqualTo("r1"));
|
|
Assert.That(route.Source, Is.EqualTo("sub"));
|
|
Assert.That(route.Target, Is.EqualTo("pub"));
|
|
Assert.That(route.TargetEncoding, Is.EqualTo(TranscodeEncoding.Json));
|
|
Assert.That(route.Topic, Is.EqualTo("t/1"));
|
|
Assert.That(route.PromoteFields, Has.Count.EqualTo(1));
|
|
Assert.That(route.PromoteFields![0], Is.EqualTo("Temperature"));
|
|
Assert.That(route.PromotedFieldPrefix, Is.EqualTo("opc_"));
|
|
Assert.That(route.RenameFields!["a"], Is.EqualTo("b"));
|
|
Assert.That(route.RemapIds!.WriterGroupId, Is.EqualTo((ushort)5));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void AddTranscoding_NullArguments_Throw()
|
|
{
|
|
IConfiguration configuration = new ConfigurationBuilder().Build();
|
|
var services = new ServiceCollection();
|
|
services.AddSingleton(NUnitTelemetryContext.Create());
|
|
services.AddLogging();
|
|
IPubSubBuilder? captured = null;
|
|
services.AddOpcUa().AddPubSub(pubsub => captured = pubsub);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(() => captured!.AddTranscoding(null!), Throws.ArgumentNullException);
|
|
Assert.That(
|
|
() => PubSubTranscodingBuilderExtensions.AddTranscoding(null!, configuration),
|
|
Throws.ArgumentNullException);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReloadCoordinator_ReconfiguresOnlyChangedRoutes()
|
|
{
|
|
await using PubSubConnection source = NewConnection("src");
|
|
await using PubSubConnection target = NewConnection("tgt");
|
|
IServiceProvider provider = BuildApplicationProvider(source, target);
|
|
var monitor = new TestOptionsMonitor<PubSubTranscodingOptions>(
|
|
Options(
|
|
Route("a", TranscodeEncoding.Uadp),
|
|
Route("b", TranscodeEncoding.Uadp)));
|
|
await using var coordinator = new PubSubTranscodingReloadCoordinator(
|
|
provider, monitor, NUnitTelemetryContext.Create());
|
|
|
|
await coordinator.StartAsync().ConfigureAwait(false);
|
|
Assert.That(coordinator.ActiveRouteCount, Is.EqualTo(2));
|
|
PubSubTranscodingBridge? bridgeA = coordinator.GetActiveBridge("a");
|
|
PubSubTranscodingBridge? bridgeB = coordinator.GetActiveBridge("b");
|
|
|
|
monitor.Set(Options(
|
|
Route("a", TranscodeEncoding.Uadp),
|
|
Route("b", TranscodeEncoding.Json)));
|
|
await coordinator.ReloadNowAsync().ConfigureAwait(false);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(coordinator.GetActiveBridge("a"), Is.SameAs(bridgeA));
|
|
Assert.That(coordinator.GetActiveBridge("b"), Is.Not.SameAs(bridgeB));
|
|
Assert.That(coordinator.ActiveRouteCount, Is.EqualTo(2));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReloadCoordinator_RemovesDeletedRoutes()
|
|
{
|
|
await using PubSubConnection source = NewConnection("src");
|
|
await using PubSubConnection target = NewConnection("tgt");
|
|
IServiceProvider provider = BuildApplicationProvider(source, target);
|
|
var monitor = new TestOptionsMonitor<PubSubTranscodingOptions>(
|
|
Options(
|
|
Route("a", TranscodeEncoding.Uadp),
|
|
Route("b", TranscodeEncoding.Uadp)));
|
|
await using var coordinator = new PubSubTranscodingReloadCoordinator(
|
|
provider, monitor, NUnitTelemetryContext.Create());
|
|
await coordinator.StartAsync().ConfigureAwait(false);
|
|
|
|
monitor.Set(Options(Route("a", TranscodeEncoding.Uadp)));
|
|
await coordinator.ReloadNowAsync().ConfigureAwait(false);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(coordinator.ActiveRouteCount, Is.EqualTo(1));
|
|
Assert.That(coordinator.GetActiveBridge("a"), Is.Not.Null);
|
|
Assert.That(coordinator.GetActiveBridge("b"), Is.Null);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReloadCoordinator_OnChange_AddsNewRoute()
|
|
{
|
|
await using PubSubConnection source = NewConnection("src");
|
|
await using PubSubConnection target = NewConnection("tgt");
|
|
IServiceProvider provider = BuildApplicationProvider(source, target);
|
|
var monitor = new TestOptionsMonitor<PubSubTranscodingOptions>(
|
|
Options(Route("a", TranscodeEncoding.Uadp)));
|
|
await using var coordinator = new PubSubTranscodingReloadCoordinator(
|
|
provider, monitor, NUnitTelemetryContext.Create());
|
|
await coordinator.StartAsync().ConfigureAwait(false);
|
|
|
|
monitor.Set(Options(
|
|
Route("a", TranscodeEncoding.Uadp),
|
|
Route("b", TranscodeEncoding.Uadp)));
|
|
|
|
await WaitForAsync(() => coordinator.ActiveRouteCount == 2, TimeSpan.FromSeconds(5))
|
|
.ConfigureAwait(false);
|
|
Assert.That(coordinator.ActiveRouteCount, Is.EqualTo(2));
|
|
}
|
|
|
|
[Test]
|
|
public void ReloadCoordinator_NullArguments_Throw()
|
|
{
|
|
IServiceProvider provider = BuildApplicationProvider();
|
|
var monitor = new TestOptionsMonitor<PubSubTranscodingOptions>(
|
|
new PubSubTranscodingOptions());
|
|
ITelemetryContext telemetry = NUnitTelemetryContext.Create();
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(
|
|
() => new PubSubTranscodingReloadCoordinator(null!, monitor, telemetry),
|
|
Throws.ArgumentNullException);
|
|
Assert.That(
|
|
() => new PubSubTranscodingReloadCoordinator(provider, null!, telemetry),
|
|
Throws.ArgumentNullException);
|
|
Assert.That(
|
|
() => new PubSubTranscodingReloadCoordinator(provider, monitor, null!),
|
|
Throws.ArgumentNullException);
|
|
});
|
|
}
|
|
|
|
private static PubSubTranscodingOptions Options(params TranscodeRouteOptions[] routes)
|
|
{
|
|
return new PubSubTranscodingOptions { Routes = [.. routes] };
|
|
}
|
|
|
|
private static TranscodeRouteOptions Route(string name, TranscodeEncoding encoding)
|
|
{
|
|
return new TranscodeRouteOptions
|
|
{
|
|
Name = name,
|
|
Source = "src",
|
|
Target = "tgt",
|
|
TargetEncoding = encoding
|
|
};
|
|
}
|
|
|
|
private static async Task WaitForAsync(Func<bool> condition, TimeSpan timeout)
|
|
{
|
|
DateTime deadline = DateTime.UtcNow + timeout;
|
|
while (DateTime.UtcNow < deadline)
|
|
{
|
|
if (condition())
|
|
{
|
|
return;
|
|
}
|
|
await Task.Delay(25).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
private sealed class TestOptionsMonitor<T> : IOptionsMonitor<T>
|
|
{
|
|
private readonly List<Action<T, string?>> m_listeners = [];
|
|
private T m_current;
|
|
|
|
public TestOptionsMonitor(T initial)
|
|
{
|
|
m_current = initial;
|
|
}
|
|
|
|
public T CurrentValue => m_current;
|
|
|
|
public T Get(string? name)
|
|
{
|
|
return m_current;
|
|
}
|
|
|
|
public IDisposable OnChange(Action<T, string?> listener)
|
|
{
|
|
m_listeners.Add(listener);
|
|
return new Subscription(m_listeners, listener);
|
|
}
|
|
|
|
public void Set(T value)
|
|
{
|
|
m_current = value;
|
|
foreach (Action<T, string?> listener in m_listeners.ToArray())
|
|
{
|
|
listener(value, null);
|
|
}
|
|
}
|
|
|
|
private sealed class Subscription : IDisposable
|
|
{
|
|
private readonly List<Action<T, string?>> m_list;
|
|
private readonly Action<T, string?> m_listener;
|
|
|
|
public Subscription(List<Action<T, string?>> list, Action<T, string?> listener)
|
|
{
|
|
m_list = list;
|
|
m_listener = listener;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
m_list.Remove(m_listener);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|