Resolve all high-severity architecture review findings

2026-09-09 16:13:58 -04:00
parent 8bfe65512e
commit 146a13238f
192 changed files with 3160 additions and 753 deletions
@@ -67,6 +67,17 @@ public class InstanceActorTests : TestKit, IDisposable

    // ── M1.6: site event log `instance_lifecycle` category ──────────────────

+    [Fact]
+    public void Stop_ReleasesTagSubscriptionWithOwnerIdentity()
+    {
+        var (instance, dcl) = CreateInstanceWithDataSourcedAttribute(new SiteRuntimeOptions());
+        dcl.ExpectMsg<SubscribeTagsRequest>();
+        Sys.Stop(instance);
+        var request = dcl.ExpectMsg<UnsubscribeTagsRequest>();
+        Assert.Equal("conn-1", request.ConnectionName);
+        Assert.Equal(instance, dcl.LastSender);
+    }
+
    [Fact]
    public void InstanceActor_Start_EmitsInstanceLifecycleSiteEvent()
    {
@@ -56,6 +56,49 @@ public class NativeAlarmActorTests : TestKit, IDisposable
            Source(), "inst", instanceActor, dclManager, _storage, options,
            NullLogger<NativeAlarmActor>.Instance, AlarmKind.NativeOpcUa, serviceProvider)));

+    [Fact]
+    public void Stop_ReleasesAlarmSubscriptionWithOwnerIdentity()
+    {
+        var dcl = CreateTestProbe();
+        var actor = Spawn(CreateTestProbe().Ref, dcl.Ref);
+        dcl.ExpectMsg<SubscribeAlarmsRequest>();
+        Sys.Stop(actor);
+        var request = dcl.ExpectMsg<UnsubscribeAlarmsRequest>();
+        Assert.Equal(Source().SourceReference, request.SourceReference);
+        Assert.Equal(actor, dcl.LastSender);
+    }
+
+    [Fact]
+    public void DuplicateSnapshotEnd_DoesNotClearCommittedAlarm()
+    {
+        var instance = CreateTestProbe();
+        var dcl = CreateTestProbe();
+        var actor = Spawn(instance.Ref, dcl.Ref);
+        dcl.ExpectMsg<SubscribeAlarmsRequest>();
+        var epoch = Guid.NewGuid();
+        NativeAlarmTransition Framed(AlarmTransitionKind kind)
+        {
+            var transition = Transition("T01.Hi", kind,
+                new AlarmConditionState(true, false, null, AlarmShelveState.Unshelved, false, 800));
+            var json = JsonSerializer.SerializeToNode(transition)!;
+            json["SnapshotId"] = JsonSerializer.SerializeToNode(epoch);
+            json["SnapshotSourceReference"] = Source().SourceReference;
+            return json.Deserialize<NativeAlarmTransition>()!;
+        }
+        // Append-only enum value for the new start marker; before the fix it is not handled.
+        actor.Tell(new NativeAlarmTransitionUpdate("Opc", Framed((AlarmTransitionKind)7)));
+        actor.Tell(new NativeAlarmTransitionUpdate("Opc", Framed(AlarmTransitionKind.Snapshot)));
+        var end = new NativeAlarmTransitionUpdate("Opc", Framed(AlarmTransitionKind.SnapshotComplete));
+        actor.Tell(end);
+        instance.ExpectMsg<AlarmStateChanged>(m => m.State == AlarmState.Active);
+        // Before the fix there is also an unwanted Active event for the unrecognized start.
+        // Fish out all initial active events before applying the duplicate marker.
+        actor.Tell(new SubscribeAlarmsResponse("barrier", "inst", true, null, DateTimeOffset.UtcNow));
+        instance.ReceiveWhile(TimeSpan.FromMilliseconds(100), msg => msg);
+        actor.Tell(end);
+        instance.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
+    }
+
    [Fact]
    public void SubscribeOnStart_SendsRequestForSourceBinding()
    {
@@ -0,0 +1,48 @@
+using Akka.Actor;
+using Akka.TestKit.Xunit2;
+using Microsoft.Extensions.Logging.Abstractions;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Instance;
+using ZB.MOM.WW.ScadaBridge.SiteRuntime.Scripts;
+
+namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Scripts;
+
+public class AttributeSchedulerRegressionTests : TestKit
+{
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task SR1_SaturatedWorkersCompleteSynchronousAccessWithoutWatchdog(bool write)
+    {
+        const int workers = 2;
+        using var scheduler = new ScriptExecutionScheduler(workers);
+        var probe = CreateTestProbe();
+        var context = new ScriptRuntimeContext(probe.Ref, null!, 0, 10, TimeSpan.FromSeconds(3),
+            "Pump", NullLogger<ScriptRuntimeContext>.Instance);
+        var accessor = new AttributeAccessor(context, "");
+        var tasks = Enumerable.Range(0, workers).Select(_ => Task.Factory.StartNew(() =>
+        {
+            if (write) accessor["x"] = 42;
+            else Assert.Equal(42, accessor["x"]);
+        }, CancellationToken.None, TaskCreationOptions.None, scheduler)).ToArray();
+
+        // Hold both replies until every worker is blocked inside the synchronous accessor.
+        var replies = new List<(IActorRef Sender, object Response)>();
+        for (var i = 0; i < workers; i++)
+        {
+            if (write)
+            {
+                var request = probe.ExpectMsg<SetStaticAttributeCommand>();
+                replies.Add((probe.LastSender, new SetStaticAttributeResponse(request.CorrelationId,
+                    "Pump", "x", true, null, DateTimeOffset.UtcNow)));
+            }
+            else
+            {
+                var request = probe.ExpectMsg<GetAttributeRequest>();
+                replies.Add((probe.LastSender, new GetAttributeResponse(request.CorrelationId,
+                    "Pump", "x", 42, true, "Good", DateTimeOffset.UtcNow)));
+            }
+        }
+        foreach (var reply in replies) reply.Sender.Tell(reply.Response);
+        await Task.WhenAll(tasks).WaitAsync(TimeSpan.FromSeconds(2));
+    }
+}
@@ -0,0 +1,55 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
+using ZB.MOM.WW.ScadaBridge.SiteRuntime.Scripts;
+
+namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Scripts;
+
+public class AuditingDbTransactionTests
+{
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task SR11_TransactionConnectionAndCommandReadbackRemainAudited(bool asynchronous)
+    {
+        var inner = new SqliteConnection("Data Source=:memory:");
+        await inner.OpenAsync();
+        using (var seed = inner.CreateCommand())
+        {
+            seed.CommandText = "CREATE TABLE t (value INTEGER); INSERT INTO t VALUES (0)";
+            seed.ExecuteNonQuery();
+        }
+        var writer = new Mock<IAuditWriter>();
+        writer.Setup(w => w.WriteAsync(It.IsAny<ZB.MOM.WW.Audit.AuditEvent>(), It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask);
+        await using var connection = new AuditingDbConnection(inner, writer.Object, "db", "site", "instance",
+            "script", NullLogger.Instance, Guid.NewGuid());
+        await using var transaction = asynchronous
+            ? await connection.BeginTransactionAsync()
+            : connection.BeginTransaction();
+        Assert.Same(connection, transaction.Connection);
+        using var command = transaction.Connection!.CreateCommand();
+        Assert.Same(connection, command.Connection);
+        command.Transaction = transaction;
+        Assert.Same(transaction, command.Transaction);
+        Assert.Same(connection, command.Transaction!.Connection);
+        command.CommandText = "UPDATE t SET value = 42";
+        Assert.Equal(1, asynchronous ? await command.ExecuteNonQueryAsync() : command.ExecuteNonQuery());
+        if (asynchronous) await transaction.CommitAsync(); else transaction.Commit();
+        writer.Verify(w => w.WriteAsync(It.IsAny<ZB.MOM.WW.Audit.AuditEvent>(), It.IsAny<CancellationToken>()), Times.Once);
+        using var check = inner.CreateCommand();
+        check.CommandText = "SELECT value FROM t";
+        Assert.Equal(42L, check.ExecuteScalar());
+    }
+
+    [Fact]
+    public void SR11_CommandConnectionCannotExposeProvider()
+    {
+        using var inner = new SqliteConnection("Data Source=:memory:");
+        using var connection = new AuditingDbConnection(inner, Mock.Of<IAuditWriter>(), "db", "site", "instance",
+            "script", NullLogger.Instance, Guid.NewGuid());
+        using var command = connection.CreateCommand();
+        Assert.Same(connection, command.Connection);
+    }
+}