feat(m9/T32c): schema-library CRUD commands + handlers + Central UI page + read-accessor
This commit is contained in:
Joseph Doherty
@@ -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>());
|
||||
}
|
||||
}
|
||||
@@ -92,6 +92,25 @@ public class ManagementCommandRegistryTests
|
||||
ManagementCommandRegistry.Resolve("ListInstanceNativeAlarmSourceOverrides"));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// M9-T32c: the schema-library CRUD commands must auto-register by reflection
|
||||
/// (no manual registry entry) so the HTTP / ClusterClient boundary can route them.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Resolve_SchemaLibraryCommands_AllRegistered()
|
||||
{
|
||||
Assert.Equal(typeof(ListSharedSchemasCommand),
|
||||
ManagementCommandRegistry.Resolve("ListSharedSchemas"));
|
||||
Assert.Equal(typeof(GetSharedSchemaCommand),
|
||||
ManagementCommandRegistry.Resolve("GetSharedSchema"));
|
||||
Assert.Equal(typeof(CreateSharedSchemaCommand),
|
||||
ManagementCommandRegistry.Resolve("CreateSharedSchema"));
|
||||
Assert.Equal(typeof(UpdateSharedSchemaCommand),
|
||||
ManagementCommandRegistry.Resolve("UpdateSharedSchema"));
|
||||
Assert.Equal(typeof(DeleteSharedSchemaCommand),
|
||||
ManagementCommandRegistry.Resolve("DeleteSharedSchema"));
|
||||
}
|
||||
|
||||
/// <summary>A *Command record outside the Management namespace, for the negative test.</summary>
|
||||
private record UnregisteredFakeCommand(int Id);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,320 @@
|
||||
using System.Text.Json;
|
||||
using Akka.Actor;
|
||||
using Akka.TestKit.Xunit2;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NSubstitute;
|
||||
using NSubstitute.ExceptionExtensions;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Schemas;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
|
||||
using ZB.MOM.WW.ScadaBridge.ManagementService;
|
||||
|
||||
namespace ZB.MOM.WW.ScadaBridge.ManagementService.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// ManagementActor handler tests for the M9-T32c schema-library CRUD commands. The
|
||||
/// reusable named JSON-Schema library (<see cref="SharedSchema"/> +
|
||||
/// <see cref="ISharedSchemaRepository"/>, T32a) gains its authoring surface here:
|
||||
/// list/get are read-only (any authenticated user), create/update/delete are
|
||||
/// Designer-gated, the schema JSON is validated as a JSON Schema, and the unique
|
||||
/// Name is enforced with a clear duplicate-name error. Mirrors the repo-backed
|
||||
/// DatabaseConnection handler idiom (direct repo writes + audit).
|
||||
/// </summary>
|
||||
public class SchemaLibraryHandlerTests : TestKit, IDisposable
|
||||
{
|
||||
private readonly ISharedSchemaRepository _schemaRepo;
|
||||
private readonly IAuditService _auditService;
|
||||
private readonly ServiceCollection _services;
|
||||
|
||||
public SchemaLibraryHandlerTests()
|
||||
{
|
||||
_schemaRepo = Substitute.For<ISharedSchemaRepository>();
|
||||
_auditService = Substitute.For<IAuditService>();
|
||||
|
||||
_services = new ServiceCollection();
|
||||
_services.AddScoped(_ => _schemaRepo);
|
||||
_services.AddScoped(_ => _auditService);
|
||||
}
|
||||
|
||||
private IActorRef CreateActor()
|
||||
{
|
||||
var sp = _services.BuildServiceProvider();
|
||||
return Sys.ActorOf(Props.Create(() => new ManagementActor(
|
||||
sp, NullLogger<ManagementActor>.Instance)));
|
||||
}
|
||||
|
||||
private static ManagementEnvelope Envelope(object command, params string[] roles) =>
|
||||
new(new AuthenticatedUser("testuser", "Test User", roles, Array.Empty<string>()),
|
||||
command, Guid.NewGuid().ToString("N"));
|
||||
|
||||
void IDisposable.Dispose() => Shutdown();
|
||||
|
||||
private const string ValidSchema =
|
||||
"""{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}""";
|
||||
|
||||
// ── Gating ──────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void CreateSharedSchema_WithDeployerRole_ReturnsUnauthorized()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new CreateSharedSchemaCommand("Addr", null, ValidSchema), "Deployer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementUnauthorized>(TimeSpan.FromSeconds(5));
|
||||
Assert.Contains("Designer", response.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateSharedSchema_WithNoRoles_ReturnsUnauthorized()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new UpdateSharedSchemaCommand(1, "Addr", null, ValidSchema));
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementUnauthorized>(TimeSpan.FromSeconds(5));
|
||||
Assert.Contains("Designer", response.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteSharedSchema_WithDeployerRole_ReturnsUnauthorized()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new DeleteSharedSchemaCommand(1), "Deployer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementUnauthorized>(TimeSpan.FromSeconds(5));
|
||||
Assert.Contains("Designer", response.Message);
|
||||
}
|
||||
|
||||
// ── List / Get (read-gated) ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void ListSharedSchemas_WithNoRoles_ReturnsSuccess()
|
||||
{
|
||||
_schemaRepo.ListAsync(Arg.Any<CancellationToken>())
|
||||
.Returns(new List<SharedSchema>
|
||||
{
|
||||
new() { Id = 1, Name = "Addr", SchemaJson = ValidSchema },
|
||||
});
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new ListSharedSchemasCommand());
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal(envelope.CorrelationId, response.CorrelationId);
|
||||
Assert.Contains("Addr", response.JsonData);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetSharedSchema_WithNoRoles_ReturnsSuccess()
|
||||
{
|
||||
_schemaRepo.GetByIdAsync(7, Arg.Any<CancellationToken>())
|
||||
.Returns(new SharedSchema { Id = 7, Name = "Addr", SchemaJson = ValidSchema });
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new GetSharedSchemaCommand(7));
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Contains("Addr", response.JsonData);
|
||||
}
|
||||
|
||||
// ── Create round-trip + validation ──────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void CreateSharedSchema_WithDesignerRole_PersistsAndReturnsEntity()
|
||||
{
|
||||
SharedSchema? saved = null;
|
||||
_schemaRepo.GetByNameAsync("Addr", Arg.Any<CancellationToken>())
|
||||
.Returns((SharedSchema?)null);
|
||||
_schemaRepo.AddAsync(Arg.Any<SharedSchema>(), Arg.Any<CancellationToken>())
|
||||
.Returns(ci => { saved = ci.Arg<SharedSchema>(); saved.Id = 42; return 42; });
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new CreateSharedSchemaCommand("Addr", "global", ValidSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal(envelope.CorrelationId, response.CorrelationId);
|
||||
Assert.NotNull(saved);
|
||||
Assert.Equal("Addr", saved!.Name);
|
||||
Assert.Equal("global", saved.Scope);
|
||||
Assert.Equal(ValidSchema, saved.SchemaJson);
|
||||
// Returned payload carries the store-generated id.
|
||||
Assert.Contains("42", response.JsonData);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CreateSharedSchema_WithDuplicateName_ReturnsClearError()
|
||||
{
|
||||
_schemaRepo.GetByNameAsync("Addr", Arg.Any<CancellationToken>())
|
||||
.Returns(new SharedSchema { Id = 1, Name = "Addr", SchemaJson = ValidSchema });
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new CreateSharedSchemaCommand("Addr", null, ValidSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.Contains("Addr", response.Error);
|
||||
Assert.Contains("already exists", response.Error);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CreateSharedSchema_WithEmptyName_ReturnsClearError()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new CreateSharedSchemaCommand(" ", null, ValidSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.Contains("name", response.Error, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CreateSharedSchema_WithInvalidJson_ReturnsClearError()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new CreateSharedSchemaCommand("Addr", null, "{ not valid json"), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.Contains("schema", response.Error, StringComparison.OrdinalIgnoreCase);
|
||||
// The repo must never be hit when the schema fails validation.
|
||||
_schemaRepo.DidNotReceive().AddAsync(Arg.Any<SharedSchema>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
// ── Update round-trip + validation ──────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void UpdateSharedSchema_WithDesignerRole_PersistsChanges()
|
||||
{
|
||||
var existing = new SharedSchema { Id = 5, Name = "Addr", Scope = null, SchemaJson = ValidSchema };
|
||||
_schemaRepo.GetByIdAsync(5, Arg.Any<CancellationToken>()).Returns(existing);
|
||||
_schemaRepo.GetByNameAsync("Address", Arg.Any<CancellationToken>())
|
||||
.Returns((SharedSchema?)null);
|
||||
|
||||
const string updatedSchema =
|
||||
"""{"type":"object","properties":{"city":{"type":"string"}}}""";
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new UpdateSharedSchemaCommand(5, "Address", "us", updatedSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal(envelope.CorrelationId, response.CorrelationId);
|
||||
Assert.Equal("Address", existing.Name);
|
||||
Assert.Equal("us", existing.Scope);
|
||||
Assert.Equal(updatedSchema, existing.SchemaJson);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateSharedSchema_NotFound_ReturnsClearError()
|
||||
{
|
||||
_schemaRepo.GetByIdAsync(99, Arg.Any<CancellationToken>())
|
||||
.Returns((SharedSchema?)null);
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new UpdateSharedSchemaCommand(99, "Addr", null, ValidSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.Contains("99", response.Error);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateSharedSchema_RenameToExistingName_ReturnsClearError()
|
||||
{
|
||||
var existing = new SharedSchema { Id = 5, Name = "Addr", SchemaJson = ValidSchema };
|
||||
_schemaRepo.GetByIdAsync(5, Arg.Any<CancellationToken>()).Returns(existing);
|
||||
// A DIFFERENT row already owns "Other".
|
||||
_schemaRepo.GetByNameAsync("Other", Arg.Any<CancellationToken>())
|
||||
.Returns(new SharedSchema { Id = 6, Name = "Other", SchemaJson = ValidSchema });
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new UpdateSharedSchemaCommand(5, "Other", null, ValidSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.Contains("already exists", response.Error);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateSharedSchema_SameName_IsAllowed()
|
||||
{
|
||||
var existing = new SharedSchema { Id = 5, Name = "Addr", SchemaJson = ValidSchema };
|
||||
_schemaRepo.GetByIdAsync(5, Arg.Any<CancellationToken>()).Returns(existing);
|
||||
// The unique-name check finds THIS row — must not be treated as a collision.
|
||||
_schemaRepo.GetByNameAsync("Addr", Arg.Any<CancellationToken>()).Returns(existing);
|
||||
|
||||
const string updatedSchema =
|
||||
"""{"type":"object","properties":{"zip":{"type":"string"}}}""";
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(
|
||||
new UpdateSharedSchemaCommand(5, "Addr", null, updatedSchema), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal(updatedSchema, existing.SchemaJson);
|
||||
}
|
||||
|
||||
// ── Delete round-trip ───────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void DeleteSharedSchema_WithDesignerRole_Deletes()
|
||||
{
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new DeleteSharedSchemaCommand(5), "Designer");
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementSuccess>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal(envelope.CorrelationId, response.CorrelationId);
|
||||
_schemaRepo.Received(1).DeleteAsync(5, Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ListSharedSchemas_WhenRepoThrows_ReturnsError()
|
||||
{
|
||||
_schemaRepo.ListAsync(Arg.Any<CancellationToken>())
|
||||
.ThrowsAsync(new InvalidOperationException("db down secret detail"));
|
||||
|
||||
var actor = CreateActor();
|
||||
var envelope = Envelope(new ListSharedSchemasCommand());
|
||||
|
||||
actor.Tell(envelope);
|
||||
|
||||
var response = ExpectMsg<ManagementError>(TimeSpan.FromSeconds(5));
|
||||
Assert.Equal("COMMAND_FAILED", response.ErrorCode);
|
||||
Assert.DoesNotContain("db down secret detail", response.Error);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user