Files
Willie be8f8b2874 fix(hub): read the same tags for drafts and the index (#909)
The index and the draft builder read a skill's tags with different readers,
so the same SKILL.md could publish different tags depending on the path:

- The index accepted only the comma form (tags: git, workflow). A YAML list
  became "[git" and "review]", and a block list produced nothing.
- Drafts accepted only a YAML list, so the documented comma form produced no
  tags, and metadata.tags replaced the root field. After #901 the index
  ignores metadata, which made the two disagree there as well.

Both now call readSkillTags. It reads the root field only, in either form:
a list comes from the decoded frontmatter, and the comma form from the
existing line scan. The scan also unwraps a one-line list, so a skill whose
frontmatter YAML rejects on another line (for example an unquoted colon in
the description) no longer publishes bracketed fragments.

Tags under metadata are custom data and are not read by either path. The
skill format page says so in all five locales.
2026-11-14 23:52:45 +08:00

300 lines
10 KiB
Go

package hub
import (
"encoding/json"
"errors"
"os"
"path/filepath"
"slices"
"testing"
)
func TestDraftLifecycle(t *testing.T) {
store := DraftStore{Dir: filepath.Join(t.TempDir(), "hub-drafts")}
d, err := store.Create(Draft{Name: "Team", Entries: []DraftEntry{{ID: "one", Data: map[string]json.RawMessage{"name": json.RawMessage(`"Review"`), "source": json.RawMessage(`"acme/skills"`)}}}})
if err != nil {
t.Fatal(err)
}
old := d
d.Name = "Changed"
d, err = store.Save(d)
if err != nil || d.Revision == old.Revision {
t.Fatalf("save: %v %#v", err, d)
}
if _, err = store.Save(old); !errors.Is(err, ErrDraftConflict) {
t.Fatalf("stale write: %v", err)
}
if err = store.Delete(d.ID, old.Revision); !errors.Is(err, ErrDraftConflict) {
t.Fatalf("stale delete: %v", err)
}
loaded, err := store.Get(d.ID)
if err != nil || loaded.Name != "Changed" {
t.Fatalf("reload: %v", err)
}
if _, err = store.Get("../outside"); err == nil {
t.Fatal("accepted traversal")
}
if err = store.Delete(d.ID, d.Revision); err != nil {
t.Fatal(err)
}
if _, err = store.Get(d.ID); !os.IsNotExist(err) {
t.Fatalf("delete: %v", err)
}
}
func TestDraftImportExport(t *testing.T) {
raw := []byte(`{"schemaVersion":1,"custom":{"keep":true},"skills":[{"name":"same","source":"acme/repo","skill":"nested/review","future":42},{"name":"same","source":"https://github.com/acme/other"}]}`)
d, err := ImportDraft(raw)
if err != nil {
t.Fatal(err)
}
if len(d.Entries) != 2 || d.Entries[0].ID == d.Entries[1].ID {
t.Fatal("duplicate names lost")
}
data, err := ExportDraft(d)
if err != nil {
t.Fatal(err)
}
var out map[string]json.RawMessage
if err = json.Unmarshal(data, &out); err != nil {
t.Fatal(err)
}
var custom map[string]bool
json.Unmarshal(out["custom"], &custom)
if !custom["keep"] {
t.Fatalf("unknown field lost: %s", data)
}
var skills []map[string]json.RawMessage
json.Unmarshal(out["skills"], &skills)
if string(skills[0]["skill"]) != `"nested/review"` || string(skills[0]["future"]) != "42" {
t.Fatalf("entry fields lost: %s", data)
}
}
func TestDraftLocalAndInvalidImport(t *testing.T) {
d, err := ImportDraft([]byte(`{"schemaVersion":1,"sourcePath":"/author/skills","skills":[{"name":"local","source":"team/review"}]}`))
if err != nil {
t.Fatal(err)
}
if _, err = ExportDraft(d); err == nil {
t.Fatal("local source exported")
}
d.Entries[0].Data["source"] = json.RawMessage(`"acme/review"`)
data, err := ExportDraft(d)
if err != nil {
t.Fatal(err)
}
var out map[string]any
json.Unmarshal(data, &out)
if _, ok := out["sourcePath"]; ok {
t.Fatal("author path leaked")
}
for _, input := range []string{`{"schemaVersion":2,"skills":[]}`, `{"schemaVersion":1,"skills":{}}`, `{"schemaVersion":1,"skills":[{"name":3}]}`, `{"schemaVersion":1,"skills":[{"name":"x","tags":"bad"}]}`} {
if _, err := ImportDraft([]byte(input)); err == nil {
t.Fatalf("accepted %s", input)
}
}
}
func TestDraftCredentialAndAudit(t *testing.T) {
for _, source := range []string{"https://token@github.com/acme/repo", "https://github.com/acme/repo?token=secret", "ssh://git:secret@host/repo"} {
if SourceProblem(source) != "credentials" {
t.Errorf("credential source accepted: %s", source)
}
}
store := DraftStore{Dir: filepath.Join(t.TempDir(), "hub-drafts")}
d, _ := ImportDraft([]byte(`{"schemaVersion":1,"skills":[{"name":"x","source":"acme/one","riskScore":0,"riskLabel":"clean","auditedAt":"yesterday"}]}`))
d, err := store.Create(d)
if err != nil {
t.Fatal(err)
}
d.Entries[0].Data["source"] = json.RawMessage(`"acme/two"`)
d, err = store.Save(d)
if err != nil {
t.Fatal(err)
}
if _, ok := d.Entries[0].Data["riskScore"]; ok {
t.Fatal("stale audit retained")
}
}
func TestDraftConcurrentSaveAndScope(t *testing.T) {
store := DraftStore{Dir: filepath.Join(t.TempDir(), "hub-drafts")}
d, err := store.Create(Draft{Name: "one"})
if err != nil {
t.Fatal(err)
}
results := make(chan error, 2)
for range 2 {
go func() { _, err := store.Save(d); results <- err }()
}
successes, conflicts := 0, 0
for range 2 {
err := <-results
if err == nil {
successes++
} else if errors.Is(err, ErrDraftConflict) {
conflicts++
} else {
t.Fatal(err)
}
}
if successes != 1 || conflicts != 1 {
t.Fatalf("successes=%d conflicts=%d", successes, conflicts)
}
other := DraftStore{Dir: filepath.Join(t.TempDir(), "hub-drafts")}
if _, err := other.Get(d.ID); !os.IsNotExist(err) {
t.Fatalf("draft leaked between scopes: %v", err)
}
}
func TestDraftRejectSymlink(t *testing.T) {
root := t.TempDir()
target := filepath.Join(root, "target")
os.Mkdir(target, 0700)
os.Symlink(target, filepath.Join(root, "hub-drafts"))
store := DraftStore{Dir: filepath.Join(root, "hub-drafts")}
if _, err := store.Create(Draft{Name: "unsafe"}); err == nil {
t.Fatal("followed symlink directory")
}
}
func TestDraftCandidatesLocalPathsAndMetadata(t *testing.T) {
root := t.TempDir()
for _, path := range []string{"team/local", "remote"} {
dir := filepath.Join(root, path)
os.MkdirAll(dir, 0755)
os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: review\ndescription: >-\n Review changes\n carefully.\ntags: [review, team]\n---\n# Review"), 0644)
}
os.WriteFile(filepath.Join(root, ".metadata.json"), []byte(`{"version":1,"entries":{"remote":{"source":"acme/repo","subdir":"skills/review"}}}`), 0644)
entries, err := DraftCandidates(root)
if err != nil {
t.Fatal(err)
}
if len(entries) != 2 {
t.Fatalf("entries=%d", len(entries))
}
for _, entry := range entries {
if field(entry.Data, "description") != "Review changes carefully." {
t.Fatalf("missing folded description: %s", entry.Data["description"])
}
if entry.ID == "team/local" && SourceProblem(field(entry.Data, "source")) != "local_source" {
t.Fatal("local path treated as GitHub repo")
}
if entry.ID == "remote" && field(entry.Data, "skill") != "skills/review" {
t.Fatal("metadata selector lost")
}
}
}
// Regression for #862: a record written before #859 is published with the
// source that installs it, by the draft and by the index.
func TestPublishedSourceOfRecordBefore859(t *testing.T) {
root := t.TempDir()
os.MkdirAll(filepath.Join(root, "x"), 0755)
os.WriteFile(filepath.Join(root, "x", "SKILL.md"), []byte("---\nname: x\ndescription: d\n---\n# x"), 0644)
os.WriteFile(filepath.Join(root, ".metadata.json"), []byte(`{"version":1,"entries":{"x":{"source":"https://gitlab.com/team/skills/x","repo_url":"https://gitlab.com/team/skills.git","subdir":"x"}}}`), 0644)
const want = "https://gitlab.com/team/skills.git/x"
entries, err := DraftCandidates(root)
if err != nil {
t.Fatal(err)
}
if len(entries) != 1 || field(entries[0].Data, "source") != want || field(entries[0].Data, "skill") != "" {
t.Errorf("draft source=%q skill=%q, want source %q and no skill", field(entries[0].Data, "source"), field(entries[0].Data, "skill"), want)
}
idx, err := BuildIndex(root, false, false)
if err != nil {
t.Fatal(err)
}
if len(idx.Skills) != 1 || idx.Skills[0].Source != want {
t.Errorf("index skills = %+v, want source %q", idx.Skills, want)
}
}
func TestDraftCandidatesTrackedRepository(t *testing.T) {
root := t.TempDir()
dir := filepath.Join(root, "_team", "skills", "review")
os.MkdirAll(dir, 0755)
os.MkdirAll(filepath.Join(root, "_team", ".git"), 0755)
os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: review\n---\nReview."), 0644)
os.WriteFile(filepath.Join(root, ".metadata.json"), []byte(`{"version":1,"entries":{"_team":{"source":"acme/repo","tracked":true}}}`), 0644)
entries, err := DraftCandidates(root)
if err != nil || len(entries) != 1 {
t.Fatalf("candidates: %v %#v", err, entries)
}
if field(entries[0].Data, "source") != "acme/repo" || field(entries[0].Data, "skill") != "skills/review" {
t.Fatalf("tracked source lost: %#v", entries[0])
}
}
func TestDraftCandidatesKeepInstalledRef(t *testing.T) {
root := t.TempDir()
for _, path := range []string{"review", "_team/skills/lint"} {
os.MkdirAll(filepath.Join(root, path), 0755)
os.WriteFile(filepath.Join(root, path, "SKILL.md"), []byte("---\nname: x\n---\nX."), 0644)
}
os.MkdirAll(filepath.Join(root, "_team", ".git"), 0755)
os.WriteFile(filepath.Join(root, ".metadata.json"), []byte(`{"version":1,"entries":{
"review":{"source":"acme/repo","subdir":"skills/review","branch":"v1.2.0"},
"_team":{"source":"github.com/acme/team/tree/release/2","tracked":true,"branch":"release/2"}}}`), 0644)
entries, err := DraftCandidates(root)
if err != nil || len(entries) != 2 {
t.Fatalf("candidates: %v %#v", err, entries)
}
got := map[string]string{}
for _, e := range entries {
got[e.ID] = field(e.Data, "source") + " " + field(e.Data, "skill")
}
if want := "github.com/acme/repo/tree/v1.2.0 skills/review"; got["review"] != want {
t.Errorf("review = %q, want %q", got["review"], want)
}
if want := "github.com/acme/team/tree/release/2 skills/lint"; got["_team/skills/lint"] != want {
t.Errorf("tracked = %q, want %q", got["_team/skills/lint"], want)
}
}
// The draft and the index publish the same tags: the root field in either
// documented form, never a custom field under metadata.
func TestDraftAndIndexReadSameTags(t *testing.T) {
for name, tt := range map[string]struct {
frontmatter string
want []string
}{
"comma separated": {"tags: git, review", []string{"git", "review"}},
"flow list": {"tags: [git, review]", []string{"git", "review"}},
"block list": {"tags:\n - git\n - review", []string{"git", "review"}},
"metadata only": {"metadata:\n tags: [hidden]", nil},
"flow list beside a line YAML rejects": {"description: Use when: reviewing\ntags: [\"git\", review]", []string{"git", "review"}},
} {
t.Run(name, func(t *testing.T) {
root := t.TempDir()
os.MkdirAll(filepath.Join(root, "x"), 0755)
os.WriteFile(filepath.Join(root, "x", "SKILL.md"), []byte("---\nname: x\n"+tt.frontmatter+"\n---\n# x"), 0644)
entries, err := DraftCandidates(root)
if err != nil || len(entries) != 1 {
t.Fatalf("drafts = %v, err = %v", entries, err)
}
var draftTags []string
if raw, ok := entries[0].Data["tags"]; ok {
if err := json.Unmarshal(raw, &draftTags); err != nil {
t.Fatal(err)
}
}
if !slices.Equal(draftTags, tt.want) {
t.Errorf("draft tags = %v, want %v", draftTags, tt.want)
}
idx, err := BuildIndex(root, false, false)
if err != nil || len(idx.Skills) != 1 {
t.Fatalf("index = %+v, err = %v", idx, err)
}
if !slices.Equal(idx.Skills[0].Tags, tt.want) {
t.Errorf("index tags = %v, want %v", idx.Skills[0].Tags, tt.want)
}
})
}
}