integration_test.go

package http2

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"
	"testing"
)

// TestConvertHTTPRequest tests request conversion from http.Request to http2.Request
func TestConvertHTTPRequest(t *testing.T) {
	tests := []struct {
		name         string
		method       string
		urlStr       string
		headers      map[string]string
		body         string
		wantMethod   string
		wantPath     string
		wantScheme   string
	}{
		{
			name:       "Simple GET",
			method:     "GET",
			urlStr:     "http://example.com/path",
			wantMethod: "GET",
			wantPath:   "/path",
			wantScheme: "http",
		},
		{
			name:       "GET with query",
			method:     "GET",
			urlStr:     "https://api.example.com/users?id=123&name=test",
			wantMethod: "GET",
			wantPath:   "/users?id=123&name=test",
			wantScheme: "https",
		},
		{
			name:       "POST with body",
			method:     "POST",
			urlStr:     "http://example.com/api/data",
			body:       `{"key":"value"}`,
			wantMethod: "POST",
			wantPath:   "/api/data",
			wantScheme: "http",
		},
		{
			name:       "Root path",
			method:     "GET",
			urlStr:     "http://example.com",
			wantMethod: "GET",
			wantPath:   "/",
			wantScheme: "http",
		},
		{
			name:       "PUT request",
			method:     "PUT",
			urlStr:     "https://example.com/resource/123",
			wantMethod: "PUT",
			wantPath:   "/resource/123",
			wantScheme: "https",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var bodyReader io.Reader
			if tt.body != "" {
				bodyReader = strings.NewReader(tt.body)
			}

			req, err := http.NewRequest(tt.method, tt.urlStr, bodyReader)
			if err != nil {
				t.Fatalf("NewRequest() error = %v", err)
			}

			if tt.headers != nil {
				for k, v := range tt.headers {
					req.Header.Set(k, v)
				}
			}

			http2Req, err := ConvertHTTPRequest(req)
			if err != nil {
				t.Fatalf("ConvertHTTPRequest() error = %v", err)
			}

			if http2Req.Method != tt.wantMethod {
				t.Errorf("Method = %s, want %s", http2Req.Method, tt.wantMethod)
			}
			if http2Req.Path != tt.wantPath {
				t.Errorf("Path = %s, want %s", http2Req.Path, tt.wantPath)
			}
			if http2Req.Scheme != tt.wantScheme {
				t.Errorf("Scheme = %s, want %s", http2Req.Scheme, tt.wantScheme)
			}
			if tt.body != "" && string(http2Req.Body) != tt.body {
				t.Errorf("Body = %s, want %s", http2Req.Body, tt.body)
			}
		})
	}
}

// TestConvertHTTPRequestHeaders tests header conversion
func TestConvertHTTPRequestHeaders(t *testing.T) {
	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
	req.Header.Set("User-Agent", "test-agent/1.0")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Connection", "keep-alive") // Should be filtered out

	http2Req, err := ConvertHTTPRequest(req)
	if err != nil {
		t.Fatalf("ConvertHTTPRequest() error = %v", err)
	}

	// Headers should be lowercase
	if http2Req.Headers["user-agent"] != "test-agent/1.0" {
		t.Errorf("user-agent header not converted properly")
	}
	if http2Req.Headers["accept"] != "application/json" {
		t.Errorf("accept header not converted properly")
	}

	// Connection-specific headers should be filtered
	if _, exists := http2Req.Headers["connection"]; exists {
		t.Error("connection header should be filtered out")
	}
}

// TestConvertHTTPResponse tests response conversion
func TestConvertHTTPResponse(t *testing.T) {
	originalReq, _ := http.NewRequest("GET", "http://example.com/test", nil)

	tests := []struct {
		name           string
		statusCode     int
		headers        map[string]string
		body           []byte
		wantStatus     string
		wantStatusCode int
	}{
		{
			name:           "200 OK",
			statusCode:     200,
			body:           []byte("success"),
			wantStatus:     "200 OK",
			wantStatusCode: 200,
		},
		{
			name:           "404 Not Found",
			statusCode:     404,
			body:           []byte("not found"),
			wantStatus:     "404 Not Found",
			wantStatusCode: 404,
		},
		{
			name:           "500 Internal Server Error",
			statusCode:     500,
			body:           []byte("error"),
			wantStatus:     "500 Internal Server Error",
			wantStatusCode: 500,
		},
		{
			name:           "204 No Content",
			statusCode:     204,
			body:           []byte{},
			wantStatus:     "204 No Content",
			wantStatusCode: 204,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			http2Resp := &Response{
				StatusCode: tt.statusCode,
				Headers:    tt.headers,
				Body:       tt.body,
			}

			httpResp, err := ConvertHTTPResponse(http2Resp, originalReq)
			if err != nil {
				t.Fatalf("ConvertHTTPResponse() error = %v", err)
			}

			if httpResp.StatusCode != tt.wantStatusCode {
				t.Errorf("StatusCode = %d, want %d", httpResp.StatusCode, tt.wantStatusCode)
			}
			if httpResp.Status != tt.wantStatus {
				t.Errorf("Status = %s, want %s", httpResp.Status, tt.wantStatus)
			}
			if httpResp.Proto != "HTTP/2.0" {
				t.Errorf("Proto = %s, want HTTP/2.0", httpResp.Proto)
			}
			if httpResp.ProtoMajor != 2 {
				t.Errorf("ProtoMajor = %d, want 2", httpResp.ProtoMajor)
			}
			if httpResp.ProtoMinor != 0 {
				t.Errorf("ProtoMinor = %d, want 0", httpResp.ProtoMinor)
			}

			// Read and verify body
			bodyBytes, _ := io.ReadAll(httpResp.Body)
			if !bytes.Equal(bodyBytes, tt.body) {
				t.Errorf("Body = %s, want %s", bodyBytes, tt.body)
			}
		})
	}
}

// TestConvertHTTPResponseHeaders tests response header conversion
func TestConvertHTTPResponseHeaders(t *testing.T) {
	originalReq, _ := http.NewRequest("GET", "http://example.com/test", nil)

	http2Resp := &Response{
		StatusCode: 200,
		Headers: map[string]string{
			"content-type":   "application/json",
			"cache-control":  "no-cache",
			":status":        "200", // Pseudo-header should be filtered
		},
		Body: []byte{},
	}

	httpResp, err := ConvertHTTPResponse(http2Resp, originalReq)
	if err != nil {
		t.Fatalf("ConvertHTTPResponse() error = %v", err)
	}

	// Regular headers should be present
	if httpResp.Header.Get("content-type") != "application/json" {
		t.Error("content-type header missing or incorrect")
	}
	if httpResp.Header.Get("cache-control") != "no-cache" {
		t.Error("cache-control header missing or incorrect")
	}

	// Pseudo-headers should be filtered
	if httpResp.Header.Get(":status") != "" {
		t.Error("pseudo-header :status should be filtered out")
	}
}

// TestIsConnectionSpecificHeader tests connection-specific header detection
func TestIsConnectionSpecificHeader(t *testing.T) {
	tests := []struct {
		header   string
		expected bool
	}{
		{"connection", true},
		{"keep-alive", true},
		{"proxy-connection", true},
		{"transfer-encoding", true},
		{"upgrade", true},
		{"content-type", false},
		{"user-agent", false},
		{"accept", false},
	}

	for _, tt := range tests {
		t.Run(tt.header, func(t *testing.T) {
			result := isConnectionSpecific(tt.header)
			if result != tt.expected {
				t.Errorf("isConnectionSpecific(%s) = %v, want %v", tt.header, result, tt.expected)
			}
		})
	}
}

// TestNewHTTPRequest tests HTTP request creation helpers
func TestNewHTTPRequest(t *testing.T) {
	tests := []struct {
		name   string
		method string
		url    string
		body   string
	}{
		{"GET", "GET", "http://example.com", ""},
		{"POST", "POST", "http://example.com/api", `{"data":"test"}`},
		{"PUT", "PUT", "http://example.com/resource", "update data"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var bodyReader io.Reader
			if tt.body != "" {
				bodyReader = strings.NewReader(tt.body)
			}

			req, err := NewHTTPRequest(tt.method, tt.url, bodyReader)
			if err != nil {
				t.Fatalf("NewHTTPRequest() error = %v", err)
			}

			if req.Method != tt.method {
				t.Errorf("Method = %s, want %s", req.Method, tt.method)
			}
			if req.URL.String() != tt.url {
				t.Errorf("URL = %s, want %s", req.URL.String(), tt.url)
			}
		})
	}
}

// TestNewHTTPRequestWithContext tests context-aware request creation
func TestNewHTTPRequestWithContext(t *testing.T) {
	ctx := context.Background()
	req, err := NewHTTPRequestWithContext(ctx, "GET", "http://example.com", nil)

	if err != nil {
		t.Fatalf("NewHTTPRequestWithContext() error = %v", err)
	}
	if req.Context() != ctx {
		t.Error("Request context not set correctly")
	}
}

// TestNewGetRequest tests GET request helper
func TestNewGetRequest(t *testing.T) {
	req, err := NewGetRequest("http://example.com/api/users")
	if err != nil {
		t.Fatalf("NewGetRequest() error = %v", err)
	}

	if req.Method != "GET" {
		t.Errorf("Method = %s, want GET", req.Method)
	}
	if req.Body != nil {
		t.Error("GET request should have nil body")
	}
}

// TestNewPostRequest tests POST request helper
func TestNewPostRequest(t *testing.T) {
	jsonBody := []byte(`{"name":"test","value":123}`)
	req, err := NewPostRequest("http://example.com/api/data", jsonBody)

	if err != nil {
		t.Fatalf("NewPostRequest() error = %v", err)
	}
	if req.Method != "POST" {
		t.Errorf("Method = %s, want POST", req.Method)
	}
	if req.Header.Get("Content-Type") != "application/json" {
		t.Error("Content-Type should be application/json")
	}

	bodyBytes, _ := io.ReadAll(req.Body)
	if !bytes.Equal(bodyBytes, jsonBody) {
		t.Errorf("Body = %s, want %s", bodyBytes, jsonBody)
	}
}

// TestNewPostFormRequest tests form POST request helper
func TestNewPostFormRequest(t *testing.T) {
	formData := url.Values{
		"username": []string{"testuser"},
		"password": []string{"testpass"},
	}

	req, err := NewPostFormRequest("http://example.com/login", formData)
	if err != nil {
		t.Fatalf("NewPostFormRequest() error = %v", err)
	}

	if req.Method != "POST" {
		t.Errorf("Method = %s, want POST", req.Method)
	}
	if req.Header.Get("Content-Type") != "application/x-www-form-urlencoded" {
		t.Error("Content-Type should be application/x-www-form-urlencoded")
	}

	bodyBytes, _ := io.ReadAll(req.Body)
	bodyStr := string(bodyBytes)
	if !strings.Contains(bodyStr, "username=testuser") {
		t.Error("Form data should contain username")
	}
	if !strings.Contains(bodyStr, "password=testpass") {
		t.Error("Form data should contain password")
	}
}

// TestConvertRequestWithMultipleHeaderValues tests header value joining
func TestConvertRequestWithMultipleHeaderValues(t *testing.T) {
	req, _ := http.NewRequest("GET", "http://example.com", nil)
	req.Header.Add("Accept", "text/html")
	req.Header.Add("Accept", "application/json")

	http2Req, err := ConvertHTTPRequest(req)
	if err != nil {
		t.Fatalf("ConvertHTTPRequest() error = %v", err)
	}

	// Multiple values should be joined with comma
	acceptHeader := http2Req.Headers["accept"]
	if !strings.Contains(acceptHeader, "text/html") || !strings.Contains(acceptHeader, "application/json") {
		t.Errorf("Accept header = %s, should contain both values", acceptHeader)
	}
}

// TestConvertResponseWithMultipleHeaderValues tests header value splitting
func TestConvertResponseWithMultipleHeaderValues(t *testing.T) {
	originalReq, _ := http.NewRequest("GET", "http://example.com", nil)

	http2Resp := &Response{
		StatusCode: 200,
		Headers: map[string]string{
			"set-cookie": "session=abc123, token=xyz789",
		},
		Body: []byte{},
	}

	httpResp, err := ConvertHTTPResponse(http2Resp, originalReq)
	if err != nil {
		t.Fatalf("ConvertHTTPResponse() error = %v", err)
	}

	// Multiple values should be split
	cookies := httpResp.Header.Values("set-cookie")
	if len(cookies) != 2 {
		t.Errorf("Expected 2 set-cookie headers, got %d", len(cookies))
	}
}

// TestConvertRequestBodyRestoration tests that request body is restored after reading
func TestConvertRequestBodyRestoration(t *testing.T) {
	bodyContent := "test body content"
	req, _ := http.NewRequest("POST", "http://example.com", strings.NewReader(bodyContent))

	_, err := ConvertHTTPRequest(req)
	if err != nil {
		t.Fatalf("ConvertHTTPRequest() error = %v", err)
	}

	// Body should be restored for retries
	restoredBody, _ := io.ReadAll(req.Body)
	if string(restoredBody) != bodyContent {
		t.Errorf("Body not restored: got %s, want %s", restoredBody, bodyContent)
	}
}

// BenchmarkConvertHTTPRequest benchmarks request conversion
func BenchmarkConvertHTTPRequest(b *testing.B) {
	req, _ := http.NewRequest("POST", "http://example.com/api/users", strings.NewReader(`{"name":"test"}`))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("User-Agent", "test/1.0")

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = ConvertHTTPRequest(req)
	}
}

// BenchmarkConvertHTTPResponse benchmarks response conversion
func BenchmarkConvertHTTPResponse(b *testing.B) {
	originalReq, _ := http.NewRequest("GET", "http://example.com", nil)
	http2Resp := &Response{
		StatusCode: 200,
		Headers: map[string]string{
			"content-type":  "application/json",
			"cache-control": "no-cache",
		},
		Body: []byte(`{"result":"success"}`),
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = ConvertHTTPResponse(http2Resp, originalReq)
	}
}