ae.net.http.websocket: Add no_context_takeover integration tests

Add two integration test phases (3 and 4) that exercise the
no_context_takeover code path with Python websockets configured
to request server_no_context_takeover and client_no_context_takeover.

Each test sends 3 messages through the echo loop. If the zlib stream
reset is not happening between messages, the second message fails
to decompress because the contexts are out of sync.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: claude

flake.nix

@@ -409,6 +409,80 @@ PYEOF
               echo "Python client test passed!"
 
               # Wait for D server to exit (closes after client disconnects)
+              wait $D_PID
+
+              echo "=== Phase 3: D client with Python server (no_context_takeover) ==="
+
+              # Start Python echo server with no_context_takeover
+              python3 << 'PYEOF' &
+import asyncio, websockets
+from websockets.extensions.permessage_deflate import ServerPerMessageDeflateFactory
+async def echo(ws):
+    async for msg in ws:
+        await ws.send(msg)
+async def main():
+    async with websockets.serve(
+        echo, "127.0.0.1", 18768,
+        extensions=[ServerPerMessageDeflateFactory(
+            server_no_context_takeover=True,
+            client_no_context_takeover=True,
+        )],
+    ):
+        await asyncio.Future()
+asyncio.run(main())
+PYEOF
+              PY_PID=$!
+
+              for i in $(seq 1 30); do
+                if python3 -c "import socket; s = socket.create_connection(('127.0.0.1', 18768), timeout=1); s.close()" 2>/dev/null; then
+                  break
+                fi
+                sleep 0.5
+              done
+
+              echo "Python server (no_context_takeover) ready, running D client test..."
+              WS_TEST_MODE=client_nctx WS_SERVER_PORT=18768 ws_test
+              echo "D client no_context_takeover test passed!"
+
+              kill $PY_PID || true
+              wait $PY_PID 2>/dev/null || true
+
+              echo "=== Phase 4: D server with Python client (no_context_takeover) ==="
+
+              WS_TEST_MODE=server_nctx WS_PORT=18767 WS_READY_FILE="$TMPDIR/ws_ready_nctx" ws_test &
+              D_PID=$!
+
+              for i in $(seq 1 30); do
+                if [ -f "$TMPDIR/ws_ready_nctx" ]; then
+                  break
+                fi
+                sleep 0.5
+              done
+
+              echo "D server ready, running Python client (no_context_takeover) test..."
+              python3 << 'PYEOF'
+import asyncio, websockets
+from websockets.extensions.permessage_deflate import ClientPerMessageDeflateFactory
+async def main():
+    async with websockets.connect(
+        "ws://127.0.0.1:18767",
+        extensions=[ClientPerMessageDeflateFactory(
+            server_no_context_takeover=True,
+            client_no_context_takeover=True,
+        )],
+    ) as ws:
+        ext_names = [e.name for e in ws.protocol.extensions]
+        assert "permessage-deflate" in ext_names, f"Expected permessage-deflate, got: {ext_names}"
+        messages = ["Message one", "Message two", "Message three"]
+        for msg in messages:
+            await ws.send(msg)
+            response = await ws.recv()
+            assert response == msg.encode(), f"Expected {msg!r}, got: {response!r}"
+        print("Python client: no_context_takeover echo verified!")
+asyncio.run(main())
+PYEOF
+              echo "Python client no_context_takeover test passed!"
+
               wait $D_PID
               echo "All WebSocket integration tests passed!"
             '';

net/http/websocket.d

@@ -985,3 +985,85 @@ debug(ae_unittest) unittest
 	socketManager.loop();
 	assert(ok);
 }
+
+version (HAVE_WS_PEER)
+static if (haveZlib)
+debug(ae_unittest) unittest
+{
+	// Integration test: D client connects to external echo server configured
+	// with no_context_takeover. Multiple messages are sent to verify that
+	// the zlib stream is properly reset between messages.
+	import std.process : environment;
+	if (environment.get("WS_TEST_MODE", "") != "client_nctx") return;
+
+	import ae.net.asockets : socketManager;
+
+	auto port = environment.get("WS_SERVER_PORT", "18765");
+	enum messages = ["Message one", "Message two", "Message three"];
+	int received;
+
+	bool ok;
+	connectWebSocket(
+		"ws://127.0.0.1:" ~ port ~ "/",
+		(WebSocketAdapter ws) {
+			assert(ws.deflateEnabled, "permessage-deflate was not negotiated");
+			ws.handleReadData = (Data data) {
+				assert(data.toGC() == messages[received], "Echo mismatch on message " ~ received.to!string);
+				received++;
+				if (received < messages.length)
+					ws.send(Data(messages[received].asBytes));
+				else
+				{
+					ok = true;
+					ws.disconnect("Test complete");
+				}
+			};
+			ws.send(Data(messages[0].asBytes));
+		},
+		(string error) {
+			assert(false, "WebSocket connection failed: " ~ error);
+		},
+	);
+
+	socketManager.loop();
+	assert(ok);
+	assert(received == messages.length);
+}
+
+version (HAVE_WS_PEER)
+static if (haveZlib)
+debug(ae_unittest) unittest
+{
+	// Integration test: D server accepts connection from external client
+	// configured with no_context_takeover. Multiple messages verify that
+	// the zlib stream is properly reset between messages.
+	import std.process : environment;
+	if (environment.get("WS_TEST_MODE", "") != "server_nctx") return;
+
+	import ae.net.http.server : HttpServer;
+	import ae.net.asockets : socketManager;
+	import ae.sys.timing : setTimeout;
+
+	auto s = new HttpServer;
+	int received;
+	s.handleRequest = (HttpRequest request, HttpServerConnection serverConn) {
+		auto ws = accept(request, serverConn);
+		assert(ws.deflateEnabled, "permessage-deflate was not negotiated with client");
+		ws.handleReadData = (Data data) {
+			received++;
+			ws.send(data); // echo
+		};
+		ws.handleDisconnect = (string reason, DisconnectType type) {
+			setTimeout({ s.close(); }, 0.seconds);
+		};
+	};
+	auto port = environment.get("WS_PORT", "18767").to!ushort;
+	s.listen(port, "127.0.0.1");
+
+	// Signal readiness to the test harness
+	import std.file : fileWrite = write;
+	fileWrite(environment.get("WS_READY_FILE", "/tmp/ws_ready_nctx"), "ready");
+
+	socketManager.loop();
+	assert(received == 3, "Expected 3 messages, got " ~ received.to!string);
+}