ModelRouter/internal/gateway/ui_image_page_test.go

package gateway

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"llmsproxy/internal/provider"
)

// TestUI_ChatPageGroupsImageModels is a UI-contract guard for the bug that
// started this: the chat page listed image models beside chat ones, and picking
// one posted to /api/chat, which cannot serve it.
//
// The contract is asserted on the HTML source rather than by running a browser,
// because the failure this must catch is a source-level one — an <option>
// without `disabled`. A DOM assertion in a headless browser would pass right
// up until someone removed the attribute, and then only if a CI machine had the
// whole stack up.
func TestUI_ChatPageGroupsImageModels(t *testing.T) {
	ui := uiSource(t)

	// The dropdown must read model_kinds, not the flat models list. Reading the
	// flat list is what made chat and image models indistinguishable.
	if !strings.Contains(ui, "model_kinds") {
		t.Error("chat page never reads model_kinds; image models will be " +
			"indistinguishable from chat models again")
	}

	// Image options must be rendered disabled. A plain String.replace over the
	// joined HTML only disables the FIRST match — that bug shipped once here
	// (one source disabled, five selectable) — so the assertion looks for the
	// per-item map, not for a global replace.
	if strings.Contains(ui, `imgOpts.join("").replace`) {
		t.Error("chat page disables image options with String.replace over the " +
			"joined HTML, which only rewrites the first option")
	}
	if !strings.Contains(ui, "disabled") {
		t.Error("chat page never emits a disabled attribute for image models")
	}
}

// TestUI_HasDedicatedImagePage pins the second half of the fix: image models
// need somewhere they CAN be tested.
func TestUI_HasDedicatedImagePage(t *testing.T) {
	ui := uiSource(t)

	for _, want := range []string{
		`data-tab="image"`,       // sidebar entry
		`id="tab-image"`,         // pane
		`function renderImage`,   // renderer registered with refresh()
		`tab === "image"`,        // dispatched
		`/v1/images/generations`, // the endpoint the page actually calls
	} {
		if !strings.Contains(ui, want) {
			t.Errorf("image page is missing %q", want)
		}
	}

	// The page must be reachable from TABS; goTab iterates TABS to toggle pane
	// visibility, so a pane outside that list is present but permanently hidden —
	// which reads as "the page is blank" because the content is in the DOM.
	if !strings.Contains(ui, `"image"`) {
		t.Error(`"image" does not appear in the TABS list`)
	}
}

// TestUI_ImagePageCallsTheImageEndpoint is the discriminator: a page that
// renders an image result but posts to the chat endpoint would produce exactly
// the original failure, just prettier.
func TestUI_ImagePageCallsTheImageEndpoint(t *testing.T) {
	ui := uiSource(t)

	i := strings.Index(ui, "async function sendImage(")
	if i < 0 {
		t.Fatal("sendImage() not found")
	}
	// Bound the search to the function body rather than the whole file, so a
	// /v1/images/generations mention elsewhere cannot satisfy this.
	body := ui[i:]
	if end := strings.Index(body, "\n      function "); end > 0 {
		body = body[:end]
	}
	if end := strings.Index(body, "\n      async function "); end > 0 {
		if s := body[:end]; strings.Contains(s, "/v1/images/generations") {
			body = s
		} else {
			body = body[:end]
		}
	}
	if !strings.Contains(body, "/v1/images/generations") {
		t.Error("sendImage() does not post to /v1/images/generations")
	}
}

// TestSourceStatus_ExposesModelKindsToTheUI is the server half of the same
// contract: the field the UI reads must actually be serialized.
func TestSourceStatus_ExposesModelKindsToTheUI(t *testing.T) {
	st := provider.SourceStatus{
		Name:   "vela",
		Models: []string{"claude-sonnet-5.5", "gpt-image-2"},
		ModelKinds: []provider.ModelKindInfo{
			{ID: "claude-sonnet-5.5", Kind: "chat"},
			{ID: "gpt-image-2", Kind: "image"},
		},
	}
	b, err := json.Marshal(st)
	if err != nil {
		t.Fatal(err)
	}
	var got map[string]interface{}
	if err := json.Unmarshal(b, &got); err != nil {
		t.Fatal(err)
	}
	mk, ok := got["model_kinds"].([]interface{})
	if !ok || len(mk) != 2 {
		t.Fatalf("model_kinds = %v, want 2 entries; the UI cannot split the list without it", got["model_kinds"])
	}
	last := mk[1].(map[string]interface{})
	if last["kind"] != "image" {
		t.Errorf("model_kinds[1].kind = %v, want \"image\"", last["kind"])
	}
}

// TestUI_BaseURLFieldExplainsWhereToCut keeps the second bug fixed: the URL
// hint has to mention the concrete failure, not just say "enter the URL".
func TestUI_BaseURLFieldExplainsWhereToCut(t *testing.T) {
	ui := uiSource(t)
	if !strings.Contains(ui, "urlHint") {
		t.Fatal("no urlHint; the base_url field gives no guidance about /v1")
	}
	hint := ui[strings.Index(ui, "urlHint:"):]
	if len(hint) > 700 {
		hint = hint[:700]
	}
	// The trap is specific and reproducible: base_url ending in /v1 makes chat
	// work and image generation 404. Saying only "enter the URL" reproduces the
	// confusion the hint exists to remove.
	for _, want := range []string{"/v1", "404"} {
		if !strings.Contains(hint, want) {
			t.Errorf("urlHint does not mention %q — the hint must name the concrete failure", want)
		}
	}
}

// TestImageEndpointComposesUnderRealConditions proves the hint describes a
// reachable path rather than a plausible-sounding one.
//
// The case that matters: base_url already ends in /v1 (which is what an
// operator pastes from an SDK example), so the RELATIVE image endpoint composes
// to …/v1/images/generations and works, while the gateway's default ABSOLUTE
// path would produce …/v1/v1/… and 404.
//
// The doubled form is served as a 404 here so the test would fail if the code
// ever reverted to relying on the default.
func TestImageEndpointComposesUnderRealConditions(t *testing.T) {
	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/v1/images/generations":
			_, _ = w.Write([]byte(`{"data":[{"url":"http://example.invalid/x.png"}]}`))
		default:
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	defer up.Close()

	// base_url as an operator types it: host root + /v1.
	base := up.URL + "/v1"

	// What discovery writes when base carries a version segment.
	relative := base + "/images/generations"
	resp, err := http.Post(relative, "application/json", strings.NewReader(`{"model":"m"}`))
	if err != nil {
		t.Fatal(err)
	}
	resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		t.Errorf("POST %s = %d, want 200 — the form discovery writes must work", relative, resp.StatusCode)
	}

	// What the gateway's built-in default would produce for the same base_url.
	doubled := base + "/v1/images/generations"
	resp2, err := http.Post(doubled, "application/json", strings.NewReader(`{"model":"m"}`))
	if err != nil {
		t.Fatal(err)
	}
	resp2.Body.Close()
	if resp2.StatusCode != http.StatusNotFound {
		t.Errorf("POST %s = %d, want 404 — this test's premise is that the "+
			"default image path doubles the version segment; if the upstream ever "+
			"accepts it, composeImageEndpoint's rule needs rechecking", doubled, resp2.StatusCode)
	}
}