mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-23 02:00:00 +08:00
Marc Schier
e73e71184d
## Summary Adds OPC UA WoT Connectivity 1.1 to the stack, together with the Types, source generation, Server and xRegistry work it is built on. This branch is the merge point for the fourteen-PR stack that replaced integration PR #4093; every constituent PR was reviewed and approved separately and is listed below. 414 files changed, +108,936 / -3,199. Roughly 46k added lines of product code, 57k of tests, plus samples, tools and documentation. ## Types - Complete `ExtensionObject` raw-body decoding for binary, XML and JSON bodies by resolving the concrete type through the message context's encodeable factory, and simplify the `Variant` structure helpers by delegating to it (#4128). - Add `IAtomicFileReplace` as an optional `IFileSystem` capability so existing external implementations keep working, with atomic publish for `LocalFileSystem` via `File.Replace`/`File.Move` and for `VirtualFileSystem` by re-keying the in-memory entry (#4128). - Add lossless conversion between WoT documents and NodeSet2 (`Opc.Ua.Wot.WotNodeSetConverter`). A byte-exact `uav:nodeSet` envelope is preserved when requested, the structured `uav:nodes` projection is used when the readable vocabulary is incomplete, and NodeSet2 is otherwise synthesized from readable WoT terms. Unmapped JSON members survive a round trip as pointer-addressed residue (#4131). ## Source generation - Improve the NodeSet to ModelDesign conversion and the generated node state (#4132). - Generate OPC UA models directly from WoT Thing Description files (#4134). ## Server - Add live NodeManager shadow and immediate reload. A reload materializes a new generation beside the active one and switches atomically; the superseded generation is retired gracefully so existing MonitoredItems keep being served until they drain, or immediately when the caller asks for it. Includes the request admission and drain machinery that lets an orderly shutdown wait for admitted requests instead of tearing down underneath them (#4147). - Make subscription transfer between sessions transactional, so a failed transfer leaves neither session holding a partially moved subscription (#4150). ## xRegistry - Allow clients to use explicit registry roots rather than assuming a well-known location (#4130). ## WoT Connectivity - Add the WoT Connectivity 1.1 information model: a registry-first revision layered on the abstract xRegistry base model, incorporating the complete published OPC 10100-1 v1.02 surface as deprecated nodes in the same namespace so existing 1.02 clients keep working (#4139). - Add the protocol binding abstractions and planners that compile WoT forms into executable plans (#4140). - Add the HTTP, Modbus, OPC UA and MQTT binding executors (#4144). - Add the registry and its stores, including document versioning, validation, dependency resolution and refresh (#4146). - Add the registry client (#4142). - Materialize WoT Thing Descriptions into the server address space, deriving types from Thing Models and instances from Thing Descriptions (#4154). - Restore the WoT asset registry bridge so the deprecated 1.02 asset surface is backed by the registry (#4171). - Add the WoT Connectivity samples and complete the documentation (#4156), and restore the remaining coverage and docs (#4172). ## New projects `src/Opc.Ua.WotCon.Bindings`, `src/Opc.Ua.WotCon.Bindings.Mqtt`, `tests/Opc.Ua.WotCon.Bindings.Tests`, `tests/Opc.Ua.WotCon.Samples.Tests`, and the `samples/WotCon` AggregationServer, AggregationClient and FlatTagServer samples. ## Constituent pull requests Merged into this branch top-down, each independently approved: | PR | Title | | --- | --- | | #4128 | [Types] Complete ExtensionObject decoding and add an atomic file replace capability | | #4131 | [Types] Add lossless conversion between WoT documents and NodeSet2 | | #4132 | [SourceGeneration] Improve NodeSet to ModelDesign conversion and generated node state | | #4134 | [SourceGeneration] Generate OPC UA models from WoT Thing Description files | | #4147 | [Server] Add live NodeManager shadow and immediate reload | | #4150 | [Server] Make subscription transfer between sessions transactional | | #4130 | [XRegistry] Allow clients to use explicit registry roots | | #4139 | [WotCon] Add the WoT Connectivity 1.1 information model | | #4140 | [WotCon] Add the WoT protocol binding abstractions and planners | | #4144 | [WotCon] Add the HTTP, Modbus, OPC UA and MQTT binding executors | | #4146 | [WotCon] Add the WoT Connectivity registry and its stores | | #4142 | [WotCon] Add the WoT Connectivity registry client | | #4154 | [WotCon] Materialize WoT Thing Descriptions into the server address space | | #4156 | [WotCon] Add the WoT Connectivity samples and complete the documentation | | #4171 | Restore WoT asset registry bridge | | #4172 | Restore WoT coverage and docs | Supersedes #4093. ## Follow-up The WoT Connectivity and WoT Binding drafts have moved to 1.1-draft2 since this work was authored. Aligning with that revision - the removed group vocabulary, the new projection/View construct, the remaining model vocabulary terms and the two new portable-identity validation rules - is tracked separately and will follow in its own pull request. ## Validation Built for every target framework with zero warnings and zero errors, and validated at the tip of the stack with `Opc.Ua.WotCon.Tests` at 999 passed / 0 failed and `Opc.Ua.Server.Tests` at 4024 passed / 0 failed. --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 9e6a5abf-3299-4cd1-9855-010fedbf0ad8
521 lines
23 KiB
C#
521 lines
23 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/
|
|
* ======================================================================*/
|
|
|
|
#nullable enable
|
|
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
|
|
namespace Opc.Ua.Server.Tests.NodeManager
|
|
{
|
|
/// <summary>
|
|
/// Unit tests for <see cref="SyncNodeManagerAdapter"/>.
|
|
/// </summary>
|
|
[TestFixture]
|
|
[Category("NodeManager")]
|
|
[Parallelizable(ParallelScope.All)]
|
|
public class SyncNodeManagerAdapterTests
|
|
{
|
|
[Test]
|
|
public void ConstructorRejectsNullNodeManager()
|
|
{
|
|
Assert.That(() => new SyncNodeManagerAdapter(null!), Throws.ArgumentNullException);
|
|
}
|
|
|
|
[Test]
|
|
public void FactoryReturnsSameInstanceWhenAsyncManagerIsAlsoSyncManager()
|
|
{
|
|
var manager = new Mock<IAsyncAndSyncNodeManager>();
|
|
|
|
INodeManager result = manager.Object.ToSyncNodeManager();
|
|
|
|
Assert.That(result, Is.SameAs(manager.Object));
|
|
}
|
|
|
|
[Test]
|
|
public void FactoryWrapsAsyncOnlyManager()
|
|
{
|
|
var manager = new Mock<IAsyncNodeManager>();
|
|
|
|
INodeManager result = manager.Object.ToSyncNodeManager();
|
|
|
|
Assert.That(result, Is.TypeOf<SyncNodeManagerAdapter>());
|
|
}
|
|
|
|
[Test]
|
|
public void AllMethodsForwardToAsyncNodeManager()
|
|
{
|
|
var manager = new Mock<IAsyncNodeManager>(MockBehavior.Strict);
|
|
var adapter = new SyncNodeManagerAdapter(manager.Object);
|
|
OperationContext context = NewOpContext(RequestType.Read);
|
|
var externalReferences = new Dictionary<NodeId, IList<IReference>>();
|
|
var references = new Dictionary<NodeId, IList<IReference>>();
|
|
var nodeId = new NodeId(123, 2);
|
|
object handle = new();
|
|
object sourceHandle = new();
|
|
var referenceTypeId = new NodeId(234, 2);
|
|
var targetId = new ExpandedNodeId(new NodeId(345, 2));
|
|
var metadata = new NodeMetadata(handle, nodeId);
|
|
var continuationPoint = new ContinuationPoint();
|
|
var returnedContinuationPoint = new ContinuationPoint();
|
|
var referenceDescriptions = new List<ReferenceDescription>();
|
|
var relativePath = new RelativePathElement();
|
|
var targetIds = new List<ExpandedNodeId>();
|
|
var unresolvedTargetIds = new List<NodeId>();
|
|
var readValues = new ArrayOf<ReadValueId>();
|
|
var values = new List<DataValue>();
|
|
var readErrors = new List<ServiceResult>();
|
|
var historyReadDetails = new ReadRawModifiedDetails();
|
|
var historyReadValues = new ArrayOf<HistoryReadValueId>();
|
|
var historyReadResults = new List<HistoryReadResult>();
|
|
var historyReadErrors = new List<ServiceResult>();
|
|
var writeValues = new ArrayOf<WriteValue>();
|
|
var writeErrors = new List<ServiceResult>();
|
|
var historyUpdates = new ArrayOf<HistoryUpdateDetails>();
|
|
var historyUpdateResults = new List<HistoryUpdateResult>();
|
|
var historyUpdateErrors = new List<ServiceResult>();
|
|
var methodsToCall = new ArrayOf<CallMethodRequest>();
|
|
var callResults = new List<CallMethodResult>();
|
|
var callErrors = new List<ServiceResult>();
|
|
IEventMonitoredItem monitoredItem = new Mock<IEventMonitoredItem>().Object;
|
|
var eventItems = new List<IEventMonitoredItem>();
|
|
var itemsToCreate = new ArrayOf<MonitoredItemCreateRequest>();
|
|
var createErrors = new List<ServiceResult>();
|
|
var filterErrors = new List<MonitoringFilterResult>();
|
|
var monitoredItems = new List<IMonitoredItem>();
|
|
var idFactory = new MonitoredItemIdFactory();
|
|
var itemsToRestore = new List<IStoredMonitoredItem>();
|
|
IUserIdentity ownerIdentity = new Mock<IUserIdentity>().Object;
|
|
var itemsToModify = new ArrayOf<MonitoredItemModifyRequest>();
|
|
var modifyErrors = new List<ServiceResult>();
|
|
var deleteProcessed = new List<bool>();
|
|
var deleteErrors = new List<ServiceResult>();
|
|
var transferProcessed = new List<bool>();
|
|
var transferErrors = new List<ServiceResult>();
|
|
var monitoringProcessed = new List<bool>();
|
|
var monitoringErrors = new List<ServiceResult>();
|
|
var sessionId = new NodeId(456, 2);
|
|
var permissionCache = new Dictionary<NodeId, Variant[]>();
|
|
var methodToCall = new CallMethodRequest();
|
|
var methodState = new MethodState(null);
|
|
IFilterTarget filterTarget = new Mock<IFilterTarget>().Object;
|
|
string[] namespaces = ["urn:test"];
|
|
var deleteReferenceResult = new ServiceResult(StatusCodes.BadNodeIdUnknown);
|
|
var eventResult = new ServiceResult(StatusCodes.BadEventFilterInvalid);
|
|
var allEventsResult = new ServiceResult(StatusCodes.BadSubscriptionIdInvalid);
|
|
var permissionResult = new ServiceResult(StatusCodes.BadUserAccessDenied);
|
|
var roleResult = new ServiceResult(StatusCodes.BadSecurityChecksFailed);
|
|
|
|
SetupAsyncMethods(
|
|
manager,
|
|
namespaces,
|
|
externalReferences,
|
|
references,
|
|
nodeId,
|
|
handle,
|
|
sourceHandle,
|
|
referenceTypeId,
|
|
targetId,
|
|
deleteReferenceResult,
|
|
context,
|
|
metadata,
|
|
continuationPoint,
|
|
returnedContinuationPoint,
|
|
referenceDescriptions,
|
|
relativePath,
|
|
targetIds,
|
|
unresolvedTargetIds,
|
|
readValues,
|
|
values,
|
|
readErrors,
|
|
historyReadDetails,
|
|
historyReadValues,
|
|
historyReadResults,
|
|
historyReadErrors,
|
|
writeValues,
|
|
writeErrors,
|
|
historyUpdates,
|
|
historyUpdateResults,
|
|
historyUpdateErrors,
|
|
methodsToCall,
|
|
callResults,
|
|
callErrors,
|
|
monitoredItem,
|
|
eventItems,
|
|
eventResult,
|
|
allEventsResult,
|
|
itemsToCreate,
|
|
createErrors,
|
|
filterErrors,
|
|
monitoredItems,
|
|
idFactory,
|
|
itemsToRestore,
|
|
ownerIdentity,
|
|
itemsToModify,
|
|
modifyErrors,
|
|
deleteProcessed,
|
|
deleteErrors,
|
|
transferProcessed,
|
|
transferErrors,
|
|
monitoringProcessed,
|
|
monitoringErrors,
|
|
sessionId,
|
|
permissionCache,
|
|
methodToCall,
|
|
methodState,
|
|
filterTarget,
|
|
permissionResult,
|
|
roleResult);
|
|
|
|
Assert.That(adapter.NamespaceUris, Is.SameAs(namespaces));
|
|
adapter.CreateAddressSpace(externalReferences);
|
|
adapter.DeleteAddressSpace();
|
|
Assert.That(adapter.GetManagerHandle(nodeId), Is.SameAs(handle));
|
|
adapter.AddReferences(references);
|
|
Assert.That(
|
|
adapter.DeleteReference(sourceHandle, referenceTypeId, true, targetId, true),
|
|
Is.SameAs(deleteReferenceResult));
|
|
Assert.That(adapter.GetNodeMetadata(context, handle, BrowseResultMask.All), Is.SameAs(metadata));
|
|
adapter.Browse(context, ref continuationPoint, referenceDescriptions);
|
|
Assert.That(continuationPoint, Is.SameAs(returnedContinuationPoint));
|
|
adapter.TranslateBrowsePath(context, sourceHandle, relativePath, targetIds, unresolvedTargetIds);
|
|
adapter.Read(context, 1.0, readValues, values, readErrors);
|
|
adapter.HistoryRead(
|
|
context,
|
|
historyReadDetails,
|
|
TimestampsToReturn.Both,
|
|
true,
|
|
historyReadValues,
|
|
historyReadResults,
|
|
historyReadErrors);
|
|
adapter.Write(context, writeValues, writeErrors);
|
|
adapter.HistoryUpdate(
|
|
context,
|
|
typeof(UpdateDataDetails),
|
|
historyUpdates,
|
|
historyUpdateResults,
|
|
historyUpdateErrors);
|
|
adapter.Call(context, methodsToCall, callResults, callErrors);
|
|
Assert.That(
|
|
adapter.SubscribeToEvents(context, sourceHandle, 1, monitoredItem, false),
|
|
Is.SameAs(eventResult));
|
|
Assert.That(adapter.SubscribeToAllEvents(context, 2, monitoredItem, true), Is.SameAs(allEventsResult));
|
|
Assert.That(ServiceResult.IsGood(adapter.ConditionRefresh(context, eventItems)), Is.True);
|
|
adapter.CreateMonitoredItems(
|
|
context,
|
|
3,
|
|
1000.0,
|
|
TimestampsToReturn.Server,
|
|
itemsToCreate,
|
|
createErrors,
|
|
filterErrors,
|
|
monitoredItems,
|
|
true,
|
|
idFactory);
|
|
adapter.RestoreMonitoredItems(itemsToRestore, monitoredItems, ownerIdentity);
|
|
adapter.ModifyMonitoredItems(
|
|
context,
|
|
TimestampsToReturn.Source,
|
|
monitoredItems,
|
|
itemsToModify,
|
|
modifyErrors,
|
|
filterErrors);
|
|
adapter.DeleteMonitoredItems(context, monitoredItems, deleteProcessed, deleteErrors);
|
|
adapter.TransferMonitoredItems(
|
|
context,
|
|
true,
|
|
monitoredItems,
|
|
transferProcessed,
|
|
transferErrors,
|
|
new MonitoredItemTransferOptions());
|
|
adapter.SetMonitoringMode(
|
|
context,
|
|
MonitoringMode.Reporting,
|
|
monitoredItems,
|
|
monitoringProcessed,
|
|
monitoringErrors);
|
|
adapter.SessionClosing(context, sessionId, true);
|
|
adapter.SessionActivated(context, sessionId);
|
|
Assert.That(adapter.IsNodeInView(context, nodeId, handle), Is.True);
|
|
Assert.That(
|
|
adapter.GetPermissionMetadata(context, handle, BrowseResultMask.All, permissionCache, true),
|
|
Is.SameAs(metadata));
|
|
Assert.That(adapter.FindMethodState(context, methodToCall), Is.SameAs(methodState));
|
|
Assert.That(adapter.ValidateEventRolePermissions(monitoredItem, filterTarget), Is.SameAs(permissionResult));
|
|
Assert.That(
|
|
adapter.ValidateRolePermissions(context, nodeId, PermissionType.Read),
|
|
Is.SameAs(roleResult));
|
|
|
|
manager.VerifyAll();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Composite interface for factory branch coverage.
|
|
/// </summary>
|
|
public interface IAsyncAndSyncNodeManager : IAsyncNodeManager, INodeManager;
|
|
|
|
private static void SetupAsyncMethods(
|
|
Mock<IAsyncNodeManager> manager,
|
|
IEnumerable<string> namespaces,
|
|
IDictionary<NodeId, IList<IReference>> externalReferences,
|
|
IDictionary<NodeId, IList<IReference>> references,
|
|
NodeId nodeId,
|
|
object handle,
|
|
object sourceHandle,
|
|
NodeId referenceTypeId,
|
|
ExpandedNodeId targetId,
|
|
ServiceResult deleteReferenceResult,
|
|
OperationContext context,
|
|
NodeMetadata metadata,
|
|
ContinuationPoint continuationPoint,
|
|
ContinuationPoint returnedContinuationPoint,
|
|
IList<ReferenceDescription> referenceDescriptions,
|
|
RelativePathElement relativePath,
|
|
IList<ExpandedNodeId> targetIds,
|
|
IList<NodeId> unresolvedTargetIds,
|
|
ArrayOf<ReadValueId> readValues,
|
|
IList<DataValue> values,
|
|
IList<ServiceResult> readErrors,
|
|
HistoryReadDetails historyReadDetails,
|
|
ArrayOf<HistoryReadValueId> historyReadValues,
|
|
IList<HistoryReadResult> historyReadResults,
|
|
IList<ServiceResult> historyReadErrors,
|
|
ArrayOf<WriteValue> writeValues,
|
|
IList<ServiceResult> writeErrors,
|
|
ArrayOf<HistoryUpdateDetails> historyUpdates,
|
|
IList<HistoryUpdateResult> historyUpdateResults,
|
|
IList<ServiceResult> historyUpdateErrors,
|
|
ArrayOf<CallMethodRequest> methodsToCall,
|
|
IList<CallMethodResult> callResults,
|
|
IList<ServiceResult> callErrors,
|
|
IEventMonitoredItem monitoredItem,
|
|
IList<IEventMonitoredItem> eventItems,
|
|
ServiceResult eventResult,
|
|
ServiceResult allEventsResult,
|
|
ArrayOf<MonitoredItemCreateRequest> itemsToCreate,
|
|
IList<ServiceResult> createErrors,
|
|
IList<MonitoringFilterResult> filterErrors,
|
|
IList<IMonitoredItem> monitoredItems,
|
|
MonitoredItemIdFactory idFactory,
|
|
IList<IStoredMonitoredItem> itemsToRestore,
|
|
IUserIdentity ownerIdentity,
|
|
ArrayOf<MonitoredItemModifyRequest> itemsToModify,
|
|
IList<ServiceResult> modifyErrors,
|
|
IList<bool> deleteProcessed,
|
|
IList<ServiceResult> deleteErrors,
|
|
IList<bool> transferProcessed,
|
|
IList<ServiceResult> transferErrors,
|
|
IList<bool> monitoringProcessed,
|
|
IList<ServiceResult> monitoringErrors,
|
|
NodeId sessionId,
|
|
Dictionary<NodeId, Variant[]> permissionCache,
|
|
CallMethodRequest methodToCall,
|
|
MethodState methodState,
|
|
IFilterTarget filterTarget,
|
|
ServiceResult permissionResult,
|
|
ServiceResult roleResult)
|
|
{
|
|
manager.Setup(m => m.NamespaceUris).Returns(namespaces);
|
|
manager.Setup(m => m.CreateAddressSpaceAsync(externalReferences, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.DeleteAddressSpaceAsync(It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.GetManagerHandleAsync(nodeId, It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<object>(handle));
|
|
manager.Setup(m => m.AddReferencesAsync(references, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.DeleteReferenceAsync(
|
|
sourceHandle,
|
|
referenceTypeId,
|
|
true,
|
|
targetId,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(deleteReferenceResult));
|
|
manager.Setup(m => m.GetNodeMetadataAsync(
|
|
context,
|
|
handle,
|
|
BrowseResultMask.All,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<NodeMetadata>(metadata));
|
|
manager.Setup(m => m.BrowseAsync(
|
|
context,
|
|
continuationPoint,
|
|
referenceDescriptions,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ContinuationPoint?>(returnedContinuationPoint));
|
|
manager.Setup(m => m.TranslateBrowsePathAsync(
|
|
context,
|
|
sourceHandle,
|
|
relativePath,
|
|
targetIds,
|
|
unresolvedTargetIds,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.ReadAsync(context, 1.0, readValues, values, readErrors, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.HistoryReadAsync(
|
|
context,
|
|
historyReadDetails,
|
|
TimestampsToReturn.Both,
|
|
true,
|
|
historyReadValues,
|
|
historyReadResults,
|
|
historyReadErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.WriteAsync(context, writeValues, writeErrors, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.HistoryUpdateAsync(
|
|
context,
|
|
typeof(UpdateDataDetails),
|
|
historyUpdates,
|
|
historyUpdateResults,
|
|
historyUpdateErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.CallAsync(
|
|
context,
|
|
methodsToCall,
|
|
callResults,
|
|
callErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.SubscribeToEventsAsync(
|
|
context,
|
|
sourceHandle,
|
|
1,
|
|
monitoredItem,
|
|
false,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(eventResult));
|
|
manager.Setup(m => m.SubscribeToAllEventsAsync(
|
|
context,
|
|
2,
|
|
monitoredItem,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(allEventsResult));
|
|
manager.Setup(m => m.ConditionRefreshAsync(context, eventItems, It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(ServiceResult.Good));
|
|
manager.Setup(m => m.CreateMonitoredItemsAsync(
|
|
context,
|
|
3,
|
|
1000.0,
|
|
TimestampsToReturn.Server,
|
|
itemsToCreate,
|
|
createErrors,
|
|
filterErrors,
|
|
monitoredItems,
|
|
true,
|
|
idFactory,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.RestoreMonitoredItemsAsync(
|
|
itemsToRestore,
|
|
monitoredItems,
|
|
ownerIdentity,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.ModifyMonitoredItemsAsync(
|
|
context,
|
|
TimestampsToReturn.Source,
|
|
monitoredItems,
|
|
itemsToModify,
|
|
modifyErrors,
|
|
filterErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.DeleteMonitoredItemsAsync(
|
|
context,
|
|
monitoredItems,
|
|
deleteProcessed,
|
|
deleteErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.TransferMonitoredItemsAsync(
|
|
context,
|
|
true,
|
|
monitoredItems,
|
|
transferProcessed,
|
|
transferErrors,
|
|
It.IsAny<MonitoredItemTransferOptions>(),
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.SetMonitoringModeAsync(
|
|
context,
|
|
MonitoringMode.Reporting,
|
|
monitoredItems,
|
|
monitoringProcessed,
|
|
monitoringErrors,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.SessionClosingAsync(context, sessionId, true, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.SessionActivatedAsync(context, sessionId, It.IsAny<CancellationToken>()))
|
|
.Returns(default(ValueTask));
|
|
manager.Setup(m => m.IsNodeInViewAsync(context, nodeId, handle, It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<bool>(true));
|
|
manager.Setup(m => m.GetPermissionMetadataAsync(
|
|
context,
|
|
handle,
|
|
BrowseResultMask.All,
|
|
permissionCache,
|
|
true,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<NodeMetadata?>(metadata));
|
|
manager.Setup(m => m.FindMethodStateAsync(context, methodToCall, It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<MethodState>(methodState));
|
|
manager.Setup(m => m.ValidateEventRolePermissionsAsync(
|
|
monitoredItem,
|
|
filterTarget,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(permissionResult));
|
|
manager.Setup(m => m.ValidateRolePermissionsAsync(
|
|
context,
|
|
nodeId,
|
|
PermissionType.Read,
|
|
It.IsAny<CancellationToken>()))
|
|
.Returns(new ValueTask<ServiceResult>(roleResult));
|
|
}
|
|
|
|
private static OperationContext NewOpContext(RequestType type)
|
|
{
|
|
var session = new Mock<ISession>();
|
|
session.Setup(s => s.EffectiveIdentity).Returns(new Mock<IUserIdentity>().Object);
|
|
session.Setup(s => s.PreferredLocales).Returns([]);
|
|
return new OperationContext(
|
|
new RequestHeader(), null!, type, RequestLifetime.None, session.Object);
|
|
}
|
|
}
|
|
}
|