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.
335 lines
12 KiB
C#
335 lines
12 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/
|
|
* ======================================================================*/
|
|
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using Opc.Ua.Tests;
|
|
|
|
namespace Opc.Ua.Client.Tests
|
|
{
|
|
[TestFixture]
|
|
[Category("Client")]
|
|
[Category("Session")]
|
|
[SetCulture("en-us")]
|
|
[SetUICulture("en-us")]
|
|
public sealed class SessionExtensionsTests
|
|
{
|
|
private Mock<ISession> m_session;
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
m_session = new Mock<ISession>(MockBehavior.Strict);
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
m_session.Verify();
|
|
}
|
|
|
|
[Test]
|
|
public async Task OpenAsyncWithNameAndIdentityForwardsToFullOverloadAsync()
|
|
{
|
|
var identity = new UserIdentity();
|
|
// ultimately calling the 7-param ISession.OpenAsync
|
|
m_session
|
|
.Setup(s => s.OpenAsync(
|
|
"TestSession",
|
|
0u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
true,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.OpenAsync("TestSession", identity).ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.OpenAsync(
|
|
"TestSession",
|
|
0u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
true,
|
|
true,
|
|
It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OpenAsyncWithTimeoutForwardsToFullOverloadAsync()
|
|
{
|
|
var identity = new UserIdentity();
|
|
ArrayOf<string> locales = ["en", "de"];
|
|
|
|
m_session
|
|
.Setup(s => s.OpenAsync(
|
|
"TestSession",
|
|
60000u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
true,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.OpenAsync("TestSession", 60000u, identity, locales).ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.OpenAsync(
|
|
"TestSession",
|
|
60000u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
true,
|
|
true,
|
|
It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OpenAsyncWithCheckDomainForwardsToFullOverloadAsync()
|
|
{
|
|
var identity = new UserIdentity();
|
|
ArrayOf<string> locales = ["en"];
|
|
|
|
m_session
|
|
.Setup(s => s.OpenAsync(
|
|
"TestSession",
|
|
30000u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
false,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.OpenAsync("TestSession", 30000u, identity, locales, false).ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.OpenAsync(
|
|
"TestSession",
|
|
30000u,
|
|
identity,
|
|
It.IsAny<ArrayOf<string>>(),
|
|
false,
|
|
true,
|
|
It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReconnectAsyncWithNoArgsForwardsCorrectlyAsync()
|
|
{
|
|
m_session
|
|
.Setup(s => s.ReconnectAsync(null, null, It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.ReconnectAsync().ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.ReconnectAsync(
|
|
null, null, It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReconnectAsyncWithConnectionForwardsCorrectlyAsync()
|
|
{
|
|
var connection = new Mock<ITransportWaitingConnection>();
|
|
|
|
m_session
|
|
.Setup(s => s.ReconnectAsync(connection.Object, null, It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.ReconnectAsync(connection.Object).ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.ReconnectAsync(
|
|
connection.Object, null, It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReconnectAsyncWithChannelForwardsCorrectlyAsync()
|
|
{
|
|
var channel = new Mock<ITransportChannel>();
|
|
|
|
m_session
|
|
.Setup(s => s.ReconnectAsync(null, channel.Object, It.IsAny<CancellationToken>()))
|
|
.Returns(Task.CompletedTask)
|
|
.Verifiable();
|
|
|
|
await m_session.Object.ReconnectAsync(channel.Object).ConfigureAwait(false);
|
|
|
|
m_session.Verify(s => s.ReconnectAsync(
|
|
null, channel.Object, It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task CloseAsyncWithCloseChannelForwardsCorrectlyAsync()
|
|
{
|
|
m_session
|
|
.SetupGet(s => s.KeepAliveInterval)
|
|
.Returns(5000);
|
|
|
|
m_session
|
|
.Setup(s => s.CloseAsync(5000, true, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(StatusCodes.Good)
|
|
.Verifiable();
|
|
|
|
StatusCode result = await m_session.Object.CloseAsync(true).ConfigureAwait(false);
|
|
|
|
Assert.That(result, Is.EqualTo(StatusCodes.Good));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CloseAsyncWithCloseChannelFalseForwardsCorrectlyAsync()
|
|
{
|
|
m_session
|
|
.SetupGet(s => s.KeepAliveInterval)
|
|
.Returns(10000);
|
|
|
|
m_session
|
|
.Setup(s => s.CloseAsync(10000, false, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(StatusCodes.Good)
|
|
.Verifiable();
|
|
|
|
StatusCode result = await m_session.Object.CloseAsync(false).ConfigureAwait(false);
|
|
|
|
Assert.That(result, Is.EqualTo(StatusCodes.Good));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CloseAsyncWithTimeoutForwardsCorrectlyAsync()
|
|
{
|
|
m_session
|
|
.Setup(s => s.CloseAsync(3000, true, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(StatusCodes.Good)
|
|
.Verifiable();
|
|
|
|
StatusCode result = await m_session.Object.CloseAsync(3000).ConfigureAwait(false);
|
|
|
|
Assert.That(result, Is.EqualTo(StatusCodes.Good));
|
|
}
|
|
|
|
[Test]
|
|
public void SaveWithSubscriptionsForwardsToStreamSave()
|
|
{
|
|
Subscription[] subscriptions = [];
|
|
m_session
|
|
.SetupGet(s => s.Subscriptions)
|
|
.Returns(subscriptions);
|
|
|
|
// The Save(filePath) extension calls Save(filePath, session.Subscriptions, null)
|
|
// which creates a FileStream. We test that it reads Subscriptions.
|
|
Assert.That(m_session.Object.Subscriptions, Is.SameAs(subscriptions));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReadByteStringInChunksAsyncThrowsWhenNoLimitIsKnown()
|
|
{
|
|
var capabilities = new ServerCapabilities { MaxByteStringLength = 0 };
|
|
m_session
|
|
.SetupGet(s => s.ServerCapabilities)
|
|
.Returns(capabilities);
|
|
SetupMessageContext(maxByteStringLength: 0);
|
|
|
|
await Assert.ThrowsAsync<ServiceResultException>(async () =>
|
|
await m_session.Object.ReadByteStringInChunksAsync(new NodeId(1)).ConfigureAwait(false));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReadByteStringInChunksAsyncThrowsWhenMaxByteStringLengthIsOne()
|
|
{
|
|
var capabilities = new ServerCapabilities { MaxByteStringLength = 1 };
|
|
m_session
|
|
.SetupGet(s => s.ServerCapabilities)
|
|
.Returns(capabilities);
|
|
SetupMessageContext(maxByteStringLength: 1024);
|
|
|
|
await Assert.ThrowsAsync<ServiceResultException>(async () =>
|
|
await m_session.Object.ReadByteStringInChunksAsync(new NodeId(1)).ConfigureAwait(false));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A server that does not provide MaxByteStringLength (0) or reports a
|
|
/// value beyond int range is read in chunks of the client limit (L3-6).
|
|
/// </summary>
|
|
[TestCase(0u)]
|
|
[TestCase(3_000_000_000u)]
|
|
public async Task ReadByteStringInChunksAsyncUsesClientLimitWhenServerLimitUnknownAsync(
|
|
uint serverLimit)
|
|
{
|
|
var capabilities = new ServerCapabilities { MaxByteStringLength = serverLimit };
|
|
m_session
|
|
.SetupGet(s => s.ServerCapabilities)
|
|
.Returns(capabilities);
|
|
SetupMessageContext(maxByteStringLength: 4);
|
|
var ranges = new List<string>();
|
|
m_session
|
|
.Setup(s => s.ReadAsync(
|
|
It.IsAny<RequestHeader>(),
|
|
It.IsAny<double>(),
|
|
It.IsAny<TimestampsToReturn>(),
|
|
It.IsAny<ArrayOf<ReadValueId>>(),
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns<RequestHeader, double, TimestampsToReturn, ArrayOf<ReadValueId>, CancellationToken>(
|
|
(_, _, _, ids, _) =>
|
|
{
|
|
ranges.Add(ids[0].IndexRange!);
|
|
byte[] chunk = ranges.Count == 1 ? [1, 2, 3, 4] : [5];
|
|
return new ValueTask<ReadResponse>(new ReadResponse
|
|
{
|
|
ResponseHeader = new ResponseHeader(),
|
|
Results = [new DataValue(new Variant(ByteString.From(chunk)))],
|
|
DiagnosticInfos = []
|
|
});
|
|
});
|
|
|
|
ByteString result = await m_session.Object
|
|
.ReadByteStringInChunksAsync(new NodeId(1))
|
|
.ConfigureAwait(false);
|
|
|
|
Assert.That(result.ToArray(), Is.EqualTo(new byte[] { 1, 2, 3, 4, 5 }));
|
|
string[] expectedRanges = ["0:3", "4:7"];
|
|
Assert.That(ranges, Is.EqualTo(expectedRanges));
|
|
}
|
|
|
|
private void SetupMessageContext(int maxByteStringLength)
|
|
{
|
|
var messageContext = ServiceMessageContext.Create(NUnitTelemetryContext.Create());
|
|
messageContext.MaxByteStringLength = maxByteStringLength;
|
|
m_session
|
|
.SetupGet(s => s.MessageContext)
|
|
.Returns(messageContext);
|
|
}
|
|
}
|
|
}
|