Clarify batch unit test

This happens over a single connection with a given peer: we clarify
that we use distinct channels, but they are not with different peers.

Author: t-bast

eclair-core/src/test/scala/fr/acinq/eclair/io/PeerConnectionSpec.scala

@@ -353,67 +353,73 @@ class PeerConnectionSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike wi
     import f._
     connect(nodeParams, remoteNodeId, switchboard, router, connection, transport, peerConnection, peer)
 
-    // The channel with A has a pending splice.
-    val channelIdA = randomBytes32()
-    val commitSigA1 = CommitSig(channelIdA, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(2)))
-    val commitSigA2 = CommitSig(channelIdA, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(2)))
-    // The channel with B has 2 pending splices.
-    val channelIdB = randomBytes32()
-    val commitSigB1 = CommitSig(channelIdB, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    val commitSigB2 = CommitSig(channelIdB, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    val commitSigB3 = CommitSig(channelIdB, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    // The channel with C doesn't have any pending splice.
-    val channelIdC = randomBytes32()
-    val commitSigC1 = CommitSig(channelIdC, randomBytes64(), Nil)
-    // The channel with D doesn't have any pending splice, but the batch TLV is (incorrectly) set.
-    val channelIdD = randomBytes32()
-    val commitSigD1 = CommitSig(channelIdD, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(1)))
+    // The first channel has a pending splice.
+    val channelId1 = randomBytes32()
+    val commitSigs1 = Seq(
+      CommitSig(channelId1, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(2))),
+      CommitSig(channelId1, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(2))),
+    )
+    // A second channel has 2 pending splices.
+    val channelId2 = randomBytes32()
+    val commitSigs2 = Seq(
+      CommitSig(channelId2, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+      CommitSig(channelId2, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+      CommitSig(channelId2, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+    )
+    // Another channel doesn't have any pending splice.
+    val channelId3 = randomBytes32()
+    val commitSig3 = CommitSig(channelId3, randomBytes64(), Nil)
+    // Another channel doesn't have any pending splice, but the batch TLV is (incorrectly) set.
+    val channelId4 = randomBytes32()
+    val commitSig4 = CommitSig(channelId4, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(1)))
 
     // Older peers may not correctly group these messages on the wire: unrelated messages may be interleaved.
-    // We start by receiving a partial batch from A and B.
-    transport.send(peerConnection, commitSigA1)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigA1))
-    transport.send(peerConnection, commitSigB1)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigB1))
-    transport.send(peerConnection, commitSigB2)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigB2))
+    // We start by receiving a partial batch from the first two channels.
+    transport.send(peerConnection, commitSigs1(0))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs1(0)))
+    transport.send(peerConnection, commitSigs2(0))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs2(0)))
+    transport.send(peerConnection, commitSigs2(1))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs2(1)))
     peer.expectNoMessage(100 millis)
-    // We then receive individual commit_sig messages from C and D.
-    transport.send(peerConnection, commitSigC1)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigC1))
-    peer.expectMsg(commitSigC1)
-    transport.send(peerConnection, commitSigD1)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigD1))
-    peer.expectMsg(commitSigD1)
-    // Finally, we receive the end of A and B's batches.
-    transport.send(peerConnection, commitSigA2)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigA2))
-    peer.expectMsg(CommitSigBatch(commitSigA1 :: commitSigA2 :: Nil))
-    transport.send(peerConnection, commitSigB3)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigB3))
-    peer.expectMsg(CommitSigBatch(commitSigB1 :: commitSigB2 :: commitSigB3 :: Nil))
+    // We then receive individual commit_sig messages from the last two channels.
+    transport.send(peerConnection, commitSig3)
+    transport.expectMsg(TransportHandler.ReadAck(commitSig3))
+    peer.expectMsg(commitSig3)
+    transport.send(peerConnection, commitSig4)
+    transport.expectMsg(TransportHandler.ReadAck(commitSig4))
+    peer.expectMsg(commitSig4)
+    // Finally, we receive the end of the first two channels' batches.
+    transport.send(peerConnection, commitSigs1(1))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs1(1)))
+    peer.expectMsg(CommitSigBatch(commitSigs1))
+    transport.send(peerConnection, commitSigs2(2))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs2(2)))
+    peer.expectMsg(CommitSigBatch(commitSigs2))
     peer.expectNoMessage(100 millis)
 
-    // We then receive another batch of messages from A with unrelated channel messages in-between.
-    val commitSigA3 = CommitSig(channelIdA, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    val commitSigA4 = CommitSig(channelIdA, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    val spliceLockedA = SpliceLocked(channelIdA, randomTxId())
-    val commitSigA5 = CommitSig(channelIdA, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3)))
-    transport.send(peerConnection, commitSigA3)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigA3))
-    transport.send(peerConnection, commitSigA4)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigA4))
-    transport.send(peerConnection, spliceLockedA)
-    transport.expectMsg(TransportHandler.ReadAck(spliceLockedA))
-    peer.expectMsg(spliceLockedA)
+    // We then receive another batch of messages from the first channel with unrelated channel messages in-between.
+    val commitSigs5 = Seq(
+      CommitSig(channelId1, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+      CommitSig(channelId1, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+      CommitSig(channelId1, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(3))),
+    )
+    val spliceLocked = SpliceLocked(channelId1, randomTxId())
+    transport.send(peerConnection, commitSigs5(0))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs5(0)))
+    transport.send(peerConnection, commitSigs5(1))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs5(1)))
+    transport.send(peerConnection, spliceLocked)
+    transport.expectMsg(TransportHandler.ReadAck(spliceLocked))
+    peer.expectMsg(spliceLocked)
     peer.expectNoMessage(100 millis)
-    transport.send(peerConnection, commitSigA5)
-    transport.expectMsg(TransportHandler.ReadAck(commitSigA5))
-    peer.expectMsg(CommitSigBatch(commitSigA3 :: commitSigA4 :: commitSigA5 :: Nil))
+    transport.send(peerConnection, commitSigs5(2))
+    transport.expectMsg(TransportHandler.ReadAck(commitSigs5(2)))
+    peer.expectMsg(CommitSigBatch(commitSigs5))
     peer.expectNoMessage(100 millis)
 
     // We receive a batch that exceeds our threshold: we process them individually.
-    val invalidCommitSigs = (0 until 30).map(_ => CommitSig(channelIdB, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(30))))
+    val invalidCommitSigs = (0 until 30).map(_ => CommitSig(channelId2, randomBytes64(), Nil, TlvStream(CommitSigTlv.BatchTlv(30))))
     invalidCommitSigs.foreach(commitSig => {
       transport.send(peerConnection, commitSig)
       transport.expectMsg(TransportHandler.ReadAck(commitSig))