Completes local-dev-master-slave-setup: dual-instance frontend tooling, module-capability gating, and master/slave protocol self-healing fixes

Frontend (Unit 2 completion): dual dev-server tooling (pnpm dev:slave,
pnpm dev:all), per-instance browser tab titles, and a backend
capability check (SystemController + useSystemCapabilities +
ModuleGuard) so a Master-only page is hidden on a slave instance
instead of assuming every backend has every module.

Master/slave protocol fixes surfaced by actually running master and
slave side by side locally:
- Deactivating a CMS instance (Inactive) now releases the slave's
  master gate instead of leaving it stuck on its last pushed status.
- The periodic integrity check now also re-pushes status to every
  reachable slave (previously URL-verification only) and runs once
  immediately on startup.
- Added the originally-specified (but never implemented) slave-pull
  path: a slave now periodically polls its own status from the master
  (GET /api/v1/SlaveStatus) and fails open to Available if the master
  is unreachable for too long, complementing the existing push.
- The slave's own Settings page can no longer "successfully" change
  local availability while the master controls it; it's now locked
  with an explanatory banner and the backend rejects the write with
  409 instead of silently no-op'ing it.
- CMS instance status badges now match the dashboard's color/icon
  styling instead of a plain grey badge.

Also corrected the master-cms-module design docs to match this
as-built behavior, and flagged (without a full rewrite) a larger,
pre-existing divergence between its inception-stage application
design and what construction actually built.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
2026-07-04 19:53:52 +02:00
co-authored by Claude Sonnet 5
parent 274946dbff
commit 0447993181
81 changed files with 2191 additions and 86 deletions
@@ -0,0 +1,95 @@
using FluentAssertions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using NSubstitute;
using NSubstitute.ExceptionExtensions;
using SlpModularCms.Modules.Availability.BackgroundServices;
using SlpModularCms.Modules.Availability.Config;
using SlpModularCms.Modules.Availability.Services;
namespace SlpModularCms.Modules.Availability.Tests.BackgroundServices;
public class MasterStatusPollingBackgroundServiceTests
{
[Fact]
public async Task ExecuteTickAsync_DoesNothing_WhenNoMasterRegistered()
{
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetPollTargetAsync().Returns((MasterPollTarget?)null);
var pollClient = Substitute.For<IMasterStatusPollClient>();
var sut = CreateSut(masterAvailabilityService, pollClient);
await sut.ExecuteTickAsync(CancellationToken.None);
await pollClient.DidNotReceive().GetStatusAsync(Arg.Any<string>(), Arg.Any<string>());
await masterAvailabilityService.DidNotReceive().ApplyPolledStatusAsync(Arg.Any<bool>(), Arg.Any<string?>());
await masterAvailabilityService.DidNotReceive().RecordPollFailureAsync(Arg.Any<TimeSpan>());
}
[Fact]
public async Task ExecuteTickAsync_AppliesPolledStatus_WhenPollSucceeds()
{
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetPollTargetAsync().Returns(new MasterPollTarget("https://master.test", "key"));
var pollClient = Substitute.For<IMasterStatusPollClient>();
pollClient.GetStatusAsync("https://master.test", "key").Returns(new PolledMasterStatus(false, "Onderhoud"));
var sut = CreateSut(masterAvailabilityService, pollClient);
await sut.ExecuteTickAsync(CancellationToken.None);
await masterAvailabilityService.Received(1).ApplyPolledStatusAsync(false, "Onderhoud");
await masterAvailabilityService.DidNotReceive().RecordPollFailureAsync(Arg.Any<TimeSpan>());
}
[Fact]
public async Task ExecuteTickAsync_RecordsPollFailure_WhenPollFails()
{
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetPollTargetAsync().Returns(new MasterPollTarget("https://master.test", "key"));
var pollClient = Substitute.For<IMasterStatusPollClient>();
pollClient.GetStatusAsync("https://master.test", "key").Returns((PolledMasterStatus?)null);
var sut = CreateSut(masterAvailabilityService, pollClient, failOpenAfterMinutes: 5);
await sut.ExecuteTickAsync(CancellationToken.None);
await masterAvailabilityService.DidNotReceive().ApplyPolledStatusAsync(Arg.Any<bool>(), Arg.Any<string?>());
await masterAvailabilityService.Received(1).RecordPollFailureAsync(TimeSpan.FromMinutes(5));
}
[Fact]
public async Task ExecuteTickAsync_DoesNotThrow_WhenPollTargetLookupThrows()
{
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetPollTargetAsync().Throws(new InvalidOperationException("boom"));
var pollClient = Substitute.For<IMasterStatusPollClient>();
var sut = CreateSut(masterAvailabilityService, pollClient);
var act = async () => await sut.ExecuteTickAsync(CancellationToken.None);
await act.Should().NotThrowAsync();
}
private static MasterStatusPollingBackgroundService CreateSut(
IMasterAvailabilityService masterAvailabilityService,
IMasterStatusPollClient pollClient,
int failOpenAfterMinutes = 5)
{
var provider = Substitute.For<IServiceProvider>();
provider.GetService(typeof(IMasterAvailabilityService)).Returns(masterAvailabilityService);
provider.GetService(typeof(IMasterStatusPollClient)).Returns(pollClient);
var scope = Substitute.For<IServiceScope>();
scope.ServiceProvider.Returns(provider);
var factory = Substitute.For<IServiceScopeFactory>();
factory.CreateAsyncScope().Returns(new AsyncServiceScope(scope));
var options = Options.Create(new MasterPollingOptions { FailOpenAfterMinutes = failOpenAfterMinutes });
return new MasterStatusPollingBackgroundService(
factory,
options,
Substitute.For<ILogger<MasterStatusPollingBackgroundService>>());
}
}
@@ -81,7 +81,10 @@ public class AvailabilityControllerTests
var availabilityOptions = Substitute.For<IOptions<AvailabilityOptions>>();
availabilityOptions.Value.Returns(new AvailabilityOptions { CircuitBreakerSeconds = 30 });
var persistentService = new PersistentAvailabilityService(context, availabilityOptions);
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetMasterStatus().Returns(new MasterGateStatus(true, null));
var persistentService = new PersistentAvailabilityService(context, availabilityOptions, masterAvailabilityService);
var controller = new AvailabilityController(persistentService);
var httpContext = new DefaultHttpContext();
@@ -94,4 +97,50 @@ public class AvailabilityControllerTests
result.Should().BeOfType<OkResult>();
}
[Fact]
public async Task UpdateStatus_ReturnsConflict_WhenMasterControlsTheGate()
{
var dbOptions = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using var context = new ApplicationDbContext(dbOptions);
var availabilityOptions = Substitute.For<IOptions<AvailabilityOptions>>();
availabilityOptions.Value.Returns(new AvailabilityOptions { CircuitBreakerSeconds = 30 });
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetMasterStatus().Returns(new MasterGateStatus(false, "Uitgeschakeld door master"));
var persistentService = new PersistentAvailabilityService(context, availabilityOptions, masterAvailabilityService);
var controller = new AvailabilityController(persistentService);
var httpContext = new DefaultHttpContext();
httpContext.User = new ClaimsPrincipal(
new ClaimsIdentity([new Claim(ClaimTypes.Name, "admin@test.com")], "TestAuth"));
controller.ControllerContext = new ControllerContext { HttpContext = httpContext };
var result = await controller.UpdateStatus(
new UpdateStatusRequest(AvailabilityStatus.Available, null));
var conflict = result.Should().BeOfType<ConflictObjectResult>().Subject;
conflict.StatusCode.Should().Be(409);
}
[Fact]
public async Task GetStatus_IncludesIsMasterControlled_WhenTrue()
{
_availabilityService.GetStatusDetailsAsync()
.Returns(new AvailabilityStatusDetails(AvailabilityStatus.NotAvailable, "Master zegt nee", IsMasterControlled: true));
var result = await CreateController().GetStatus();
var ok = result.Should().BeOfType<OkObjectResult>().Subject;
ok.Value.Should().BeEquivalentTo(new
{
Status = "NotAvailable",
Message = "Master zegt nee",
IsMasterControlled = true,
}, options => options.ExcludingMissingMembers());
}
}
@@ -24,8 +24,11 @@ public class PersistentAvailabilityServiceTests
var availabilityOptions = Substitute.For<IOptions<AvailabilityOptions>>();
availabilityOptions.Value.Returns(new AvailabilityOptions { CircuitBreakerSeconds = 30 });
_service = new PersistentAvailabilityService(_context, availabilityOptions);
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetMasterStatus().Returns(new MasterGateStatus(true, null));
_service = new PersistentAvailabilityService(_context, availabilityOptions, masterAvailabilityService);
}
[Fact]
@@ -99,6 +102,24 @@ public class PersistentAvailabilityServiceTests
details.Status.Should().Be(AvailabilityStatus.Available); // Fallback
}
[Fact]
public async Task GetStatusDetailsAsync_ShouldReturnNotAvailable_WhenMasterGateDisabled()
{
var availabilityOptions = Substitute.For<IOptions<AvailabilityOptions>>();
availabilityOptions.Value.Returns(new AvailabilityOptions { CircuitBreakerSeconds = 30 });
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetMasterStatus().Returns(new MasterGateStatus(false, "Master heeft deze slave uitgeschakeld"));
var service = new PersistentAvailabilityService(_context, availabilityOptions, masterAvailabilityService);
var details = await service.GetStatusDetailsAsync();
details.Status.Should().Be(AvailabilityStatus.NotAvailable);
details.Message.Should().Be("Master heeft deze slave uitgeschakeld");
details.IsMasterControlled.Should().BeTrue();
}
[Fact]
public async Task UpdateStatusAsync_UpdatesExistingRecord_WhenCalledTwice()
{
@@ -112,4 +133,21 @@ public class PersistentAvailabilityServiceTests
dbState.Status.Should().Be(AvailabilityStatus.Available);
dbState.UpdatedBy.Should().Be("Admin2");
}
[Fact]
public async Task UpdateStatusAsync_Throws_WhenMasterControlsTheGate()
{
var availabilityOptions = Substitute.For<IOptions<AvailabilityOptions>>();
availabilityOptions.Value.Returns(new AvailabilityOptions { CircuitBreakerSeconds = 30 });
var masterAvailabilityService = Substitute.For<IMasterAvailabilityService>();
masterAvailabilityService.GetMasterStatus().Returns(new MasterGateStatus(false, "Uitgeschakeld door master"));
var service = new PersistentAvailabilityService(_context, availabilityOptions, masterAvailabilityService);
var act = async () => await service.UpdateStatusAsync(AvailabilityStatus.Available, null, "Admin");
await act.Should().ThrowAsync<MasterControlledAvailabilityException>();
(await _context.AvailabilityStates.FirstOrDefaultAsync()).Should().BeNull();
}
}
@@ -237,4 +237,115 @@ public class MasterAvailabilityServiceTests : IDisposable
status.IsAvailable.Should().BeTrue();
status.DisableMessage.Should().BeNull();
}
// --- GetPollTargetAsync ---
[Fact]
public async Task GetPollTargetAsync_ReturnsMasterUrlAndPlainKey_WhenRegistered()
{
var existing = new MasterRegistration
{
Id = MasterRegistration.SingletonId,
MasterUrl = "https://master.example.com",
ApiKey = "enc:key",
RegisteredAt = DateTimeOffset.UtcNow
};
_repo.GetAsync().Returns(existing);
_protector.Unprotect("enc:key").Returns("key");
var target = await _svc.GetPollTargetAsync();
target.Should().NotBeNull();
target!.MasterUrl.Should().Be("https://master.example.com");
target.PlainApiKey.Should().Be("key");
}
[Fact]
public async Task GetPollTargetAsync_ReturnsNull_WhenNoRegistration()
{
_repo.GetAsync().Returns((MasterRegistration?)null);
var target = await _svc.GetPollTargetAsync();
target.Should().BeNull();
}
// --- ApplyPolledStatusAsync ---
[Fact]
public async Task ApplyPolledStatusAsync_UpdatesGateAndPersistsPollTimestamp()
{
var existing = new MasterRegistration
{
Id = MasterRegistration.SingletonId,
MasterUrl = "https://master.example.com",
ApiKey = "enc:key",
RegisteredAt = DateTimeOffset.UtcNow
};
_repo.GetAsync().Returns(existing);
await _svc.ApplyPolledStatusAsync(false, "Onderhoud");
var status = _svc.GetMasterStatus();
status.IsAvailable.Should().BeFalse();
status.DisableMessage.Should().Be("Onderhoud");
existing.LastPolledAt.Should().NotBeNull();
_repo.Received(1).Update(existing);
await _repo.Received(1).SaveChangesAsync();
}
// --- RecordPollFailureAsync ---
[Fact]
public async Task RecordPollFailureAsync_DoesNotFailOpen_WhenWithinGracePeriod()
{
var existing = new MasterRegistration
{
Id = MasterRegistration.SingletonId,
MasterUrl = "https://master.example.com",
ApiKey = "enc:key",
RegisteredAt = DateTimeOffset.UtcNow,
LastPolledAt = DateTimeOffset.UtcNow
};
_repo.GetAsync().Returns(existing);
_protector.Unprotect("enc:key").Returns("key");
await _svc.PushStatusAsync("key", false, "Down");
await _svc.RecordPollFailureAsync(TimeSpan.FromMinutes(5));
var status = _svc.GetMasterStatus();
status.IsAvailable.Should().BeFalse();
}
[Fact]
public async Task RecordPollFailureAsync_FailsOpen_WhenMasterUnreachableTooLong()
{
var existing = new MasterRegistration
{
Id = MasterRegistration.SingletonId,
MasterUrl = "https://master.example.com",
ApiKey = "enc:key",
RegisteredAt = DateTimeOffset.UtcNow.AddMinutes(-30),
LastPolledAt = DateTimeOffset.UtcNow.AddMinutes(-10)
};
_repo.GetAsync().Returns(existing);
_protector.Unprotect("enc:key").Returns("key");
await _svc.PushStatusAsync("key", false, "Down");
await _svc.RecordPollFailureAsync(TimeSpan.FromMinutes(5));
var status = _svc.GetMasterStatus();
status.IsAvailable.Should().BeTrue();
status.DisableMessage.Should().BeNull();
}
[Fact]
public async Task RecordPollFailureAsync_DoesNothing_WhenNoRegistration()
{
_repo.GetAsync().Returns((MasterRegistration?)null);
var act = async () => await _svc.RecordPollFailureAsync(TimeSpan.FromMinutes(5));
await act.Should().NotThrowAsync();
}
}
@@ -0,0 +1,99 @@
using FluentAssertions;
using SlpModularCms.Modules.Availability.Services;
using System.Net;
using System.Text;
using System.Text.Json;
namespace SlpModularCms.Modules.Availability.Tests.Services;
public class MasterStatusPollClientTests
{
private const string MasterUrl = "https://master.test";
private const string ApiKey = "plain-key";
private static MasterStatusPollClient CreateSut(HttpMessageHandler handler)
=> new(new HttpClient(handler));
[Fact]
public async Task GetStatusAsync_ReturnsStatus_WhenResponseIsSuccess()
{
var json = JsonSerializer.Serialize(new { IsAvailable = false, DisableMessage = "Onderhoud" });
var handler = new FakeHttpMessageHandler(HttpStatusCode.OK, json);
var sut = CreateSut(handler);
var result = await sut.GetStatusAsync(MasterUrl, ApiKey);
result.Should().NotBeNull();
result!.IsAvailable.Should().BeFalse();
result.DisableMessage.Should().Be("Onderhoud");
}
[Fact]
public async Task GetStatusAsync_ReturnsNull_WhenResponseIsFailure()
{
var handler = new FakeHttpMessageHandler(HttpStatusCode.Unauthorized);
var sut = CreateSut(handler);
var result = await sut.GetStatusAsync(MasterUrl, ApiKey);
result.Should().BeNull();
}
[Fact]
public async Task GetStatusAsync_ReturnsNull_WhenExceptionIsThrown()
{
var handler = new ThrowingHttpMessageHandler();
var sut = CreateSut(handler);
var result = await sut.GetStatusAsync(MasterUrl, ApiKey);
result.Should().BeNull();
}
[Fact]
public async Task GetStatusAsync_SetsApiKeyHeader()
{
string? capturedKey = null;
var handler = new CapturingHttpMessageHandler(req =>
{
req.Headers.TryGetValues("X-Master-Api-Key", out var values);
capturedKey = values?.FirstOrDefault();
});
var sut = CreateSut(handler);
await sut.GetStatusAsync(MasterUrl, ApiKey);
capturedKey.Should().Be(ApiKey);
}
private class FakeHttpMessageHandler(HttpStatusCode statusCode, string? content = null) : HttpMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var response = new HttpResponseMessage(statusCode);
if (content is not null)
response.Content = new StringContent(content, Encoding.UTF8, "application/json");
return Task.FromResult(response);
}
}
private class ThrowingHttpMessageHandler : HttpMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
=> throw new HttpRequestException("Connection refused");
}
private class CapturingHttpMessageHandler(Action<HttpRequestMessage> capture) : HttpMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
capture(request);
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(
JsonSerializer.Serialize(new { IsAvailable = true, DisableMessage = (string?)null }),
Encoding.UTF8,
"application/json");
return Task.FromResult(response);
}
}
}