starnet/response_test.go

package starnet

import (
	"io"
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestResponseBody(t *testing.T) {
	testData := "test response data"
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(testData))
	}))
	defer server.Close()

	resp, err := Get(server.URL)
	if err != nil {
		t.Fatalf("Get() error: %v", err)
	}
	defer resp.Close()

	// Test String()
	body, err := resp.Body().String()
	if err != nil {
		t.Fatalf("Body().String() error: %v", err)
	}
	if body != testData {
		t.Errorf("Body = %v; want %v", body, testData)
	}

	// Test multiple reads (should work because body is cached)
	body2, err := resp.Body().String()
	if err != nil {
		t.Fatalf("Second Body().String() error: %v", err)
	}
	if body2 != testData {
		t.Errorf("Second Body = %v; want %v", body2, testData)
	}
}

func TestResponseJSON(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.Write([]byte(`{"name":"John","age":30}`))
	}))
	defer server.Close()

	resp, err := Get(server.URL)
	if err != nil {
		t.Fatalf("Get() error: %v", err)
	}
	defer resp.Close()

	var result struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}

	err = resp.Body().JSON(&result)
	if err != nil {
		t.Fatalf("Body().JSON() error: %v", err)
	}

	if result.Name != "John" {
		t.Errorf("Name = %v; want John", result.Name)
	}
	if result.Age != 30 {
		t.Errorf("Age = %v; want 30", result.Age)
	}
}

func TestResponseBytes(t *testing.T) {
	testData := []byte("binary data")
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write(testData)
	}))
	defer server.Close()

	resp, err := Get(server.URL)
	if err != nil {
		t.Fatalf("Get() error: %v", err)
	}
	defer resp.Close()

	body, err := resp.Body().Bytes()
	if err != nil {
		t.Fatalf("Body().Bytes() error: %v", err)
	}

	if string(body) != string(testData) {
		t.Errorf("Body = %v; want %v", body, testData)
	}
}

func TestResponseReader(t *testing.T) {
	testData := "stream data"
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(testData))
	}))
	defer server.Close()

	resp, err := Get(server.URL)
	if err != nil {
		t.Fatalf("Get() error: %v", err)
	}
	defer resp.Close()

	reader, err := resp.Body().Reader()
	if err != nil {
		t.Fatalf("Body().Reader() error: %v", err)
	}
	defer reader.Close()

	body, err := io.ReadAll(reader)
	if err != nil {
		t.Fatalf("ReadAll() error: %v", err)
	}

	if string(body) != testData {
		t.Errorf("Body = %v; want %v", string(body), testData)
	}
}

func TestResponseAutoFetch(t *testing.T) {
	testData := "auto fetch data"
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(testData))
	}))
	defer server.Close()

	// With auto fetch
	resp, err := Get(server.URL, WithAutoFetch(true))
	if err != nil {
		t.Fatalf("Get() error: %v", err)
	}
	defer resp.Close()

	if !resp.Body().IsConsumed() {
		t.Error("Body should be consumed with auto fetch")
	}

	body, _ := resp.Body().String()
	if body != testData {
		t.Errorf("Body = %v; want %v", body, testData)
	}
}

func TestResponseStatusCode(t *testing.T) {
	tests := []struct {
		name       string
		statusCode int
	}{
		{"OK", http.StatusOK},
		{"Created", http.StatusCreated},
		{"BadRequest", http.StatusBadRequest},
		{"NotFound", http.StatusNotFound},
		{"InternalServerError", http.StatusInternalServerError},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(tt.statusCode)
			}))
			defer server.Close()

			resp, err := Get(server.URL)
			if err != nil {
				t.Fatalf("Get() error: %v", err)
			}
			defer resp.Close()

			if resp.StatusCode != tt.statusCode {
				t.Errorf("StatusCode = %v; want %v", resp.StatusCode, tt.statusCode)
			}
		})
	}
}