mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
The list TUI marks a skill with disable-model-invocation as manual only, but the dashboard showed that state only inside the skill editor, so a skill the model never loads looked the same as any other. The skills list, tiles and the detail page's info column now carry a manual only tag. The skills API reports manualOnly, read the same way the TUI reads it. Agents are left out: their harnesses do not read the key. Refs #283
477 lines
15 KiB
Go
477 lines
15 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/trash"
|
|
)
|
|
|
|
func TestHandleListSkills_Empty(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
req := httptest.NewRequest(http.MethodGet, "/api/resources", nil)
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
var resp struct {
|
|
Resources []any `json:"resources"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if len(resp.Resources) != 0 {
|
|
t.Errorf("expected 0 resources, got %d", len(resp.Resources))
|
|
}
|
|
}
|
|
|
|
func TestHandleListSkills_WithSkills(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "alpha")
|
|
addSkill(t, src, "beta")
|
|
|
|
req := httptest.NewRequest(http.MethodGet, "/api/resources", nil)
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
var resp struct {
|
|
Resources []map[string]any `json:"resources"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if len(resp.Resources) != 2 {
|
|
t.Errorf("expected 2 resources, got %d", len(resp.Resources))
|
|
}
|
|
}
|
|
|
|
func TestHandleListSkills_ManualOnly(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "auto")
|
|
addSkill(t, src, "manual")
|
|
md := "---\nname: manual\ndisable-model-invocation: true\n---\n# manual\n"
|
|
if err := os.WriteFile(filepath.Join(src, "manual", "SKILL.md"), []byte(md), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/api/resources", nil))
|
|
|
|
var resp struct {
|
|
Resources []struct {
|
|
Name string `json:"name"`
|
|
ManualOnly bool `json:"manualOnly"`
|
|
} `json:"resources"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
for _, r := range resp.Resources {
|
|
if r.ManualOnly != (r.Name == "manual") {
|
|
t.Errorf("%s: manualOnly = %v", r.Name, r.ManualOnly)
|
|
}
|
|
}
|
|
if len(resp.Resources) != 2 {
|
|
t.Fatalf("expected 2 resources, got %d", len(resp.Resources))
|
|
}
|
|
}
|
|
|
|
func TestHandleGetSkill_Found(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "my-skill")
|
|
|
|
req := httptest.NewRequest(http.MethodGet, "/api/resources/my-skill", nil)
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
var resp map[string]any
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
res := resp["resource"].(map[string]any)
|
|
if res["flatName"] != "my-skill" {
|
|
t.Errorf("expected flatName 'my-skill', got %v", res["flatName"])
|
|
}
|
|
}
|
|
|
|
func TestHandleGetSkill_NotFound(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
req := httptest.NewRequest(http.MethodGet, "/api/resources/nonexistent", nil)
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
|
|
if rr.Code != http.StatusNotFound {
|
|
t.Errorf("expected 404, got %d", rr.Code)
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallSkill_DisabledSkill(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "disabled-skill")
|
|
if err := os.WriteFile(filepath.Join(src, ".skillignore"), []byte("disabled-skill\n"), 0644); err != nil {
|
|
t.Fatalf("disable skill: %v", err)
|
|
}
|
|
s.skillsStore = install.NewMetadataStore()
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/resources/disabled-skill", nil)
|
|
req.SetPathValue("name", "disabled-skill")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallSkill(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
if _, err := os.Stat(filepath.Join(src, "disabled-skill")); !os.IsNotExist(err) {
|
|
t.Fatalf("expected disabled-skill directory to be removed from source, stat err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestHandleGetSkillFile_PathTraversal(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "my-skill")
|
|
|
|
// Go's HTTP mux cleans ".." from URL paths before routing, so we need
|
|
// to bypass mux and call the handler directly with a crafted PathValue.
|
|
// Instead, test that a valid-looking but still-traversal path is rejected.
|
|
// The handler checks strings.Contains(fp, "..").
|
|
req := httptest.NewRequest(http.MethodGet, "/api/resources/my-skill/files/sub%2F..%2F..%2Fetc%2Fpasswd", nil)
|
|
rr := httptest.NewRecorder()
|
|
s.mux.ServeHTTP(rr, req)
|
|
|
|
// The mux will decode %2F as / and clean the path, which may result in
|
|
// 404 or the handler never seeing "..". Either non-200 is acceptable.
|
|
if rr.Code == http.StatusOK {
|
|
t.Error("expected non-200 for path traversal attempt")
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_NestedRepoPath(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/org/_team-skills", nil)
|
|
req.SetPathValue("name", "org/_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
if _, err := os.Stat(filepath.Join(src, "org", "_team-skills")); !os.IsNotExist(err) {
|
|
t.Fatalf("expected nested tracked repo to be removed from source, stat err=%v", err)
|
|
}
|
|
|
|
entries, err := filepath.Glob(filepath.Join(trash.TrashDir(), "org", "_team-skills_*"))
|
|
if err != nil {
|
|
t.Fatalf("failed to inspect trash: %v", err)
|
|
}
|
|
if len(entries) != 1 {
|
|
t.Fatalf("expected nested tracked repo to be moved to trash, got %d matches", len(entries))
|
|
}
|
|
|
|
// Verify List() can find nested trash entries
|
|
items := trash.List(trash.TrashDir())
|
|
if len(items) != 1 {
|
|
t.Fatalf("expected 1 trash item from List, got %d", len(items))
|
|
}
|
|
if items[0].Name != "org/_team-skills" {
|
|
t.Fatalf("expected Name 'org/_team-skills', got %q", items[0].Name)
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_AmbiguousBasenameRequiresFullPath(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
addTrackedRepo(t, src, filepath.Join("dept", "_team-skills"))
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/team-skills", nil)
|
|
req.SetPathValue("name", "team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
if !strings.Contains(rr.Body.String(), "multiple tracked repositories match") {
|
|
t.Fatalf("expected ambiguous repo error, got %s", rr.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_RejectsPathTraversal(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/../../evil", nil)
|
|
req.SetPathValue("name", "../evil")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
if !strings.Contains(rr.Body.String(), "invalid or missing tracked repository name") {
|
|
t.Fatalf("expected invalid name error, got %s", rr.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_PrunesRegistry(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, "_team-skills")
|
|
addSkill(t, src, "unrelated-skill") // must exist on disk to survive reconcile
|
|
|
|
// Seed store with entries belonging to this repo
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("team-skills/vue-best-practices", &install.MetadataEntry{Group: "team-skills", Tracked: true})
|
|
s.skillsStore.Set("team-skills/react-patterns", &install.MetadataEntry{Group: "team-skills", Tracked: true})
|
|
s.skillsStore.Set("unrelated-skill", &install.MetadataEntry{})
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/_team-skills", nil)
|
|
req.SetPathValue("name", "_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
// Store should not contain any team-skills entries
|
|
for _, name := range s.skillsStore.List() {
|
|
entry := s.skillsStore.Get(name)
|
|
if entry != nil && entry.Group == "team-skills" {
|
|
t.Fatalf("expected team-skills entries to be pruned, but found %q", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_NestedPruneDoesNotAffectSibling(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
addTrackedRepo(t, src, filepath.Join("dept", "_team-skills"))
|
|
|
|
// Seed store: entries from both nested repos + an exact-group entry
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("org/_team-skills/vue", &install.MetadataEntry{Group: "org/_team-skills", Tracked: true})
|
|
s.skillsStore.Set("dept/_team-skills/react", &install.MetadataEntry{Group: "dept/_team-skills", Tracked: true})
|
|
s.skillsStore.Set("unrelated", &install.MetadataEntry{})
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/org/_team-skills", nil)
|
|
req.SetPathValue("name", "org/_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
// org/_team-skills entries should be pruned
|
|
for _, name := range s.skillsStore.List() {
|
|
entry := s.skillsStore.Get(name)
|
|
if entry != nil && entry.Group == "org/_team-skills" {
|
|
t.Fatalf("expected org/_team-skills entries to be pruned, but found %q", name)
|
|
}
|
|
}
|
|
|
|
// dept/_team-skills entries must survive
|
|
var found bool
|
|
for _, name := range s.skillsStore.List() {
|
|
entry := s.skillsStore.Get(name)
|
|
if entry != nil && entry.Group == "dept/_team-skills" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("expected dept/_team-skills entries to survive, but they were pruned")
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_ProjectMode_GitignorePath(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
|
|
// Simulate project mode: set projectRoot to a temp dir containing .skillshare/
|
|
projectRoot := t.TempDir()
|
|
projectSkillsDir := filepath.Join(projectRoot, ".skillshare", "skills")
|
|
os.MkdirAll(projectSkillsDir, 0755)
|
|
s.projectRoot = projectRoot
|
|
s.projectCfg = &config.ProjectConfig{}
|
|
s.cfg.Source = projectSkillsDir
|
|
|
|
// Create tracked repo inside project skills dir
|
|
addTrackedRepo(t, projectSkillsDir, "_team-skills")
|
|
_ = src // global source unused in this test
|
|
|
|
// Write a gitignore entry the way project install does: in .skillshare/.gitignore
|
|
gitignoreDir := filepath.Join(projectRoot, ".skillshare")
|
|
gitignorePath := filepath.Join(gitignoreDir, ".gitignore")
|
|
os.WriteFile(gitignorePath, []byte("# BEGIN SKILLSHARE MANAGED - DO NOT EDIT\nskills/_team-skills/\n# END SKILLSHARE MANAGED\n"), 0644)
|
|
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("_team-skills", &install.MetadataEntry{Tracked: true})
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/_team-skills", nil)
|
|
req.SetPathValue("name", "_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
// Verify gitignore entry was removed from .skillshare/.gitignore
|
|
data, err := os.ReadFile(gitignorePath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read gitignore: %v", err)
|
|
}
|
|
if strings.Contains(string(data), "skills/_team-skills/") {
|
|
t.Fatal("expected skills/_team-skills/ to be removed from .skillshare/.gitignore, but it still exists")
|
|
}
|
|
}
|
|
|
|
// --- resolveTrackedRepo tests ---
|
|
|
|
func TestResolveTrackedRepo_AutoPrefixUnderscore(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, "_team-skills")
|
|
|
|
name, path, err := s.resolveTrackedRepo("team-skills")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if name != "_team-skills" {
|
|
t.Errorf("expected name '_team-skills', got %q", name)
|
|
}
|
|
if path == "" {
|
|
t.Fatal("expected non-empty path")
|
|
}
|
|
}
|
|
|
|
func TestResolveTrackedRepo_NestedAutoPrefix(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
|
|
name, path, err := s.resolveTrackedRepo("org/team-skills")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if name != filepath.Join("org", "_team-skills") {
|
|
t.Errorf("expected 'org/_team-skills', got %q", name)
|
|
}
|
|
if path == "" {
|
|
t.Fatal("expected non-empty path")
|
|
}
|
|
}
|
|
|
|
func TestResolveTrackedRepo_AlreadyPrefixed(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, "_team-skills")
|
|
|
|
name, path, err := s.resolveTrackedRepo("_team-skills")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if name != "_team-skills" {
|
|
t.Errorf("expected '_team-skills', got %q", name)
|
|
}
|
|
if path == "" {
|
|
t.Fatal("expected non-empty path")
|
|
}
|
|
}
|
|
|
|
func TestResolveTrackedRepo_NotFound(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
|
|
name, path, err := s.resolveTrackedRepo("nonexistent")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error for not-found: %v", err)
|
|
}
|
|
if name != "" || path != "" {
|
|
t.Errorf("expected empty results for not-found, got name=%q path=%q", name, path)
|
|
}
|
|
}
|
|
|
|
func TestResolveTrackedRepo_BasenameFallback(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
|
|
// Search by basename only — should find via fallback
|
|
name, path, err := s.resolveTrackedRepo("team-skills")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if name != filepath.Join("org", "_team-skills") {
|
|
t.Errorf("expected 'org/_team-skills', got %q", name)
|
|
}
|
|
if path == "" {
|
|
t.Fatal("expected non-empty path")
|
|
}
|
|
}
|
|
|
|
// --- Additional registry prune tests ---
|
|
|
|
func TestHandleUninstallRepo_PrunesNestedFullPathGroup(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
|
|
// Store with entries using full nested path as Group (new reconcile format)
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("org/_team-skills/vue", &install.MetadataEntry{Group: "org/_team-skills", Tracked: true})
|
|
s.skillsStore.Set("org/_team-skills/react", &install.MetadataEntry{Group: "org/_team-skills", Tracked: true})
|
|
s.skillsStore.Set("unrelated", &install.MetadataEntry{})
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/org/_team-skills", nil)
|
|
req.SetPathValue("name", "org/_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
// All org/_team-skills entries should be pruned, unrelated survives
|
|
names := s.skillsStore.List()
|
|
if len(names) != 1 {
|
|
t.Fatalf("expected 1 surviving entry, got %d", len(names))
|
|
}
|
|
if !s.skillsStore.Has("unrelated") {
|
|
t.Fatalf("expected 'unrelated' to survive")
|
|
}
|
|
}
|
|
|
|
func TestHandleUninstallRepo_PrunesNestedMembersByPrefix(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addTrackedRepo(t, src, filepath.Join("org", "_team-skills"))
|
|
|
|
// Store with the repo's own entry + a sub-skill using name prefix
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("org/_team-skills", &install.MetadataEntry{Tracked: true}) // repo entry
|
|
s.skillsStore.Set("org/_team-skills/sub-skill", &install.MetadataEntry{Group: "org/_team-skills", Tracked: true}) // member
|
|
s.skillsStore.Set("standalone", &install.MetadataEntry{})
|
|
|
|
req := httptest.NewRequest(http.MethodDelete, "/api/repos/org/_team-skills", nil)
|
|
req.SetPathValue("name", "org/_team-skills")
|
|
rr := httptest.NewRecorder()
|
|
s.handleUninstallRepo(rr, req)
|
|
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
|
|
names := s.skillsStore.List()
|
|
if len(names) != 1 {
|
|
t.Fatalf("expected 1 surviving entry, got %d", len(names))
|
|
}
|
|
if !s.skillsStore.Has("standalone") {
|
|
t.Fatalf("expected 'standalone' to survive")
|
|
}
|
|
}
|