fix(tests): three CI failures — NagleBuf cap, stress test dedup, timeouts

MaxNagleBuf raised from 32 KB to 256 KB: the 32 KB cap silently dropped
64 KB data-exchange sends (IPC fire-and-forget never surfaced ErrSendBufFull
back to the caller), causing TestDataExchangeLargePayload and
TestLargeWriteSegmentation to hang until timeout.

TestStressConcurrentConnections: 20 concurrent dials to the same
(peerNode, dstPort) were all deduplicated to one connection by
DialConnectionContext — fixed by giving each goroutine its own port
(3000+idx) so dials are independent. Also reduced numConns 20→10 and
moved base port away from built-in service ports (1001-1003).

TestLargeWriteSegmentation: added 60 s read deadline so a stall fails
fast instead of hanging until the global timeout fires.

CI workflow: raised test timeout 120 s → 300 s for macOS arm64 runners.

Author: teovl

.github/workflows/release.yml

@@ -29,7 +29,7 @@ jobs:
         run: make build
 
       - name: Unit tests
-        run: go test -parallel 4 -count=1 -timeout 120s ./tests/ ./pkg/beacon/
+        run: go test -parallel 4 -count=1 -timeout 300s ./tests/ ./pkg/beacon/
 
   build:
     name: Build (${{ matrix.goos }}/${{ matrix.goarch }})

pkg/daemon/nagle_buf_bug_test.go

@@ -29,7 +29,7 @@ import (
 // memory budget. Multiple writers would amplify this further.
 //
 // What v1.9.1's NagleBuf cap fix will change:
-//   - introduce MaxNagleBuf = 8 * MaxSegmentSize (32 KB)
+//   - introduce MaxNagleBuf = 64 * MaxSegmentSize (256 KB)
 //   - SendData returns ErrSendBufFull when len(NagleBuf) + len(data) > MaxNagleBuf
 //   - test assertion flips: NagleBuf plateaus at MaxNagleBuf;
 //     SendData returns ErrSendBufFull on the oversized write.
@@ -63,7 +63,7 @@ func TestSendDataNagleBufGrowsUnbounded(t *testing.T) {
 	// FIXED (v1.9.1): SendData now rejects an oversized write up-front
 	// instead of appending it to NagleBuf. The 5 MiB write should
 	// return ErrSendBufFull immediately and NagleBuf should remain
-	// at 0 (not grow at all). MaxNagleBuf = 8 * MaxSegmentSize = 32 KB.
+	// at 0 (not grow at all). MaxNagleBuf = 64 * MaxSegmentSize = 256 KB.
 	const payloadSize = 5 * 1024 * 1024
 	payload := make([]byte, payloadSize)
 	for i := range payload {

pkg/daemon/ports.go

@@ -153,15 +153,17 @@ const (
 	AcceptQueueLen = 64                           // listener accept channel capacity
 	SendBufLen     = 256                          // send buffer channel capacity (segments)
 
-	// MaxNagleBuf caps the per-connection NagleBuf at 8 segments
-	// (32 KB). v1.9.1 fix: SendData previously appended without bound,
+	// MaxNagleBuf caps the per-connection NagleBuf at 64 segments
+	// (256 KB). v1.9.1 fix: SendData previously appended without bound,
 	// so an application writing faster than the network could drain
 	// (slow peer, full cwnd, packet loss) leaked memory linearly with
 	// offered-but-undeliverable load. With many connections in that
 	// state, daemon RSS climbed until OOM. SendData now returns
 	// ErrSendBufFull when len(NagleBuf) + len(write) would exceed
 	// this cap; callers must retry with backpressure.
-	MaxNagleBuf = 8 * MaxSegmentSize
+	// 256 KB accommodates the largest single data-exchange frame
+	// (64 KB) with headroom, while still bounding per-connection memory.
+	MaxNagleBuf = 64 * MaxSegmentSize
 )
 
 // RTO parameters (RFC 6298)

tests/dataexchange_test.go

@@ -179,7 +179,7 @@ func TestDataExchangeLargePayload(t *testing.T) {
 			t.Errorf("large binary mismatch: got %d bytes, expected %d", len(frame.Payload), len(largeData))
 		}
 		t.Logf("received large binary: %d bytes", len(frame.Payload))
-	case <-time.After(10 * time.Second):
+	case <-time.After(30 * time.Second):
 		t.Fatal("timeout")
 	}
 }

tests/segmentation_test.go

@@ -76,7 +76,8 @@ func TestLargeWriteSegmentation(t *testing.T) {
 	}
 	elapsed := time.Since(start)
 
-	// Read hash back
+	// Read hash back — set a deadline so a stalled transfer fails fast on CI
+	conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 	hashBuf := make([]byte, 32)
 	n, err := conn.Read(hashBuf)
 	if err != nil {

tests/stress_test.go

@@ -18,32 +18,41 @@ func TestStressConcurrentConnections(t *testing.T) {
 	a := env.AddDaemon()
 	b := env.AddDaemon()
 
-	// Echo server on A
-	ln, err := a.Driver.Listen(1000)
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-	go func() {
-		for {
-			conn, err := ln.Accept()
-			if err != nil {
-				return
-			}
-			go func() {
-				defer conn.Close()
-				buf := make([]byte, 65535)
-				for {
-					n, err := conn.Read(buf)
-					if err != nil {
-						return
-					}
-					conn.Write(buf[:n])
+	// Each goroutine dials its own port so dials aren't deduplicated by
+	// DialConnectionContext, which keys on (peerNode, dstPort).
+	const numConns = 10
+	const basePort = 3000 // avoid ports used by daemon services (1001-1003)
+
+	startEchoListener := func(ln *driver.Listener) {
+		go func() {
+			for {
+				conn, err := ln.Accept()
+				if err != nil {
+					return
 				}
-			}()
+				go func() {
+					defer conn.Close()
+					buf := make([]byte, 65535)
+					for {
+						n, err := conn.Read(buf)
+						if err != nil {
+							return
+						}
+						conn.Write(buf[:n])
+					}
+				}()
+			}
+		}()
+	}
+
+	for i := 0; i < numConns; i++ {
+		ln, err := a.Driver.Listen(uint16(basePort + i))
+		if err != nil {
+			t.Fatalf("listen port %d: %v", basePort+i, err)
 		}
-	}()
+		startEchoListener(ln)
+	}
 
-	const numConns = 20
 	var wg sync.WaitGroup
 	var successes atomic.Int32
 	var failures atomic.Int32
@@ -61,7 +70,7 @@ func TestStressConcurrentConnections(t *testing.T) {
 			}
 			defer d.Close()
 
-			conn, err := d.DialAddr(a.Daemon.Addr(), 1000)
+			conn, err := d.DialAddr(a.Daemon.Addr(), uint16(basePort+idx))
 			if err != nil {
 				t.Logf("conn %d: dial failed: %v", idx, err)
 				failures.Add(1)