mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-26 12:40:03 +08:00
Marc Schier
9bfc780e14
# Description Update 55 NuGet dependencies to the latest stable releases available on 2026-10-19, preserving documented compatibility pins and framework-specific version bands. Existing OpenUSD prereleases remain unchanged because no newer releases are available. Migrate existing tests to NUnit 5: await asynchronous assertions, propagate async through helpers, handle nullable predicates, and replace obsolete `Order` attributes with sequencing dependencies. Sequencing dependencies use `AllowFailure = true`; filtering a dependent test also runs prerequisites. Adjust fixture-level parallelism where NUnit dependency scheduling requires it. Keep Roslyn API/runtime pins intact; select newer Immutable/Metadata runtime packages only for test and profiling hosts requiring them. Update the approved SDK pin to 10.0.402 across local, CI, and container builds. Document NUnit 5 conventions.
614 lines
27 KiB
C#
614 lines
27 KiB
C#
/* ========================================================================
|
||
* Copyright (c) 2005-2025 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/
|
||
* ======================================================================*/
|
||
|
||
#pragma warning disable CA2016
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using NUnit.Framework;
|
||
using Opc.Ua.Client;
|
||
using Opc.Ua.Client.Subscriptions;
|
||
using Opc.Ua.Client.TestFramework;
|
||
|
||
namespace Opc.Ua.Subscriptions.Tests
|
||
{
|
||
/// <summary>
|
||
/// V2-shaped transfer tests. The classic engine exposes an explicit
|
||
/// <c>Subscription.TransferAsync</c> across 5 transfer types
|
||
/// (KeepOpen / CloseSession / DisconnectedAck / DisconnectedRepublish /
|
||
/// DisconnectedRepublishDelayedAck) × <c>sendInitialValues</c> ×
|
||
/// <c>sequentialPublishing</c> = 20 combinations. The V2 engine
|
||
/// exposes transfer only as
|
||
/// (a) <see cref="ManagedSessionBuilder.WithTransferSubscriptionsOnRecreate"/>
|
||
/// driven from inside <c>RecreateInPlaceAsync</c> (failover), or
|
||
/// (b) the new
|
||
/// <see cref="ISubscriptionManager.LoadAsync(Stream, IServiceMessageContext, Func{string, ISubscriptionNotificationHandler}, bool, CancellationToken)"/>
|
||
/// with <c>transferSubscriptions: true</c>.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// This file covers the V2-public surfaces of transfer. Tests for
|
||
/// the classic-specific shape (explicit
|
||
/// <c>Subscription.TransferAsync</c> with manual delayed-ack hooks)
|
||
/// remain in the Classic project. See
|
||
/// <c>plans/v2-subscription-parity.md</c> for the parity matrix.
|
||
/// </remarks>
|
||
[TestFixture]
|
||
[Category("Client")]
|
||
[Category("V2")]
|
||
[Category("TransferSubscription")]
|
||
[SetCulture("en-us")]
|
||
[SetUICulture("en-us")]
|
||
public class TransferSubscriptionTests : ClientTestFramework
|
||
{
|
||
[OneTimeSetUp]
|
||
public override Task OneTimeSetUpAsync()
|
||
{
|
||
SupportsExternalServerUrl = true;
|
||
SingleSession = false;
|
||
return OneTimeSetUpCoreAsync(securityNone: true);
|
||
}
|
||
|
||
[OneTimeTearDown]
|
||
public override Task OneTimeTearDownAsync()
|
||
{
|
||
return base.OneTimeTearDownAsync();
|
||
}
|
||
|
||
[SetUp]
|
||
public override Task SetUpAsync()
|
||
{
|
||
return base.SetUpAsync();
|
||
}
|
||
|
||
[TearDown]
|
||
public override Task TearDownAsync()
|
||
{
|
||
return base.TearDownAsync();
|
||
}
|
||
|
||
// ===== 1. Save → Load with transferSubscriptions = true =====
|
||
|
||
[Test]
|
||
[CancelAfter(60_000)]
|
||
public async Task TransferViaSaveLoadV2Async(CancellationToken ct)
|
||
{
|
||
string saveFile = Path.Combine(Path.GetTempPath(),
|
||
$"V2Transfer-{Guid.NewGuid():N}.bin");
|
||
|
||
ManagedSession originSession = await ConnectV2Async(
|
||
nameof(TransferViaSaveLoadV2Async) + "_origin", ct,
|
||
deleteSubscriptionsOnClose: false).ConfigureAwait(false);
|
||
ManagedSession? targetSession = null;
|
||
try
|
||
{
|
||
var originHandler = new RecordingSubscriptionHandler();
|
||
ISubscription originSub = originSession.AddSubscription(
|
||
originHandler, new Client.Subscriptions.SubscriptionOptions
|
||
{
|
||
PublishingInterval = TimeSpan.FromMilliseconds(500),
|
||
KeepAliveCount = 10,
|
||
LifetimeCount = 100,
|
||
PublishingEnabled = true
|
||
});
|
||
bool created = await WaitForAsync(() => originSub.Created,
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(created, Is.True);
|
||
|
||
NodeId timeNode = VariableIds.Server_ServerStatus_CurrentTime;
|
||
Assert.That(originSub.TryAddMonitoredItem(
|
||
"CurrentTime", timeNode,
|
||
o => o with { SamplingInterval = TimeSpan.FromMilliseconds(100) },
|
||
out Client.Subscriptions.MonitoredItems.IMonitoredItem? originItem), Is.True);
|
||
|
||
bool firstData = await originHandler.WaitForFirstDataAsync(
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(firstData, Is.True);
|
||
|
||
uint originSubscriptionServerId = ((LogicalSubscription)originSub).ServerId;
|
||
uint originItemServerId = originItem!.ServerId;
|
||
uint originItemClientHandle = originItem.ClientHandle;
|
||
|
||
using (FileStream saveStream = File.Create(saveFile))
|
||
{
|
||
await originSession.SaveSubscriptionsAsync(saveStream, ct: ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
Assert.That(new FileInfo(saveFile).Length, Is.GreaterThan(0));
|
||
|
||
// Let outstanding publish requests drain so CloseSession is not
|
||
// pre-empted by an in-flight Publish (which can return BadRequestInterrupted
|
||
// / BadCommunicationError due to channel teardown ordering).
|
||
await Task.Delay(500, ct).ConfigureAwait(false);
|
||
|
||
StatusCode close = await originSession.CloseAsync()
|
||
.ConfigureAwait(false);
|
||
// The test goal is to verify subscription transfer on the target session.
|
||
// Accept transient transport-race close codes when the V2 publisher's
|
||
// outstanding Publish raced the CloseSession service call. Some races
|
||
// produce BadSessionIdInvalid (server-side cleanup completed before
|
||
// the close request reached it) and BadInvalidState (channel teardown
|
||
// ordering on the client side) — both equivalent to "session already
|
||
// gone" for the purposes of this test.
|
||
if (!ServiceResult.IsGood(close))
|
||
{
|
||
Assert.That(close.Code, Is.AnyOf(
|
||
StatusCodes.BadRequestInterrupted,
|
||
StatusCodes.BadCommunicationError,
|
||
StatusCodes.BadConnectionClosed,
|
||
StatusCodes.BadSecureChannelClosed,
|
||
StatusCodes.BadSessionClosed,
|
||
StatusCodes.BadSessionIdInvalid,
|
||
StatusCodes.BadInvalidState),
|
||
$"Unexpected close status: {close}");
|
||
TestContext.Out.WriteLine(
|
||
$"CloseAsync returned transient transport-race code {close} — tolerated.");
|
||
}
|
||
|
||
targetSession = await ConnectV2Async(
|
||
nameof(TransferViaSaveLoadV2Async) + "_target", ct)
|
||
.ConfigureAwait(false);
|
||
|
||
var targetHandler = new RecordingSubscriptionHandler();
|
||
IReadOnlyList<ISubscription> loaded;
|
||
using (FileStream input = File.OpenRead(saveFile))
|
||
{
|
||
loaded = await targetSession.LoadSubscriptionsAsync(
|
||
input, _ => targetHandler,
|
||
transferSubscriptions: true, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
Assert.That(loaded, Has.Count.EqualTo(1));
|
||
ISubscription transferred = loaded[0];
|
||
|
||
// Two valid outcomes after LoadAsync(transferSubscriptions:true):
|
||
// 1. Transfer succeeded: server id preserved, item server id preserved.
|
||
// 2. Transfer rejected by server (e.g. BadUserAccessDenied between
|
||
// two anonymous sessions per Part 4 §5.13.7): the V2 manager
|
||
// falls back to recreate which mints fresh ids.
|
||
//
|
||
// Both must produce a working subscription that publishes against
|
||
// the target session. Distinguish via the preserved id; assert the
|
||
// outcome is internally consistent.
|
||
bool transferActuallyTookOver =
|
||
((LogicalSubscription)transferred).ServerId == originSubscriptionServerId;
|
||
TestContext.Out.WriteLine(transferActuallyTookOver
|
||
? $"Transfer preserved server id {originSubscriptionServerId}"
|
||
: $"Transfer denied → fallback recreate (origin Id={originSubscriptionServerId}, new Id={((LogicalSubscription)transferred).ServerId})");
|
||
|
||
Assert.That(transferred.MonitoredItems.TryGetMonitoredItemByName(
|
||
"CurrentTime", out Client.Subscriptions.MonitoredItems.IMonitoredItem? transferredItem),
|
||
Is.True);
|
||
Assert.That(transferredItem, Is.Not.Null);
|
||
if (transferActuallyTookOver)
|
||
{
|
||
Assert.That(transferredItem!.ServerId,
|
||
Is.EqualTo(originItemServerId),
|
||
"Transfer should preserve the server item id");
|
||
Assert.That(transferredItem.ClientHandle,
|
||
Is.EqualTo(originItemClientHandle),
|
||
"Transfer should preserve the client handle so " +
|
||
"notifications route to the correct item");
|
||
}
|
||
|
||
// Either way, publish must resume against the target session.
|
||
bool dataAfterTransfer = await targetHandler.WaitForFirstDataAsync(
|
||
TimeSpan.FromSeconds(15), ct).ConfigureAwait(false);
|
||
Assert.That(dataAfterTransfer, Is.True,
|
||
"Restored subscription should publish on the target session");
|
||
|
||
await transferred.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
try
|
||
{
|
||
await originSession.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
if (targetSession != null)
|
||
{
|
||
try
|
||
{
|
||
await targetSession.CloseAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
try
|
||
{
|
||
await targetSession.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
try
|
||
{
|
||
File.Delete(saveFile);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== 2. Save → Load with transferSubscriptions = false (recreate fallback) =====
|
||
|
||
[Test]
|
||
[CancelAfter(60_000)]
|
||
[DependsOnTest(nameof(TransferViaSaveLoadV2Async), AllowFailure = true)]
|
||
public async Task LoadWithoutTransferRecreatesSubscriptionV2Async(
|
||
CancellationToken ct)
|
||
{
|
||
string saveFile = Path.Combine(Path.GetTempPath(),
|
||
$"V2LoadNoTransfer-{Guid.NewGuid():N}.bin");
|
||
|
||
ManagedSession originSession = await ConnectV2Async(
|
||
nameof(LoadWithoutTransferRecreatesSubscriptionV2Async) + "_origin", ct)
|
||
.ConfigureAwait(false);
|
||
ManagedSession? targetSession = null;
|
||
try
|
||
{
|
||
var originHandler = new RecordingSubscriptionHandler();
|
||
ISubscription originSub = originSession.AddSubscription(
|
||
originHandler, new Client.Subscriptions.SubscriptionOptions
|
||
{
|
||
PublishingInterval = TimeSpan.FromMilliseconds(500),
|
||
KeepAliveCount = 10,
|
||
LifetimeCount = 100,
|
||
PublishingEnabled = true
|
||
});
|
||
bool created = await WaitForAsync(() => originSub.Created,
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(created, Is.True);
|
||
|
||
Assert.That(originSub.TryAddMonitoredItem(
|
||
"State", VariableIds.Server_ServerStatus_State,
|
||
o => o with { SamplingInterval = TimeSpan.Zero },
|
||
out _), Is.True);
|
||
|
||
bool gotData = await originHandler.WaitForFirstDataAsync(
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(gotData, Is.True);
|
||
|
||
uint originSubServerId = ((LogicalSubscription)originSub).ServerId;
|
||
|
||
using (FileStream output = File.Create(saveFile))
|
||
{
|
||
await originSession.RequireSubscriptionManager().SaveAsync(
|
||
output, originSession.MessageContext, null, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
|
||
targetSession = await ConnectV2Async(
|
||
nameof(LoadWithoutTransferRecreatesSubscriptionV2Async) + "_target", ct)
|
||
.ConfigureAwait(false);
|
||
|
||
var targetHandler = new RecordingSubscriptionHandler();
|
||
IReadOnlyList<ISubscription> loaded;
|
||
using (FileStream input = File.OpenRead(saveFile))
|
||
{
|
||
loaded = await targetSession.RequireSubscriptionManager()
|
||
.LoadAsync(input, targetSession.MessageContext,
|
||
_ => targetHandler,
|
||
transferSubscriptions: false, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
Assert.That(loaded, Has.Count.EqualTo(1));
|
||
ISubscription recreated = loaded[0];
|
||
|
||
bool reCreated = await WaitForAsync(() => recreated.Created,
|
||
TimeSpan.FromSeconds(15), ct).ConfigureAwait(false);
|
||
Assert.That(reCreated, Is.True,
|
||
"Loaded subscription should be re-created on the server when transferSubscriptions=false");
|
||
|
||
// With transferSubscriptions=false, the V2 manager
|
||
// creates a fresh server subscription with a new id
|
||
// rather than taking over the saved id.
|
||
uint newSubServerId = ((LogicalSubscription)recreated).ServerId;
|
||
Assert.That(newSubServerId, Is.Not.Zero);
|
||
Assert.That(newSubServerId, Is.Not.EqualTo(originSubServerId),
|
||
"Recreated subscription should have a fresh server id");
|
||
|
||
bool targetData = await targetHandler.WaitForFirstDataAsync(
|
||
TimeSpan.FromSeconds(15), ct).ConfigureAwait(false);
|
||
Assert.That(targetData, Is.True,
|
||
"Recreated subscription should publish on the target session");
|
||
|
||
await recreated.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
try
|
||
{
|
||
await originSession.CloseAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
try
|
||
{
|
||
await originSession.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
if (targetSession != null)
|
||
{
|
||
try
|
||
{
|
||
await targetSession.CloseAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
try
|
||
{
|
||
await targetSession.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
try
|
||
{
|
||
File.Delete(saveFile);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== 3. WithTransferSubscriptionsOnRecreate propagates the option =====
|
||
|
||
[Test]
|
||
[CancelAfter(60_000)]
|
||
[DependsOnTest(nameof(LoadWithoutTransferRecreatesSubscriptionV2Async), AllowFailure = true)]
|
||
public async Task BuilderTransferOnRecreateOptionV2Async(CancellationToken ct)
|
||
{
|
||
ConfiguredEndpoint endpoint = await ClientFixture
|
||
.GetEndpointAsync(ServerUrl, SecurityPolicies.None)
|
||
.ConfigureAwait(false);
|
||
|
||
ManagedSession session = await new ManagedSessionBuilder(
|
||
ClientFixture.Config, Telemetry)
|
||
.UseEndpoint(endpoint)
|
||
.WithSessionName(nameof(BuilderTransferOnRecreateOptionV2Async))
|
||
.WithTransferSubscriptionsOnRecreate(true)
|
||
.ConnectAsync(ct).ConfigureAwait(false);
|
||
try
|
||
{
|
||
// The option lives on the V2 SubscriptionManager. We can
|
||
// verify the manager has the property set so the recreate
|
||
// path will request transfer when it runs.
|
||
ISubscriptionManager manager = session.RequireSubscriptionManager();
|
||
Assert.That(manager, Is.Not.Null);
|
||
// The interface itself doesn't surface the flag (it's on
|
||
// the concrete SubscriptionManager). We exercise the
|
||
// through-flow by creating a subscription and confirming
|
||
// the manager continues to work — the flag is verified
|
||
// via the failover path in the test for
|
||
// ManagedSessionReconnectIntegrationTests in Sessions.Tests
|
||
// when that runs end-to-end.
|
||
var handler = new RecordingSubscriptionHandler();
|
||
ISubscription sub = session.AddSubscription(handler,
|
||
new Client.Subscriptions.SubscriptionOptions
|
||
{
|
||
PublishingInterval = TimeSpan.FromMilliseconds(500),
|
||
KeepAliveCount = 10,
|
||
LifetimeCount = 100,
|
||
PublishingEnabled = true
|
||
});
|
||
bool created = await WaitForAsync(() => sub.Created,
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(created, Is.True,
|
||
"Subscription should be created on the server");
|
||
await sub.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
await session.CloseAsync().ConfigureAwait(false);
|
||
await session.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
}
|
||
|
||
// ===== 4. Save → Load round-trips multiple items + triggering =====
|
||
|
||
[Test]
|
||
[CancelAfter(60_000)]
|
||
[DependsOnTest(nameof(BuilderTransferOnRecreateOptionV2Async), AllowFailure = true)]
|
||
public async Task SaveLoadRoundTripWithMultipleItemsV2Async(
|
||
CancellationToken ct)
|
||
{
|
||
string saveFile = Path.Combine(Path.GetTempPath(),
|
||
$"V2SaveLoadRound-{Guid.NewGuid():N}.bin");
|
||
|
||
ManagedSession session = await ConnectV2Async(
|
||
nameof(SaveLoadRoundTripWithMultipleItemsV2Async), ct)
|
||
.ConfigureAwait(false);
|
||
ManagedSession? target = null;
|
||
try
|
||
{
|
||
var handler = new RecordingSubscriptionHandler();
|
||
ISubscription sub = session.AddSubscription(handler,
|
||
new Client.Subscriptions.SubscriptionOptions
|
||
{
|
||
PublishingInterval = TimeSpan.FromMilliseconds(500),
|
||
KeepAliveCount = 10,
|
||
LifetimeCount = 100,
|
||
PublishingEnabled = true,
|
||
Priority = 50,
|
||
MaxNotificationsPerPublish = 42
|
||
});
|
||
bool created = await WaitForAsync(() => sub.Created,
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(created, Is.True);
|
||
|
||
// Add 3 items with different configs
|
||
Assert.That(sub.TryAddMonitoredItem("Time",
|
||
VariableIds.Server_ServerStatus_CurrentTime,
|
||
o => o with { SamplingInterval = TimeSpan.FromMilliseconds(250) },
|
||
out Client.Subscriptions.MonitoredItems.IMonitoredItem? timeItem), Is.True);
|
||
Assert.That(sub.TryAddMonitoredItem("State",
|
||
VariableIds.Server_ServerStatus_State,
|
||
o => o with { SamplingInterval = TimeSpan.FromMilliseconds(500) },
|
||
out Client.Subscriptions.MonitoredItems.IMonitoredItem? stateItem), Is.True);
|
||
Assert.That(sub.TryAddMonitoredItem("Build",
|
||
VariableIds.Server_ServerStatus_BuildInfo,
|
||
o => o with { SamplingInterval = TimeSpan.Zero },
|
||
out Client.Subscriptions.MonitoredItems.IMonitoredItem? buildItem), Is.True);
|
||
|
||
bool allCreated = await WaitForAsync(
|
||
() => timeItem!.Created && stateItem!.Created && buildItem!.Created,
|
||
TimeSpan.FromSeconds(10), ct).ConfigureAwait(false);
|
||
Assert.That(allCreated, Is.True);
|
||
|
||
using (FileStream output = File.Create(saveFile))
|
||
{
|
||
await session.RequireSubscriptionManager().SaveAsync(
|
||
output, session.MessageContext, null, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
|
||
target = await ConnectV2Async(
|
||
nameof(SaveLoadRoundTripWithMultipleItemsV2Async) + "_target", ct)
|
||
.ConfigureAwait(false);
|
||
|
||
var targetHandler = new RecordingSubscriptionHandler();
|
||
IReadOnlyList<ISubscription> loaded;
|
||
using (FileStream input = File.OpenRead(saveFile))
|
||
{
|
||
loaded = await target.RequireSubscriptionManager().LoadAsync(input,
|
||
target.MessageContext, _ => targetHandler,
|
||
transferSubscriptions: false, ct).ConfigureAwait(false);
|
||
}
|
||
|
||
Assert.That(loaded, Has.Count.EqualTo(1));
|
||
ISubscription loadedSub = loaded[0];
|
||
Assert.That(loadedSub.MonitoredItems.Count, Is.EqualTo(3u));
|
||
Assert.That(loadedSub.MonitoredItems.TryGetMonitoredItemByName(
|
||
"Time", out _), Is.True);
|
||
Assert.That(loadedSub.MonitoredItems.TryGetMonitoredItemByName(
|
||
"State", out _), Is.True);
|
||
Assert.That(loadedSub.MonitoredItems.TryGetMonitoredItemByName(
|
||
"Build", out _), Is.True);
|
||
|
||
bool reCreated = await WaitForAsync(() => loadedSub.Created,
|
||
TimeSpan.FromSeconds(15), ct).ConfigureAwait(false);
|
||
Assert.That(reCreated, Is.True);
|
||
|
||
await loadedSub.DisposeAsync().ConfigureAwait(false);
|
||
await sub.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
try
|
||
{
|
||
await session.CloseAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
try
|
||
{
|
||
await session.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
if (target != null)
|
||
{
|
||
try
|
||
{
|
||
await target.CloseAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
try
|
||
{
|
||
await target.DisposeAsync().ConfigureAwait(false);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
try
|
||
{
|
||
File.Delete(saveFile);
|
||
}
|
||
catch
|
||
{ /* best effort */
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== helpers =====
|
||
|
||
private async Task<ManagedSession> ConnectV2Async(
|
||
string sessionName, CancellationToken ct,
|
||
bool deleteSubscriptionsOnClose = true)
|
||
{
|
||
ConfiguredEndpoint endpoint = await ClientFixture
|
||
.GetEndpointAsync(ServerUrl, SecurityPolicies.None)
|
||
.ConfigureAwait(false);
|
||
ManagedSession session = await new ManagedSessionBuilder(
|
||
ClientFixture.Config, Telemetry)
|
||
.UseEndpoint(endpoint)
|
||
.WithSessionName(sessionName)
|
||
.WithSessionTimeout(TimeSpan.FromSeconds(120))
|
||
.ConnectAsync(ct).ConfigureAwait(false);
|
||
session.DeleteSubscriptionsOnClose = deleteSubscriptionsOnClose;
|
||
return session;
|
||
}
|
||
|
||
private static async Task<bool> WaitForAsync(
|
||
Func<bool> predicate, TimeSpan timeout, CancellationToken ct)
|
||
{
|
||
DateTime deadline = DateTime.UtcNow + timeout;
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
ct.ThrowIfCancellationRequested();
|
||
if (predicate())
|
||
{
|
||
return true;
|
||
}
|
||
await Task.Delay(50, ct).ConfigureAwait(false);
|
||
}
|
||
return predicate();
|
||
}
|
||
}
|
||
}
|