uopi/internal/api/api_test.go

package api_test

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"

	"github.com/uopi/uopi/internal/api"
	"github.com/uopi/uopi/internal/broker"
	"github.com/uopi/uopi/internal/datasource/stub"
	"github.com/uopi/uopi/internal/storage"
)

// ── Test helpers ─────────────────────────────────────────────────────────────

func setup(t *testing.T) (*httptest.Server, func()) {
	t.Helper()

	ctx, cancel := context.WithCancel(context.Background())

	log := slog.New(slog.NewTextHandler(io.Discard, nil))
	brk := broker.New(ctx, log)
	ds := stub.New()
	if err := ds.Connect(ctx); err != nil {
		t.Fatal("stub connect:", err)
	}
	brk.Register(ds)

	dir := t.TempDir()
	store, err := storage.New(dir)
	if err != nil {
		t.Fatal("storage.New:", err)
	}

	mux := http.NewServeMux()
	api.New(brk, nil, store, "", "", log).Register(mux, "/api/v1")

	srv := httptest.NewServer(mux)
	return srv, func() {
		srv.Close()
		cancel()
	}
}

func get(t *testing.T, srv *httptest.Server, path string) *http.Response {
	t.Helper()
	resp, err := http.Get(srv.URL + path)
	if err != nil {
		t.Fatal("GET", path, err)
	}
	return resp
}

func postJSON(t *testing.T, srv *httptest.Server, path string, body any) *http.Response {
	t.Helper()
	b, err := json.Marshal(body)
	if err != nil {
		t.Fatal("json.Marshal:", err)
	}
	resp, err := http.Post(srv.URL+path, "application/json", bytes.NewReader(b))
	if err != nil {
		t.Fatal("POST", path, err)
	}
	return resp
}

func postRaw(t *testing.T, srv *httptest.Server, path, ct string, body []byte) *http.Response {
	t.Helper()
	resp, err := http.Post(srv.URL+path, ct, bytes.NewReader(body))
	if err != nil {
		t.Fatal("POST", path, err)
	}
	return resp
}

func putRaw(t *testing.T, srv *httptest.Server, path, ct string, body []byte) *http.Response {
	t.Helper()
	req, err := http.NewRequest(http.MethodPut, srv.URL+path, bytes.NewReader(body))
	if err != nil {
		t.Fatal("NewRequest PUT:", err)
	}
	req.Header.Set("Content-Type", ct)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal("PUT", path, err)
	}
	return resp
}

func deleteReq(t *testing.T, srv *httptest.Server, path string) *http.Response {
	t.Helper()
	req, err := http.NewRequest(http.MethodDelete, srv.URL+path, nil)
	if err != nil {
		t.Fatal("NewRequest DELETE:", err)
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal("DELETE", path, err)
	}
	return resp
}

func readJSON(t *testing.T, resp *http.Response, v any) {
	t.Helper()
	defer resp.Body.Close()
	if err := json.NewDecoder(resp.Body).Decode(v); err != nil {
		t.Fatal("decode response:", err)
	}
}

func assertStatus(t *testing.T, resp *http.Response, want int) {
	t.Helper()
	if resp.StatusCode != want {
		body, _ := io.ReadAll(resp.Body)
		resp.Body.Close()
		t.Fatalf("expected HTTP %d, got %d: %s", want, resp.StatusCode, bytes.TrimSpace(body))
	}
}

// ── /api/v1/datasources ───────────────────────────────────────────────────────

func TestListDataSources(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/datasources")
	assertStatus(t, resp, http.StatusOK)

	var sources []struct {
		Name   string `json:"name"`
		Status string `json:"status"`
	}
	readJSON(t, resp, &sources)

	if len(sources) == 0 {
		t.Fatal("expected at least one data source")
	}
	found := false
	for _, s := range sources {
		if s.Name == "stub" {
			found = true
			if s.Status != "connected" {
				t.Errorf("stub status = %q, want connected", s.Status)
			}
		}
	}
	if !found {
		t.Error("stub data source not in list")
	}
}

// ── /api/v1/signals ───────────────────────────────────────────────────────────

func TestListSignalsMissingDs(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/signals")
	assertStatus(t, resp, http.StatusBadRequest)
}

func TestListSignalsUnknownDs(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/signals?ds=nonexistent")
	assertStatus(t, resp, http.StatusNotFound)
}

func TestListSignalsStub(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/signals?ds=stub")
	assertStatus(t, resp, http.StatusOK)

	var signals []struct {
		Name string `json:"name"`
		Type string `json:"type"`
	}
	readJSON(t, resp, &signals)

	if len(signals) == 0 {
		t.Fatal("expected signals from stub data source")
	}
}

// ── /api/v1/signals/search ────────────────────────────────────────────────────

func TestSearchSignals(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/signals/search?q=sine")
	assertStatus(t, resp, http.StatusOK)

	var signals []struct{ Name string `json:"name"` }
	readJSON(t, resp, &signals)

	for _, s := range signals {
		if !strings.Contains(s.Name, "sine") {
			t.Errorf("signal %q does not match query 'sine'", s.Name)
		}
	}
}

func TestSearchSignalsEmpty(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	// Empty query should return all signals.
	resp := get(t, srv, "/api/v1/signals/search")
	assertStatus(t, resp, http.StatusOK)

	var signals []any
	readJSON(t, resp, &signals)
	if len(signals) == 0 {
		t.Error("expected signals for empty query")
	}
}

// ── /api/v1/interfaces ────────────────────────────────────────────────────────

const sampleXML = `<interface id="" name="Test Panel" version="1" w="800" h="600"></interface>`

func TestInterfaceCRUD(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	// List — initially empty
	resp := get(t, srv, "/api/v1/interfaces")
	assertStatus(t, resp, http.StatusOK)
	var list []any
	readJSON(t, resp, &list)
	if len(list) != 0 {
		t.Fatalf("expected empty interface list, got %d", len(list))
	}

	// Create
	resp = postRaw(t, srv, "/api/v1/interfaces", "application/xml", []byte(sampleXML))
	assertStatus(t, resp, http.StatusCreated)
	var created struct{ ID string `json:"id"` }
	readJSON(t, resp, &created)
	if created.ID == "" {
		t.Fatal("expected non-empty ID from create")
	}

	// Get
	resp = get(t, srv, "/api/v1/interfaces/"+created.ID)
	assertStatus(t, resp, http.StatusOK)
	body, _ := io.ReadAll(resp.Body)
	resp.Body.Close()
	if !bytes.Contains(body, []byte("Test Panel")) {
		t.Errorf("GET response missing interface name: %s", body)
	}

	// Update
	updated := `<interface id="" name="Updated Panel" version="2" w="1024" h="768"></interface>`
	resp = putRaw(t, srv, "/api/v1/interfaces/"+created.ID, "application/xml", []byte(updated))
	assertStatus(t, resp, http.StatusNoContent)

	// Verify update
	resp = get(t, srv, "/api/v1/interfaces/"+created.ID)
	assertStatus(t, resp, http.StatusOK)
	body, _ = io.ReadAll(resp.Body)
	resp.Body.Close()
	if !bytes.Contains(body, []byte("Updated Panel")) {
		t.Errorf("GET after update missing new name: %s", body)
	}

	// List — now one entry
	resp = get(t, srv, "/api/v1/interfaces")
	assertStatus(t, resp, http.StatusOK)
	readJSON(t, resp, &list)
	if len(list) != 1 {
		t.Fatalf("expected 1 interface in list, got %d", len(list))
	}

	// Clone
	req, _ := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/interfaces/"+created.ID+"/clone", nil)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal("clone:", err)
	}
	assertStatus(t, resp, http.StatusCreated)
	var cloned struct{ ID string `json:"id"` }
	readJSON(t, resp, &cloned)
	if cloned.ID == created.ID {
		t.Error("clone produced same ID as original")
	}

	// Delete original
	resp = deleteReq(t, srv, "/api/v1/interfaces/"+created.ID)
	assertStatus(t, resp, http.StatusNoContent)

	// Get after delete → 404
	resp = get(t, srv, "/api/v1/interfaces/"+created.ID)
	assertStatus(t, resp, http.StatusNotFound)

	// Delete non-existent → 404
	resp = deleteReq(t, srv, "/api/v1/interfaces/"+created.ID)
	assertStatus(t, resp, http.StatusNotFound)
}

func TestInterfaceInvalidXML(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := postRaw(t, srv, "/api/v1/interfaces", "application/xml", []byte("not xml at all"))
	assertStatus(t, resp, http.StatusBadRequest)
}

func TestInterfacePathTraversal(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	// Attempt to read a file outside the storage dir via path traversal in the ID.
	resp := get(t, srv, "/api/v1/interfaces/../etc/passwd")
	// Should be 404 (invalid ID), not 200 or 500.
	if resp.StatusCode == http.StatusOK {
		t.Error("path traversal succeeded — expected 404")
	}
}

// ── Synthetic (disabled — synth is nil) ──────────────────────────────────────

func TestSyntheticDisabled(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/synthetic")
	assertStatus(t, resp, http.StatusOK)
	var out []any
	readJSON(t, resp, &out)
	if len(out) != 0 {
		t.Errorf("expected empty list when synthetic is nil, got %v", out)
	}
}

func TestSyntheticCreateDisabled(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := postJSON(t, srv, "/api/v1/synthetic", map[string]any{"name": "test"})
	assertStatus(t, resp, http.StatusServiceUnavailable)
}

// ── Channel Finder (not configured) ──────────────────────────────────────────

func TestChannelFinderNotConfigured(t *testing.T) {
	srv, teardown := setup(t)
	defer teardown()

	resp := get(t, srv, "/api/v1/channel-finder?q=test")
	assertStatus(t, resp, http.StatusNotImplemented)
}

// ── /healthz ──────────────────────────────────────────────────────────────────

func TestHealthz(t *testing.T) {
	// healthz is registered in server.go, not api.go, so test it directly.
	mux := http.NewServeMux()
	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ok"))
	})
	srv := httptest.NewServer(mux)
	defer srv.Close()

	resp, err := http.Get(srv.URL + "/healthz")
	if err != nil {
		t.Fatal(err)
	}
	assertStatus(t, resp, http.StatusOK)
	body, _ := io.ReadAll(resp.Body)
	resp.Body.Close()
	if string(body) != "ok" {
		t.Errorf("healthz body = %q, want ok", body)
	}
}

// ── Storage ID validation ─────────────────────────────────────────────────────

func TestStorageValidateID(t *testing.T) {
	dir := t.TempDir()
	store, err := storage.New(dir)
	if err != nil {
		t.Fatal(err)
	}

	// Create a real interface first to get a valid ID.
	id, err := store.Create([]byte(sampleXML))
	if err != nil {
		t.Fatal("create:", err)
	}

	// Valid ID works.
	data, err := store.Get(id)
	if err != nil {
		t.Fatalf("Get(%q): %v", id, err)
	}
	if len(data) == 0 {
		t.Error("expected data, got empty")
	}

	// Malicious IDs must be rejected.
	malicious := []string{"../etc/passwd", "../../secret", "a/b", "a\x00b", ""}
	for _, bad := range malicious {
		if _, err := store.Get(bad); err == nil {
			t.Errorf("Get(%q) should have failed, got nil error", bad)
		}
		if err := store.Update(bad, []byte(sampleXML)); err == nil {
			t.Errorf("Update(%q) should have failed", bad)
		}
		if err := store.Delete(bad); err == nil {
			t.Errorf("Delete(%q) should have failed", bad)
		}
	}
}

// ── Ensure os is used (blank import guard) ─────────────────────────────────────

var _ = os.DevNull