@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/httpclient/client_test.go

@@ -0,0 +1,287 @@
+package httpclient
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+type URLReflectingErrorTransport struct{}
+
+func (URLReflectingErrorTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	return nil, fmt.Errorf("transport rejected %s", req.URL.String())
+}
+
+func TestSanitizeHeadersRedactsCheckoutAndIdentityCredentials(t *testing.T) {
+	headers := http.Header{
+		"X-Checkout-Session-Token": {"checkout-secret"},
+		"X-Checkout-Return-State":  {"return-secret"},
+		"X-Onex-Guest-Capability":  {"guest-secret"},
+		"X-OneX-Webhook-Signature": {"webhook-secret"},
+		"X-Widget-App-Key":         {"widget-secret"},
+		"X-Device-ID":              {"device-public-value"},
+	}
+	sanitized := SanitizeHeaders(headers)
+	for _, key := range []string{
+		"X-Checkout-Session-Token",
+		"X-Checkout-Return-State",
+		"X-Onex-Guest-Capability",
+		"X-OneX-Webhook-Signature",
+		"X-Widget-App-Key",
+	} {
+		if sanitized[key] != "[REDACTED]" {
+			t.Fatalf("header %s = %q", key, sanitized[key])
+		}
+	}
+	if sanitized["X-Device-ID"] != "device-public-value" {
+		t.Fatalf("X-Device-ID unexpectedly treated as capability: %q", sanitized["X-Device-ID"])
+	}
+}
+
+func TestPostOnceWithHeadersDoesNotRetryRetryableStatus(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		calls.Add(1)
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	defer server.Close()
+
+	client := New(zap.NewNop(), Options{Retry: &RetryConfig{
+		MaxRetries:            3,
+		RetryDelay:            time.Nanosecond,
+		UseExponentialBackoff: false,
+		MaxDelay:              time.Nanosecond,
+		RetryableStatusCodes:  []int{http.StatusServiceUnavailable},
+		RetryOnNetworkError:   true,
+	}})
+
+	resp, err := client.PostOnceWithHeaders(context.Background(), server.URL, map[string]string{"prompt": "x"}, nil, nil)
+	if err != nil {
+		t.Fatalf("PostOnceWithHeaders returned error: %v", err)
+	}
+	if resp.StatusCode != http.StatusServiceUnavailable {
+		t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusServiceUnavailable)
+	}
+	if resp.RetryCount != 0 {
+		t.Fatalf("retry count = %d, want 0", resp.RetryCount)
+	}
+	if calls.Load() != 1 {
+		t.Fatalf("server calls = %d, want 1", calls.Load())
+	}
+}
+
+func TestPostWithHeadersKeepsConfiguredRetryBehavior(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		calls.Add(1)
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	defer server.Close()
+
+	client := New(zap.NewNop(), Options{Retry: &RetryConfig{
+		MaxRetries:            3,
+		RetryDelay:            time.Nanosecond,
+		UseExponentialBackoff: false,
+		MaxDelay:              time.Nanosecond,
+		RetryableStatusCodes:  []int{http.StatusServiceUnavailable},
+		RetryOnNetworkError:   true,
+	}})
+
+	resp, err := client.PostWithHeaders(context.Background(), server.URL, map[string]string{"prompt": "x"}, nil, nil)
+	if err != nil {
+		t.Fatalf("PostWithHeaders returned error: %v", err)
+	}
+	if resp.RetryCount != 3 {
+		t.Fatalf("retry count = %d, want 3", resp.RetryCount)
+	}
+	if calls.Load() != 4 {
+		t.Fatalf("server calls = %d, want 4", calls.Load())
+	}
+}
+
+func TestPostOnceHTTP1WithHeadersDoesNotRetryNetworkError(t *testing.T) {
+	client := New(zap.NewNop(), Options{Retry: &RetryConfig{
+		MaxRetries:            3,
+		RetryDelay:            time.Nanosecond,
+		UseExponentialBackoff: false,
+		MaxDelay:              time.Nanosecond,
+		RetryableStatusCodes:  []int{http.StatusServiceUnavailable},
+		RetryOnNetworkError:   true,
+	}})
+
+	_, err := client.PostOnceHTTP1WithHeaders(context.Background(), "http://127.0.0.1:1", map[string]string{"prompt": "x"}, nil, nil)
+	if err == nil {
+		t.Fatal("PostOnceHTTP1WithHeaders returned nil error")
+	}
+}
+
+func TestPostOnceHTTP1WithHeadersReturns2xxBodyWhenConnectionClosesAfterBody(t *testing.T) {
+	body := []byte(`{"task_id":"task_123"}`)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Content-Length", strconv.Itoa(len(body)+16))
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(body)
+		if flusher, ok := w.(http.Flusher); ok {
+			flusher.Flush()
+		}
+		hijacker, ok := w.(http.Hijacker)
+		if !ok {
+			t.Fatal("response writer does not support hijack")
+		}
+		conn, _, err := hijacker.Hijack()
+		if err != nil {
+			t.Fatalf("hijack response: %v", err)
+		}
+		_ = conn.Close()
+	}))
+	defer server.Close()
+
+	client := New(zap.NewNop(), Options{Retry: &RetryConfig{
+		MaxRetries:            3,
+		RetryDelay:            time.Nanosecond,
+		UseExponentialBackoff: false,
+		MaxDelay:              time.Nanosecond,
+		RetryableStatusCodes:  []int{http.StatusServiceUnavailable},
+		RetryOnNetworkError:   true,
+	}})
+
+	resp, err := client.PostOnceHTTP1WithHeaders(context.Background(), server.URL, map[string]string{"prompt": "x"}, nil, nil)
+	if err != nil {
+		t.Fatalf("PostOnceHTTP1WithHeaders returned error: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusOK)
+	}
+	if string(resp.Body) != string(body) {
+		t.Fatalf("body = %q, want %q", string(resp.Body), string(body))
+	}
+	if resp.RetryCount != 0 {
+		t.Fatalf("retry count = %d, want 0", resp.RetryCount)
+	}
+}
+
+func TestPostMultipartOnceHTTP1WithHeadersTimeoutPreservesRedirectResponsePolicy(t *testing.T) {
+	var targetCalls atomic.Int32
+	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		targetCalls.Add(1)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer target.Close()
+
+	redirect := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Location", target.URL)
+		w.WriteHeader(http.StatusTemporaryRedirect)
+	}))
+	defer redirect.Close()
+
+	client := New(zap.NewNop(), Options{
+		RedirectPolicy: PreserveRedirectResponsePolicy(),
+	})
+	resp, err := client.PostMultipartOnceHTTP1WithHeadersTimeout(
+		context.Background(),
+		redirect.URL,
+		map[string]any{"category": "avatar"},
+		[]MultipartFilePart{{FieldName: "file", FileName: "avatar.png", ContentType: "image/png", Content: []byte("png")}},
+		nil,
+		nil,
+		time.Second,
+	)
+	if err != nil {
+		t.Fatalf("PostMultipartOnceHTTP1WithHeadersTimeout returned error: %v", err)
+	}
+	if resp.StatusCode != http.StatusTemporaryRedirect {
+		t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusTemporaryRedirect)
+	}
+	if targetCalls.Load() != 0 {
+		t.Fatalf("redirect target calls = %d, want 0", targetCalls.Load())
+	}
+}
+
+func TestURLLogSanitizerRedactsPathCredentialWhenLoggingDisabledAndRetrying(t *testing.T) {
+	core, observed := observer.New(zap.DebugLevel)
+	client := New(zap.New(core), Options{
+		EnableLogging: false,
+		Transport:     URLReflectingErrorTransport{},
+		Retry: &RetryConfig{
+			MaxRetries:            1,
+			RetryDelay:            time.Nanosecond,
+			UseExponentialBackoff: false,
+			MaxDelay:              time.Nanosecond,
+			RetryableStatusCodes:  []int{http.StatusServiceUnavailable},
+			RetryOnNetworkError:   true,
+		},
+		URLLogSanitizer: NewPathSegmentURLLogSanitizer(URLPathSegmentRedactionRule{
+			AfterSegment:        "tokens",
+			Replacement:         "{purchaseToken}",
+			PreserveColonSuffix: true,
+		}),
+	})
+
+	const secret = "purchase-token-secret"
+	const querySecret = "query-secret"
+	requestURL := "https://publisher.example/applications/app/purchases/products/sku/tokens/" + secret + ":acknowledge?access_token=" + querySecret
+	_, err := client.Get(context.Background(), requestURL, nil)
+	if err == nil {
+		t.Fatal("Get returned nil error")
+	}
+	if strings.Contains(err.Error(), secret) || strings.Contains(err.Error(), querySecret) {
+		t.Fatalf("returned error leaked request credential: %s", err)
+	}
+	if !strings.Contains(err.Error(), "{purchaseToken}:acknowledge") {
+		t.Fatalf("returned error does not contain redacted path template: %s", err)
+	}
+
+	entries := observed.All()
+	if len(entries) != 1 || entries[0].Level != zap.WarnLevel || entries[0].Message != "retrying request" {
+		t.Fatalf("logging disabled entries = %#v, want one retry warning", entries)
+	}
+	logged := fmt.Sprint(entries[0].ContextMap())
+	if strings.Contains(logged, secret) || strings.Contains(logged, querySecret) {
+		t.Fatalf("retry warning leaked request credential: %s", logged)
+	}
+	if !strings.Contains(logged, "{purchaseToken}:acknowledge") {
+		t.Fatalf("retry warning does not contain redacted path template: %s", logged)
+	}
+}
+
+func TestURLLogSanitizerRedactsTransportErrorLog(t *testing.T) {
+	core, observed := observer.New(zap.DebugLevel)
+	client := New(zap.New(core), Options{
+		EnableLogging: true,
+		Transport:     URLReflectingErrorTransport{},
+		Retry: &RetryConfig{
+			MaxRetries:          0,
+			RetryOnNetworkError: false,
+		},
+		URLLogSanitizer: NewPathSegmentURLLogSanitizer(URLPathSegmentRedactionRule{
+			AfterSegment: "tokens",
+			Replacement:  "{purchaseToken}",
+		}),
+	})
+
+	const secret = "purchase-token-secret"
+	_, err := client.Get(context.Background(), "https://publisher.example/purchases/subscriptionsv2/tokens/"+secret, nil)
+	if err == nil {
+		t.Fatal("Get returned nil error")
+	}
+	for _, entry := range observed.All() {
+		logged := entry.Message + fmt.Sprint(entry.ContextMap())
+		if strings.Contains(logged, secret) {
+			t.Fatalf("HTTP log leaked request credential: %s", logged)
+		}
+	}
+	errorEntries := observed.FilterMessage("HTTP request error").All()
+	if len(errorEntries) != 1 {
+		t.Fatalf("error log entries = %d, want 1", len(errorEntries))
+	}
+}