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,159 @@
+using System;
+using System.Collections.Generic;
+using ZB.MOM.WW.MxGateway.Worker.MxAccess;
+
+namespace ZB.MOM.WW.MxGateway.Worker.Tests.MxAccess;
+
+/// <summary>
+/// Worker-007 regression tests for <see cref="MxAccessComServer"/>. The
+/// adapter no longer falls back to late-bound <c>Type.InvokeMember</c>
+/// reflection: a COM object must implement either the typed
+/// <c>ILMXProxyServer</c> COM interface family (production) or
+/// <see cref="IMxAccessServer"/> directly (test fakes).
+/// </summary>
+public sealed class MxAccessComServerTests
+{
+    /// <summary>
+    /// A COM object implementing <see cref="IMxAccessServer"/> is routed
+    /// through the typed interface — no reflection — preserving arguments
+    /// and return values.
+    /// </summary>
+    [Fact]
+    public void Methods_WithTypedServer_RouteThroughTypedInterface()
+    {
+        RecordingMxAccessServer typed = new(registerHandle: 77);
+        MxAccessComServer adapter = new(typed);
+
+        int serverHandle = adapter.Register("client-a");
+        adapter.Advise(serverHandle, itemHandle: 9);
+        adapter.Unregister(serverHandle);
+
+        Assert.Equal(77, serverHandle);
+        Assert.Equal("client-a", typed.RegisteredClientName);
+        Assert.Equal(new[] { "Register:client-a", "Advise:77:9", "Unregister:77" }, typed.Calls);
+    }
+
+    /// <summary>
+    /// A COM object that implements neither the typed COM interface family
+    /// nor <see cref="IMxAccessServer"/> fails fast with a clear
+    /// <see cref="InvalidOperationException"/> instead of a late-bound
+    /// reflection call.
+    /// </summary>
+    [Fact]
+    public void Methods_WithUntypedObject_ThrowInvalidOperation()
+    {
+        MxAccessComServer adapter = new(new object());
+
+        InvalidOperationException exception =
+            Assert.Throws<InvalidOperationException>(() => adapter.Register("client"));
+
+        Assert.Contains("does not implement", exception.Message, StringComparison.Ordinal);
+        Assert.Contains(nameof(IMxAccessServer), exception.Message, StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// Exceptions thrown by the typed server propagate unchanged — no
+    /// <c>TargetInvocationException</c> wrapping (reflection is gone).
+    /// </summary>
+    [Fact]
+    public void Methods_WhenTypedServerThrows_PropagateOriginalException()
+    {
+        RecordingMxAccessServer typed = new(registerHandle: 1)
+        {
+            ThrowOnRegister = new InvalidOperationException("register failed"),
+        };
+        MxAccessComServer adapter = new(typed);
+
+        InvalidOperationException exception =
+            Assert.Throws<InvalidOperationException>(() => adapter.Register("client"));
+
+        Assert.Equal("register failed", exception.Message);
+    }
+
+    private sealed class RecordingMxAccessServer : IMxAccessServer
+    {
+        private readonly int registerHandle;
+        private readonly List<string> calls = new();
+
+        public RecordingMxAccessServer(int registerHandle)
+        {
+            this.registerHandle = registerHandle;
+        }
+
+        public string? RegisteredClientName { get; private set; }
+
+        public Exception? ThrowOnRegister { get; set; }
+
+        public IReadOnlyList<string> Calls => calls.ToArray();
+
+        public int Register(string clientName)
+        {
+            calls.Add($"Register:{clientName}");
+            RegisteredClientName = clientName;
+            if (ThrowOnRegister is not null)
+            {
+                throw ThrowOnRegister;
+            }
+
+            return registerHandle;
+        }
+
+        public void Unregister(int serverHandle)
+        {
+            calls.Add($"Unregister:{serverHandle}");
+        }
+
+        public int AddItem(int serverHandle, string itemDefinition)
+        {
+            calls.Add($"AddItem:{serverHandle}:{itemDefinition}");
+            return 0;
+        }
+
+        public int AddItem2(int serverHandle, string itemDefinition, string itemContext)
+        {
+            calls.Add($"AddItem2:{serverHandle}:{itemDefinition}:{itemContext}");
+            return 0;
+        }
+
+        public void RemoveItem(int serverHandle, int itemHandle)
+        {
+            calls.Add($"RemoveItem:{serverHandle}:{itemHandle}");
+        }
+
+        public void Advise(int serverHandle, int itemHandle)
+        {
+            calls.Add($"Advise:{serverHandle}:{itemHandle}");
+        }
+
+        public void UnAdvise(int serverHandle, int itemHandle)
+        {
+            calls.Add($"UnAdvise:{serverHandle}:{itemHandle}");
+        }
+
+        public void AdviseSupervisory(int serverHandle, int itemHandle)
+        {
+            calls.Add($"AdviseSupervisory:{serverHandle}:{itemHandle}");
+        }
+
+        public void Write(int serverHandle, int itemHandle, object? value, int userId)
+        {
+            calls.Add($"Write:{serverHandle}:{itemHandle}:{value}:{userId}");
+        }
+
+        public void Write2(int serverHandle, int itemHandle, object? value, object? timestamp, int userId)
+        {
+            calls.Add($"Write2:{serverHandle}:{itemHandle}:{value}:{timestamp}:{userId}");
+        }
+
+        public void WriteSecured(int serverHandle, int itemHandle, int currentUserId, int verifierUserId, object? value)
+        {
+            calls.Add($"WriteSecured:{serverHandle}:{itemHandle}:{currentUserId}:{verifierUserId}:{value}");
+        }
+
+        public void WriteSecured2(
+            int serverHandle, int itemHandle, int currentUserId, int verifierUserId, object? value, object? timestamp)
+        {
+            calls.Add($"WriteSecured2:{serverHandle}:{itemHandle}:{currentUserId}:{verifierUserId}:{value}:{timestamp}");
+        }
+    }
+}