ez-api/internal/api/provider_admin_handler_test.go

package api

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/ez-api/ez-api/internal/model"
	"github.com/gin-gonic/gin"
)

func TestAdmin_TestProvider_OpenAICompatible(t *testing.T) {
	h, db := newTestHandler(t)

	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/v1/models" {
			http.NotFound(w, r)
			return
		}
		if got := r.Header.Get("Authorization"); got != "Bearer k" {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"object":"list","data":[]}`))
	}))
	defer upstream.Close()

	p := &model.Provider{
		Name:    "p1",
		Type:    "openai",
		BaseURL: upstream.URL + "/v1",
		APIKey:  "k",
		Group:   "default",
		Models:  "gpt-4o-mini",
		Status:  "active",
	}
	if err := db.Create(p).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}

	r := gin.New()
	r.POST("/admin/providers/:id/test", h.TestProvider)

	req := httptest.NewRequest(http.MethodPost, "/admin/providers/1/test", nil)
	rr := httptest.NewRecorder()
	r.ServeHTTP(rr, req)

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rr.Code, rr.Body.String())
	}
	var payload map[string]any
	if err := json.Unmarshal(rr.Body.Bytes(), &payload); err != nil {
		t.Fatalf("unmarshal: %v", err)
	}
	if ok, _ := payload["ok"].(bool); !ok {
		t.Fatalf("expected ok=true, got %v body=%s", payload["ok"], rr.Body.String())
	}
}

func TestAdmin_FetchProviderModels_OpenAICompatible(t *testing.T) {
	h, db := newTestHandler(t)

	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/v1/models" {
			http.NotFound(w, r)
			return
		}
		if got := r.Header.Get("Authorization"); got != "Bearer k" {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"gpt-4o-mini"},{"id":"gpt-4o"}]}`))
	}))
	defer upstream.Close()

	p := &model.Provider{
		Name:    "p1",
		Type:    "openai",
		BaseURL: upstream.URL + "/v1",
		APIKey:  "k",
		Group:   "default",
		Models:  "old-model",
		Status:  "active",
	}
	if err := db.Create(p).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}

	r := gin.New()
	r.POST("/admin/providers/:id/fetch-models", h.FetchProviderModels)

	req := httptest.NewRequest(http.MethodPost, "/admin/providers/1/fetch-models", nil)
	rr := httptest.NewRecorder()
	r.ServeHTTP(rr, req)

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rr.Code, rr.Body.String())
	}

	var updated model.Provider
	if err := db.First(&updated, p.ID).Error; err != nil {
		t.Fatalf("reload provider: %v", err)
	}
	if updated.Models != "gpt-4o,gpt-4o-mini" {
		t.Fatalf("expected models to update, got %q", updated.Models)
	}
}

func TestAdmin_BatchProviders_Status(t *testing.T) {
	h, db := newTestHandler(t)

	banUntil := time.Now().Add(2 * time.Hour).UTC()
	p := &model.Provider{
		Name:      "p1",
		Type:      "openai",
		BaseURL:   "https://api.openai.com/v1",
		Group:     "default",
		Models:    "gpt-4o-mini",
		Status:    "manual_disabled",
		BanReason: "bad",
		BanUntil:  &banUntil,
	}
	if err := db.Create(p).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}

	r := gin.New()
	r.POST("/admin/providers/batch", h.BatchProviders)

	payload := map[string]any{
		"action": "status",
		"status": "active",
		"ids":    []uint{p.ID},
	}
	b, _ := json.Marshal(payload)
	req := httptest.NewRequest(http.MethodPost, "/admin/providers/batch", bytes.NewReader(b))
	req.Header.Set("Content-Type", "application/json")
	rr := httptest.NewRecorder()
	r.ServeHTTP(rr, req)

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rr.Code, rr.Body.String())
	}
	var updated model.Provider
	if err := db.First(&updated, p.ID).Error; err != nil {
		t.Fatalf("reload provider: %v", err)
	}
	if updated.Status != "active" {
		t.Fatalf("expected status active, got %q", updated.Status)
	}
	if updated.BanReason != "" {
		t.Fatalf("expected ban_reason cleared, got %q", updated.BanReason)
	}
	if updated.BanUntil != nil {
		t.Fatalf("expected ban_until cleared, got %v", updated.BanUntil)
	}
}