UA-.NETStandard/tests/Opc.Ua.Server.Tests/NodeManager/SamplingGroupTests.cs

/* ========================================================================
 * 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;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;

// CA2000: test code; the sampling group is short-lived and disposed per test.
#pragma warning disable CA2000

namespace Opc.Ua.Server.Tests.NodeManager
{
    /// <summary>
    /// Deterministic, offline unit tests for <see cref="SamplingGroup"/> that
    /// exercise construction validation and the <c>MeetsGroupCriteria</c>
    /// branches without ever starting the background sampling loop.
    /// </summary>
    [TestFixture]
    [Category("NodeManager")]
    [Category("SamplingGroup")]
    [Parallelizable(ParallelScope.All)]
    public class SamplingGroupTests
    {
        private static List<SamplingRateGroup> SamplingRates()
        {
            return [new SamplingRateGroup(1000, 0, 1)];
        }

        private static OperationContext SessionlessContext()
        {
            return new OperationContext(
                new RequestHeader(), null, RequestType.CreateMonitoredItems, RequestLifetime.None);
        }

        private static OperationContext SessionContext(ISession session)
        {
            return new OperationContext(
                new RequestHeader(), null!, RequestType.CreateMonitoredItems, RequestLifetime.None, session);
        }

        private static Mock<ISession> CreateSessionMock(NodeId id, IUserIdentity identity)
        {
            var session = new Mock<ISession>();
            session.SetupGet(s => s.Id).Returns(id);
            session.SetupGet(s => s.EffectiveIdentity).Returns(identity);
            return session;
        }

        private static SamplingGroup CreateGroup(
            IUserIdentity identity,
            double samplingInterval = 500,
            OperationContext? context = null)
        {
            Mock<IServerInternal> mockServer = DeterministicServerMock.Create(out _);
            var mockNodeManager = new Mock<IAsyncNodeManager>();
            return new SamplingGroup(
                mockServer.Object,
                mockNodeManager.Object,
                SamplingRates(),
                context ?? SessionlessContext(),
                samplingInterval,
                identity);
        }

        private static Mock<ISampledDataChangeMonitoredItem> CreateItem(
            int type = MonitoredItemTypeMask.DataChange,
            MonitoringMode mode = MonitoringMode.Reporting,
            double samplingInterval = 500)
        {
            var item = new Mock<ISampledDataChangeMonitoredItem>();
            item.SetupGet(m => m.Id).Returns(1);
            item.SetupGet(m => m.MonitoredItemType).Returns(type);
            item.SetupGet(m => m.MonitoringMode).Returns(mode);
            item.SetupGet(m => m.SamplingInterval).Returns(samplingInterval);
            return item;
        }

        /// <summary>
        /// Verifies that sampling-group construction rejects a null server.
        /// </summary>
        [Test]
        public void ConstructorWithNullServerThrows()
        {
            var nm = new Mock<IAsyncNodeManager>();
            Assert.That(
                () => new SamplingGroup(
                    null!, nm.Object, SamplingRates(), SessionlessContext(), 500,
                    new Mock<IUserIdentity>().Object),
                Throws.TypeOf<ArgumentNullException>());
        }

        /// <summary>
        /// Verifies that sampling-group construction rejects a null node manager.
        /// </summary>
        [Test]
        public void ConstructorWithNullNodeManagerThrows()
        {
            Mock<IServerInternal> mockServer = DeterministicServerMock.Create(out _);
            Assert.That(
                () => new SamplingGroup(
                    mockServer.Object, null!, SamplingRates(), SessionlessContext(), 500,
                    new Mock<IUserIdentity>().Object),
                Throws.TypeOf<ArgumentNullException>());
        }

        /// <summary>
        /// Verifies that sampling-group construction rejects null sampling rates.
        /// </summary>
        [Test]
        public void ConstructorWithNullSamplingRatesThrows()
        {
            Mock<IServerInternal> mockServer = DeterministicServerMock.Create(out _);
            var nm = new Mock<IAsyncNodeManager>();
            Assert.That(
                () => new SamplingGroup(
                    mockServer.Object, nm.Object, null!, SessionlessContext(), 500,
                    new Mock<IUserIdentity>().Object),
                Throws.TypeOf<ArgumentNullException>());
        }

        /// <summary>
        /// Verifies that a sessionless sampling group requires an owner identity.
        /// </summary>
        [Test]
        public void ConstructorSessionlessWithoutOwnerIdentityThrows()
        {
            Mock<IServerInternal> mockServer = DeterministicServerMock.Create(out _);
            var nm = new Mock<IAsyncNodeManager>();
            Assert.That(
                () => new SamplingGroup(
                    mockServer.Object, nm.Object, SamplingRates(), SessionlessContext(), 500,
                    savedOwnerIdentity: null),
                Throws.TypeOf<ArgumentNullException>());
        }

        /// <summary>
        /// Verifies that a sampling group rejects items that do not monitor data changes.
        /// </summary>
        [Test]
        public void StartMonitoringRejectsNonDataChangeItem()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem(type: MonitoredItemTypeMask.Events);

            bool added = group.StartMonitoring(SessionlessContext(), item.Object, identity.Object);

            Assert.That(added, Is.False);
        }

        /// <summary>
        /// Verifies that a sampling group rejects disabled monitored items.
        /// </summary>
        [Test]
        public void StartMonitoringRejectsDisabledItem()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem(mode: MonitoringMode.Disabled);

            bool added = group.StartMonitoring(SessionlessContext(), item.Object, identity.Object);

            Assert.That(added, Is.False);
        }

        /// <summary>
        /// Verifies that a sampling group rejects items with a mismatched sampling interval.
        /// </summary>
        [Test]
        public void StartMonitoringRejectsMismatchedSamplingInterval()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem(samplingInterval: 5000);

            bool added = group.StartMonitoring(SessionlessContext(), item.Object, identity.Object);

            Assert.That(added, Is.False);
        }

        /// <summary>
        /// Verifies that a sampling group rejects items belonging to another session.
        /// </summary>
        [Test]
        public void StartMonitoringRejectsMismatchedSession()
        {
            var identity = new Mock<IUserIdentity>();
            Mock<ISession> sessionA = CreateSessionMock(new NodeId(1, 1), identity.Object);
            Mock<ISession> sessionB = CreateSessionMock(new NodeId(2, 1), identity.Object);
            using SamplingGroup group = CreateGroup(
                identity.Object, context: SessionContext(sessionA.Object));
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            bool added = group.StartMonitoring(
                SessionContext(sessionB.Object), item.Object, identity.Object);

            Assert.That(added, Is.False);
        }

        /// <summary>
        /// Verifies that a sampling group accepts a matching monitored item.
        /// </summary>
        [Test]
        public void StartMonitoringAcceptsMatchingItem()
        {
            var identity = new Mock<IUserIdentity>();
            Mock<ISession> session = CreateSessionMock(new NodeId(1234, 1), identity.Object);
            OperationContext context = SessionContext(session.Object);
            using SamplingGroup group = CreateGroup(identity.Object, context: context);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            bool added = group.StartMonitoring(context, item.Object, identity.Object);

            Assert.That(added, Is.True);
            item.Verify(m => m.SetSamplingInterval(1000.0), Times.Once);
        }

        /// <summary>
        /// Verifies that a sessionless sampling group accepts an item with the matching owner identity.
        /// </summary>
        [Test]
        public void StartMonitoringAcceptsMatchingItemSessionlessByOwnerIdentity()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(
                identity.Object, context: SessionlessContext());
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            bool added = group.StartMonitoring(
                SessionlessContext(), item.Object, identity.Object);

            bool addedWithNullContext = group.StartMonitoring(
                null!, item.Object, identity.Object);

            Assert.That(added, Is.True);
            Assert.That(addedWithNullContext, Is.False);
            item.Verify(m => m.SetSamplingInterval(1000.0), Times.Once);
        }

        /// <summary>
        /// Verifies that a sessionless sampling group rejects an item with a different owner identity.
        /// </summary>
        [Test]
        public void StartMonitoringRejectsMismatchedOwnerIdentitySessionless()
        {
            var identity = new Mock<IUserIdentity>();
            var otherIdentity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(
                identity.Object, context: SessionlessContext());
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            bool added = group.StartMonitoring(
                SessionlessContext(), item.Object, otherIdentity.Object);

            Assert.That(added, Is.False);
        }

        /// <summary>
        /// Verifies that stopping an unknown monitored item returns false.
        /// </summary>
        [Test]
        public void StopMonitoringReturnsFalseForUnknownItem()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            Assert.That(group.StopMonitoring(item.Object), Is.False);
        }

        /// <summary>
        /// Verifies that stopping an item removes its pending addition to the sampling group.
        /// </summary>
        [Test]
        public void StopMonitoringRemovesItemPendingAddition()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            Assert.That(
                group.StartMonitoring(
                    SessionlessContext(),
                    item.Object,
                    identity.Object),
                Is.True);
            Assert.That(group.StopMonitoring(item.Object), Is.True);
            Assert.That(group.ApplyChanges(), Is.True);
        }

        /// <summary>
        /// Verifies that modifying an unknown monitored item returns false.
        /// </summary>
        [Test]
        public void ModifyMonitoringReturnsFalseForUnknownItem()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();

            Assert.That(group.ModifyMonitoring(SessionlessContext(), item.Object), Is.False);
        }

        /// <summary>
        /// Verifies that applying changes without monitored items reports an empty sampling group.
        /// </summary>
        [Test]
        public void ApplyChangesWithoutItemsReportsGroupEmpty()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);

            Assert.That(group.ApplyChanges(), Is.True);
        }

        /// <summary>
        /// Verifies that shutting down a sampling group before it starts is safe.
        /// </summary>
        [Test]
        public void ShutdownIsSafeWhenNotStarted()
        {
            var identity = new Mock<IUserIdentity>();
            using SamplingGroup group = CreateGroup(identity.Object);

            Assert.DoesNotThrow(group.Shutdown);
        }

        /// <summary>
        /// Verifies that an item transferred to another session is read and permission-checked
        /// as the new owner, not as the session that created the sampling group.
        /// </summary>
        [Test]
        public async Task SampleUsesSessionOfTransferredItemAsync()
        {
            var creatorIdentity = new Mock<IUserIdentity>();
            var ownerIdentity = new Mock<IUserIdentity>();
            Mock<ISession> creator = CreateSessionMock(new NodeId(1, 1), creatorIdentity.Object);
            Mock<ISession> owner = CreateSessionMock(new NodeId(2, 1), ownerIdentity.Object);
            OperationContext creatorContext = SessionContext(creator.Object);

            var readIdentity = new TaskCompletionSource<IUserIdentity>(
                TaskCreationOptions.RunContinuationsAsynchronously);
            var permissionIdentity = new TaskCompletionSource<IUserIdentity>(
                TaskCreationOptions.RunContinuationsAsynchronously);
            var nodeManager = new Mock<IAsyncNodeManager>();
            nodeManager
                .Setup(m => m.ReadAsync(
                    It.IsAny<OperationContext>(),
                    It.IsAny<double>(),
                    It.IsAny<ArrayOf<ReadValueId>>(),
                    It.IsAny<IList<DataValue>>(),
                    It.IsAny<IList<ServiceResult>>(),
                    It.IsAny<CancellationToken>()))
                .Callback<OperationContext, double, ArrayOf<ReadValueId>, IList<DataValue>,
                    IList<ServiceResult>, CancellationToken>(
                    (context, _, _, _, _, _) => readIdentity.TrySetResult(context.UserIdentity))
                .Returns(default(ValueTask));
            nodeManager
                .Setup(m => m.ValidateRolePermissionsAsync(
                    It.IsAny<OperationContext>(),
                    It.IsAny<NodeId>(),
                    PermissionType.Read,
                    It.IsAny<CancellationToken>()))
                .Callback<OperationContext, NodeId, PermissionType, CancellationToken>(
                    (context, _, _, _) => permissionIdentity.TrySetResult(context.UserIdentity))
                .Returns(new ValueTask<ServiceResult>(ServiceResult.Good));

            Mock<IServerInternal> mockServer = DeterministicServerMock.Create(out _);
            using var group = new SamplingGroup(
                mockServer.Object,
                nodeManager.Object,
                SamplingRates(),
                creatorContext,
                500);
            Mock<ISampledDataChangeMonitoredItem> item = CreateItem();
            item.SetupGet(m => m.Session).Returns(owner.Object);
            item.Setup(m => m.GetReadValueId()).Returns(new ReadValueId
            {
                NodeId = new NodeId(10, 1),
                AttributeId = Attributes.Value
            });

            Assert.That(group.StartMonitoring(creatorContext, item.Object), Is.True);
            group.ApplyChanges();

            Assert.That(
                await readIdentity.Task.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false),
                Is.SameAs(ownerIdentity.Object));
            Assert.That(
                await permissionIdentity.Task.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false),
                Is.SameAs(ownerIdentity.Object));
        }
    }
}