fix(communication): resolve Communication-012..015 — endpoint-aware gRPC client cache, address-change recreation, correlation-id validation, node-flip tests

tests/ScadaLink.Communication.Tests/Grpc/DebugStreamBridgeActorTests.cs

@@ -308,6 +308,46 @@ public class DebugStreamBridgeActorTests : TestKit
         Assert.True(ctx.TerminatedFlag[0]);
     }
 
+    [Fact]
+    public void On_GrpcError_Reconnects_To_Other_Node_Endpoint()
+    {
+        // Communication-015 regression: drive the bridge actor through a node flip
+        // with an endpoint-aware factory (one distinct mock client per endpoint).
+        // The first subscribe targets NodeA; after a gRPC error the bridge must
+        // reconnect via a client bound to the *NodeB* endpoint.
+        var commProbe = CreateTestProbe();
+        var factory = new EndpointTrackingGrpcClientFactory();
+        var events = new List<object>();
+        var terminated = new[] { false };
+
+        var props = Props.Create(typeof(DebugStreamBridgeActor),
+            SiteId, InstanceName, "corr-1", commProbe.Ref,
+            (Action<object>)(evt => { lock (events) { events.Add(evt); } }),
+            (Action)(() => terminated[0] = true),
+            factory, GrpcNodeA, GrpcNodeB);
+
+        var actor = Sys.ActorOf(props);
+        commProbe.ExpectMsg<SiteEnvelope>();
+
+        actor.Tell(new DebugViewSnapshot(
+            InstanceName,
+            new List<AttributeValueChanged>(),
+            new List<AlarmStateChanged>(),
+            DateTimeOffset.UtcNow));
+
+        // First subscribe goes to NodeA.
+        AwaitCondition(() => factory.ClientFor(GrpcNodeA).SubscribeCalls.Count == 1,
+            TimeSpan.FromSeconds(3));
+
+        // gRPC error → bridge flips to NodeB.
+        factory.ClientFor(GrpcNodeA).SubscribeCalls[0].OnError(new Exception("NodeA down"));
+
+        // The reconnect must reach a client bound to the NodeB endpoint.
+        AwaitCondition(() => factory.ClientFor(GrpcNodeB).SubscribeCalls.Count == 1,
+            TimeSpan.FromSeconds(5));
+        Assert.Equal("corr-1", factory.ClientFor(GrpcNodeB).SubscribeCalls[0].CorrelationId);
+    }
+
     [Fact]
     public void RetryCount_RecoveredOnlyAfterStreamStaysStableForStabilityWindow()
     {
@@ -415,3 +455,24 @@ internal class MockSiteStreamGrpcClientFactory : SiteStreamGrpcClientFactory
         return _mockClient;
     }
 }
+
+/// <summary>
+/// Endpoint-aware mock factory: hands out a distinct <see cref="MockSiteStreamGrpcClient"/>
+/// per endpoint, mirroring the real factory's corrected NodeA→NodeB failover behaviour
+/// so node-flip coverage is meaningful (Communication-015).
+/// </summary>
+internal class EndpointTrackingGrpcClientFactory : SiteStreamGrpcClientFactory
+{
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, MockSiteStreamGrpcClient> _byEndpoint = new();
+
+    public EndpointTrackingGrpcClientFactory()
+        : base(Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory.Instance)
+    {
+    }
+
+    public MockSiteStreamGrpcClient ClientFor(string endpoint) =>
+        _byEndpoint.GetOrAdd(endpoint, _ => new MockSiteStreamGrpcClient());
+
+    public override SiteStreamGrpcClient GetOrCreate(string siteIdentifier, string grpcEndpoint)
+        => ClientFor(grpcEndpoint);
+}

tests/ScadaLink.Communication.Tests/Grpc/SiteStreamGrpcClientFactoryTests.cs

@@ -63,4 +63,70 @@ public class SiteStreamGrpcClientFactoryTests
         // After dispose, creating new clients should work (new instances)
         // This tests that Dispose doesn't throw
     }
+
+    [Fact]
+    public void GetOrCreate_EndpointChanged_ReturnsClientBoundToNewEndpoint()
+    {
+        // Communication-012 regression: when the same site is requested with a
+        // *different* endpoint (the NodeA→NodeB failover flip), the factory must
+        // hand back a client bound to the new endpoint, not the stale cached one.
+        using var factory = new TrackingEndpointFactory();
+
+        var nodeA = factory.GetOrCreate("site-a", "http://localhost:5100");
+        var nodeB = factory.GetOrCreate("site-a", "http://localhost:5200");
+
+        Assert.NotSame(nodeA, nodeB);
+        Assert.Equal("http://localhost:5100", nodeA.Endpoint);
+        Assert.Equal("http://localhost:5200", nodeB.Endpoint);
+    }
+
+    [Fact]
+    public void GetOrCreate_EndpointChanged_DisposesPriorClient()
+    {
+        // Communication-013 regression: a later edit to a site's gRPC address must
+        // invalidate (and dispose) the stale cached client, so the corrected
+        // endpoint takes effect without a central restart.
+        using var factory = new TrackingEndpointFactory();
+
+        var first = (TrackingEndpointClient)factory.GetOrCreate("site-a", "http://localhost:5100");
+        var second = (TrackingEndpointClient)factory.GetOrCreate("site-a", "http://localhost:5200");
+
+        Assert.NotSame(first, second);
+        Assert.True(first.Disposed, "stale client for the old endpoint should be disposed");
+        Assert.False(second.Disposed, "fresh client for the new endpoint should still be live");
+    }
+
+    [Fact]
+    public void GetOrCreate_SameEndpoint_DoesNotDisposeOrRecreate()
+    {
+        // Endpoint unchanged → the cached client is reused untouched.
+        using var factory = new TrackingEndpointFactory();
+
+        var first = (TrackingEndpointClient)factory.GetOrCreate("site-a", "http://localhost:5100");
+        var second = (TrackingEndpointClient)factory.GetOrCreate("site-a", "http://localhost:5100");
+
+        Assert.Same(first, second);
+        Assert.False(first.Disposed);
+    }
+
+    /// <summary>Test client that records its endpoint and disposal (no real channel).</summary>
+    private sealed class TrackingEndpointClient : SiteStreamGrpcClient
+    {
+        public TrackingEndpointClient(string endpoint) : base(endpoint) { }
+        public bool Disposed { get; private set; }
+        public override void Dispose() => Disposed = true;
+        public override ValueTask DisposeAsync()
+        {
+            Disposed = true;
+            return ValueTask.CompletedTask;
+        }
+    }
+
+    /// <summary>Factory that hands out endpoint-tracking clients.</summary>
+    private sealed class TrackingEndpointFactory : SiteStreamGrpcClientFactory
+    {
+        public TrackingEndpointFactory() : base(NullLoggerFactory.Instance) { }
+        protected override SiteStreamGrpcClient CreateClient(string grpcEndpoint)
+            => new TrackingEndpointClient(grpcEndpoint);
+    }
 }

tests/ScadaLink.Communication.Tests/Grpc/SiteStreamGrpcServerTests.cs

@@ -207,6 +207,50 @@ public class SiteStreamGrpcServerTests : TestKit
         await streamTask;
     }
 
+    [Theory]
+    [InlineData("corr/with/slash")]
+    [InlineData("corr with space")]
+    [InlineData("")]
+    [InlineData("$weird")]
+    public async Task RejectsCorrelationIdThatIsNotActorNameSafe(string badCorrelationId)
+    {
+        // Communication-014 regression: a public gRPC SubscribeInstance must not feed
+        // an untrusted correlation_id straight into an Akka actor name. An unsafe id
+        // must be rejected cleanly with InvalidArgument rather than escaping as an
+        // unhandled InvalidActorNameException.
+        var server = CreateServer();
+        server.SetReady(Sys);
+
+        var writer = Substitute.For<IServerStreamWriter<SiteStreamEvent>>();
+        var context = CreateMockContext();
+
+        var ex = await Assert.ThrowsAsync<RpcException>(
+            () => server.SubscribeInstance(MakeRequest(badCorrelationId), writer, context));
+
+        Assert.Equal(StatusCode.InvalidArgument, ex.StatusCode);
+        Assert.Equal(0, server.ActiveStreamCount);
+    }
+
+    [Fact]
+    public async Task AcceptsActorNameSafeCorrelationId()
+    {
+        // A normal GUID-style correlation id (what central always supplies) is accepted.
+        var server = CreateServer();
+        server.SetReady(Sys);
+
+        var cts = new CancellationTokenSource();
+        var context = CreateMockContext(cts.Token);
+        var writer = Substitute.For<IServerStreamWriter<SiteStreamEvent>>();
+
+        var streamTask = Task.Run(() => server.SubscribeInstance(
+            MakeRequest(Guid.NewGuid().ToString()), writer, context));
+
+        await WaitForConditionAsync(() => server.ActiveStreamCount == 1);
+
+        cts.Cancel();
+        await streamTask;
+    }
+
     [Fact]
     public void SetReady_AllowsStreamCreation()
     {