From 9475e3653d3e870382cef098262a915c8b968da2 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Tue, 29 Sep 2026 20:47:53 +0200 Subject: [PATCH] cultnet-rs, cultnet-ts: tests that fail when the fix is removed The hub test counts replaced sessions, since a fresh session repeats the same Accept sequence and the distinct-sequence count could not see it. The TS test requires an Ack, not a new Accept, once the Accept was acknowledged. A peer Disconnect is pinned as an ended session for flush and receipts. Co-Authored-By: Claude Opus 5.5 --- .../cultnet-rs/tests/rudp_stray_packets.rs | 40 ++++++++++++++++++- packages/cultnet-ts/test/cultnet.test.ts | 30 +++++++++----- 2 files changed, 59 insertions(+), 11 deletions(-) diff --git a/packages/cultnet-rs/tests/rudp_stray_packets.rs b/packages/cultnet-rs/tests/rudp_stray_packets.rs index f60cf582..bbb96395 100644 --- a/packages/cultnet-rs/tests/rudp_stray_packets.rs +++ b/packages/cultnet-rs/tests/rudp_stray_packets.rs @@ -491,10 +491,18 @@ fn hub_owes_one_reliable_accept_however_many_connects_repeat() -> Result<()> { let peer = socket()?; let mut peer_session = raw_session(CONNECTION_ID); let connect = peer_session.create_connect(0, b"peer".to_vec())?; + let mut connected = 0; for _ in 0..20 { send_to(&peer, hub_addr, &connect)?; - while hub.receive_event_once()?.is_some() {} + while let Some(event) = hub.receive_event_once()? { + assert!( + matches!(event, CultNetRudpServerEvent::Connected { .. }), + "a repeated Connect must not replace the admitted session" + ); + connected += 1; + } } + assert_eq!(connected, 1); assert_eq!(accept_sequences(&peer)?.len(), 1); Ok(()) } @@ -582,3 +590,33 @@ fn a_write_unacknowledged_when_the_session_is_refused_fails_its_flush() -> Resul ); Ok(()) } + +/// A peer's Disconnect ends the session as surely as a refusal: writes it never +/// acknowledged are lost, and the transport says so. +#[test] +fn a_write_unacknowledged_when_the_peer_disconnects_fails_its_flush() -> Result<()> { + let server = socket()?; + let server_addr = server.local_addr()?; + let mut client = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::client("client", socket()?, server_addr, CONNECTION_ID), + )?; + client.connect(b"hello".to_vec())?; + let mut buffer = vec![0_u8; 65_535]; + let (received, client_addr) = server.recv_from(&mut buffer)?; + let mut server_session = raw_session(CONNECTION_ID); + let accept = + server_session.accept_connect(&decode_rudp_packet(&buffer[..received])?, 0, Vec::new())?; + send_to(&server, client_addr, &accept)?; + let _ = client.receive_once()?; + + let receipt = client.send_reliable("schema", b"never acknowledged".to_vec())?; + send_to(&server, client_addr, &server_session.create_disconnect(b"bye".to_vec()))?; + let _ = client.receive_once()?; + + assert!(client.flush_reliable(Duration::from_millis(200)).is_err()); + assert_eq!( + client.reliable_send_status(&receipt), + CultNetRudpReliableSendStatus::Invalidated + ); + Ok(()) +} diff --git a/packages/cultnet-ts/test/cultnet.test.ts b/packages/cultnet-ts/test/cultnet.test.ts index 0a513cbf..cf4af8c0 100644 --- a/packages/cultnet-ts/test/cultnet.test.ts +++ b/packages/cultnet-ts/test/cultnet.test.ts @@ -2145,20 +2145,30 @@ test("server-mode transport and operation service owe one reliable Accept howeve handler: () => { throw new Error("no requests expected"); }, }); const raw = await bindUdpSocket(); - const accepts = new Set(); - raw.on("message", (wire) => { - const packet = decodeRudpPacket(wire); - if (packet.packetType === "accept" && packet.reliable) accepts.add(packet.sequence); - }); + let received: CultNetRudpPacket[] = []; + raw.on("message", (wire) => received.push(decodeRudpPacket(wire))); + const settle = () => new Promise((resolve) => setTimeout(resolve, 100)); try { - const connect = new CultNetRudpSession({ connectionId }).createConnect(0); for (const port of [udpPort(serverSocket), Number(new URL(service.endpoint).port)]) { - accepts.clear(); + const peer = new CultNetRudpSession({ connectionId }); + const connect = peer.createConnect(0); + received = []; for (let attempt = 0; attempt < 20; attempt += 1) raw.send(encodeRudpPacket(connect), port, "127.0.0.1"); - await new Promise((resolve) => setTimeout(resolve, 100)); - assert.equal(accepts.size, 1, `reliable Accepts sent by port ${port}`); + await settle(); + const accepts = received.filter((p) => p.packetType === "accept"); + assert.equal(new Set(accepts.map((p) => p.sequence)).size, 1, `reliable Accepts sent by port ${port}`); + + // Once the Accept is acknowledged, a repeated Connect is answered with an Ack, never a new Accept. + peer.receive(accepts[0]!, 0); + raw.send(encodeRudpPacket(peer.createAckForReceived(accepts[0]!.sequence)), port, "127.0.0.1"); + await settle(); + received = []; + for (let attempt = 0; attempt < 20; attempt += 1) raw.send(encodeRudpPacket(connect), port, "127.0.0.1"); + await settle(); + assert.equal(received.filter((p) => p.packetType === "accept").length, 0, `Accepts sent by port ${port} after the ack`); + assert.ok(received.some((p) => p.packetType === "ack"), `an Ack from port ${port}`); } - assert.ok(transport.outstandingReliablePacketCount <= 1); + assert.equal(transport.outstandingReliablePacketCount, 0); } finally { raw.close(); transport.close();