hpack_test.go

package http2

import (
	"strings"
	"testing"
)

// TestHPACKEncoderDecoder tests basic HPACK encode/decode
func TestHPACKEncoderDecoder(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	tests := []struct {
		name    string
		headers map[string]string
	}{
		{
			name: "Simple headers",
			headers: map[string]string{
				":method": "GET",
				":path":   "/",
			},
		},
		{
			name: "Common HTTP headers",
			headers: map[string]string{
				":method":      "POST",
				":path":        "/api/users",
				":scheme":      "https",
				":authority":   "example.com",
				"content-type": "application/json",
				"user-agent":   "test/1.0",
			},
		},
		{
			name: "Response headers",
			headers: map[string]string{
				":status":       "200",
				"content-type":  "text/html",
				"cache-control": "max-age=3600",
			},
		},
		{
			name: "Multiple values",
			headers: map[string]string{
				"accept":          "text/html",
				"accept-encoding": "gzip, deflate",
				"accept-language": "en-US,en;q=0.9",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Encode
			encoded, err := encoder.encode(tt.headers)
			if err != nil {
				t.Fatalf("Encode() error = %v", err)
			}

			if len(encoded) == 0 {
				t.Error("Encoded output should not be empty")
			}

			// Decode
			decoded, err := decoder.decode(encoded)
			if err != nil {
				t.Fatalf("Decode() error = %v", err)
			}

			// Verify all headers are present
			for name, value := range tt.headers {
				if decoded[name] != value {
					t.Errorf("Header %s = %s, want %s", name, decoded[name], value)
				}
			}

			// Verify no extra headers
			if len(decoded) != len(tt.headers) {
				t.Errorf("Decoded %d headers, want %d", len(decoded), len(tt.headers))
			}
		})
	}
}

// TestHPACKStaticTableLookup tests static table indexing
func TestHPACKStaticTableLookup(t *testing.T) {
	encoder := newHPACKEncoder()

	tests := []struct {
		name   string
		header string
		value  string
	}{
		{":method", ":method", "GET"},
		{":method POST", ":method", "POST"},
		{":path /", ":path", "/"},
		{":scheme http", ":scheme", "http"},
		{":scheme https", ":scheme", "https"},
		{":status 200", ":status", "200"},
		{":status 404", ":status", "404"},
		{":status 500", ":status", "500"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			headers := map[string]string{
				tt.header: tt.value,
			}

			encoded, err := encoder.encode(headers)
			if err != nil {
				t.Fatalf("Encode() error = %v", err)
			}

			// Static table entries should be very compact (1-2 bytes)
			if len(encoded) > 10 {
				t.Logf("Static table entry encoded to %d bytes (might not be using static table)", len(encoded))
			}
		})
	}
}

// TestHPACKDynamicTable tests dynamic table functionality
func TestHPACKDynamicTable(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	// First request
	headers1 := map[string]string{
		":method":      "GET",
		":path":        "/api/users",
		"custom-header": "custom-value",
	}

	encoded1, err := encoder.encode(headers1)
	if err != nil {
		t.Fatalf("Encode(1) error = %v", err)
	}

	decoded1, err := decoder.decode(encoded1)
	if err != nil {
		t.Fatalf("Decode(1) error = %v", err)
	}

	if decoded1["custom-header"] != "custom-value" {
		t.Error("First decode failed")
	}

	// Second request with same custom header (should use dynamic table)
	headers2 := map[string]string{
		":method":      "POST",
		":path":        "/api/data",
		"custom-header": "custom-value", // Same as before
	}

	encoded2, err := encoder.encode(headers2)
	if err != nil {
		t.Fatalf("Encode(2) error = %v", err)
	}

	decoded2, err := decoder.decode(encoded2)
	if err != nil {
		t.Fatalf("Decode(2) error = %v", err)
	}

	if decoded2["custom-header"] != "custom-value" {
		t.Error("Second decode failed")
	}
}

// TestHPACKEmptyHeaders tests encoding/decoding empty headers
func TestHPACKEmptyHeaders(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	headers := map[string]string{}

	encoded, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}

	decoded, err := decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode() error = %v", err)
	}

	if len(decoded) != 0 {
		t.Errorf("Expected empty headers, got %d", len(decoded))
	}
}

// TestHPACKDecodeEmpty tests decoding empty data
func TestHPACKDecodeEmpty(t *testing.T) {
	decoder := newHPACKDecoder()

	decoded, err := decoder.decode([]byte{})
	if err != nil {
		t.Fatalf("Decode(empty) error = %v", err)
	}

	if len(decoded) != 0 {
		t.Errorf("Expected empty headers, got %d", len(decoded))
	}
}

// TestHPACKPseudoHeadersFirst tests that pseudo-headers come first
func TestHPACKPseudoHeadersFirst(t *testing.T) {
	encoder := newHPACKEncoder()

	headers := map[string]string{
		"content-type": "application/json",
		":method":      "POST",
		"user-agent":   "test/1.0",
		":path":        "/api",
		":scheme":      "https",
	}

	encoded, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}

	// Just verify it encodes without error
	// Order verification would require parsing the encoded bytes
	if len(encoded) == 0 {
		t.Error("Encoded output should not be empty")
	}
}

// TestHPACKEncoderPooling tests encoder pooling
func TestHPACKEncoderPooling(t *testing.T) {
	enc1 := getHPACKEncoder()
	putHPACKEncoder(enc1)

	enc2 := getHPACKEncoder()

	// Should get the same instance from pool
	if enc1 != enc2 {
		t.Log("Got different encoder instance from pool (pool might have created new one)")
	}

	putHPACKEncoder(enc2)
}

// TestHPACKDecoderPooling tests decoder pooling
func TestHPACKDecoderPooling(t *testing.T) {
	dec1 := getHPACKDecoder()
	putHPACKDecoder(dec1)

	dec2 := getHPACKDecoder()

	if dec1 != dec2 {
		t.Log("Got different decoder instance from pool (pool might have created new one)")
	}

	putHPACKDecoder(dec2)
}

// TestHPACKEncoderReset tests encoder reset functionality
func TestHPACKEncoderReset(t *testing.T) {
	encoder := newHPACKEncoder()

	// Encode first headers
	headers1 := map[string]string{
		":method": "GET",
		":path":   "/test",
	}
	_, err := encoder.encode(headers1)
	if err != nil {
		t.Fatalf("Encode(1) error = %v", err)
	}

	// Reset encoder
	encoder.reset()

	// Encode second headers
	headers2 := map[string]string{
		":method": "POST",
		":path":   "/api",
	}
	_, err = encoder.encode(headers2)
	if err != nil {
		t.Fatalf("Encode(2) error = %v", err)
	}
}

// TestHPACKDecoderReset tests decoder reset functionality
func TestHPACKDecoderReset(t *testing.T) {
	decoder := newHPACKDecoder()
	encoder := newHPACKEncoder()

	headers := map[string]string{
		":method": "GET",
		":path":   "/test",
	}
	encoded, _ := encoder.encode(headers)

	_, err := decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode(1) error = %v", err)
	}

	// Reset decoder
	decoder.reset()

	// Decode again
	_, err = decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode(2) error = %v", err)
	}
}

// TestHPACKLargeHeaders tests encoding large headers
func TestHPACKLargeHeaders(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	// Create large header value
	largeValue := strings.Repeat("x", 1000)

	headers := map[string]string{
		":method":      "POST",
		":path":        "/api/data",
		"large-header": largeValue,
	}

	encoded, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}

	decoded, err := decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode() error = %v", err)
	}

	if decoded["large-header"] != largeValue {
		t.Error("Large header value not preserved")
	}
}

// TestHPACKManyHeaders tests encoding many headers
func TestHPACKManyHeaders(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	headers := make(map[string]string)
	headers[":method"] = "GET"
	headers[":path"] = "/"

	// Add 50 custom headers
	for i := 0; i < 50; i++ {
		headers["header-"+string(rune('a'+i%26))+"-"+string(rune('0'+i%10))] = "value-" + string(rune('0'+i%10))
	}

	encoded, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}

	decoded, err := decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode() error = %v", err)
	}

	if len(decoded) != len(headers) {
		t.Errorf("Decoded %d headers, want %d", len(decoded), len(headers))
	}
}

// TestHPACKSpecialCharacters tests headers with special characters
func TestHPACKSpecialCharacters(t *testing.T) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	headers := map[string]string{
		":method":     "GET",
		":path":       "/test?query=value&foo=bar",
		"user-agent":  "Mozilla/5.0 (Windows NT 10.0)",
		"accept":      "text/html,application/json;q=0.9",
		"cookie":      "session=abc123; token=xyz789",
	}

	encoded, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}

	decoded, err := decoder.decode(encoded)
	if err != nil {
		t.Fatalf("Decode() error = %v", err)
	}

	for name, value := range headers {
		if decoded[name] != value {
			t.Errorf("Header %s = %s, want %s", name, decoded[name], value)
		}
	}
}

// TestHPACKSetMaxTableSize tests dynamic table size update
func TestHPACKSetMaxTableSize(t *testing.T) {
	encoder := newHPACKEncoder()

	// Set smaller table size
	encoder.SetMaxTableSize(1024)

	headers := map[string]string{
		":method": "GET",
		":path":   "/test",
	}

	_, err := encoder.encode(headers)
	if err != nil {
		t.Fatalf("Encode() error = %v", err)
	}
}

// BenchmarkHPACKEncode benchmarks HPACK encoding
func BenchmarkHPACKEncode(b *testing.B) {
	encoder := newHPACKEncoder()
	headers := map[string]string{
		":method":      "POST",
		":path":        "/api/users",
		":scheme":      "https",
		":authority":   "api.example.com",
		"content-type": "application/json",
		"user-agent":   "test/1.0",
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = encoder.encode(headers)
	}
}

// BenchmarkHPACKDecode benchmarks HPACK decoding
func BenchmarkHPACKDecode(b *testing.B) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	headers := map[string]string{
		":method":      "POST",
		":path":        "/api/users",
		":scheme":      "https",
		":authority":   "api.example.com",
		"content-type": "application/json",
		"user-agent":   "test/1.0",
	}

	encoded, _ := encoder.encode(headers)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = decoder.decode(encoded)
	}
}

// BenchmarkHPACKRoundtrip benchmarks full encode/decode cycle
func BenchmarkHPACKRoundtrip(b *testing.B) {
	encoder := newHPACKEncoder()
	decoder := newHPACKDecoder()

	headers := map[string]string{
		":method":      "GET",
		":path":        "/",
		"user-agent":   "test/1.0",
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		encoded, _ := encoder.encode(headers)
		_, _ = decoder.decode(encoded)
	}
}

// BenchmarkHPACKPooling benchmarks pooling overhead
func BenchmarkHPACKPooling(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		enc := getHPACKEncoder()
		putHPACKEncoder(enc)
	}
}