Jakub Zych
464c74b80f
- viaMCP, includeBody and the material views (no body unless asked) - jz.bm.mcp-links: absolute url / *_url under MCP only - jz.bm.manage keyed per user for dispatched calls - bm_material and bm_materials in the pinned tool list Compile-only stubs; the tests fail on their assertions.
387 lines
13 KiB
Go
387 lines
13 KiB
Go
package bm_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"reflect"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.golem15.com/golem15/summercms/modules/backpack"
|
|
"git.golem15.com/golem15/summercms/modules/bouncer"
|
|
"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_material",
|
|
"bm_materials",
|
|
"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"},
|
|
"materials": {"course", "meeting", "tag", "type", "page", "per_page"},
|
|
"material": {"include_body"},
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
// dispatched returns r as pier dispatches it in-process: the api_token
|
|
// marker with principal id on its context.
|
|
func dispatched(r *http.Request, id uint) *http.Request {
|
|
return r.WithContext(bouncer.WithDispatch(r.Context(), &bouncer.Dispatch{
|
|
Guards: []string{"api_token"},
|
|
Principal: &bouncer.Principal{ID: id},
|
|
}))
|
|
}
|
|
|
|
// TestMCPLinks (D-16): under MCP every string under url or *_url that starts
|
|
// with a single / becomes absolute; other keys, protocol-relative and
|
|
// absolute URLs, error answers and plain HTTP answers are left alone.
|
|
func TestMCPLinks(t *testing.T) {
|
|
const answer = `{"data":{"url":"/storage/x","files":[{"url":"/storage/y","name":"/n"}],"syllabus_url":"/sylabusy/z.pdf","link":"https://x.test/a","other":"/keep","cdn_url":"//cdn.test/a","abs_url":"https://y.test/b","count":12345678901234567890,"nested":{"items":[{"thumb_url":"/t.png"}]}}}`
|
|
mw := (&bm.Plugin{}).Middlewares()[bm.MiddlewareMCPLinks]
|
|
if mw == nil {
|
|
t.Fatalf("%s is not exported", bm.MiddlewareMCPLinks)
|
|
}
|
|
handler := func(status int, body string) http.Handler {
|
|
return mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("Content-Length", strconv.Itoa(len(body)))
|
|
w.WriteHeader(status)
|
|
_, _ = w.Write([]byte(body))
|
|
}))
|
|
}
|
|
|
|
t.Run("plain HTTP untouched", func(t *testing.T) {
|
|
rec := httptest.NewRecorder()
|
|
handler(http.StatusOK, answer).ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
|
|
if rec.Body.String() != answer {
|
|
t.Errorf("plain answer = %s, want it unchanged", rec.Body.String())
|
|
}
|
|
})
|
|
|
|
t.Run("MCP answer absolute", func(t *testing.T) {
|
|
rec := httptest.NewRecorder()
|
|
handler(http.StatusOK, answer).ServeHTTP(rec, dispatched(httptest.NewRequest(http.MethodGet, "/", nil), 7))
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d", rec.Code)
|
|
}
|
|
if cl := rec.Header().Get("Content-Length"); cl != strconv.Itoa(rec.Body.Len()) {
|
|
t.Errorf("Content-Length = %s, body is %d bytes", cl, rec.Body.Len())
|
|
}
|
|
dec := json.NewDecoder(bytes.NewReader(rec.Body.Bytes()))
|
|
dec.UseNumber()
|
|
var got struct {
|
|
Data map[string]any `json:"data"`
|
|
}
|
|
if err := dec.Decode(&got); err != nil {
|
|
t.Fatalf("decode %s: %v", rec.Body.String(), err)
|
|
}
|
|
d := got.Data
|
|
want := map[string]string{
|
|
"url": "http://example.com/storage/x",
|
|
"syllabus_url": "http://example.com/sylabusy/z.pdf",
|
|
"link": "https://x.test/a",
|
|
"other": "/keep",
|
|
"cdn_url": "//cdn.test/a",
|
|
"abs_url": "https://y.test/b",
|
|
}
|
|
for k, v := range want {
|
|
if d[k] != v {
|
|
t.Errorf("%s = %v, want %s", k, d[k], v)
|
|
}
|
|
}
|
|
file := d["files"].([]any)[0].(map[string]any)
|
|
if file["url"] != "http://example.com/storage/y" || file["name"] != "/n" {
|
|
t.Errorf("files[0] = %v", file)
|
|
}
|
|
thumb := d["nested"].(map[string]any)["items"].([]any)[0].(map[string]any)
|
|
if thumb["thumb_url"] != "http://example.com/t.png" {
|
|
t.Errorf("nested thumb_url = %v", thumb["thumb_url"])
|
|
}
|
|
if n, _ := d["count"].(json.Number); n.String() != "12345678901234567890" {
|
|
t.Errorf("count = %v, want the number kept exactly", d["count"])
|
|
}
|
|
})
|
|
|
|
t.Run("MCP forwarded scheme", func(t *testing.T) {
|
|
rec := httptest.NewRecorder()
|
|
r := httptest.NewRequest(http.MethodGet, "/", nil)
|
|
r.Host = "bm.example.test"
|
|
r.Header.Set("X-Forwarded-Proto", "https")
|
|
handler(http.StatusOK, `{"url":"/a"}`).ServeHTTP(rec, dispatched(r, 7))
|
|
if !strings.Contains(rec.Body.String(), `"https://bm.example.test/a"`) {
|
|
t.Errorf("answer = %s", rec.Body.String())
|
|
}
|
|
})
|
|
|
|
t.Run("MCP error untouched", func(t *testing.T) {
|
|
const notFound = `{"error":"not_found","url":"/x"}`
|
|
rec := httptest.NewRecorder()
|
|
handler(http.StatusNotFound, notFound).ServeHTTP(rec, dispatched(httptest.NewRequest(http.MethodGet, "/", nil), 7))
|
|
if rec.Code != http.StatusNotFound || rec.Body.String() != notFound {
|
|
t.Errorf("error answer = %d %s", rec.Code, rec.Body.String())
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestManageBucketKey (research Pitfall 6): a dispatched management call is
|
|
// throttled per user, a bearer request per token hash, a bare one per IP;
|
|
// the token twins are throttled per user.
|
|
func TestManageBucketKey(t *testing.T) {
|
|
buckets := (&bm.Plugin{}).Buckets()
|
|
manage, ok := buckets["jz.bm.manage"]
|
|
if !ok {
|
|
t.Fatal("jz.bm.manage is not declared")
|
|
}
|
|
if manage.Max != 120 {
|
|
t.Errorf("jz.bm.manage Max = %d, want 120", manage.Max)
|
|
}
|
|
if got := manage.Key(dispatched(httptest.NewRequest(http.MethodGet, "/", nil), 7)); got != "jz.bm.manage.user|7" {
|
|
t.Errorf("dispatched key = %q, want jz.bm.manage.user|7", got)
|
|
}
|
|
bearer := httptest.NewRequest(http.MethodGet, "/", nil)
|
|
bearer.Header.Set("Authorization", "Bearer usr_secret")
|
|
if got := manage.Key(bearer); !strings.HasPrefix(got, "jz.bm.manage.token|") || strings.Contains(got, "usr_secret") {
|
|
t.Errorf("bearer key = %q, want the token hash", got)
|
|
}
|
|
if got := manage.Key(httptest.NewRequest(http.MethodGet, "/", nil)); !strings.HasPrefix(got, "jz.bm.manage.ip|") {
|
|
t.Errorf("bare key = %q, want the IP", got)
|
|
}
|
|
token, ok := buckets["jz.bm.token"]
|
|
if !ok {
|
|
t.Fatal("jz.bm.token is not declared")
|
|
}
|
|
r := httptest.NewRequest(http.MethodGet, "/", nil)
|
|
r = r.WithContext(bouncer.WithUser(context.Background(), &bouncer.Principal{ID: 7}))
|
|
if got := token.Key(r); got != "jz.bm.token|u:7" {
|
|
t.Errorf("token twin key = %q, want jz.bm.token|u:7", got)
|
|
}
|
|
}
|