fix(saf): chunk the resync snapshot to fit Akka remoting frames (additive protocol, byte-budgeted) (plan R2-02 T5)

tests/ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests/Actors/SiteReplicationActorTests.cs

@@ -248,8 +248,10 @@ akka {
     }
 
     [Fact]
-    public async Task ActiveNode_AnswersResyncRequest_WithFullBufferSnapshot()
+    public async Task ActiveNode_AnswersResyncRequest_WithChunkedSnapshot()
     {
+        // Post-R2-T5 the active node answers with byte-budgeted SfBufferSnapshotChunk(s)
+        // (a single small row rides one chunk) rather than the monolithic SfBufferSnapshot.
         await _sfStorage.EnqueueAsync(NewSfMessage("m1"));
         var probe = CreateTestProbe();
         var actor = ActorOf(Props.Create(() => new ResyncTestActor(
@@ -258,9 +260,11 @@ akka {
 
         actor.Tell(new RequestSfBufferResync(), TestActor);
 
-        var snapshot = ExpectMsg<SfBufferSnapshot>(TimeSpan.FromSeconds(3));
-        Assert.Single(snapshot.Messages);
-        Assert.False(snapshot.Truncated);
+        var chunk = ExpectMsg<SfBufferSnapshotChunk>(TimeSpan.FromSeconds(3));
+        Assert.Equal(1, chunk.TotalChunks);
+        Assert.Equal(1, chunk.Sequence);
+        Assert.Single(chunk.Messages);
+        Assert.False(chunk.Truncated);
     }
 
     [Fact]
@@ -281,6 +285,56 @@ akka {
         }, TimeSpan.FromSeconds(5));
     }
 
+    // ── R2 T5: chunked resync answer ──
+
+    [Fact]
+    public void ChunkForRemoting_SplitsByByteBudget_PreservingOrderAndSequence()
+    {
+        var rows = Enumerable.Range(0, 10)
+            .Select(i => NewMessage($"m{i}", payloadJson: new string('x', 20_000)))
+            .ToList();
+
+        var chunks = SiteReplicationActor.ChunkForRemoting(rows, maxChunkBytes: 64_000, maxChunkRows: 200);
+
+        Assert.True(chunks.Count > 1); // 10 × 20 KB cannot ride one 64 KB chunk
+        Assert.Equal(rows.Select(r => r.Id), chunks.SelectMany(c => c).Select(r => r.Id)); // order preserved
+        Assert.All(chunks, c => Assert.True(
+            c.Sum(r => r.PayloadJson.Length) <= 64_000 || c.Count == 1)); // budget honored (oversized row isolated)
+    }
+
+    [Fact]
+    public void ChunkForRemoting_RowCapHonored_AndSingleOversizedRowIsolated()
+    {
+        var many = Enumerable.Range(0, 500).Select(i => NewMessage($"s{i}", payloadJson: "{}")).ToList();
+        Assert.All(SiteReplicationActor.ChunkForRemoting(many, 64_000, 200), c => Assert.True(c.Count <= 200));
+
+        var oversized = new List<StoreAndForwardMessage>
+            { NewMessage("big", payloadJson: new string('y', 100_000)), NewMessage("small", payloadJson: "{}") };
+        var chunks = SiteReplicationActor.ChunkForRemoting(oversized, 64_000, 200);
+        Assert.Equal(2, chunks.Count); // the oversized row rides alone
+    }
+
+    [Fact]
+    public async Task ActiveNode_AnswersResyncRequest_WithSequencedChunks_SharingOneResyncId()
+    {
+        for (var i = 0; i < 3; i++)
+            await _sfStorage.EnqueueAsync(NewMessage($"c{i}", payloadJson: new string('z', 30_000)));
+        var actor = CreateResyncActor(isActive: () => true);
+
+        actor.Tell(new RequestSfBufferResync(), TestActor);
+
+        var first = ExpectMsg<SfBufferSnapshotChunk>(TimeSpan.FromSeconds(5));
+        var rest = Enumerable.Range(1, first.TotalChunks - 1)
+            .Select(_ => ExpectMsg<SfBufferSnapshotChunk>(TimeSpan.FromSeconds(5)))
+            .Prepend(first)
+            .ToList();
+
+        Assert.True(first.TotalChunks > 1);
+        Assert.All(rest, c => Assert.Equal(first.ResyncId, c.ResyncId));
+        Assert.Equal(Enumerable.Range(1, first.TotalChunks), rest.Select(c => c.Sequence));
+        Assert.Equal(3, rest.Sum(c => c.Messages.Count));
+    }
+
     private static StoreAndForwardMessage NewSfMessage(string id) => new()
     {
         Id = id,
@@ -294,6 +348,30 @@ akka {
         Status = StoreAndForwardMessageStatus.Pending,
     };
 
+    /// <summary>
+    /// Builds a resync-test message with a settable payload (additive to
+    /// <see cref="NewSfMessage"/> — the chunker sizes on <c>PayloadJson</c> length).
+    /// </summary>
+    private static StoreAndForwardMessage NewMessage(string id, string payloadJson = "{}") => new()
+    {
+        Id = id,
+        Category = StoreAndForwardCategory.ExternalSystem,
+        Target = "t",
+        PayloadJson = payloadJson,
+        RetryCount = 0,
+        MaxRetries = 50,
+        RetryIntervalMs = 30000,
+        CreatedAt = DateTimeOffset.UtcNow,
+        Status = StoreAndForwardMessageStatus.Pending,
+    };
+
+    /// <summary>Constructs a <see cref="ResyncTestActor"/> with the given active-node check
+    /// (the resync chunk/ack tests Tell to and expect from <see cref="TestKit.TestActor"/>).</summary>
+    private IActorRef CreateResyncActor(Func<bool> isActive) =>
+        ActorOf(Props.Create(() => new ResyncTestActor(
+            _storage, _sfStorage, _replicationService, SiteRole,
+            NullLogger<SiteReplicationActor>.Instance, CreateTestProbe().Ref, isActive)));
+
     /// <summary>Test message: drives <see cref="SiteReplicationActor.OnPeerTracked"/> directly,
     /// standing in for the MemberUp→TryTrackPeer path (a single-node TestKit cannot form a real peer).</summary>
     private sealed record TriggerPeerTracked;