refactor: rename ScadaLink → ZB.MOM.WW.ScadaBridge (code + projects + namespaces)

Solution + 23 src projects + 26 test projects renamed; folders, csproj, namespaces, and ScadaLinkDbContext/ScadaBridgeDbContext class updated. ActorSystem "scadalink" → "scadabridge", Akka seed-node URLs migrated. SQL roles/logins, LDAP domains, CLI command name, and CLI config dir (~/.scadalink → ~/.scadabridge) also renamed. Build green; 5 Host.Tests fail awaiting SQL login rename in next commit. Pre-existing StaleTagMonitor timing flakes unchanged. Rename script committed at tools/rename-to-scadabridge.sh.
2026-05-28 09:37:45 -04:00
parent 6d87ee3c3b
commit 7b0b9c7365
1531 changed files with 11180 additions and 11054 deletions
@@ -0,0 +1,181 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.Extensions.Logging.Abstractions;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
+
+namespace ZB.MOM.WW.ScadaBridge.StoreAndForward.Tests;
+
+/// <summary>
+/// WP-11: Tests for async replication to standby.
+/// </summary>
+public class ReplicationServiceTests : IAsyncLifetime, IDisposable
+{
+    private readonly SqliteConnection _keepAlive;
+    private readonly StoreAndForwardStorage _storage;
+    private readonly ReplicationService _replicationService;
+
+    public ReplicationServiceTests()
+    {
+        var dbName = $"RepTests_{Guid.NewGuid():N}";
+        var connStr = $"Data Source={dbName};Mode=Memory;Cache=Shared";
+        _keepAlive = new SqliteConnection(connStr);
+        _keepAlive.Open();
+
+        _storage = new StoreAndForwardStorage(connStr, NullLogger<StoreAndForwardStorage>.Instance);
+
+        var options = new StoreAndForwardOptions { ReplicationEnabled = true };
+        _replicationService = new ReplicationService(
+            options, NullLogger<ReplicationService>.Instance);
+    }
+
+    public async Task InitializeAsync() => await _storage.InitializeAsync();
+
+    public Task DisposeAsync() => Task.CompletedTask;
+
+    public void Dispose() => _keepAlive.Dispose();
+
+    [Fact]
+    public void ReplicateEnqueue_NoHandler_DoesNotThrow()
+    {
+        var msg = CreateMessage("rep1");
+        _replicationService.ReplicateEnqueue(msg);
+    }
+
+    [Fact]
+    public async Task ReplicateEnqueue_WithHandler_ForwardsOperation()
+    {
+        ReplicationOperation? captured = null;
+        _replicationService.SetReplicationHandler(op =>
+        {
+            captured = op;
+            return Task.CompletedTask;
+        });
+
+        var msg = CreateMessage("rep2");
+        _replicationService.ReplicateEnqueue(msg);
+
+        await Task.Delay(200);
+
+        Assert.NotNull(captured);
+        Assert.Equal(ReplicationOperationType.Add, captured!.OperationType);
+        Assert.Equal("rep2", captured.MessageId);
+    }
+
+    [Fact]
+    public async Task ReplicateRemove_WithHandler_ForwardsRemoveOperation()
+    {
+        ReplicationOperation? captured = null;
+        _replicationService.SetReplicationHandler(op =>
+        {
+            captured = op;
+            return Task.CompletedTask;
+        });
+
+        _replicationService.ReplicateRemove("rep3");
+
+        await Task.Delay(200);
+
+        Assert.NotNull(captured);
+        Assert.Equal(ReplicationOperationType.Remove, captured!.OperationType);
+        Assert.Equal("rep3", captured.MessageId);
+    }
+
+    [Fact]
+    public async Task ReplicatePark_WithHandler_ForwardsParkOperation()
+    {
+        ReplicationOperation? captured = null;
+        _replicationService.SetReplicationHandler(op =>
+        {
+            captured = op;
+            return Task.CompletedTask;
+        });
+
+        var msg = CreateMessage("rep4");
+        _replicationService.ReplicatePark(msg);
+
+        await Task.Delay(200);
+
+        Assert.NotNull(captured);
+        Assert.Equal(ReplicationOperationType.Park, captured!.OperationType);
+    }
+
+    [Fact]
+    public async Task ApplyReplicatedOperationAsync_Add_EnqueuesMessage()
+    {
+        var msg = CreateMessage("apply1");
+        var operation = new ReplicationOperation(ReplicationOperationType.Add, "apply1", msg);
+
+        await _replicationService.ApplyReplicatedOperationAsync(operation, _storage);
+
+        var retrieved = await _storage.GetMessageByIdAsync("apply1");
+        Assert.NotNull(retrieved);
+    }
+
+    [Fact]
+    public async Task ApplyReplicatedOperationAsync_Remove_DeletesMessage()
+    {
+        var msg = CreateMessage("apply2");
+        await _storage.EnqueueAsync(msg);
+
+        var operation = new ReplicationOperation(ReplicationOperationType.Remove, "apply2", null);
+        await _replicationService.ApplyReplicatedOperationAsync(operation, _storage);
+
+        var retrieved = await _storage.GetMessageByIdAsync("apply2");
+        Assert.Null(retrieved);
+    }
+
+    [Fact]
+    public async Task ApplyReplicatedOperationAsync_Park_UpdatesStatus()
+    {
+        var msg = CreateMessage("apply3");
+        await _storage.EnqueueAsync(msg);
+
+        var operation = new ReplicationOperation(ReplicationOperationType.Park, "apply3", msg);
+        await _replicationService.ApplyReplicatedOperationAsync(operation, _storage);
+
+        var retrieved = await _storage.GetMessageByIdAsync("apply3");
+        Assert.NotNull(retrieved);
+        Assert.Equal(StoreAndForwardMessageStatus.Parked, retrieved!.Status);
+    }
+
+    [Fact]
+    public void ReplicateEnqueue_WhenReplicationDisabled_DoesNothing()
+    {
+        var options = new StoreAndForwardOptions { ReplicationEnabled = false };
+        var service = new ReplicationService(options, NullLogger<ReplicationService>.Instance);
+
+        bool handlerCalled = false;
+        service.SetReplicationHandler(_ => { handlerCalled = true; return Task.CompletedTask; });
+
+        service.ReplicateEnqueue(CreateMessage("disabled1"));
+
+        Assert.False(handlerCalled);
+    }
+
+    [Fact]
+    public async Task ReplicateEnqueue_HandlerThrows_DoesNotPropagateException()
+    {
+        _replicationService.SetReplicationHandler(_ =>
+            throw new InvalidOperationException("standby down"));
+
+        _replicationService.ReplicateEnqueue(CreateMessage("err1"));
+
+        await Task.Delay(200);
+        // No exception -- fire-and-forget, best-effort
+    }
+
+    private static StoreAndForwardMessage CreateMessage(string id)
+    {
+        return new StoreAndForwardMessage
+        {
+            Id = id,
+            Category = StoreAndForwardCategory.ExternalSystem,
+            Target = "target",
+            PayloadJson = "{}",
+            RetryCount = 0,
+            MaxRetries = 50,
+            RetryIntervalMs = 30000,
+            CreatedAt = DateTimeOffset.UtcNow,
+            Status = StoreAndForwardMessageStatus.Pending
+        };
+    }
+}