feat(m9/T32c): schema-library CRUD commands + handlers + Central UI page + read-accessor

2026-06-18 12:32:31 -04:00
parent 71d5722692
commit 71a2bca4df
13 changed files with 1363 additions and 0 deletions
@@ -0,0 +1,200 @@
+using System.Security.Claims;
+using Bunit;
+using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using ZB.MOM.WW.ScadaBridge.CentralUI.Components.Shared;
+using ZB.MOM.WW.ScadaBridge.CentralUI.Services;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Schemas;
+using ZB.MOM.WW.ScadaBridge.Security;
+using SchemaLibraryPage = ZB.MOM.WW.ScadaBridge.CentralUI.Components.Pages.Design.SchemaLibrary;
+
+namespace ZB.MOM.WW.ScadaBridge.CentralUI.Tests.Design;
+
+/// <summary>
+/// bUnit tests for the Schema Library page (M9-T32c). The page lists the reusable named
+/// JSON-Schema library entries, authors create/edit via the shared <c>SchemaBuilder</c>
+/// component, and deletes with a confirm — every mutation dispatched through
+/// <see cref="ISchemaLibraryService"/> (the guard-running ManagementActor path), never a
+/// direct repo write. The service is substituted so the tests capture the dispatched
+/// commands and simulate success / guard-error responses without a real ManagementActor.
+/// </summary>
+public class SchemaLibraryPageTests : BunitContext
+{
+    private readonly ISchemaLibraryService _service = Substitute.For<ISchemaLibraryService>();
+
+    public SchemaLibraryPageTests()
+    {
+        Services.AddSingleton(_service);
+        Services.AddSingleton<IDialogService>(new AlwaysConfirmDialogService());
+        AddTestAuth();
+
+        // Default: empty library. Tests that need rows override this.
+        _service.ListAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<IReadOnlyList<SharedSchema>>(new List<SharedSchema>()));
+    }
+
+    private void AddTestAuth()
+    {
+        var claims = new[]
+        {
+            new Claim(JwtTokenService.UsernameClaimType, "tester"),
+            new Claim(JwtTokenService.RoleClaimType, "Designer"),
+        };
+        var user = new ClaimsPrincipal(new ClaimsIdentity(claims, "TestAuth"));
+        Services.AddSingleton<AuthenticationStateProvider>(new TestAuthStateProvider(user));
+        Services.AddAuthorizationCore();
+    }
+
+    private void SeedSchemas(params SharedSchema[] schemas) =>
+        _service.ListAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<IReadOnlyList<SharedSchema>>(schemas.ToList()));
+
+    [Fact]
+    public void Renders_EmptyState_WhenNoSchemas()
+    {
+        var cut = Render<SchemaLibraryPage>();
+
+        cut.WaitForAssertion(() =>
+            Assert.Contains("No library schemas defined", cut.Markup));
+    }
+
+    [Fact]
+    public void Lists_ExistingSchemas_WithLibReference()
+    {
+        SeedSchemas(
+            new SharedSchema { Id = 1, Name = "Address", Scope = "global", SchemaJson = "{\"type\":\"object\"}" },
+            new SharedSchema { Id = 2, Name = "GeoPoint", SchemaJson = "{\"type\":\"object\"}" });
+
+        var cut = Render<SchemaLibraryPage>();
+
+        cut.WaitForAssertion(() =>
+        {
+            Assert.Contains("Address", cut.Markup);
+            Assert.Contains("GeoPoint", cut.Markup);
+            // The list surfaces the lib:Name reference designers paste into a $ref.
+            Assert.Contains("lib:Address", cut.Markup);
+        });
+    }
+
+    [Fact]
+    public void NewSchema_OpensEditor_WithSchemaBuilder()
+    {
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));
+
+        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
+
+        // The editor card mounts with a name field and the SchemaBuilder component.
+        Assert.Contains("New Schema", cut.Markup);
+        Assert.NotEmpty(cut.FindAll("input")); // name / scope inputs
+        Assert.NotNull(cut.FindComponent<SchemaBuilder>());
+    }
+
+    [Fact]
+    public void Create_DispatchesCreateCommand_WithNameAndSchema()
+    {
+        _service.CreateAsync(Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));
+
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));
+
+        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
+
+        // Type a name and save (the SchemaBuilder seeds a default object schema).
+        cut.FindAll("input").First().Change("Address");
+        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();
+
+        cut.WaitForAssertion(() =>
+            _service.Received(1).CreateAsync(
+                "Address", Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>()));
+    }
+
+    [Fact]
+    public void Create_GuardError_IsShownInline_AndEditorStaysOpen()
+    {
+        _service.CreateAsync(Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(SchemaLibraryActionResult.Fail("A schema named 'Address' already exists.")));
+
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));
+
+        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
+        cut.FindAll("input").First().Change("Address");
+        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();
+
+        cut.WaitForAssertion(() =>
+        {
+            Assert.Contains("already exists", cut.Markup);
+            // Editor stays open (Save button still present) on a guard error.
+            Assert.Contains(cut.FindAll("button"), b => b.TextContent.Trim() == "Save");
+        });
+    }
+
+    [Fact]
+    public void EmptyName_DoesNotDispatch()
+    {
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));
+
+        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
+        // Leave name blank and save.
+        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();
+
+        cut.WaitForAssertion(() => Assert.Contains("name is required", cut.Markup));
+        _service.DidNotReceive().CreateAsync(
+            Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public void Delete_ConfirmsThenDispatchesDeleteCommand_AndReloads()
+    {
+        SeedSchemas(new SharedSchema { Id = 7, Name = "Address", SchemaJson = "{\"type\":\"object\"}" });
+        _service.DeleteAsync(Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));
+
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("Address"));
+
+        cut.FindAll("tbody tr button").First(b => b.TextContent.Contains("Delete")).Click();
+
+        cut.WaitForAssertion(() =>
+        {
+            _service.Received(1).DeleteAsync(7, Arg.Any<CancellationToken>());
+            // Reload re-invokes the list query (once on init, once after delete).
+            _service.Received(2).ListAsync(Arg.Any<CancellationToken>());
+        });
+    }
+
+    [Fact]
+    public void Edit_OpensEditor_AndDispatchesUpdateCommand()
+    {
+        SeedSchemas(new SharedSchema { Id = 9, Name = "Address", Scope = "us", SchemaJson = "{\"type\":\"object\"}" });
+        _service.UpdateAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));
+
+        var cut = Render<SchemaLibraryPage>();
+        cut.WaitForState(() => cut.Markup.Contains("Address"));
+
+        cut.FindAll("tbody tr button").First(b => b.TextContent.Contains("Edit")).Click();
+        Assert.Contains("Edit Schema: Address", cut.Markup);
+
+        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();
+
+        cut.WaitForAssertion(() =>
+            _service.Received(1).UpdateAsync(
+                9, "Address", Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>()));
+    }
+
+    /// <summary>A dialog service that auto-confirms, so the delete path runs end-to-end.</summary>
+    private sealed class AlwaysConfirmDialogService : IDialogService
+    {
+        public Task<bool> ConfirmAsync(string title, string message, bool danger = false)
+            => Task.FromResult(true);
+
+        public Task<string?> PromptAsync(
+            string title, string label, string initialValue = "", string? placeholder = null)
+            => Task.FromResult<string?>(null);
+    }
+}
@@ -0,0 +1,85 @@
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using ZB.MOM.WW.ScadaBridge.CentralUI.Services;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Schemas;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
+
+namespace ZB.MOM.WW.ScadaBridge.CentralUI.Tests.Design;
+
+/// <summary>
+/// Tests for the schema-library read-accessor (M9-T32c) that T30's schema-driven
+/// value-entry forms reuse to resolve <c>{"$ref":"lib:Name"}</c> pointers. It projects
+/// <see cref="ISharedSchemaRepository"/> onto a name → schema-JSON map (and a single-name
+/// lookup) over a fresh DI scope. The repository is substituted and registered scoped so
+/// the service's <c>IServiceScopeFactory</c> resolves it exactly as it would at runtime.
+/// </summary>
+public class SchemaLibraryQueryServiceTests
+{
+    private static (SchemaLibraryQueryService Service, ISharedSchemaRepository Repo) Build()
+    {
+        var repo = Substitute.For<ISharedSchemaRepository>();
+        var services = new ServiceCollection();
+        services.AddScoped(_ => repo);
+        var provider = services.BuildServiceProvider();
+        var service = new SchemaLibraryQueryService(provider.GetRequiredService<IServiceScopeFactory>());
+        return (service, repo);
+    }
+
+    [Fact]
+    public async Task GetSchemaMapAsync_MapsNameToSchemaJson()
+    {
+        var (service, repo) = Build();
+        repo.ListAsync(Arg.Any<CancellationToken>()).Returns(new List<SharedSchema>
+        {
+            new() { Id = 1, Name = "Address", SchemaJson = "{\"type\":\"object\"}" },
+            new() { Id = 2, Name = "GeoPoint", SchemaJson = "{\"type\":\"array\"}" },
+        });
+
+        var map = await service.GetSchemaMapAsync();
+
+        Assert.Equal(2, map.Count);
+        Assert.Equal("{\"type\":\"object\"}", map["Address"]);
+        Assert.Equal("{\"type\":\"array\"}", map["GeoPoint"]);
+    }
+
+    [Fact]
+    public async Task GetSchemaMapAsync_EmptyLibrary_ReturnsEmptyMap()
+    {
+        var (service, repo) = Build();
+        repo.ListAsync(Arg.Any<CancellationToken>()).Returns(new List<SharedSchema>());
+
+        var map = await service.GetSchemaMapAsync();
+
+        Assert.Empty(map);
+    }
+
+    [Fact]
+    public async Task ResolveAsync_KnownName_ReturnsSchemaJson()
+    {
+        var (service, repo) = Build();
+        repo.GetByNameAsync("Address", Arg.Any<CancellationToken>())
+            .Returns(new SharedSchema { Id = 1, Name = "Address", SchemaJson = "{\"type\":\"object\"}" });
+
+        var json = await service.ResolveAsync("Address");
+
+        Assert.Equal("{\"type\":\"object\"}", json);
+    }
+
+    [Fact]
+    public async Task ResolveAsync_UnknownName_ReturnsNull()
+    {
+        var (service, repo) = Build();
+        repo.GetByNameAsync("Missing", Arg.Any<CancellationToken>()).Returns((SharedSchema?)null);
+
+        Assert.Null(await service.ResolveAsync("Missing"));
+    }
+
+    [Fact]
+    public async Task ResolveAsync_EmptyName_ReturnsNull_WithoutHittingRepo()
+    {
+        var (service, repo) = Build();
+
+        Assert.Null(await service.ResolveAsync(""));
+        await repo.DidNotReceive().GetByNameAsync(Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+}