Files
api-go/internal/api/handlers_train_test.go
T

286 lines
10 KiB
Go

package api
import (
"bytes"
"encoding/json"
"io"
"mime/multipart"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"pulsecast/api/internal/config"
"pulsecast/api/internal/ml"
)
func newTrainServer(t *testing.T, fastapiURL string) *httptest.Server {
t.Helper()
_, ts := newTestServer(t, ml.New(fastapiURL, 500*time.Millisecond), func(cfg *config.Config) {
cfg.FastAPIURL = fastapiURL
cfg.ControlUser = "control"
cfg.ControlPass = "secret"
})
return ts
}
func controlRequest(t *testing.T, method, url, contentType string, body io.Reader, user, pass string) (*http.Response, []byte) {
t.Helper()
req, err := http.NewRequest(method, url, body)
if err != nil {
t.Fatal(err)
}
if contentType != "" {
req.Header.Set("Content-Type", contentType)
}
if user != "" {
req.SetBasicAuth(user, pass)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatalf("%s %s: %v", method, url, err)
}
defer resp.Body.Close()
raw, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatalf("read %s %s: %v", method, url, err)
}
return resp, raw
}
func TestTrainJSONProxyAndControlAuth(t *testing.T) {
var calls atomic.Int32
var gotBody []byte
fastapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost || r.URL.Path != "/train" {
http.Error(w, "unexpected", http.StatusNotFound)
return
}
calls.Add(1)
if ct := r.Header.Get("Content-Type"); ct != "application/json" {
t.Errorf("FastAPI Content-Type=%q, want application/json", ct)
}
gotBody, _ = io.ReadAll(r.Body)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusAccepted)
_, _ = w.Write([]byte(`{"job_id":"job-1","status":"queued","model":"small","submitted_at":"2026-11-14T09:00:00Z"}`))
}))
defer fastapi.Close()
ts := newTrainServer(t, fastapi.URL)
body := `{"path":"/tmp/new.csv"}`
if resp, _ := controlRequest(t, http.MethodPost, ts.URL+"/api/train", "application/json", strings.NewReader(body), "", ""); resp.StatusCode != http.StatusUnauthorized {
t.Fatalf("no auth status=%d, want 401", resp.StatusCode)
} else if resp.Header.Get("WWW-Authenticate") == "" {
t.Error("missing WWW-Authenticate header")
}
if resp, _ := controlRequest(t, http.MethodPost, ts.URL+"/api/train", "application/json", strings.NewReader(body), "control", "wrong"); resp.StatusCode != http.StatusUnauthorized {
t.Fatalf("bad auth status=%d, want 401", resp.StatusCode)
}
if got := calls.Load(); got != 0 {
t.Fatalf("FastAPI calls=%d before auth succeeded, want 0", got)
}
resp, raw := controlRequest(t, http.MethodPost, ts.URL+"/api/train", "application/json", strings.NewReader(body), "control", "secret")
if resp.StatusCode != http.StatusAccepted {
t.Fatalf("train status=%d body=%s, want 202", resp.StatusCode, raw)
}
var job map[string]any
if err := json.Unmarshal(raw, &job); err != nil {
t.Fatalf("decode train response: %v", err)
}
if job["job_id"] != "job-1" || job["status"] != "queued" {
t.Fatalf("train response=%v", job)
}
var forwarded ml.TrainRequest
if err := json.Unmarshal(gotBody, &forwarded); err != nil {
t.Fatalf("decode forwarded body: %v", err)
}
if forwarded.Path != "/tmp/new.csv" || forwarded.Model != "small" {
t.Fatalf("forwarded body=%+v, want path and default model=small", forwarded)
}
if resp, _ := controlRequest(t, http.MethodGet, ts.URL+"/api/train/job-1", "", nil, "", ""); resp.StatusCode != http.StatusUnauthorized {
t.Fatalf("status without auth=%d, want 401", resp.StatusCode)
}
}
func TestTrainStatusProxy(t *testing.T) {
fastapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch r.URL.Path {
case "/train/job-1":
if r.Method != http.MethodGet {
t.Errorf("method=%s, want GET", r.Method)
}
_, _ = w.Write([]byte(`{"job_id":"job-1","status":"succeeded","model":"forecast","metrics":{"accuracy":0.9},"model_version":"v2","error":null}`))
default:
w.WriteHeader(http.StatusNotFound)
_, _ = w.Write([]byte(`{"detail":"job not found"}`))
}
}))
defer fastapi.Close()
ts := newTrainServer(t, fastapi.URL)
resp, raw := controlRequest(t, http.MethodGet, ts.URL+"/api/train/job-1", "", nil, "control", "secret")
if resp.StatusCode != http.StatusOK {
t.Fatalf("status=%d body=%s, want 200", resp.StatusCode, raw)
}
var job struct {
JobID string `json:"job_id"`
Status string `json:"status"`
Metrics map[string]any `json:"metrics"`
Error any `json:"error"`
}
if err := json.Unmarshal(raw, &job); err != nil {
t.Fatalf("decode status response: %v", err)
}
if job.JobID != "job-1" || job.Status != "succeeded" || job.Metrics["accuracy"] != 0.9 {
t.Fatalf("status response=%+v", job)
}
resp, raw = controlRequest(t, http.MethodGet, ts.URL+"/api/train/missing", "", nil, "control", "secret")
if resp.StatusCode != http.StatusNotFound {
t.Fatalf("unknown job status=%d body=%s, want 404", resp.StatusCode, raw)
}
if !json.Valid(raw) {
t.Fatalf("unknown job body is not JSON: %s", raw)
}
}
func TestTrainMultipartProxy(t *testing.T) {
var gotFile, gotModel string
fastapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost || r.URL.Path != "/train" {
http.Error(w, "unexpected", http.StatusNotFound)
return
}
if !strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data; boundary=") {
t.Errorf("Content-Type=%q, want multipart/form-data", r.Header.Get("Content-Type"))
}
if err := r.ParseMultipartForm(1 << 20); err != nil {
t.Errorf("parse multipart: %v", err)
http.Error(w, "bad multipart", http.StatusBadRequest)
return
}
gotModel = r.FormValue("model")
file, _, err := r.FormFile("file")
if err != nil {
t.Errorf("form file: %v", err)
} else {
raw, _ := io.ReadAll(file)
file.Close()
gotFile = string(raw)
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusAccepted)
_, _ = w.Write([]byte(`{"job_id":"job-2","status":"queued","model":"forecast","submitted_at":"2026-11-14T09:00:00Z"}`))
}))
defer fastapi.Close()
ts := newTrainServer(t, fastapi.URL)
var buf bytes.Buffer
mw := multipart.NewWriter(&buf)
part, err := mw.CreateFormFile("file", "new-data.csv")
if err != nil {
t.Fatal(err)
}
if _, err := part.Write([]byte("timestamp,count\n2026-11-01T10:00:00Z,42\n")); err != nil {
t.Fatal(err)
}
if err := mw.WriteField("model", "forecast"); err != nil {
t.Fatal(err)
}
if err := mw.Close(); err != nil {
t.Fatal(err)
}
resp, raw := controlRequest(t, http.MethodPost, ts.URL+"/api/train", mw.FormDataContentType(), &buf, "control", "secret")
if resp.StatusCode != http.StatusAccepted {
t.Fatalf("multipart status=%d body=%s, want 202", resp.StatusCode, raw)
}
if gotModel != "forecast" {
t.Errorf("forwarded model=%q, want forecast", gotModel)
}
if !strings.Contains(gotFile, "42") {
t.Errorf("forwarded file=%q, want CSV content", gotFile)
}
}
func TestTrainValidationAndUpstreamErrors(t *testing.T) {
var calls atomic.Int32
fastapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
calls.Add(1)
w.Header().Set("Content-Type", "application/json")
if r.Method == http.MethodPost {
w.WriteHeader(http.StatusConflict)
_, _ = w.Write([]byte(`{"detail":"a training job is already running"}`))
return
}
http.NotFound(w, r)
}))
defer fastapi.Close()
ts := newTrainServer(t, fastapi.URL)
for _, tc := range []struct {
name string
contentType string
body string
}{
{"unknown model", "application/json", `{"path":"/tmp/x.csv","model":"huge"}`},
{"missing path", "application/json", `{"model":"small"}`},
{"malformed json", "application/json", `{`},
{"wrong content type", "text/plain", `path=/tmp/x.csv`},
} {
resp, raw := controlRequest(t, http.MethodPost, ts.URL+"/api/train", tc.contentType, strings.NewReader(tc.body), "control", "secret")
if resp.StatusCode != http.StatusBadRequest {
t.Errorf("%s: status=%d body=%s, want 400", tc.name, resp.StatusCode, raw)
}
}
if got := calls.Load(); got != 0 {
t.Fatalf("FastAPI calls=%d for invalid requests, want 0", got)
}
resp, raw := controlRequest(t, http.MethodPost, ts.URL+"/api/train", "application/json", strings.NewReader(`{"path":"/tmp/x.csv","model":"forecast"}`), "control", "secret")
if resp.StatusCode != http.StatusConflict {
t.Fatalf("busy status=%d body=%s, want upstream 409", resp.StatusCode, raw)
}
if resp, _ := controlRequest(t, http.MethodPost, ts.URL+"/api/train/job-1", "application/json", strings.NewReader(`{}`), "control", "secret"); resp.StatusCode != http.StatusMethodNotAllowed {
t.Errorf("POST job status=%d, want 405", resp.StatusCode)
} else if allow := resp.Header.Get("Allow"); allow != "GET" {
t.Errorf("Allow=%q, want GET", allow)
}
if resp, _ := controlRequest(t, http.MethodGet, ts.URL+"/api/train", "", nil, "control", "secret"); resp.StatusCode != http.StatusMethodNotAllowed {
t.Errorf("GET train status=%d, want 405", resp.StatusCode)
}
if resp, _ := controlRequest(t, http.MethodGet, ts.URL+"/api/train/a/b", "", nil, "control", "secret"); resp.StatusCode != http.StatusNotFound {
t.Errorf("nested job path status=%d, want 404", resp.StatusCode)
}
}
func TestTrainFastAPIDownAndAuthUnconfigured(t *testing.T) {
_, down := newTestServer(t, ml.New("http://127.0.0.1:1", 50*time.Millisecond), func(cfg *config.Config) {
cfg.FastAPIURL = "http://127.0.0.1:1"
cfg.ControlUser = "control"
cfg.ControlPass = "secret"
})
resp, raw := controlRequest(t, http.MethodPost, down.URL+"/api/train", "application/json", strings.NewReader(`{"path":"/tmp/x.csv"}`), "control", "secret")
if resp.StatusCode != http.StatusBadGateway {
t.Fatalf("train with FastAPI down status=%d body=%s, want 502", resp.StatusCode, raw)
}
resp, raw = controlRequest(t, http.MethodGet, down.URL+"/api/train/job-1", "", nil, "control", "secret")
if resp.StatusCode != http.StatusBadGateway {
t.Fatalf("status with FastAPI down=%d body=%s, want 502", resp.StatusCode, raw)
}
_, unconfigured := newTestServer(t, &stubML{}, nil)
resp, raw = controlRequest(t, http.MethodPost, unconfigured.URL+"/api/train", "application/json", strings.NewReader(`{"path":"/tmp/x.csv"}`), "control", "secret")
if resp.StatusCode != http.StatusServiceUnavailable {
t.Fatalf("train without control env status=%d body=%s, want 503", resp.StatusCode, raw)
}
}