llmgw/internal/control/modelsvc/modelsvc_test.go

package modelsvc

import (
	"context"
	"encoding/json"
	"log/slog"
	"strings"
	"testing"
	"time"

	"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
	"gitea.mynodes.xyz/ilker/llmgw/internal/store"
)

type memStore struct {
	rows map[string]store.StoredModel
	err  error
}

func newMemStore() *memStore { return &memStore{rows: map[string]store.StoredModel{}} }

func (m *memStore) PutModel(_ context.Context, s store.StoredModel) error {
	if m.err != nil {
		return m.err
	}
	m.rows[s.Name] = s
	return nil
}

func (m *memStore) DeleteModel(_ context.Context, name string) error {
	delete(m.rows, name)
	return nil
}

func (m *memStore) Models(context.Context) ([]store.StoredModel, error) {
	out := make([]store.StoredModel, 0, len(m.rows))
	for _, r := range m.rows {
		out = append(out, r)
	}
	return out, nil
}

type recorder struct{ last *catalog.Catalog }

func (r *recorder) ReplaceCatalog(_ context.Context, c *catalog.Catalog) { r.last = c }

func model(name string) catalog.Model {
	return catalog.Model{
		Name: name, Source: "/models/" + name,
		Scaling:  catalog.Scaling{Min: 1, Max: 1},
		Profiles: []catalog.Profile{{Name: "p", Engine: "llamacpp", Weight: 1}},
	}
}

func newService(t *testing.T, declared ...catalog.Model) (*Service, *memStore, *recorder) {
	t.Helper()
	st, rec := newMemStore(), &recorder{}
	return New(declared, st, rec, slog.New(slog.DiscardHandler)), st, rec
}

func TestAddedModelReachesTheCatalogAndSurvivesARestart(t *testing.T) {
	// The whole point: trying a model should not mean a config change, a
	// restart and an outage — and it should still be there tomorrow.
	s, st, rec := newService(t, model("declared"))

	if err := s.Add(t.Context(), model("added"), "ilker"); err != nil {
		t.Fatal(err)
	}
	if _, ok := rec.last.Resolve("added"); !ok {
		t.Error("the new model is not in the catalog that was applied")
	}
	if _, ok := rec.last.Resolve("declared"); !ok {
		t.Error("the declared model was lost")
	}
	if _, ok := st.rows["added"]; !ok {
		t.Error("the model was not persisted")
	}

	// A fresh service over the same store, as after a restart.
	s2, _, _ := newService(t, model("declared"))
	s2.store = st
	built, err := s2.Load(t.Context())
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := built.Resolve("added"); !ok {
		t.Error("the model did not survive a restart")
	}
}

func TestConfigurationWinsOverTheDatabase(t *testing.T) {
	// The dangerous direction: a request for a reviewed production model must
	// never be answered by something added from a laptop.
	s, _, _ := newService(t, model("shared"))
	err := s.Add(t.Context(), model("shared"), "ilker")
	if err == nil {
		t.Fatal("a stored model was allowed to shadow a declared one")
	}
	if !strings.Contains(err.Error(), "declared in configuration") {
		t.Errorf("the error does not say why: %v", err)
	}
}

func TestADeclaredModelCannotBeRemovedAtRuntime(t *testing.T) {
	// It would come back on the next restart, so the cluster would disagree
	// with its own config file until then.
	s, _, _ := newService(t, model("declared"))
	err := s.Remove(t.Context(), "declared")
	if err == nil {
		t.Fatal("a declared model was removed at runtime")
	}
	if !strings.Contains(err.Error(), "comes back") {
		t.Errorf("the error does not explain the consequence: %v", err)
	}
}

func TestNothingIsPersistedWhenTheCatalogWouldBeInvalid(t *testing.T) {
	// A model that is written and then skipped on every start is a model that
	// looks added and never appears.
	s, st, rec := newService(t)
	bad := model("bad")
	bad.Fallbacks = []string{"a-model-that-does-not-exist"}

	if err := s.Add(t.Context(), bad, "ilker"); err == nil {
		t.Fatal("a model naming a missing fallback was accepted")
	}
	if len(st.rows) != 0 {
		t.Errorf("it was persisted anyway: %v", st.rows)
	}
	if rec.last != nil {
		t.Error("a catalog was applied for a model that was rejected")
	}
}

func TestRemovingAModelOthersFallBackToIsRefused(t *testing.T) {
	// Leaving a fallback pointing at nothing is discovered during the outage it
	// was meant to cover.
	s, _, _ := newService(t)
	if err := s.Add(t.Context(), model("small"), "ilker"); err != nil {
		t.Fatal(err)
	}
	big := model("big")
	big.Fallbacks = []string{"small"}
	if err := s.Add(t.Context(), big, "ilker"); err != nil {
		t.Fatal(err)
	}

	if err := s.Remove(t.Context(), "small"); err == nil {
		t.Fatal("removed a model another falls back to")
	}
}

func TestOneUnreadableStoredModelDoesNotStopTheCluster(t *testing.T) {
	// Refusing to start over one bad row would let a model somebody added from
	// a laptop take the cluster down, and the declared models are precisely the
	// ones that must survive that.
	s, st, _ := newService(t, model("declared"))
	good, _ := json.Marshal(model("good"))
	st.rows["good"] = store.StoredModel{Name: "good", Definition: good, CreatedAt: time.Now()}
	st.rows["broken"] = store.StoredModel{
		Name: "broken", Definition: []byte(`{"name":`), CreatedAt: time.Now(),
	}

	built, err := s.Load(t.Context())
	if err != nil {
		t.Fatalf("one bad row stopped the catalog from loading: %v", err)
	}
	for _, name := range []string{"declared", "good"} {
		if _, ok := built.Resolve(name); !ok {
			t.Errorf("%s was lost alongside the bad row", name)
		}
	}
	if _, ok := built.Resolve("broken"); ok {
		t.Error("the unreadable model was loaded anyway")
	}
}

func TestAStoredModelThatNoLongerValidatesIsSkippedAlone(t *testing.T) {
	// Checked one at a time and against what is already accepted, so one bad
	// model cannot take a good one with it.
	s, st, _ := newService(t)
	bad := model("bad")
	bad.Profiles = nil // a model with no profile cannot be placed
	badJSON, _ := json.Marshal(bad)
	goodJSON, _ := json.Marshal(model("good"))
	st.rows["bad"] = store.StoredModel{Name: "bad", Definition: badJSON, CreatedAt: time.Now()}
	st.rows["good"] = store.StoredModel{Name: "good", Definition: goodJSON, CreatedAt: time.Now().Add(time.Second)}

	built, err := s.Load(t.Context())
	if err != nil {
		t.Fatalf("load failed: %v", err)
	}
	if _, ok := built.Resolve("good"); !ok {
		t.Error("a valid stored model was dropped because another was invalid")
	}
}