golangLAKEHOUSE/internal/matrix/playbook_test.go

package matrix

import (
	"encoding/json"
	"testing"
)

func TestPlaybookEntry_Validate(t *testing.T) {
	good := PlaybookEntry{
		QueryText: "x", AnswerID: "y", AnswerCorpus: "z", Score: 0.5,
	}
	if err := good.Validate(); err != nil {
		t.Errorf("good entry should validate: %v", err)
	}

	cases := []struct {
		name  string
		entry PlaybookEntry
	}{
		{"empty query", PlaybookEntry{AnswerID: "y", AnswerCorpus: "z", Score: 0.5}},
		{"empty answer id", PlaybookEntry{QueryText: "x", AnswerCorpus: "z", Score: 0.5}},
		{"empty corpus", PlaybookEntry{QueryText: "x", AnswerID: "y", Score: 0.5}},
		{"score too high", PlaybookEntry{QueryText: "x", AnswerID: "y", AnswerCorpus: "z", Score: 1.5}},
		{"score negative", PlaybookEntry{QueryText: "x", AnswerID: "y", AnswerCorpus: "z", Score: -0.1}},
	}
	for _, c := range cases {
		if err := c.entry.Validate(); err == nil {
			t.Errorf("%s: expected validation error, got nil", c.name)
		}
	}
}

func TestPlaybookEntry_BoostFactor(t *testing.T) {
	cases := []struct {
		score float64
		want  float64
	}{
		{0.0, 1.0},
		{0.5, 0.75},
		{1.0, 0.5},
		{-0.1, 1.0}, // clamped
		{1.5, 0.5},  // clamped
	}
	for _, c := range cases {
		got := PlaybookEntry{Score: c.score}.BoostFactor()
		if abs(got-c.want) > 1e-9 {
			t.Errorf("BoostFactor(score=%.2f): want %.4f, got %.4f", c.score, c.want, got)
		}
	}
}

func TestApplyPlaybookBoost_NoHitsLeaveResultsAlone(t *testing.T) {
	results := []Result{
		{ID: "a", Distance: 0.1, Corpus: "x"},
		{ID: "b", Distance: 0.2, Corpus: "x"},
	}
	n := ApplyPlaybookBoost(results, nil)
	if n != 0 {
		t.Errorf("expected 0 boosted, got %d", n)
	}
	if results[0].ID != "a" || results[1].ID != "b" {
		t.Errorf("results reordered without hits: %v", results)
	}
}

func TestApplyPlaybookBoost_BoostMovesResultUp(t *testing.T) {
	// Initial: a (0.10) beats b (0.20) beats c (0.30).
	// Playbook says (answer=c, score=1.0) should be boosted → c's
	// distance becomes 0.30 * 0.5 = 0.15. New ordering: a, c, b.
	results := []Result{
		{ID: "a", Distance: 0.10, Corpus: "x"},
		{ID: "b", Distance: 0.20, Corpus: "x"},
		{ID: "c", Distance: 0.30, Corpus: "x"},
	}
	hits := []PlaybookHit{
		{PlaybookID: "p1", Distance: 0.05, Entry: PlaybookEntry{
			AnswerID: "c", AnswerCorpus: "x", Score: 1.0,
		}},
	}
	n := ApplyPlaybookBoost(results, hits)
	if n != 1 {
		t.Errorf("expected 1 boosted, got %d", n)
	}
	if results[0].ID != "a" || results[1].ID != "c" || results[2].ID != "b" {
		t.Errorf("expected order a,c,b after boost; got %v", idsOf(results))
	}
	if abs(float64(results[1].Distance)-0.15) > 1e-6 {
		t.Errorf("expected c distance 0.15 after boost; got %.4f", results[1].Distance)
	}
}

func TestApplyPlaybookBoost_HighestScoreWinsForSameAnswer(t *testing.T) {
	results := []Result{
		{ID: "a", Distance: 0.30, Corpus: "x"},
	}
	// Two playbook hits both pointing at "a". Score=0.4 (weak boost)
	// + Score=0.9 (strong boost). Strong should win — distance gets
	// multiplied by 1-0.5*0.9 = 0.55, not by 1-0.5*0.4 = 0.80.
	hits := []PlaybookHit{
		{PlaybookID: "p_weak", Distance: 0.05, Entry: PlaybookEntry{
			AnswerID: "a", AnswerCorpus: "x", Score: 0.4,
		}},
		{PlaybookID: "p_strong", Distance: 0.05, Entry: PlaybookEntry{
			AnswerID: "a", AnswerCorpus: "x", Score: 0.9,
		}},
	}
	ApplyPlaybookBoost(results, hits)
	wantDist := 0.30 * 0.55
	if abs(float64(results[0].Distance)-wantDist) > 1e-6 {
		t.Errorf("strong-score boost should win: want %.4f, got %.4f", wantDist, results[0].Distance)
	}
}

func TestApplyPlaybookBoost_CorpusAttributionRespected(t *testing.T) {
	// Playbook references answer_id="a" in corpus="x".
	// Results have answer_id="a" in corpus="y" — DIFFERENT corpus.
	// Boost should NOT apply; the (id, corpus) tuple is the join key,
	// not just id (otherwise different-corpus collisions would create
	// false positives).
	results := []Result{
		{ID: "a", Distance: 0.30, Corpus: "y"},
	}
	hits := []PlaybookHit{
		{PlaybookID: "p1", Distance: 0.05, Entry: PlaybookEntry{
			AnswerID: "a", AnswerCorpus: "x", Score: 1.0,
		}},
	}
	n := ApplyPlaybookBoost(results, hits)
	if n != 0 {
		t.Errorf("cross-corpus collision should not boost: got %d", n)
	}
	if abs(float64(results[0].Distance)-0.30) > 1e-6 {
		// 1e-6 tolerance accounts for float32→float64 conversion;
		// the assertion that matters is "unchanged from input."
		t.Errorf("distance should be unchanged: got %.6f", results[0].Distance)
	}
}

func TestPlaybookEntry_RoundTripJSON(t *testing.T) {
	e := NewPlaybookEntry("forklift query", "w-12345", "workers", 0.85, []string{"chicago", "verified"})
	raw, err := e.MarshalMetadata()
	if err != nil {
		t.Fatalf("marshal: %v", err)
	}
	got, err := UnmarshalPlaybookMetadata(raw)
	if err != nil {
		t.Fatalf("unmarshal: %v", err)
	}
	if got.QueryText != e.QueryText || got.AnswerID != e.AnswerID ||
		got.AnswerCorpus != e.AnswerCorpus || got.Score != e.Score {
		t.Errorf("round-trip mismatch: want %+v, got %+v", e, got)
	}
	if len(got.Tags) != 2 || got.Tags[0] != "chicago" {
		t.Errorf("tags lost in round-trip: %v", got.Tags)
	}
	if got.RecordedAtNs == 0 {
		t.Error("RecordedAtNs not set by NewPlaybookEntry")
	}
}

func TestUnmarshalPlaybookMetadata_RejectsEmpty(t *testing.T) {
	if _, err := UnmarshalPlaybookMetadata(json.RawMessage{}); err == nil {
		t.Error("empty metadata should error")
	}
}

func abs(f float64) float64 {
	if f < 0 {
		return -f
	}
	return f
}

func idsOf(rs []Result) []string {
	out := make([]string, len(rs))
	for i, r := range rs {
		out[i] = r.ID
	}
	return out
}