Files
CLIProxyAPI/internal/api/response_compression_test.go
JohnsonRan 12f2cafe33 test(api): measure open-stream heap with empty encoder pools
BenchmarkResponseCompressionOpenStreams took its baseline after one GC,
which only moves pooled encoders to the sync.Pool victim cache. Streams
then reused memory the baseline already counted, so heap per open stream
collapsed toward zero once b.N > 1. Run two GC cycles before the baseline
so every sample starts with empty pools.

TestResponseCompressionReusesPooledEncoders now counts encoder creations
and fails when finished encoders are not returned to the pool. It also
interleaves responses whose client writes fail, so an encoder pooled
after an error must still produce correct output.
2026-10-28 04:08:45 +09:00

372 lines
13 KiB
Go

package api
import (
"bufio"
"bytes"
"compress/gzip"
"context"
"io"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"sync"
"testing"
"github.com/gin-gonic/gin"
"github.com/klauspost/compress/zstd"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
"github.com/router-for-me/CLIProxyAPI/v8/internal/httpwire"
log "github.com/sirupsen/logrus"
)
func compressionTestBody(t *testing.T, encoding string, body []byte) []byte {
t.Helper()
var reader io.Reader = bytes.NewReader(body)
switch encoding {
case "gzip":
decoder, errNewReader := gzip.NewReader(reader)
if errNewReader != nil {
t.Fatal(errNewReader)
}
defer func() {
if errClose := decoder.Close(); errClose != nil {
log.Errorf("close test gzip decoder: %v", errClose)
}
}()
reader = decoder
case "zstd":
decoder, errNewReader := zstd.NewReader(reader)
if errNewReader != nil {
t.Fatal(errNewReader)
}
defer decoder.Close()
reader = decoder
}
decoded, errReadAll := io.ReadAll(reader)
if errReadAll != nil {
t.Fatal(errReadAll)
}
return decoded
}
func TestResponseCompression(t *testing.T) {
body := "{\"message\":\"" + strings.Repeat("compressible text ", 128) + "\"}"
for _, tc := range []struct {
name string
accept string
encoding string
body string
contentType string
existingEncoding string
status int
method string
contentLength bool
writeString bool
forceHeader bool
}{
{name: "zstd", accept: "zstd", encoding: "zstd"},
{name: "gzip", accept: "gzip", encoding: "gzip"},
{name: "large_known_length", accept: "gzip", encoding: "gzip", contentLength: true},
{name: "no_accept"},
{name: "identity", accept: "identity"},
{name: "excluded", accept: "gzip;q=0"},
{name: "preference", accept: "gzip;q=1,zstd;q=0.5", encoding: "gzip"},
{name: "preference_tie", accept: "zstd;q=0.5,gzip;q=0.5", encoding: "zstd"},
{name: "small_identity_refused", accept: "gzip, identity;q=0", body: "{}", encoding: "gzip"},
{name: "small_known_length_identity_refused", accept: "gzip, identity;q=0", body: "{}", encoding: "gzip", contentLength: true},
{name: "small_wildcard_identity_refused", accept: "gzip, *;q=0", body: "{}", encoding: "gzip"},
{name: "small_identity_overrides_wildcard", accept: "gzip, *;q=0, identity;q=1", body: "{}"},
{name: "identity_refused_no_encoding", accept: "identity;q=0,*;q=0", body: "{}"},
{name: "wildcard", accept: "*;q=0.5", encoding: "zstd"},
{name: "wildcard_explicit_exclusion", accept: "*;q=1,zstd;q=0", encoding: "gzip"},
{name: "all_excluded", accept: "*;q=1,zstd;q=0,gzip;q=0"},
{name: "invalid_quality", accept: "zstd;q=invalid,gzip;q=2"},
{name: "small", accept: "zstd", body: "{}"},
{name: "small_known_length", accept: "gzip", body: "{}", contentLength: true},
{name: "existing_encoding", accept: "gzip", existingEncoding: "br"},
{name: "binary", accept: "zstd", contentType: "image/png"},
{name: "json_suffix", accept: "gzip", contentType: "application/problem+json; charset=utf-8", encoding: "gzip"},
{name: "partial", accept: "gzip", status: http.StatusPartialContent},
{name: "no_content", accept: "gzip", status: http.StatusNoContent},
{name: "not_modified", accept: "gzip", status: http.StatusNotModified},
{name: "informational", accept: "gzip", status: http.StatusEarlyHints},
{name: "head", accept: "gzip", method: http.MethodHead},
{name: "string_writer", accept: "gzip", encoding: "gzip", writeString: true},
{name: "explicit_header", accept: "gzip", body: "{}", forceHeader: true},
} {
t.Run(tc.name, func(t *testing.T) {
payload := body
if tc.body != "" {
payload = tc.body
}
engine := gin.New()
engine.Use(responseCompressionMiddleware(&config.Config{}))
engine.Any("/", func(c *gin.Context) {
contentType := tc.contentType
if contentType == "" {
contentType = "application/json"
}
c.Header("Content-Type", contentType)
c.Header("Vary", "Origin")
if tc.existingEncoding != "" {
c.Header("Content-Encoding", tc.existingEncoding)
}
if tc.contentLength {
c.Header("Content-Length", strconv.Itoa(len(payload)))
}
if tc.status != 0 {
c.Status(tc.status)
}
if tc.status != 0 && (tc.status < 200 || tc.status == http.StatusNoContent || tc.status == http.StatusNotModified) {
c.Writer.WriteHeaderNow()
return
}
if tc.forceHeader {
c.Writer.WriteHeaderNow()
}
if tc.writeString {
_, _ = io.WriteString(c.Writer, payload)
} else {
if _, errWrite := c.Writer.Write([]byte(payload[:len(payload)/2])); errWrite != nil {
t.Errorf("first write: %v", errWrite)
}
if _, errWrite := c.Writer.Write([]byte(payload[len(payload)/2:])); errWrite != nil {
t.Errorf("second write: %v", errWrite)
}
}
})
method := tc.method
if method == "" {
method = http.MethodGet
}
req := httptest.NewRequest(method, "/", nil)
req.Header.Set("Accept-Encoding", tc.accept)
response := httptest.NewRecorder()
engine.ServeHTTP(response, req)
wantEncoding := tc.encoding
if tc.existingEncoding != "" {
wantEncoding = tc.existingEncoding
}
if got := response.Header().Get("Content-Encoding"); got != wantEncoding {
t.Fatalf("Content-Encoding = %q, want %q", got, wantEncoding)
}
if tc.encoding != "" {
if got := response.Header().Get("Vary"); !strings.Contains(got, "Origin") || !strings.Contains(got, "Accept-Encoding") {
t.Fatalf("Vary = %q", got)
}
if got := response.Header().Get("Content-Length"); got != "" {
t.Fatalf("Content-Length = %q", got)
}
}
if tc.contentLength && tc.encoding == "" && response.Header().Get("Content-Length") != strconv.Itoa(len(payload)) {
t.Fatal("plaintext Content-Length was changed")
}
wantBody := payload
if tc.status != 0 && (tc.status < 200 || tc.status == http.StatusNoContent || tc.status == http.StatusNotModified) {
wantBody = ""
}
if got := string(compressionTestBody(t, tc.encoding, response.Body.Bytes())); got != wantBody {
t.Fatalf("decoded body differs: got %d bytes, want %d", len(got), len(wantBody))
}
})
}
}
func TestResponseCompressionDisabled(t *testing.T) {
disabled := false
for _, cfg := range []*config.Config{nil, {ServerResponseCompression: config.ResponseCompressionConfig{Enabled: &disabled}}} {
engine := gin.New()
engine.Use(responseCompressionMiddleware(cfg))
engine.GET("/", func(c *gin.Context) { c.String(http.StatusOK, strings.Repeat("text", 1024)) })
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.Header.Set("Accept-Encoding", "zstd")
response := httptest.NewRecorder()
engine.ServeHTTP(response, req)
if response.Header().Get("Content-Encoding") != "" {
t.Fatal("disabled middleware compressed response")
}
if got := response.Result().Header.Values("Vary"); len(got) != 0 {
t.Fatalf("disabled middleware added Vary=%q", got)
}
}
}
func TestResponseCompressionWebsocketUpgradeSkipped(t *testing.T) {
engine := gin.New()
var original gin.ResponseWriter
engine.Use(func(c *gin.Context) { original = c.Writer; c.Next() })
engine.Use(responseCompressionMiddleware(&config.Config{}))
engine.GET("/", func(c *gin.Context) {
if c.Writer != original {
t.Error("WebSocket upgrade writer was wrapped")
}
c.String(http.StatusOK, strings.Repeat("text", 1024))
})
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.Header.Set("Upgrade", "websocket")
req.Header.Set("Accept-Encoding", "gzip")
response := httptest.NewRecorder()
engine.ServeHTTP(response, req)
if response.Header().Get("Content-Encoding") != "" {
t.Fatal("WebSocket upgrade response was compressed")
}
if got := response.Result().Header.Values("Vary"); len(got) != 0 {
t.Fatalf("WebSocket upgrade middleware added Vary=%q", got)
}
}
func TestResponseCompressionSSEIncremental(t *testing.T) {
for _, encoding := range []string{"zstd", "gzip"} {
t.Run(encoding, func(t *testing.T) {
advance := make(chan struct{})
engine := gin.New()
engine.Use(responseCompressionMiddleware(&config.Config{}))
events := []string{"data: first\n\n", "data: second\n\n", "data: third\n\n"}
engine.GET("/", func(c *gin.Context) {
c.Header("Content-Type", "text/event-stream")
for _, event := range events {
if _, errWrite := io.WriteString(c.Writer, event); errWrite != nil {
return
}
if errFlush := httpwire.FlushResponse(c.Writer); errFlush != nil {
return
}
select {
case <-advance:
case <-c.Request.Context().Done():
return
}
}
})
server := httptest.NewServer(engine)
defer server.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
req, errNewRequest := http.NewRequestWithContext(ctx, http.MethodGet, server.URL, nil)
if errNewRequest != nil {
t.Fatal(errNewRequest)
}
req.Header.Set("Accept-Encoding", encoding)
response, errDo := server.Client().Do(req)
if errDo != nil {
t.Fatal(errDo)
}
defer func() {
if errClose := response.Body.Close(); errClose != nil {
log.Errorf("close SSE test response: %v", errClose)
}
}()
if got := response.Header.Get("Content-Encoding"); got != encoding {
t.Fatalf("Content-Encoding = %q, want %q", got, encoding)
}
var reader io.Reader = response.Body
if encoding == "gzip" {
decoder, errNewReader := gzip.NewReader(reader)
if errNewReader != nil {
t.Fatal(errNewReader)
}
defer func() {
if errClose := decoder.Close(); errClose != nil {
log.Errorf("close SSE gzip decoder: %v", errClose)
}
}()
reader = decoder
} else {
decoder, errNewReader := zstd.NewReader(reader, zstd.WithDecoderConcurrency(1))
if errNewReader != nil {
t.Fatal(errNewReader)
}
defer decoder.Close()
reader = decoder
}
buffered := bufio.NewReader(reader)
var decoded strings.Builder
for _, event := range events {
line, errReadString := buffered.ReadString('\n')
if errReadString != nil {
t.Fatal(errReadString)
}
blank, errReadBlank := buffered.ReadString('\n')
if errReadBlank != nil {
t.Fatal(errReadBlank)
}
if line+blank != event {
t.Fatalf("event = %q, want %q", line+blank, event)
}
decoded.WriteString(line + blank)
advance <- struct{}{}
}
tail, errReadAll := io.ReadAll(buffered)
if errReadAll != nil {
t.Fatal(errReadAll)
}
decoded.Write(tail)
if decoded.String() != strings.Join(events, "") {
t.Fatal("decoded SSE differs")
}
})
}
}
func TestResponseCompressionReusesPooledEncoders(t *testing.T) {
bodies := []string{
"{\"message\":\"" + strings.Repeat("first response ", 200) + "\"}",
"{\"message\":\"" + strings.Repeat("second, different response ", 150) + "\"}",
}
engine := gin.New()
engine.Use(responseCompressionMiddleware(&config.Config{}))
body := ""
engine.GET("/", func(c *gin.Context) {
c.Data(http.StatusOK, "application/json", []byte(body))
})
for _, encoding := range []string{"zstd", "gzip"} {
original := responseCompressorPools[encoding]
created := 0
responseCompressorPools[encoding] = &sync.Pool{New: func() any { created++; return original.New() }}
t.Cleanup(func() { responseCompressorPools[encoding] = original })
const rounds = 16
for round := 0; round < rounds; round++ {
if round%2 == 1 {
// A failed client write must not poison the encoder handed to the next response.
context, _ := gin.CreateTestContext(httptest.NewRecorder())
context.Header("Content-Type", "application/json")
writer := &responseCompressionWriter{ResponseWriter: &compressionErrorWriter{ResponseWriter: context.Writer}, encoding: encoding, minBytes: 1}
_, _ = writer.WriteString(bodies[0])
writer.finish()
continue
}
body = bodies[(round/2)%len(bodies)]
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.Header.Set("Accept-Encoding", encoding)
rec := httptest.NewRecorder()
engine.ServeHTTP(rec, req)
if got := rec.Header().Get("Content-Encoding"); got != encoding {
t.Fatalf("%s round %d: Content-Encoding = %q", encoding, round, got)
}
if got := string(compressionTestBody(t, encoding, rec.Body.Bytes())); got != body {
t.Fatalf("%s round %d: decoded body mismatch", encoding, round)
}
}
// sync.Pool may drop a Put (randomly under -race), so require reuse rather than one encoder.
if created >= rounds {
t.Fatalf("%s: created %d encoders for %d responses; finished encoders are not reused", encoding, created, rounds)
}
}
}
func TestResponseCompressionWriteAfterFinishFails(t *testing.T) {
for _, encoding := range []string{"zstd", "gzip"} {
context, _ := gin.CreateTestContext(httptest.NewRecorder())
context.Header("Content-Type", "text/event-stream")
writer := &responseCompressionWriter{ResponseWriter: context.Writer, encoding: encoding, minBytes: 1}
if _, errWrite := writer.WriteString("data: one\n\n"); errWrite != nil {
t.Fatal(errWrite)
}
writer.finish()
if _, errWrite := writer.WriteString("data: late\n\n"); errWrite == nil {
t.Fatalf("%s: a write after finish must fail, not go out uncompressed", encoding)
}
}
}