supply-intelligence/internal/admission/runner_test.go

package admission

import (
	"context"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"
)

func TestHTTPTestRunner_Run_Success(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`{"id":"model-1"}`))
	}))
	defer server.Close()

	runner := NewHTTPTestRunner()
	result := runner.Run(context.Background(), TestCase{
		ID:          "test-1",
		Name:        "Test Case",
		Endpoint:    server.URL,
		Method:      http.MethodGet,
		TimeoutSecs: 30,
	})

	if !result.Passed {
		t.Fatalf("expected pass, got failed: status=%d", result.StatusCode)
	}
	if result.StatusCode != http.StatusOK {
		t.Fatalf("expected 200, got: %d", result.StatusCode)
	}
	if result.LatencyMs < 0 {
		t.Fatalf("expected latency >= 0, got: %d", result.LatencyMs)
	}
}

func TestHTTPTestRunner_Run_Non2xx_Fails(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer server.Close()

	runner := NewHTTPTestRunner()
	result := runner.Run(context.Background(), TestCase{
		ID:          "test-2",
		Name:        "Test 500",
		Endpoint:    server.URL,
		Method:      http.MethodGet,
		TimeoutSecs: 30,
	})

	if result.Passed {
		t.Fatal("expected failure for 500")
	}
	if result.StatusCode != http.StatusInternalServerError {
		t.Fatalf("expected 500, got: %d", result.StatusCode)
	}
}

func TestHTTPTestRunner_Run_Timeout(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(500 * time.Millisecond)
		w.WriteHeader(http.StatusOK)
	}))
	defer server.Close()

	runner := NewHTTPTestRunner()
	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel()

	result := runner.Run(ctx, TestCase{
		ID:          "test-3",
		Name:        "Test Timeout",
		Endpoint:    server.URL,
		Method:      http.MethodGet,
		TimeoutSecs: 1, // but context is 50ms
	})

	if result.Error == "" {
		t.Fatal("expected error on timeout")
	}
}

func TestHTTPTestRunner_Run_ContextCanceled(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(5 * time.Second)
		w.WriteHeader(http.StatusOK)
	}))
	defer server.Close()

	runner := NewHTTPTestRunner()
	ctx, cancel := context.WithCancel(context.Background())
	cancel() // cancel immediately

	result := runner.Run(ctx, TestCase{
		ID:          "test-4",
		Name:        "Test Cancel",
		Endpoint:    server.URL,
		Method:      http.MethodGet,
		TimeoutSecs: 30,
	})

	if result.Error == "" {
		t.Fatal("expected error on context cancel")
	}
}

func TestBuildTestSuiteForPlatform_OpenAI(t *testing.T) {
	suite := BuildTestSuiteForPlatform("openai", "https://api.openai.com", "sk-test")
	if suite.Platform != "openai" {
		t.Fatalf("expected openai, got: %s", suite.Platform)
	}
	if len(suite.Cases) == 0 {
		t.Fatal("expected at least 1 test case")
	}
	if suite.Cases[0].Method != http.MethodGet {
		t.Fatalf("expected GET for models list, got: %s", suite.Cases[0].Method)
	}
}

func TestBuildTestSuiteForPlatform_Anthropic(t *testing.T) {
	suite := BuildTestSuiteForPlatform("anthropic", "https://api.anthropic.com", "sk-ant-test")
	if suite.Platform != "anthropic" {
		t.Fatalf("expected anthropic, got: %s", suite.Platform)
	}
	if len(suite.Cases) == 0 {
		t.Fatal("expected at least 1 test case")
	}
}

func TestBuildTestSuiteForPlatform_Unknown(t *testing.T) {
	suite := BuildTestSuiteForPlatform("unknown", "", "")
	if len(suite.Cases) != 0 {
		t.Fatal("expected 0 cases for unknown platform")
	}
}

func TestHTTPTestRunner_Run_PostWithJSONBody(t *testing.T) {
	var receivedBody string
	var receivedContentType string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		receivedContentType = r.Header.Get("Content-Type")
		body := make([]byte, 1024)
		n, _ := r.Body.Read(body)
		receivedBody = string(body[:n])
		w.WriteHeader(http.StatusOK)
	}))
	defer server.Close()

	runner := NewHTTPTestRunner()
	result := runner.Run(context.Background(), TestCase{
		ID:          "test-post",
		Name:        "POST JSON",
		Endpoint:    server.URL,
		Method:      http.MethodPost,
		Headers:     map[string]string{"Authorization": "Bearer token"},
		Body:        `{"model":"gpt-4","messages":[{"role":"user","content":"hi"}]}`,
		TimeoutSecs: 30,
	})

	if !result.Passed {
		t.Fatalf("expected pass: %+v", result)
	}
	if receivedContentType != "application/json" {
		t.Fatalf("expected application/json, got: %s", receivedContentType)
	}
	_ = receivedBody // validated via status code pass check
}