feat(uns): IUnsTreeService structural load + DI registration

2026-06-08 12:23:00 -04:00
parent 0f286a70b8
commit cec670f0c8
6 changed files with 343 additions and 0 deletions
@@ -0,0 +1,94 @@
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.AdminUI.Uns;
+
+namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns;
+
+/// <summary>
+/// Verifies <see cref="UnsTreeService.LoadStructureAsync"/> builds the Enterprise→Cluster→
+/// Area→Line→Equipment structure from the config database, including per-equipment tag/
+/// virtual-tag counts and the retention of empty clusters.
+/// </summary>
+[Trait("Category", "Unit")]
+public sealed class UnsTreeServiceStructureTests
+{
+    private static UnsTreeService SeededService()
+    {
+        var dbName = $"uns-{Guid.NewGuid():N}";
+        UnsTreeTestDb.SeedNamed(dbName);
+        return new UnsTreeService(UnsTreeTestDb.Factory(dbName));
+    }
+
+    /// <summary>Root enterprise "zb" carries both clusters, and MAIN exposes the full
+    /// area→line→equipment path with the expected kinds and keys.</summary>
+    [Fact]
+    public async Task LoadStructure_builds_full_hierarchy()
+    {
+        var service = SeededService();
+
+        var roots = await service.LoadStructureAsync();
+
+        var enterprise = roots.ShouldHaveSingleItem();
+        enterprise.Kind.ShouldBe(UnsNodeKind.Enterprise);
+        enterprise.DisplayName.ShouldBe("zb");
+        enterprise.Children.Count.ShouldBe(2);
+        enterprise.Children.ShouldAllBe(c => c.Kind == UnsNodeKind.Cluster);
+
+        var main = enterprise.Children.Single(c => c.ClusterId == UnsTreeTestDb.PopulatedClusterId);
+        main.Kind.ShouldBe(UnsNodeKind.Cluster);
+
+        var area = main.Children.ShouldHaveSingleItem();
+        area.Kind.ShouldBe(UnsNodeKind.Area);
+        area.Key.ShouldBe("area:AREA-1");
+        area.EntityId.ShouldBe("AREA-1");
+
+        var line = area.Children.ShouldHaveSingleItem();
+        line.Kind.ShouldBe(UnsNodeKind.Line);
+        line.Key.ShouldBe("line:LINE-1");
+        line.EntityId.ShouldBe("LINE-1");
+
+        var equipment = line.Children.ShouldHaveSingleItem();
+        equipment.Kind.ShouldBe(UnsNodeKind.Equipment);
+        equipment.Key.ShouldBe($"eq:{UnsTreeTestDb.SeededEquipmentId}");
+        equipment.EntityId.ShouldBe(UnsTreeTestDb.SeededEquipmentId);
+        equipment.ClusterId.ShouldBe(UnsTreeTestDb.PopulatedClusterId);
+    }
+
+    /// <summary>The seeded equipment node's badge count equals tags + virtual tags and it is
+    /// flagged as lazily expandable.</summary>
+    [Fact]
+    public async Task LoadStructure_counts_tags_and_vtags_per_equipment()
+    {
+        var service = SeededService();
+
+        var roots = await service.LoadStructureAsync();
+
+        var equipment = roots
+            .Single()
+            .Children.Single(c => c.ClusterId == UnsTreeTestDb.PopulatedClusterId)
+            .Children.Single()
+            .Children.Single()
+            .Children.Single();
+
+        // Seed: 2 driver tags + 1 virtual tag (the orphan tag has no equipment and is excluded).
+        equipment.ChildCount.ShouldBe(3);
+        equipment.HasLazyChildren.ShouldBeTrue();
+    }
+
+    /// <summary>An empty cluster (no areas) is still rendered as a Cluster node with no children.</summary>
+    [Fact]
+    public async Task LoadStructure_includes_empty_clusters()
+    {
+        var service = SeededService();
+
+        var roots = await service.LoadStructureAsync();
+
+        var siteA = roots
+            .Single()
+            .Children.Single(c => c.ClusterId == UnsTreeTestDb.EmptyClusterId);
+
+        siteA.Kind.ShouldBe(UnsNodeKind.Cluster);
+        siteA.Children.ShouldBeEmpty();
+        siteA.ChildCount.ShouldBe(0);
+    }
+}
@@ -0,0 +1,149 @@
+using Microsoft.EntityFrameworkCore;
+using ZB.MOM.WW.OtOpcUa.Configuration;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
+
+namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns;
+
+/// <summary>
+/// Shared in-memory fixture for <c>UnsTreeService</c> structural tests. Builds an
+/// <see cref="OtOpcUaConfigDbContext"/> over a named InMemory database and seeds a small,
+/// deterministic UNS hierarchy: enterprise "zb" across two clusters (MAIN populated,
+/// SITE-A intentionally empty), plus tags and a virtual tag on one equipment node so
+/// the per-equipment count joins can be exercised.
+/// </summary>
+internal static class UnsTreeTestDb
+{
+    /// <summary>The equipment that carries the seeded tags and virtual tag.</summary>
+    public const string SeededEquipmentId = "EQ-000000000001";
+
+    /// <summary>The cluster that has no areas, used to cover the empty-cluster case.</summary>
+    public const string EmptyClusterId = "SITE-A";
+
+    /// <summary>The populated cluster with the area→line→equipment path.</summary>
+    public const string PopulatedClusterId = "MAIN";
+
+    /// <summary>Creates a context over a fresh, uniquely-named InMemory database.</summary>
+    public static OtOpcUaConfigDbContext Create() => CreateNamed($"uns-{Guid.NewGuid():N}");
+
+    /// <summary>Creates a context bound to the supplied InMemory database name.</summary>
+    public static OtOpcUaConfigDbContext CreateNamed(string name) =>
+        new(new DbContextOptionsBuilder<OtOpcUaConfigDbContext>()
+            .UseInMemoryDatabase(name)
+            .Options);
+
+    /// <summary>
+    /// Returns an <see cref="IDbContextFactory{TContext}"/> whose contexts all share the
+    /// supplied InMemory database name, so data seeded by <see cref="SeedNamed"/> is visible
+    /// to the service under test.
+    /// </summary>
+    public static IDbContextFactory<OtOpcUaConfigDbContext> Factory(string name) => new NamedFactory(name);
+
+    /// <summary>Seeds the fixture into the supplied (already-bound) context and saves.</summary>
+    public static void Seed(OtOpcUaConfigDbContext db)
+    {
+        // Two clusters under the same enterprise; only MAIN gets a hierarchy.
+        db.ServerClusters.Add(new ServerCluster
+        {
+            ClusterId = PopulatedClusterId,
+            Name = "Main",
+            Enterprise = "zb",
+            Site = "warsaw-west",
+            RedundancyMode = RedundancyMode.None,
+            CreatedBy = "test",
+        });
+        db.ServerClusters.Add(new ServerCluster
+        {
+            ClusterId = EmptyClusterId,
+            Name = "Site A",
+            Enterprise = "zb",
+            Site = "site-a",
+            RedundancyMode = RedundancyMode.None,
+            CreatedBy = "test",
+        });
+
+        // MAIN: one area → one line → one equipment.
+        db.UnsAreas.Add(new UnsArea
+        {
+            UnsAreaId = "AREA-1",
+            ClusterId = PopulatedClusterId,
+            Name = "assembly",
+        });
+        db.UnsLines.Add(new UnsLine
+        {
+            UnsLineId = "LINE-1",
+            UnsAreaId = "AREA-1",
+            Name = "line-a",
+        });
+        db.Equipment.Add(new Equipment
+        {
+            EquipmentId = SeededEquipmentId,
+            EquipmentUuid = Guid.NewGuid(),
+            UnsLineId = "LINE-1",
+            Name = "machine-1",
+            MachineCode = "machine_001",
+        });
+
+        // Two driver tags + one virtual tag on the seeded equipment → ChildCount 3.
+        db.Tags.Add(new Tag
+        {
+            TagId = "TAG-1",
+            DriverInstanceId = "DRV-1",
+            EquipmentId = SeededEquipmentId,
+            Name = "speed",
+            DataType = "Float",
+            AccessLevel = TagAccessLevel.Read,
+            TagConfig = "{}",
+        });
+        db.Tags.Add(new Tag
+        {
+            TagId = "TAG-2",
+            DriverInstanceId = "DRV-1",
+            EquipmentId = SeededEquipmentId,
+            Name = "running",
+            DataType = "Boolean",
+            AccessLevel = TagAccessLevel.Read,
+            TagConfig = "{}",
+        });
+        // A tag with no equipment must be ignored by the count query.
+        db.Tags.Add(new Tag
+        {
+            TagId = "TAG-ORPHAN",
+            DriverInstanceId = "DRV-1",
+            EquipmentId = null,
+            Name = "orphan",
+            DataType = "Int32",
+            AccessLevel = TagAccessLevel.Read,
+            TagConfig = "{}",
+        });
+        db.VirtualTags.Add(new VirtualTag
+        {
+            VirtualTagId = "VTAG-1",
+            EquipmentId = SeededEquipmentId,
+            Name = "computed",
+            DataType = "Double",
+            ScriptId = "SCRIPT-1",
+        });
+
+        db.SaveChanges();
+    }
+
+    /// <summary>Seeds the fixture into a context bound to the supplied InMemory database name.</summary>
+    public static void SeedNamed(string name)
+    {
+        using var db = CreateNamed(name);
+        Seed(db);
+    }
+
+    /// <summary>
+    /// Minimal <see cref="IDbContextFactory{TContext}"/> that hands back contexts sharing a
+    /// single InMemory database name — the test-side stand-in for the runtime pooled factory.
+    /// </summary>
+    private sealed class NamedFactory(string name) : IDbContextFactory<OtOpcUaConfigDbContext>
+    {
+        public OtOpcUaConfigDbContext CreateDbContext() => CreateNamed(name);
+
+        public Task<OtOpcUaConfigDbContext> CreateDbContextAsync(CancellationToken cancellationToken = default) =>
+            Task.FromResult(CreateNamed(name));
+    }
+}
@@ -10,6 +10,7 @@
    <ItemGroup>
        <PackageReference Include="xunit"/>
        <PackageReference Include="Shouldly"/>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory"/>
        <PackageReference Include="Microsoft.NET.Test.Sdk"/>
        <PackageReference Include="xunit.runner.visualstudio">
            <PrivateAssets>all</PrivateAssets>