Files
CLIProxyAPI/internal/runtime/executor/codex_websockets_connection_test.go
Luis Pater 064e008b07 feat(codex): add full-chain compression for Codex upstream and downstream traffic
- Compress finalized Codex OAuth request bodies with zstd on the verified ChatGPT backend path, with size/benefit gating, header-body alignment, and one uncompressed retry on 400/415 rejection.
- Negotiate downstream HTTP response compression under server.response-compression (zstd/gzip with q-values, SSE-safe flushing, commit-time Vary merging) and enable negotiated permessage-deflate on Codex and downstream WebSockets.
- Advertise Accept-Encoding to Codex upstreams and decode gzip/deflate/br/zstd upstream responses through a shared decoder before parsing or relaying.

Closes: #6905
2026-10-26 10:09:56 +08:00

133 lines
4.2 KiB
Go

package executor
import (
"bufio"
"bytes"
"context"
"math/rand"
"net"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"github.com/gorilla/websocket"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
log "github.com/sirupsen/logrus"
)
// compressionFrameRecorder observes the first WebSocket frame after HTTP hijacking.
type compressionFrameRecorder struct {
net.Conn
firstByte chan byte
once sync.Once
}
func (c *compressionFrameRecorder) Read(data []byte) (int, error) {
n, errRead := c.Conn.Read(data)
if n > 0 {
c.once.Do(func() { c.firstByte <- data[0] })
}
return n, errRead
}
type compressionHijackRecorder struct {
http.ResponseWriter
firstByte chan byte
}
func (w *compressionHijackRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
conn, buffered, errHijack := w.ResponseWriter.(http.Hijacker).Hijack()
if errHijack != nil {
return nil, nil, errHijack
}
recorder := &compressionFrameRecorder{Conn: conn, firstByte: w.firstByte}
return recorder, bufio.NewReadWriter(bufio.NewReader(recorder), buffered.Writer), nil
}
func TestWebsocketCompressionRoundTrip(t *testing.T) {
enabled, disabled := true, false
for _, provider := range []string{"codex", "xai"} {
for _, tc := range []struct {
name string
cfg *config.Config
want bool
}{
{name: "nil_config", want: true},
{name: "default", cfg: &config.Config{}, want: true},
{name: "enabled", cfg: &config.Config{Codex: config.CodexConfig{WebsocketCompression: &enabled}}, want: true},
{name: "disabled", cfg: &config.Config{Codex: config.CodexConfig{WebsocketCompression: &disabled}}},
} {
t.Run(provider+"/"+tc.name, func(t *testing.T) {
firstByte := make(chan byte, 1)
serverErr := make(chan error, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{EnableCompression: true, ReadBufferSize: 1024}
conn, errUpgrade := upgrader.Upgrade(&compressionHijackRecorder{ResponseWriter: w, firstByte: firstByte}, r, nil)
if errUpgrade != nil {
serverErr <- errUpgrade
return
}
defer func() {
if errClose := conn.Close(); errClose != nil {
log.Errorf("close compression test server websocket: %v", errClose)
}
}()
messageType, payload, errReadMessage := conn.ReadMessage()
if errReadMessage != nil {
serverErr <- errReadMessage
return
}
serverErr <- conn.WriteMessage(messageType, payload)
}))
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
auth := &cliproxyauth.Auth{ProxyURL: "direct"}
var conn *websocket.Conn
var closer *websocketConnectionCloser
var response *http.Response
var errDial error
if provider == "codex" {
conn, closer, response, errDial = NewCodexWebsocketsExecutor(tc.cfg).dialCodexWebsocket(context.Background(), auth, wsURL, nil)
} else {
conn, closer, response, errDial = NewXAIWebsocketsExecutor(tc.cfg).dialXAIWebsocket(context.Background(), auth, wsURL, nil)
}
if errDial != nil {
t.Fatal(errDial)
}
defer func() {
if errClose := closer.Close(); errClose != nil {
log.Errorf("close compression test client websocket: %v", errClose)
}
}()
if !strings.Contains(response.Header.Get("Sec-WebSocket-Extensions"), "permessage-deflate") {
t.Fatal("compression was not negotiated")
}
payload := make([]byte, 96*1024)
random := rand.New(rand.NewSource(6905))
for i := range payload {
payload[i] = byte(' ' + random.Intn(95))
}
if errWriteMessage := conn.WriteMessage(websocket.TextMessage, payload); errWriteMessage != nil {
t.Fatal(errWriteMessage)
}
_, echoed, errReadMessage := conn.ReadMessage()
if errReadMessage != nil {
t.Fatal(errReadMessage)
}
if !bytes.Equal(echoed, payload) {
t.Fatal("large payload echo differs")
}
if errServer := <-serverErr; errServer != nil {
t.Fatal(errServer)
}
if got := (<-firstByte)&0x40 != 0; got != tc.want {
t.Fatalf("frame RSV1 = %v, want %v", got, tc.want)
}
})
}
}
}