126 lines
3.0 KiB
Go
126 lines
3.0 KiB
Go
package semantic
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/kami/maven/internal/router"
|
|
)
|
|
|
|
func TestValidRoute(t *testing.T) {
|
|
for _, r := range AllRoutes {
|
|
if !ValidRoute(r) {
|
|
t.Errorf("ValidRoute(%q) = false, want true", r)
|
|
}
|
|
}
|
|
if ValidRoute("bogus") {
|
|
t.Error("ValidRoute(\"bogus\") = true, want false")
|
|
}
|
|
}
|
|
|
|
func TestIntentToRouteMapping(t *testing.T) {
|
|
cases := []struct {
|
|
intent router.Intent
|
|
route SemanticRoute
|
|
}{
|
|
{router.IntentChat, RouteConversation},
|
|
{router.IntentQuery, RouteKnowledge},
|
|
{router.IntentAct, RouteAction},
|
|
{router.IntentReminder, RouteAction},
|
|
{router.IntentFact, RouteMemoryWrite},
|
|
{router.IntentNote, RouteMemoryWrite},
|
|
{router.IntentSystem, RouteSystem},
|
|
{router.Intent("unknown"), RouteUncertain},
|
|
{router.Intent(""), RouteUncertain},
|
|
}
|
|
for _, c := range cases {
|
|
got := IntentToRoute(c.intent)
|
|
if got != c.route {
|
|
t.Errorf("IntentToRoute(%q) = %q, want %q", c.intent, got, c.route)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLoadCorpus(t *testing.T) {
|
|
exs, err := LoadCorpus()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(exs) == 0 {
|
|
t.Fatal("corpus is empty")
|
|
}
|
|
for _, e := range exs {
|
|
if !ValidRoute(e.Route) {
|
|
t.Errorf("example %q has invalid route %q", e.SourceID, e.Route)
|
|
}
|
|
if e.Source == "" {
|
|
t.Errorf("example %q has empty source", e.SourceID)
|
|
}
|
|
if e.SplitGroup == "" {
|
|
t.Errorf("example %q has empty split_group", e.SourceID)
|
|
}
|
|
}
|
|
fastPath, residual := SplitCounts(exs)
|
|
if fastPath == 0 {
|
|
t.Error("no fast_path_resolved examples in corpus")
|
|
}
|
|
if residual == 0 {
|
|
t.Error("no residual examples in corpus")
|
|
}
|
|
t.Logf("corpus: %d examples (%d fast-path, %d residual)", len(exs), fastPath, residual)
|
|
}
|
|
|
|
func TestCorpusByRoute(t *testing.T) {
|
|
exs, err := LoadCorpus()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
byRoute := ByRoute(exs)
|
|
for _, route := range AllRoutes {
|
|
count := len(byRoute[route])
|
|
if count == 0 {
|
|
t.Errorf("no examples for route %q", route)
|
|
}
|
|
t.Logf(" %s: %d examples", route, count)
|
|
}
|
|
}
|
|
|
|
func TestSplitByFamily(t *testing.T) {
|
|
exs, err := LoadCorpus()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
train, eval := SplitByFamily(exs, 0.8)
|
|
total := len(train) + len(eval)
|
|
if total != len(exs) {
|
|
t.Errorf("split lost examples: train=%d eval=%d total=%d, want %d",
|
|
len(train), len(eval), total, len(exs))
|
|
}
|
|
trainGroups := map[string]bool{}
|
|
for _, e := range train {
|
|
trainGroups[e.SplitGroup] = true
|
|
}
|
|
for _, e := range eval {
|
|
if trainGroups[e.SplitGroup] {
|
|
t.Errorf("split_group %q leaked across train/eval (example %q)",
|
|
e.SplitGroup, e.SourceID)
|
|
}
|
|
}
|
|
t.Logf("split: %d train, %d eval", len(train), len(eval))
|
|
}
|
|
|
|
func TestFamilyID(t *testing.T) {
|
|
id1 := FamilyID("ru-act-002", "negation")
|
|
id2 := FamilyID("ru-act-002", "question")
|
|
id3 := FamilyID("ru-act-002", "")
|
|
id4 := FamilyID("ru-act-001", "negation")
|
|
if id1 == id2 {
|
|
t.Error("different transforms produced same FamilyID")
|
|
}
|
|
if id1 == id3 {
|
|
t.Error("transform and base produced same FamilyID")
|
|
}
|
|
if id1 == id4 {
|
|
t.Error("different base IDs produced same FamilyID")
|
|
}
|
|
}
|