package bm_test import ( "net/http" "reflect" "slices" "strings" "testing" "git.golem15.com/golem15/summercms/modules/backpack" "git.golem15.com/golem15/summercms/modules/pact" "git.golem15.com/golem15/summercms/modules/pier" "git.golem15.com/golem15/summercms/modules/surf" bm "git.golem15.com/jakub/sm-bm-plugin" ) // mountHost adapts a built surf router to pier.Host for a compile-only // mount: pier compiles every declared tool against the real route table. type mountHost struct{ r *surf.Router } func (h mountHost) Routes() []pier.RouteInfo { var out []pier.RouteInfo for _, ri := range h.r.Routes() { out = append(out, pier.RouteInfo{Method: ri.Method, Pattern: ri.Pattern, PluginID: ri.PluginID, Middleware: ri.Middleware}) } return out } func (h mountHost) Handler(method, pattern string) (http.Handler, bool) { return h.r.Handler(method, pattern) } func (mountHost) MountStream(string, string, http.Handler, ...string) error { return nil } func (mountHost) MountJSON(string, string, http.Handler) error { return nil } func (h mountHost) Owner(method, path string) (string, bool) { for _, ri := range h.r.Routes() { if ri.Method == method && ri.Pattern == path { return ri.PluginID, true } } return "", false } // pinnedTools is the sorted tool list of golem15.user plus jz.bm. var pinnedTools = []string{ "bm_course", "bm_courses", "bm_dashboard", "bm_deadlines", "bm_mark_reading_owned", "bm_mark_reading_read", "bm_meetings", "bm_readings", "bm_schedule", "bm_unmark_reading_owned", "bm_unmark_reading_read", "user_me", } // studentQueryKeys are the query keys each student handler reads // (controllers/api: query(r, ...)), by tool name. A tool query field outside // these would be sent and silently ignored. var studentQueryKeys = map[string][]string{ "courses": {"semester"}, "schedule": {"from", "to"}, "deadlines": {"from", "to"}, "readings": {"course"}, } // bmTools returns jz.bm's declared tools. func bmTools() []pact.MCPTool { return (&bm.Plugin{}).MCP().Tools } // TestBMMCP (criterion 4, D-09, D-14, D-15) mounts pier against golem15.user // and jz.bm without a database and pins the compiled tools; every tool binds // a token-guarded jz.bm route, names its scope, and reads only keys the // route reads. Runs under -short. func TestBMMCP(t *testing.T) { tools := bmTools() t.Run("compiles", func(t *testing.T) { app := backpack.New(testConfig(t)) if err := app.Config.Set("app.url", "https://bm.example.test"); err != nil { t.Fatal(err) } plugins := activate(t, app) router, err := surf.BuildRouter(app, plugins) if err != nil { t.Fatalf("BuildRouter: %v", err) } if err := app.Config.Set(pier.EnabledKey, true); err != nil { t.Fatal(err) } if err := pier.Mount(mountHost{r: router}, app, plugins); err != nil { t.Fatalf("pier.Mount: %v", err) } p, ok := app.Lookup[*pier.Pier]() if !ok { t.Fatal("pier was not mounted") } if got := p.ToolNames(); !slices.Equal(got, pinnedTools) { t.Fatalf("compiled tools %v, want %v", got, pinnedTools) } }) t.Run("routes", func(t *testing.T) { for _, tool := range tools { if !strings.HasPrefix(tool.Path, bm.TokenPrefix+"/") && !strings.HasPrefix(tool.Path, bm.ManagePrefix+"/") { t.Errorf("%s binds %s, outside %s and %s", tool.Name, tool.Path, bm.TokenPrefix, bm.ManagePrefix) } if tool.Guard != "user" { t.Errorf("%s: Guard %q, want user", tool.Name, tool.Guard) } } }) t.Run("descriptions", func(t *testing.T) { for _, tool := range tools { if !strings.Contains(tool.Description, "Needs scope read") && !strings.Contains(tool.Description, "Needs scope write") { t.Errorf("%s: description does not name its scope: %q", tool.Name, tool.Description) } if tool.Title == "" { t.Errorf("%s has no title", tool.Name) } } }) t.Run("inputs", func(t *testing.T) { for _, tool := range tools { rt := reflect.TypeOf(tool.Input) for rt.Kind() == reflect.Pointer { rt = rt.Elem() } if rt.Kind() != reflect.Struct { t.Errorf("%s: input is %s, not a struct", tool.Name, rt.Kind()) continue } for i := 0; i < rt.NumField(); i++ { f := rt.Field(i) key, _, _ := strings.Cut(f.Tag.Get("json"), ",") if key == "dry_run" { t.Errorf("%s has a dry_run field (D-14)", tool.Name) } switch { case f.Tag.Get("path") != "": if !strings.Contains(tool.Path, "{"+f.Tag.Get("path")+"}") { t.Errorf("%s.%s: path tag %q not in %s", tool.Name, f.Name, f.Tag.Get("path"), tool.Path) } case f.Tag.Get("query") != "": if strings.HasPrefix(tool.Path, bm.TokenPrefix+"/") && !slices.Contains(studentQueryKeys[tool.Name], f.Tag.Get("query")) { t.Errorf("%s.%s: query key %q is not one the handler reads", tool.Name, f.Name, f.Tag.Get("query")) } default: if tool.Method == http.MethodGet || tool.Method == http.MethodDelete { t.Errorf("%s.%s: a %s tool carries a body field %q", tool.Name, f.Name, tool.Method, key) } } } } }) } // studentRoutes are the routes mountStudent registers, in order. var studentRoutes = []string{ "GET /dashboard", "GET /courses", "GET /courses/{id}", "GET /schedule", "GET /meetings", "GET /deadlines", "GET /readings", "PUT /readings/{id}/progress", "DELETE /readings/{id}/progress", "PUT /readings/{id}/owned", "DELETE /readings/{id}/owned", "GET /materials", "GET /materials/{id}", } // TestTokenMirrorRoutes is the invariant of the two student surfaces: every // student route exists under APIPrefix (jwt.auth, no user.* middleware) and // under TokenPrefix (user.api_token, the token bucket and the matching // scope, no jwt.auth); the calendar feed and the chat have no twin. func TestTokenMirrorRoutes(t *testing.T) { app := backpack.New(testConfig(t)) plugins := activate(t, app) router, err := surf.BuildRouter(app, plugins) if err != nil { t.Fatalf("BuildRouter: %v", err) } byRoute := map[string][]string{} for _, rt := range router.Routes() { if rt.PluginID != "jz.bm" { continue } byRoute[rt.Method+" "+rt.Pattern] = rt.Middleware if strings.HasPrefix(rt.Pattern, bm.TokenPrefix+"/") { rest := strings.TrimPrefix(rt.Pattern, bm.TokenPrefix) if !slices.Contains(studentRoutes, rt.Method+" "+rest) { t.Errorf("%s %s under the token prefix is not a student route", rt.Method, rt.Pattern) } } } for _, route := range studentRoutes { method, pattern, _ := strings.Cut(route, " ") jwt, ok := byRoute[method+" "+bm.APIPrefix+pattern] if !ok { t.Errorf("%s %s is not registered", method, bm.APIPrefix+pattern) } else { if !slices.Contains(jwt, "jwt.auth") { t.Errorf("%s %s lacks jwt.auth: %v", method, bm.APIPrefix+pattern, jwt) } if slices.ContainsFunc(jwt, func(name string) bool { return strings.HasPrefix(name, "user.") }) { t.Errorf("%s %s carries user.* middleware: %v", method, bm.APIPrefix+pattern, jwt) } } tok, ok := byRoute[method+" "+bm.TokenPrefix+pattern] if !ok { t.Errorf("%s %s (the token twin) is not registered", method, bm.TokenPrefix+pattern) continue } scope := "user.scope:write" if method == http.MethodGet { scope = "user.scope:read" } for _, name := range []string{"user.api_token", "throttle:jz.bm.token", scope} { if !slices.Contains(tok, name) { t.Errorf("%s %s lacks %s: %v", method, bm.TokenPrefix+pattern, name, tok) } } if slices.Contains(tok, "jwt.auth") { t.Errorf("%s %s carries jwt.auth: %v", method, bm.TokenPrefix+pattern, tok) } if slices.Index(tok, "user.api_token") > slices.Index(tok, "throttle:jz.bm.token") { t.Errorf("%s %s: the token bucket runs before the guard: %v", method, bm.TokenPrefix+pattern, tok) } } for route := range byRoute { if strings.Contains(route, bm.TokenPrefix+"/calendar-feed") || strings.Contains(route, bm.TokenPrefix+"/chat") { t.Errorf("%s has a token twin", route) } } }