ae.net.http.websocket: Add integration tests with Python websockets peer

Add two-phase integration test using Python websockets as an
independent peer implementation:

Phase 1: D client connects to Python echo server, verifying
permessage-deflate is negotiated (ws.deflateEnabled assertion)
and data round-trips correctly.

Phase 2: D server accepts Python client, which verifies
permessage-deflate appears in the negotiated extensions list
and that echo works through the compressed channel.

Both phases confirm compression is actually in use, not just
that uncompressed echo works.

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

Author: claude

flake.nix

@@ -116,9 +116,44 @@
           '';
         };
 
+        # WebSocket test binary - needs HAVE_WS_PEER version flag and zlib
+        websocket-test-bin = pkgs.stdenv.mkDerivation {
+          name = "ae-websocket-test-bin";
+
+          nativeBuildInputs = [ pkgs.ldc pkgs.zlib ];
+          dontStrip = true;
+
+          unpackPhase = ''
+            cp -a ${self} ae
+          '';
+
+          buildPhase = ''
+            echo "Compiling WebSocket tests..."
+
+            # ASOCKETS_DEBUG_IDLE: DO NOT REMOVE - essential for detecting stuck event loops
+            ldc2 \
+              -i \
+              -I. \
+              -g \
+              -d-debug=ae_unittest \
+              -d-debug=ASOCKETS_DEBUG_IDLE \
+              -d-version=HAVE_WS_PEER \
+              -unittest \
+              --main \
+              -of=ws_test \
+              -L=-lz \
+              ae/net/http/websocket.d
+          '';
+
+          installPhase = ''
+            mkdir -p $out/bin
+            cp ws_test $out/bin/
+          '';
+        };
+
       in {
         packages = {
-          inherit mysql-test-bin psql-test-bin;
+          inherit mysql-test-bin psql-test-bin websocket-test-bin;
         };
 
         checks = {
@@ -265,6 +300,89 @@
               touch $out
             '';
           };
+
+          # WebSocket integration tests (with Python websockets peer)
+          websocket = pkgs.stdenv.mkDerivation {
+            name = "ae-websocket-test";
+            src = self;
+
+            nativeBuildInputs = [
+              websocket-test-bin
+              (pkgs.python3.withPackages (ps: [ ps.websockets ]))
+            ];
+
+            buildPhase = ''
+              export HOME="$TMPDIR"
+
+              echo "=== Phase 1: D client with Python server ==="
+
+              # Start Python WebSocket echo server (permessage-deflate enabled by default)
+              python3 << 'PYEOF' &
+import asyncio, websockets
+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", 18765):
+        await asyncio.Future()
+asyncio.run(main())
+PYEOF
+              PY_PID=$!
+
+              # Wait for Python server to be ready
+              for i in $(seq 1 30); do
+                if python3 -c "import socket; s = socket.create_connection(('127.0.0.1', 18765), timeout=1); s.close()" 2>/dev/null; then
+                  break
+                fi
+                sleep 0.5
+              done
+
+              echo "Python server ready, running D client test..."
+              WS_TEST_MODE=client WS_SERVER_PORT=18765 ws_test
+              echo "D client test passed!"
+
+              kill $PY_PID || true
+              wait $PY_PID 2>/dev/null || true
+
+              echo "=== Phase 2: D server with Python client ==="
+
+              # Start D WebSocket echo server
+              WS_TEST_MODE=server WS_PORT=18766 WS_READY_FILE="$TMPDIR/ws_ready" ws_test &
+              D_PID=$!
+
+              # Wait for D server to be ready
+              for i in $(seq 1 30); do
+                if [ -f "$TMPDIR/ws_ready" ]; then
+                  break
+                fi
+                sleep 0.5
+              done
+
+              echo "D server ready, running Python client test..."
+              python3 << 'PYEOF'
+import asyncio, websockets
+async def main():
+    async with websockets.connect("ws://127.0.0.1:18766") as ws:
+        # Verify permessage-deflate was negotiated
+        ext_names = [e.name for e in ws.extensions]
+        assert "permessage-deflate" in ext_names, f"Expected permessage-deflate, got: {ext_names}"
+        await ws.send("Hello from Python client")
+        response = await ws.recv()
+        assert response == b"Hello from Python client", f"Expected echo, got: {response!r}"
+        print("Python client: echo verified with compression!")
+asyncio.run(main())
+PYEOF
+              echo "Python client test passed!"
+
+              # Wait for D server to exit (closes after client disconnects)
+              wait $D_PID
+              echo "All WebSocket integration tests passed!"
+            '';
+
+            installPhase = ''
+              touch $out
+            '';
+          };
         };
 
         devShells.default = pkgs.mkShell {

net/http/websocket.d

@@ -830,6 +830,77 @@ debug(ae_unittest) unittest
 	assert(ok);
 }
 
+version (HAVE_WS_PEER)
+static if (haveZlib)
+debug(ae_unittest) unittest
+{
+	// Integration test: D client connects to external WebSocket echo server.
+	// The peer server must support permessage-deflate (RFC 7692).
+	import std.process : environment;
+	if (environment.get("WS_TEST_MODE", "") != "client") return;
+
+	import ae.net.asockets : socketManager;
+
+	auto port = environment.get("WS_SERVER_PORT", "18765");
+
+	bool ok;
+	connectWebSocket(
+		"ws://127.0.0.1:" ~ port ~ "/",
+		(WebSocketAdapter ws) {
+			assert(ws.deflateEnabled, "permessage-deflate was not negotiated with server");
+			ws.handleReadData = (Data data) {
+				assert(data.toGC() == "Hello from D client");
+				ok = true;
+				ws.disconnect("Test complete");
+			};
+			ws.send(Data("Hello from D client".asBytes));
+		},
+		(string error) {
+			assert(false, "WebSocket connection failed: " ~ error);
+		},
+	);
+
+	socketManager.loop();
+	assert(ok);
+}
+
+version (HAVE_WS_PEER)
+static if (haveZlib)
+debug(ae_unittest) unittest
+{
+	// Integration test: D server accepts connection from external WebSocket client.
+	// The peer client must support permessage-deflate (RFC 7692).
+	import std.process : environment;
+	if (environment.get("WS_TEST_MODE", "") != "server") return;
+
+	import ae.net.http.server : HttpServer;
+	import ae.net.asockets : socketManager;
+	import ae.sys.timing : setTimeout;
+
+	auto s = new HttpServer;
+	bool ok;
+	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) {
+			ok = true;
+			ws.send(data); // echo
+		};
+		ws.handleDisconnect = (string reason, DisconnectType type) {
+			setTimeout({ s.close(); }, 0.seconds);
+		};
+	};
+	auto port = environment.get("WS_PORT", "18766").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"), "ready");
+
+	socketManager.loop();
+	assert(ok);
+}
+
 static if (haveZlib)
 debug(ae_unittest) unittest
 {