rename: prefix gateway projects/namespaces with ZB.MOM.WW + sln→slnx

Apply the ZB.MOM.WW. prefix to all gateway-side projects, folders, .csproj/.sln contents, C# namespaces, using directives, generated proto C# (csharp_namespace + checked-in generated files), InternalsVisibleTo attributes, project-name string literals (LoadProject, .sln lookups, worker exe paths, staticwebassets manifest), and the install/script/doc references that point at any of the above. Migrate the solution from .sln to .slnx via `dotnet sln migrate` and delete the old file. External-runtime identifiers are intentionally NOT prefixed so external configuration keeps working: - GatewayMetrics.cs MeterName ("MxGateway.Server") - DashboardAuthenticationDefaults Scheme/Policy ("MxGateway.Dashboard") - GatewayRequestLoggingMiddleware logger category ("MxGateway.Request") - StaRuntime thread name ("MxGateway.Worker.STA") - appsettings.json root section "MxGateway" + env-var prefix MxGateway__... and secret-name MxGateway:ApiKeyPepper - C:\ProgramData\MxGateway\ data dir paths Also fixes two tests that were not rename-related but became visible while validating the rename: - WorkerLiveMxAccessSmokeTests.ShutDownAsync: cancellation that the gateway service correctly maps to RpcException(Cancelled) per gRPC convention was being misclassified as a stream fault. Added a sibling catch on RpcException with StatusCode.Cancelled. - IntegrationTestEnvironment.ResolveRepositoryRoot: extracted IsRepositoryRoot and made it accept either a .git marker OR a .sln/.slnx next to src/ so the worker-exe walker works in non-git working copies. clients/proto/proto-inputs.json's protoRoot updated to point at src/ZB.MOM.WW.MxGateway.Contracts/Protos. Verified by `dotnet build` and a full `dotnet test` of the .slnx with MXGATEWAY_RUN_LIVE_{MXACCESS,LDAP,GALAXY}_TESTS=1: Tests: 472/472 pass Worker.Tests: 280/280 pass (4 dev-rig [Fact(Skip=...)] skipped) IntegrationTests: 18/18 pass Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-23 16:22:23 -04:00
parent 867bf18116
commit dc9c0c950c
491 changed files with 32854 additions and 8414 deletions
@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using ZB.MOM.WW.MxGateway.Contracts.Proto;
+using ZB.MOM.WW.MxGateway.Worker.MxAccess;
+
+namespace ZB.MOM.WW.MxGateway.Worker.Tests.MxAccess;
+
+/// <summary>
+///     Unit tests for the per-session alarm command router. Uses a fake
+///     consumer factory so the lazy-construction lifecycle on
+///     <c>SubscribeAlarms</c> is exercised without touching wnwrap COM.
+/// </summary>
+public sealed class AlarmCommandHandlerTests
+{
+    [Fact]
+    public void Subscribe_WhenNotYetSubscribed_CreatesConsumerAndCallsSubscribe()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+
+        handler.Subscribe(@"\\HOST\Galaxy!Area", "session-1");
+
+        Assert.True(handler.IsSubscribed);
+        Assert.Equal(@"\\HOST\Galaxy!Area", consumer.LastSubscription);
+    }
+
+    [Fact]
+    public void Subscribe_WhenAlreadySubscribed_Throws()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+        Assert.Throws<InvalidOperationException>(
+            () => handler.Subscribe(@"\\HOST\Galaxy!B", "s1"));
+    }
+
+    /// <summary>
+    ///     Worker.Tests-024: pins both the disposal contract and the
+    ///     origin of the propagated exception. The fake throws
+    ///     <c>InvalidOperationException("simulated wnwrap subscribe failure")</c>
+    ///     from <c>Subscribe</c>; the handler must propagate that exact
+    ///     exception (not swallow it and rethrow its own) and dispose the
+    ///     just-constructed consumer so a retry can build a fresh one.
+    ///     Pinning the message guards against a regression where the
+    ///     handler throws a different <see cref="InvalidOperationException"/>
+    ///     (for example its own "already subscribed" guard) and the
+    ///     disposal assertion alone would still pass while hiding the
+    ///     real swallow.
+    /// </summary>
+    [Fact]
+    public void Subscribe_WhenUnderlyingSubscribeThrows_DisposesConsumer()
+    {
+        FakeConsumer consumer = new FakeConsumer { ThrowOnSubscribe = true };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+
+        InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
+            () => handler.Subscribe(@"\\HOST\Galaxy!A", "s1"));
+        Assert.Contains("simulated wnwrap subscribe failure", exception.Message);
+        Assert.False(handler.IsSubscribed);
+        Assert.True(consumer.Disposed);
+    }
+
+    [Fact]
+    public void Unsubscribe_WhenSubscribed_DisposesConsumerAndClearsState()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+
+        handler.Unsubscribe();
+
+        Assert.False(handler.IsSubscribed);
+        Assert.True(consumer.Disposed);
+    }
+
+    [Fact]
+    public void Unsubscribe_WithoutPriorSubscribe_IsNoop()
+    {
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => new FakeConsumer());
+        handler.Unsubscribe(); // Should not throw.
+        Assert.False(handler.IsSubscribed);
+    }
+
+    [Fact]
+    public void Acknowledge_WhenSubscribed_ForwardsToConsumerWithFullOperatorIdentity()
+    {
+        FakeConsumer consumer = new FakeConsumer { AcknowledgeReturn = 0 };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+
+        Guid g = Guid.NewGuid();
+        int rc = handler.Acknowledge(g, "c", "u", "n", "d", "F");
+
+        Assert.Equal(0, rc);
+        Assert.Equal(g, consumer.LastAckGuid);
+        Assert.Equal("u", consumer.LastAckOperatorName);
+    }
+
+    [Fact]
+    public void Acknowledge_BeforeSubscribe_ThrowsInvalidOperation()
+    {
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => new FakeConsumer());
+
+        Assert.Throws<InvalidOperationException>(
+            () => handler.Acknowledge(Guid.Empty, "", "", "", "", ""));
+    }
+
+    [Fact]
+    public void QueryActive_WhenConsumerHasAlarms_ReturnsMappedProtoSnapshots()
+    {
+        FakeConsumer consumer = new FakeConsumer
+        {
+            SnapshotResult = new[]
+            {
+                new MxAlarmSnapshotRecord
+                {
+                    AlarmGuid = Guid.NewGuid(),
+                    ProviderName = "Galaxy",
+                    Group = "TestArea",
+                    TagName = "Tag1",
+                    Type = "DSC",
+                    Priority = 500,
+                    State = MxAlarmStateKind.UnackAlm,
+                },
+            },
+        };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+
+        IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null);
+
+        Assert.Single(snapshots);
+        Assert.Equal("Galaxy!TestArea.Tag1", snapshots[0].AlarmFullReference);
+        Assert.Equal(AlarmConditionState.Active, snapshots[0].CurrentState);
+    }
+
+    [Fact]
+    public void QueryActive_WithPrefix_FiltersByPrefix()
+    {
+        FakeConsumer consumer = new FakeConsumer
+        {
+            SnapshotResult = new[]
+            {
+                NewRecord("Galaxy", "AreaA", "Tag1"),
+                NewRecord("Galaxy", "AreaB", "Tag2"),
+            },
+        };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+
+        IReadOnlyList<ActiveAlarmSnapshot> filtered = handler.QueryActive("Galaxy!AreaA");
+
+        Assert.Single(filtered);
+        Assert.Equal("Galaxy!AreaA.Tag1", filtered[0].AlarmFullReference);
+    }
+
+    [Fact]
+    public void Dispose_WhenSubscribed_UnsubscribesAndDisposesConsumer()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+
+        handler.Dispose();
+
+        Assert.True(consumer.Disposed);
+        Assert.Throws<ObjectDisposedException>(
+            () => handler.Subscribe("x", "y"));
+    }
+
+    /// <summary>
+    ///     Worker-024 regression: every method that touches the underlying
+    ///     <see cref="IMxAccessAlarmConsumer"/> must invoke the configured
+    ///     STA-affinity guard. A guard that throws (simulating an off-STA
+    ///     call) must propagate from every command-path entry point.
+    /// </summary>
+    [Fact]
+    public void EveryCommandPathEntry_InvokesThreadAffinityGuard()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        int guardInvocations = 0;
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer,
+            () => guardInvocations++);
+
+        // Subscribe is the first call — guard must run before the consumer
+        // factory is invoked. We tally invocation counts after each call so
+        // that a missed guard surfaces as the diagnostic count, not a generic
+        // "Subscribe should have failed".
+        handler.Subscribe(@"\\HOST\Galaxy!A", "s1");
+        Assert.Equal(1, guardInvocations);
+
+        handler.Acknowledge(Guid.NewGuid(), "c", "u", "n", "d", "F");
+        Assert.Equal(2, guardInvocations);
+
+        handler.AcknowledgeByName("a", "p", "g", "c", "u", "n", "d", "F");
+        Assert.Equal(3, guardInvocations);
+
+        _ = handler.QueryActive(null);
+        Assert.Equal(4, guardInvocations);
+
+        handler.PollOnce();
+        Assert.Equal(5, guardInvocations);
+
+        handler.Unsubscribe();
+        Assert.Equal(6, guardInvocations);
+    }
+
+    /// <summary>
+    ///     Worker-024 regression: a guard that throws must propagate from
+    ///     every command-path entry point — proving the guard is not
+    ///     swallowed by an inner try/catch.
+    /// </summary>
+    [Fact]
+    public void EveryCommandPathEntry_PropagatesAffinityGuardException()
+    {
+        FakeConsumer consumer = new FakeConsumer();
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer,
+            threadAffinityCheck: () =>
+                throw new InvalidOperationException("off-STA"));
+
+        // Subscribe: guard runs before the dispatcher is constructed.
+        Assert.Throws<InvalidOperationException>(
+            () => handler.Subscribe(@"\\HOST\Galaxy!A", "s1"));
+
+        // To exercise the other entry points we need a subscribed handler.
+        // Construct a parallel handler with a passing guard, then swap in a
+        // throwing one — but the existing handler is the simpler vehicle:
+        // re-build the handler with the guard initially silent, subscribe,
+        // then verify each remaining entry by passing a guard that throws
+        // through a second handler instance — actually the cleaner way is to
+        // assert each independently with a fresh handler. Below we reuse
+        // the same throwing handler for the not-subscribed-yet entries:
+        Assert.Throws<InvalidOperationException>(
+            () => handler.Acknowledge(Guid.Empty, "", "", "", "", ""));
+        Assert.Throws<InvalidOperationException>(
+            () => handler.AcknowledgeByName("", "", "", "", "", "", "", ""));
+        Assert.Throws<InvalidOperationException>(() => handler.QueryActive(null));
+        Assert.Throws<InvalidOperationException>(() => handler.PollOnce());
+        Assert.Throws<InvalidOperationException>(() => handler.Unsubscribe());
+    }
+
+    private static MxAlarmSnapshotRecord NewRecord(string provider, string group, string tag)
+    {
+        return new MxAlarmSnapshotRecord
+        {
+            AlarmGuid = Guid.NewGuid(),
+            ProviderName = provider,
+            Group = group,
+            TagName = tag,
+            Type = "DSC",
+            Priority = 500,
+            State = MxAlarmStateKind.UnackAlm,
+        };
+    }
+
+    private sealed class FakeConsumer : IMxAccessAlarmConsumer
+    {
+#pragma warning disable CS0067 // Event never invoked — fake; AlarmCommandHandler tests don't drive transitions.
+        public event EventHandler<MxAlarmTransitionEvent>? AlarmTransitionEmitted;
+#pragma warning restore CS0067
+
+        public string? LastSubscription { get; private set; }
+        public Guid LastAckGuid { get; private set; }
+        public string? LastAckOperatorName { get; private set; }
+        public int AcknowledgeReturn { get; set; }
+        public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotResult { get; set; } =
+            Array.Empty<MxAlarmSnapshotRecord>();
+        public bool ThrowOnSubscribe { get; set; }
+        public bool Disposed { get; private set; }
+
+        public void Subscribe(string subscription)
+        {
+            LastSubscription = subscription;
+            if (ThrowOnSubscribe)
+            {
+                throw new InvalidOperationException("simulated wnwrap subscribe failure");
+            }
+        }
+
+        public int AcknowledgeByGuid(
+            Guid alarmGuid, string ackComment, string ackOperatorName,
+            string ackOperatorNode, string ackOperatorDomain, string ackOperatorFullName)
+        {
+            LastAckGuid = alarmGuid;
+            LastAckOperatorName = ackOperatorName;
+            return AcknowledgeReturn;
+        }
+
+        public int AcknowledgeByName(
+            string alarmName, string providerName, string groupName,
+            string ackComment, string ackOperatorName, string ackOperatorNode,
+            string ackOperatorDomain, string ackOperatorFullName)
+        {
+            LastAckByNameTuple = (alarmName, providerName, groupName);
+            LastAckOperatorName = ackOperatorName;
+            return AcknowledgeReturn;
+        }
+
+        public (string Name, string Provider, string Group)? LastAckByNameTuple { get; private set; }
+
+        public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms() => SnapshotResult;
+
+        public int PollCount { get; private set; }
+
+        public void PollOnce()
+        {
+            PollCount++;
+        }
+
+        public void Dispose()
+        {
+            Disposed = true;
+        }
+    }
+}