UA-.NETStandard/tests/Opc.Ua.Server.Tests/Fluent/PropertyInitBuilderExtensionsTests.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 Moq;
using NUnit.Framework;
using Opc.Ua.Server.Fluent;

#pragma warning disable CA2000

namespace Opc.Ua.Server.Tests.Fluent
{
    /// <summary>
    /// Tests for <see cref="PropertyInitBuilderExtensions"/> — fluent
    /// <c>WithProperty(string|QualifiedName, value)</c> helpers.
    /// </summary>
    [TestFixture]
    [Category("Fluent")]
    public class PropertyInitBuilderExtensionsTests
    {
        private const ushort kNs = 2;

        private static SystemContext CreateContext()
        {
            var ns = new NamespaceTable();
            ns.Append(Ua.Namespaces.OpcUa);
            return new SystemContext(telemetry: null!)
            {
                NamespaceUris = ns
            };
        }

        private static (NodeManagerBuilder Builder, BaseObjectState Root,
            PropertyState<string> StringProp,
            PropertyState<int> IntProp,
            BaseObjectState NonVariableChild)
            CreateBuilderWithObject()
        {
            SystemContext ctx = CreateContext();

            var root = new BaseObjectState(parent: null)
            {
                NodeId = new NodeId("Root", kNs),
                BrowseName = new QualifiedName("Root", kNs),
                DisplayName = new LocalizedText("Root")
            };

            PropertyState<string> stringProp =
                new PropertyState<string>.Implementation<VariantBuilder>(root)
                {
                    NodeId = new NodeId("Root.Manufacturer", kNs),
                    BrowseName = new QualifiedName("Manufacturer", kNs),
                    DisplayName = new LocalizedText("Manufacturer"),
                    DataType = DataTypeIds.String,
                    ValueRank = ValueRanks.Scalar
                };
            root.AddChild(stringProp);

            PropertyState<int> intProp =
                new PropertyState<int>.Implementation<VariantBuilder>(root)
                {
                    NodeId = new NodeId("Root.Count", kNs),
                    BrowseName = new QualifiedName("Count", kNs),
                    DisplayName = new LocalizedText("Count"),
                    DataType = DataTypeIds.Int32,
                    ValueRank = ValueRanks.Scalar
                };
            root.AddChild(intProp);

            var nonVar = new BaseObjectState(root)
            {
                NodeId = new NodeId("Root.NonVar", kNs),
                BrowseName = new QualifiedName("NonVar", kNs),
                DisplayName = new LocalizedText("NonVar")
            };
            root.AddChild(nonVar);

            var roots = new Dictionary<QualifiedName, NodeState> { [root.BrowseName] = root };
            var byId = new Dictionary<NodeId, NodeState>
            {
                [root.NodeId] = root,
                [stringProp.NodeId] = stringProp,
                [intProp.NodeId] = intProp,
                [nonVar.NodeId] = nonVar
            };

            var builder = new NodeManagerBuilder(
                ctx,
                nodeManager: FluentTestNodeManager.Create(kNs),
                defaultNamespaceIndex: kNs,
                rootResolver: q => roots.TryGetValue(q, out NodeState? n) ? n! : null!,
                nodeIdResolver: id => byId.TryGetValue(id, out NodeState? n) ? n! : null!,
                typeIdResolver: _ => []);

            return (builder, root, stringProp, intProp, nonVar);
        }

        [Test]
        public void WithPropertyStringSetsValue()
        {
            (NodeManagerBuilder b, _, PropertyState<string> sp, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            INodeBuilder chain = nb.WithProperty("Manufacturer", "SimPump Corp");

            Assert.That(chain, Is.SameAs(nb));
            Assert.That(sp.Value, Is.EqualTo("SimPump Corp"));
        }

        [Test]
        public void WithPropertyIntSetsValue()
        {
            (NodeManagerBuilder b, _, _, PropertyState<int> ip, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Count", 42);

            Assert.That(ip.Value, Is.EqualTo(42));
        }

        [Test]
        public void WithPropertyVariantSetsValue()
        {
            (NodeManagerBuilder b, _, PropertyState<string> sp, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Manufacturer", Variant.From("Vendor X"));

            Assert.That(sp.Value, Is.EqualTo("Vendor X"));
        }

        [Test]
        public void WithPropertyQualifiedNameSetsValue()
        {
            (NodeManagerBuilder b, _, PropertyState<string> sp, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty(new QualifiedName("Manufacturer", kNs), Variant.From("Acme"));

            Assert.That(sp.Value, Is.EqualTo("Acme"));
        }

        [Test]
        public void WithPropertyChainsMultipleSetters()
        {
            (NodeManagerBuilder b, _, PropertyState<string> sp, PropertyState<int> ip, _) =
                CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Manufacturer", "Vendor A")
              .WithProperty("Count", 7)
              .WithProperty("Manufacturer", "Vendor B");

            Assert.That(sp.Value, Is.EqualTo("Vendor B"));
            Assert.That(ip.Value, Is.EqualTo(7));
        }

        [Test]
        public void WithPropertyUnknownNameCreatesReadOnlyProperty()
        {
            (NodeManagerBuilder b, BaseObjectState root, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            INodeBuilder chain = nb.WithProperty("NewCount", 7);

            Assert.That(chain, Is.SameAs(nb));
            var created = root.FindChild(
                b.Context, new QualifiedName("NewCount", kNs)) as PropertyState;
            Assert.That(created, Is.Not.Null);
            Assert.That(created!.WrappedValue.AsBoxedObject(), Is.EqualTo(7));
            Assert.That(created.DataType, Is.EqualTo(DataTypeIds.Int32));
            Assert.That(created.ValueRank, Is.EqualTo(ValueRanks.Scalar));
            Assert.That(created.AccessLevel, Is.EqualTo(AccessLevels.CurrentRead));
            Assert.That(created.TypeDefinitionId, Is.EqualTo(VariableTypeIds.PropertyType));
            Assert.That(created.ReferenceTypeId, Is.EqualTo(ReferenceTypeIds.HasProperty));
        }

        [Test]
        public void WithPropertyCreatesThenUpdatesSameProperty()
        {
            (NodeManagerBuilder b, BaseObjectState root, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Dynamic", 1)
              .WithProperty("Dynamic", 2);

            var created = root.FindChild(
                b.Context, new QualifiedName("Dynamic", kNs)) as PropertyState;
            Assert.That(created, Is.Not.Null);
            Assert.That(created!.WrappedValue.AsBoxedObject(), Is.EqualTo(2));
        }

        [Test]
        public void WithPropertyQualifiedNameUnknownCreatesProperty()
        {
            (NodeManagerBuilder b, BaseObjectState root, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty(new QualifiedName("QnProp", kNs), Variant.From("v"));

            var created = root.FindChild(
                b.Context, new QualifiedName("QnProp", kNs)) as PropertyState;
            Assert.That(created, Is.Not.Null);
            Assert.That(created!.WrappedValue.AsBoxedObject(), Is.EqualTo("v"));
            Assert.That(created.DataType, Is.EqualTo(DataTypeIds.String));
        }

        [Test]
        public void WithPropertyConfigureCallbackCanMakePropertyWritable()
        {
            (NodeManagerBuilder b, BaseObjectState root, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Writable", Variant.From(true), p => p.Writable());

            var created = root.FindChild(
                b.Context, new QualifiedName("Writable", kNs)) as PropertyState;
            Assert.That(created, Is.Not.Null);
            Assert.That(
                created!.AccessLevel & AccessLevels.CurrentWrite,
                Is.EqualTo(AccessLevels.CurrentWrite));
            Assert.That(
                created.UserAccessLevel & AccessLevels.CurrentWrite,
                Is.EqualTo(AccessLevels.CurrentWrite));
        }

        [Test]
        public void WithPropertyConfigureCallbackNullThrowsArgumentNullException()
        {
            (NodeManagerBuilder b, _, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            Assert.Throws<ArgumentNullException>(
                () => nb.WithProperty("X", Variant.From(1), null!));
        }

        [Test]
        public void WithPropertyNonVariableChildThrowsBadTypeMismatch()
        {
            (NodeManagerBuilder b, _, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            ServiceResultException ex = Assert.Throws<ServiceResultException>(
                () => nb.WithProperty("NonVar", "x"))!;
            Assert.That(ex.StatusCode, Is.EqualTo((uint)StatusCodes.BadTypeMismatch));
        }

        [Test]
        public void WithPropertyEmptyBrowseNameThrowsArgumentException()
        {
            (NodeManagerBuilder b, _, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            Assert.Throws<ArgumentException>(
                () => nb.WithProperty(string.Empty, "x"));
        }

        [Test]
        public void WithPropertyOnNullBuilderThrowsArgumentNullException()
        {
            INodeBuilder nb = null!;
            Assert.Throws<ArgumentNullException>(
                () => nb.WithProperty("Manufacturer", "x"));
        }

        [Test]
        public void WithPropertyNullQualifiedNameThrowsArgumentNullException()
        {
            (NodeManagerBuilder b, _, _, _, _) = CreateBuilderWithObject();
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            Assert.Throws<ArgumentNullException>(
                () => nb.WithProperty(QualifiedName.Null, Variant.From("x")));
        }

        [Test]
        public void WithPropertyOnTypedBuilderPreservesTypedView()
        {
            (NodeManagerBuilder b, _, _, _, _) = CreateBuilderWithObject();
            INodeBuilder<BaseObjectState> typed = b.Node<BaseObjectState>(new NodeId("Root", kNs));

            INodeBuilder<BaseObjectState> chain = typed.WithProperty("Manufacturer", Variant.From("X"));

            Assert.That(chain, Is.SameAs(typed));
        }

        private static (NodeManagerBuilder Builder, BaseDataVariableState Prop)
            CreateBuilderWithDataVariable(string browseName)
        {
            SystemContext ctx = CreateContext();

            var root = new BaseObjectState(parent: null)
            {
                NodeId = new NodeId("Root", kNs),
                BrowseName = new QualifiedName("Root", kNs),
                DisplayName = new LocalizedText("Root")
            };

            var prop = new BaseDataVariableState(root)
            {
                NodeId = new NodeId("Root." + browseName, kNs),
                BrowseName = new QualifiedName(browseName, kNs),
                DisplayName = new LocalizedText(browseName),
                DataType = DataTypeIds.BaseDataType,
                ValueRank = ValueRanks.Scalar
            };
            root.AddChild(prop);

            var roots = new Dictionary<QualifiedName, NodeState> { [root.BrowseName] = root };
            var byId = new Dictionary<NodeId, NodeState>
            {
                [root.NodeId] = root,
                [prop.NodeId] = prop
            };

            var builder = new NodeManagerBuilder(
                ctx,
                nodeManager: FluentTestNodeManager.Create(kNs),
                defaultNamespaceIndex: kNs,
                rootResolver: q => roots.TryGetValue(q, out NodeState? n) ? n! : null!,
                nodeIdResolver: id => byId.TryGetValue(id, out NodeState? n) ? n! : null!,
                typeIdResolver: _ => []);

            return (builder, prop);
        }

        [Test]
        public void WithPropertyBoolSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("Enabled");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Enabled", true);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.True);
        }

        [Test]
        public void WithPropertyDoubleSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("Pressure");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Pressure", 3.14);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.EqualTo(3.14));
        }

        [Test]
        public void WithPropertyLongSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("BigCount");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("BigCount", 1234567890123L);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.EqualTo(1234567890123L));
        }

        [Test]
        public void WithPropertyByteSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("Flags");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            nb.WithProperty("Flags", (byte)0xAB);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.EqualTo((byte)0xAB));
        }

        [Test]
        public void WithPropertyNodeIdSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("RefId");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            var value = new NodeId(42u, kNs);
            nb.WithProperty("RefId", value);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.EqualTo(value));
        }

        [Test]
        public void WithPropertyLocalizedTextSetsValue()
        {
            (NodeManagerBuilder b, BaseDataVariableState prop) =
                CreateBuilderWithDataVariable("Description");
            INodeBuilder nb = b.Node(new NodeId("Root", kNs));

            var value = new LocalizedText("en", "hello");
            nb.WithProperty("Description", value);

            Assert.That(prop.WrappedValue.AsBoxedObject(), Is.EqualTo(value));
        }
    }
}