220 lines
7.2 KiB
Go
220 lines
7.2 KiB
Go
package ml
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestPredictObjectResponseAndRequest(t *testing.T) {
|
|
var got PredictRequest
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/predict" {
|
|
t.Errorf("path=%q", r.URL.Path)
|
|
}
|
|
if r.Header.Get("Content-Type") != "application/json" {
|
|
t.Errorf("Content-Type=%q", r.Header.Get("Content-Type"))
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
|
|
t.Errorf("decode request: %v", err)
|
|
}
|
|
_, _ = w.Write([]byte(`{"points":[{"t":"2026-11-16T09:00:00Z","v":12.3,"lo":8.1,"hi":17.2}]}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
client := New(srv.URL+"/", time.Second)
|
|
points, err := client.Predict(context.Background(), PredictRequest{
|
|
Sensor: "hn-bahnhof-01", Horizon: "1h", Scenario: "base",
|
|
Weather: WeatherInput{TempC: 9, PrecipMM: 0}, IsHoliday: false,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Predict: %v", err)
|
|
}
|
|
if len(points) != 1 || points[0].V != 12.3 || points[0].Lo != 8.1 {
|
|
t.Fatalf("points=%+v", points)
|
|
}
|
|
if got.Sensor != "hn-bahnhof-01" || got.Horizon != "1h" || got.Weather.TempC != 9 {
|
|
t.Fatalf("request=%+v", got)
|
|
}
|
|
}
|
|
|
|
func TestPredictBareArrayResponse(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
_, _ = w.Write([]byte(`[{"t":"2026-11-16T09:00:00Z","v":1,"lo":0.5,"hi":1.5}]`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
points, err := New(srv.URL, time.Second).Predict(context.Background(), PredictRequest{})
|
|
if err != nil {
|
|
t.Fatalf("Predict: %v", err)
|
|
}
|
|
if len(points) != 1 || points[0].V != 1 {
|
|
t.Fatalf("points=%+v", points)
|
|
}
|
|
}
|
|
|
|
func TestPredictRejectsEmptyAndErrorStatus(t *testing.T) {
|
|
empty := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
_, _ = w.Write([]byte(`{"points":[]}`))
|
|
}))
|
|
defer empty.Close()
|
|
if _, err := New(empty.URL, time.Second).Predict(context.Background(), PredictRequest{}); err == nil {
|
|
t.Fatal("expected an error for an empty points array")
|
|
}
|
|
|
|
boom := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
http.Error(w, "nope", http.StatusInternalServerError)
|
|
}))
|
|
defer boom.Close()
|
|
if _, err := New(boom.URL, time.Second).Predict(context.Background(), PredictRequest{}); err == nil {
|
|
t.Fatal("expected an error for HTTP 500")
|
|
}
|
|
}
|
|
|
|
func TestPredictTimeout(t *testing.T) {
|
|
slow := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
time.Sleep(150 * time.Millisecond)
|
|
_, _ = w.Write([]byte(`{"points":[{"t":"2026-11-16T09:00:00Z","v":1,"lo":0,"hi":2}]}`))
|
|
}))
|
|
defer slow.Close()
|
|
|
|
client := New(slow.URL, 20*time.Millisecond)
|
|
start := time.Now()
|
|
if _, err := client.Predict(context.Background(), PredictRequest{}); err == nil {
|
|
t.Fatal("expected a timeout error")
|
|
}
|
|
if elapsed := time.Since(start); elapsed > time.Second {
|
|
t.Fatalf("timeout took %s", elapsed)
|
|
}
|
|
}
|
|
|
|
func TestSimulate(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var req SimulateRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
t.Errorf("decode: %v", err)
|
|
}
|
|
if req.Scenario != "rainy-saturday" || req.Sensors != "all" {
|
|
t.Errorf("request=%+v", req)
|
|
}
|
|
_, _ = w.Write([]byte(`{"scenario":"rainy-saturday","generated_at":"2026-11-14T09:12:00Z","forecasts":{"hn-bahnhof-01":{"7d":[{"t":"2026-11-16T09:00:00Z","v":5,"lo":4,"hi":6}]}}}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
forecasts, err := New(srv.URL, time.Second).Simulate(context.Background(), SimulateRequest{
|
|
Scenario: "rainy-saturday", Sensors: "all",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Simulate: %v", err)
|
|
}
|
|
points := forecasts["hn-bahnhof-01"]["7d"]
|
|
if len(points) != 1 || points[0].V != 5 {
|
|
t.Fatalf("forecasts=%+v", forecasts)
|
|
}
|
|
if _, ok := forecasts["missing"]; ok {
|
|
t.Fatal("unexpected sensor")
|
|
}
|
|
}
|
|
|
|
func TestNewUsesDefaultTimeout(t *testing.T) {
|
|
client := New("http://example.invalid", 0)
|
|
if client.http.Timeout != DefaultTimeout {
|
|
t.Fatalf("timeout=%s, want %s", client.http.Timeout, DefaultTimeout)
|
|
}
|
|
}
|
|
|
|
func TestTrainForwardsBodyContentTypeAndStatus(t *testing.T) {
|
|
var gotMethod, gotPath, gotType, gotBody string
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
gotMethod, gotPath = r.Method, r.URL.Path
|
|
gotType = r.Header.Get("Content-Type")
|
|
raw, _ := io.ReadAll(r.Body)
|
|
gotBody = string(raw)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusAccepted)
|
|
_, _ = w.Write([]byte(`{"job_id":"job-1","status":"queued","model":"small"}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
status, body, err := New(srv.URL, time.Second).Train(context.Background(), "application/json",
|
|
strings.NewReader(`{"path":"/tmp/new.csv","model":"small"}`))
|
|
if err != nil {
|
|
t.Fatalf("Train: %v", err)
|
|
}
|
|
if status != http.StatusAccepted {
|
|
t.Fatalf("status=%d, want 202", status)
|
|
}
|
|
if !strings.Contains(string(body), `"job_id":"job-1"`) {
|
|
t.Fatalf("body=%s", body)
|
|
}
|
|
if gotMethod != http.MethodPost || gotPath != "/train" {
|
|
t.Fatalf("request=%s %s, want POST /train", gotMethod, gotPath)
|
|
}
|
|
if gotType != "application/json" || !strings.Contains(gotBody, "/tmp/new.csv") {
|
|
t.Fatalf("content-type=%q body=%q", gotType, gotBody)
|
|
}
|
|
}
|
|
|
|
func TestControlRequestsForwardBearerToken(t *testing.T) {
|
|
var got []string
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
got = append(got, r.Header.Get("Authorization"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if r.Method == http.MethodPost {
|
|
w.WriteHeader(http.StatusAccepted)
|
|
}
|
|
_, _ = w.Write([]byte(`{"job_id":"job-1","status":"queued"}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
client := NewWithToken(srv.URL, time.Second, "token-123")
|
|
if _, _, err := client.Train(context.Background(), "application/json", strings.NewReader(`{"path":"/tmp/x.csv"}`)); err != nil {
|
|
t.Fatalf("Train: %v", err)
|
|
}
|
|
if _, _, err := client.TrainStatus(context.Background(), "job-1"); err != nil {
|
|
t.Fatalf("TrainStatus: %v", err)
|
|
}
|
|
for i, auth := range got {
|
|
if auth != "Bearer token-123" {
|
|
t.Errorf("request %d Authorization=%q, want Bearer token-123", i, auth)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTrainStatusForwardsJobIDAndUpstreamError(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
t.Errorf("method=%s, want GET", r.Method)
|
|
}
|
|
if r.URL.Path == "/train/job-1" {
|
|
_, _ = w.Write([]byte(`{"job_id":"job-1","status":"succeeded","error":null}`))
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNotFound)
|
|
_, _ = w.Write([]byte(`{"detail":"job not found"}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
client := New(srv.URL, time.Second)
|
|
status, body, err := client.TrainStatus(context.Background(), "job-1")
|
|
if err != nil {
|
|
t.Fatalf("TrainStatus: %v", err)
|
|
}
|
|
if status != http.StatusOK || !strings.Contains(string(body), `"succeeded"`) {
|
|
t.Fatalf("status=%d body=%s", status, body)
|
|
}
|
|
|
|
status, body, err = client.TrainStatus(context.Background(), "missing")
|
|
if err != nil {
|
|
t.Fatalf("TrainStatus missing: %v", err)
|
|
}
|
|
if status != http.StatusNotFound || !strings.Contains(string(body), "job not found") {
|
|
t.Fatalf("status=%d body=%s, want forwarded 404", status, body)
|
|
}
|
|
}
|