Commit872c88a0Recorded4 Sep 2026Repositorysigil-websocket
Add a regression test for the nowait-only pump with no scheduler
Message
Drives the shape that stalled: no with-async, a bounded upgrade-timeout-ms, and a poll loop whose only read primitive is ws-receive-nowait. The server sends its text frame AFTER the 101 rather than coalesced with it, so the payload is reachable only through nowait's own non-blocking socket read -- a coalesced frame lands in the connection buffer during the handshake and would pass even with the read disabled, which is what hid this defect.
Plain ws:// on purpose. The guard was never about TLS, so the test needs no certificate and no openssl on PATH (openssl is absent from the bare PATH on this estate's hosts, which is enough on its own to keep it out of a gate).
The harness distinguishes SETUP-FAILED from a regression: if the server never managed to send its frame, the client's silence says nothing about the client and must not be scored as a pass or as a failure of the code under test.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AbXvyDXoTUyqV1tb1fkeFa
Changed
test/integration/nowait-pump-client.sgl | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
test/integration/test-native-websocket-nowait-pump.mjs | 93 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
test/integration/test-native-websocket-nowait-pump.sh | 3 +++
3 files changed, 150 insertions(+)Diff
test/integration/nowait-pump-client.sgladded
@@ -0,0 +1,54 @@
+1
;;; Regression: a nowait-only pump with NO scheduler must still hear the peer.+2
;;;+3
;;; This is the shape `slate node init` uses, and the shape that stalled: no+4
;;; `with-async`, a bounded `upgrade-timeout-ms`, and a poll loop whose only+5
;;; read primitive is `ws-receive-nowait`. `ws-connect` puts the transport in+6
;;; non-blocking mode whenever a scheduler OR an upgrade timeout is present,+7
;;; so nowait's single socket read is safe here -- but it used to be gated on+8
;;; `(current-scheduler)` alone, which denied it, and the pump went deaf while+9
;;; the server's frame sat unread in the kernel receive queue.+10
;;;+11
;;; The server sends its frame AFTER the 101, deliberately not coalesced with+12
;;; it: a coalesced frame lands in `ws-connection-buffer` during the handshake+13
;;; and would be decodable without any socket read at all, which is exactly+14
;;; the case that hid this defect.+15
;;;+16
;;; Nothing here is TLS-specific. The guard was never about TLS, and this runs+17
;;; over plain `ws://` so it needs no certificate and no `openssl` on PATH.+18
(import (sigil core)+19
(sigil time)+20
(sigil websocket))+21
+22
(define port+23
(or (and (getenv "SIGIL_WS_TEST_PORT")+24
(string->number (getenv "SIGIL_WS_TEST_PORT")))+25
(error "nowait pump client requires SIGIL_WS_TEST_PORT")))+26
+27
(define conn+28
(ws-connect (string-append "ws://127.0.0.1:" (number->string port) "/")+29
connect-timeout-ms: 5000+30
handshake-timeout-ms: 5000+31
upgrade-timeout-ms: 5000))+32
+33
(unless conn+34
(error "nowait pump client: upgrade did not complete"))+35
+36
;; Deliberately NOT inside with-async: the absence of a scheduler is the+37
;; condition under test, so wrapping this would silently retire the regression.+38
(define deadline (+ (current-milliseconds) 5000))+39
+40
(let loop ()+41
(let ((msg (ws-receive-nowait conn)))+42
(cond+43
((ws-message? msg)+44
(unless (string=? (ws-message-data msg) "HELLO-FROM-SERVER")+45
(error "nowait pump client: unexpected payload" (ws-message-data msg)))+46
(display "native-websocket-nowait-pump-ok")+47
(newline))+48
((eq? msg 'closed)+49
(error "nowait pump client: connection closed before the frame arrived"))+50
((> (current-milliseconds) deadline)+51
(error "nowait pump client: no frame after 5000ms (nowait pump went deaf)"))+52
(else+53
(sleep 0.05)+54
(loop)))))test/integration/test-native-websocket-nowait-pump.mjsadded
@@ -0,0 +1,93 @@
+1
// Regression harness for the nowait-only pump with no scheduler.+2
//+3
// Completes a real WebSocket upgrade, then sends ONE text frame after a delay+4
// so it cannot be coalesced with the 101. A client that never issues a socket+5
// read will never see it; the frame is only reachable through nowait's own+6
// single non-blocking read.+7
//+8
// Plain TCP on purpose: the defect was in a `(current-scheduler)` guard, not+9
// in TLS, so this needs no certificate and no `openssl` on PATH.+10
import crypto from "node:crypto";+11
import net from "node:net";+12
import path from "node:path";+13
import { fileURLToPath } from "node:url";+14
import { spawn } from "node:child_process";+15
+16
const here = path.dirname(fileURLToPath(import.meta.url));+17
const repo = path.resolve(here, "../..");+18
const PAYLOAD = "HELLO-FROM-SERVER";+19
const FRAME_DELAY_MS = 300;+20
+21
function textFrame(text) {+22
const payload = Buffer.from(text, "utf8");+23
if (payload.length >= 126) throw new Error("fixture payload is unexpectedly large");+24
return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);+25
}+26
+27
let sentFrame = false;+28
const server = net.createServer((socket) => {+29
let buffer = Buffer.alloc(0);+30
socket.on("data", (chunk) => {+31
buffer = Buffer.concat([buffer, chunk]);+32
const end = buffer.indexOf("\r\n\r\n");+33
if (end < 0) return;+34
const request = buffer.subarray(0, end + 4).toString("ascii");+35
const key = request.match(/Sec-WebSocket-Key:\s*([^\r\n]+)/i)?.[1];+36
if (!key) throw new Error("client handshake omitted Sec-WebSocket-Key");+37
const accept = crypto.createHash("sha1")+38
.update(`${key.trim()}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)+39
.digest("base64");+40
// The 101 goes out ALONE. Coalescing the frame with it would put the+41
// payload in the connection buffer during the handshake and the test+42
// would pass without any socket read ever happening.+43
socket.write(Buffer.from(+44
`HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`,+45
"ascii",+46
));+47
buffer = Buffer.alloc(0);+48
setTimeout(() => {+49
socket.write(textFrame(PAYLOAD));+50
sentFrame = true;+51
}, FRAME_DELAY_MS);+52
});+53
socket.on("error", () => {});+54
});+55
+56
let resolvePort;+57
const listening = new Promise((resolve) => { resolvePort = resolve; });+58
server.listen(0, "127.0.0.1", () => resolvePort(server.address().port));+59
const port = await listening;+60
+61
const dependencyRoots = [+62
"sigil-stdlib", "sigil-socket", "sigil-tls", "sigil-crypto",+63
].map((name) => path.join(repo, ".sigil", "deps", name, "src"));+64
const args = [+65
"-L", path.join(repo, "build/dev/lib"),+66
...dependencyRoots.flatMap((root) => ["-L", root]),+67
path.join(here, "nowait-pump-client.sgl"),+68
];+69
const child = spawn("sigil", args, {+70
cwd: "/tmp",+71
env: { ...process.env, SIGIL_WS_TEST_PORT: String(port) },+72
stdio: ["ignore", "pipe", "pipe"],+73
});+74
let stdout = "";+75
let stderr = "";+76
child.stdout.on("data", (chunk) => { stdout += chunk; });+77
child.stderr.on("data", (chunk) => { stderr += chunk; });+78
+79
const timeout = setTimeout(() => child.kill("SIGKILL"), 15000);+80
const status = await new Promise((resolve) => child.on("close", resolve));+81
clearTimeout(timeout);+82
server.close();+83
+84
// Positive control on the apparatus: if the server never got far enough to+85
// send the frame, the client's silence says nothing about the client. That+86
// must read as a setup failure, not as a regression.+87
if (!sentFrame) {+88
throw new Error(`SETUP-FAILED: server never sent its frame, so this run tests nothing\nstdout:\n${stdout}\nstderr:\n${stderr}`);+89
}+90
if (status !== 0 || !stdout.includes("native-websocket-nowait-pump-ok")) {+91
throw new Error(`nowait pump client failed (${status})\nstdout:\n${stdout}\nstderr:\n${stderr}`);+92
}+93
console.log("native-websocket-nowait-pump-integration-ok");test/integration/test-native-websocket-nowait-pump.shadded
@@ -0,0 +1,3 @@
+1
#!/usr/bin/env bash+2
set -eu+3
exec node test/integration/test-native-websocket-nowait-pump.mjs