Files
skillshare/internal/server/handler_skills_batch_test.go
T
Willie 7a7cceefab feat(update): flag and protect skills edited since install (#622)
* feat(update): flag and protect skills edited since install

A skill installed from a repository and then edited by hand looked
exactly like an untouched one: check said up to date, and update either
reported it current or silently reinstalled it over the edit (#621).

Install already records each file's hash, so check now compares a
remote skill's files with those hashes and reports "modified", and
update skips such a skill until --force (CLI single, --all/--group,
dashboard). --force, the dashboard's Force Retry on the skipped row, or
the confirmation on the skill page discards the edit and reinstalls.

Two hash paths had to be made reliable for this to be trusted: the
dashboard's folder-wide target edit refreshed hashes by basename, so a
nested skill looked edited after skillshare's own change, and a skill
whose files cannot be hashed now counts as modified instead of being
overwritten.

* fix(server): keep earlier local edits when a target change rewrites SKILL.md

Changing a skill's targets in the dashboard rewrites its SKILL.md, and
both the folder-wide and the single-skill handler then re-hashed the
whole directory as the new baseline. An edit the user had already made
to any file in the skill was absorbed into that baseline, so the skill
stopped counting as modified and the next update overwrote the edit
without --force.

Both handlers now move only SKILL.md's recorded hash, and only when the
file still matched it before the rewrite. skillshare's own target edit
no longer reads as a local change, and an earlier edit still does. The
whole-directory refresh helpers lost their last callers and are removed.
2026-10-24 16:33:37 +08:00

477 lines
16 KiB
Go

package server
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"testing"
"skillshare/internal/install"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
// addSkillWithTargets creates a skill with an existing targets field in frontmatter.
func addSkillWithTargets(t *testing.T, sourceDir, name string, targets []string) {
t.Helper()
skillDir := filepath.Join(sourceDir, name)
os.MkdirAll(skillDir, 0755)
targetYAML := ""
if len(targets) > 0 {
targetYAML = "\nmetadata:\n targets:\n"
for _, tgt := range targets {
targetYAML += " - " + tgt + "\n"
}
}
content := "---\nname: " + name + targetYAML + "\n---\n# " + name
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(content), 0644)
}
// addSkillNested creates a skill in a subdirectory (e.g. "folder/skill-name").
func addSkillNested(t *testing.T, sourceDir, relPath string) {
t.Helper()
skillDir := filepath.Join(sourceDir, filepath.FromSlash(relPath))
os.MkdirAll(skillDir, 0755)
name := filepath.Base(relPath)
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: "+name+"\n---\n# "+name), 0644)
}
// --- Batch endpoint tests ---
func TestHandleBatchSetTargets_SetSingleTarget(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
addSkillNested(t, src, "frontend/skill-b")
body := `{"folder":"frontend","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
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 batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2, got %d", resp.Updated)
}
if resp.Skipped != 0 {
t.Errorf("expected skipped=0, got %d", resp.Skipped)
}
if len(resp.Errors) != 0 {
t.Errorf("expected no errors, got %v", resp.Errors)
}
// Verify SKILL.md was modified for both skills
for _, name := range []string{"frontend/skill-a", "frontend/skill-b"} {
skillMD := filepath.Join(src, filepath.FromSlash(name), "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 1 || targets[0] != "claude" {
t.Errorf("skill %s: expected targets=[claude], got %v", name, targets)
}
}
}
// A target edit rewrites SKILL.md. The skill's recorded hashes must follow
// that edit, so skillshare's own change is not reported as modified, but must
// not absorb an edit the user made before, or update would overwrite it.
func TestSetTargets_KeepsLocalChangeStateOfRemoteSkill(t *testing.T) {
for _, endpoint := range []string{"folder", "skill"} {
for _, edited := range []bool{false, true} {
t.Run(fmt.Sprintf("%s/edited=%t", endpoint, edited), func(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
dir := filepath.Join(src, "frontend", "skill-a")
hashes, err := install.ComputeFileHashes(dir)
if err != nil {
t.Fatal(err)
}
s.skillsStore = install.NewMetadataStore()
s.skillsStore.Set("frontend/skill-a", &install.MetadataEntry{Source: "org/repo/skill-a", RepoURL: "https://github.com/org/repo.git", FileHashes: hashes})
if err := s.skillsStore.Save(src); err != nil {
t.Fatal(err)
}
if edited {
if err := os.WriteFile(filepath.Join(dir, "notes.md"), []byte("mine\n"), 0644); err != nil {
t.Fatal(err)
}
}
rr := httptest.NewRecorder()
if endpoint == "folder" {
s.handler.ServeHTTP(rr, httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"frontend","target":"claude"}`)))
} else {
req := httptest.NewRequest(http.MethodPatch, "/api/resources/skill-a/targets", bytes.NewBufferString(`{"target":"claude"}`))
req.SetPathValue("name", "skill-a")
s.handleSetSkillTargets(rr, req)
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if got := s.skillsStore.GetByPath("frontend/skill-a").LocallyModified(dir); got != edited {
t.Errorf("LocallyModified = %t, want %t", got, edited)
}
})
}
}
}
func TestHandleBatchSetTargets_RemoveTargets(t *testing.T) {
s, src := newTestServer(t)
addSkillWithTargets(t, src, "skill-a", []string{"claude", "cursor"})
addSkillWithTargets(t, src, "skill-b", []string{"claude"})
// Set target="" to remove targets (root-level folder)
body := `{"folder":"","target":""}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
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 batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2, got %d", resp.Updated)
}
// Verify targets were removed
for _, name := range []string{"skill-a", "skill-b"} {
skillMD := filepath.Join(src, name, "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 0 {
t.Errorf("skill %s: expected no targets after removal, got %v", name, targets)
}
}
}
func TestHandleBatchSetTargets_PathTraversal(t *testing.T) {
s, _ := newTestServer(t)
body := `{"folder":"../../../etc","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Errorf("expected 400 for path traversal, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandleBatchSetTargets_EmptyFolder_RootOnly(t *testing.T) {
s, src := newTestServer(t)
// Root-level skills
addSkill(t, src, "root-skill-a")
addSkill(t, src, "root-skill-b")
// Nested skill — should NOT be touched
addSkillNested(t, src, "nested-folder/deep-skill")
body := `{"folder":"","target":"cursor"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
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 batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2 (root only), got %d", resp.Updated)
}
// Nested skill must remain untouched
nestedMD := filepath.Join(src, "nested-folder", "deep-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(nestedMD, "targets")
if len(targets) != 0 {
t.Errorf("nested skill should not be modified, but got targets %v", targets)
}
}
func TestMatchesFolder(t *testing.T) {
tests := []struct {
relPath string
folder string
want bool
}{
// Wildcard matches everything
{"skill-a", "*", true},
{"frontend/skill-a", "*", true},
// Empty folder = root-level only
{"skill-a", "", true},
{"frontend/skill-a", "", false},
// Exact folder match
{"frontend/skill-a", "frontend", true},
{"frontend/sub/skill-a", "frontend", true},
{"backend/skill-a", "frontend", false},
// No trailing slash confusion
{"frontend/skill-a", "frontend/", false}, // trailing slash should not match
}
for _, tt := range tests {
got := matchesFolder(tt.relPath, tt.folder)
if got != tt.want {
t.Errorf("matchesFolder(%q, %q) = %v, want %v", tt.relPath, tt.folder, got, tt.want)
}
}
}
func TestHandleBatchSetTargets_FolderTrailingSlash(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
addSkillNested(t, src, "frontend/skill-b")
// Trailing slash should still match (server cleans the input)
body := `{"folder":"frontend/","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
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 batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2 (trailing slash cleaned), got %d", resp.Updated)
}
}
// --- Single skill endpoint tests ---
func TestHandleSetSkillTargets_SetTarget(t *testing.T) {
s, src := newTestServer(t)
addSkill(t, src, "my-skill")
body := `{"target":"claude"}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/my-skill/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "my-skill")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp map[string]any
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp["success"] != true {
t.Errorf("expected success=true, got %v", resp["success"])
}
// Verify SKILL.md was updated
skillMD := filepath.Join(src, "my-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 1 || targets[0] != "claude" {
t.Errorf("expected targets=[claude], got %v", targets)
}
}
func TestHandleSetSkillTargets_RemoveTarget(t *testing.T) {
s, src := newTestServer(t)
addSkillWithTargets(t, src, "my-skill", []string{"claude", "cursor"})
body := `{"target":""}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/my-skill/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "my-skill")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
// Verify targets field was removed
skillMD := filepath.Join(src, "my-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 0 {
t.Errorf("expected no targets after removal, got %v", targets)
}
}
func TestHandleSetSkillTargets_NotFound(t *testing.T) {
s, _ := newTestServer(t)
body := `{"target":"claude"}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/nonexistent/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "nonexistent")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusNotFound {
t.Errorf("expected 404, got %d: %s", rr.Code, rr.Body.String())
}
}
// --- Tracked-repo skills ---
const trackedSkillRel = "_caveman/plugins/caveman/skills/cavecrew"
// addTrackedRepoSkill creates a committed git repo "_caveman" holding one skill
// whose frontmatter targets cursor.
func addTrackedRepoSkill(t *testing.T, sourceDir string) string {
t.Helper()
repoDir := filepath.Join(sourceDir, "_caveman")
skillDir := filepath.Join(sourceDir, filepath.FromSlash(trackedSkillRel))
os.MkdirAll(skillDir, 0755)
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: cavecrew\nmetadata:\n targets:\n - cursor\n---\n# cavecrew"), 0644)
initGitRepo(t, repoDir)
return repoDir
}
// effectiveTargets returns the targets discovery reports for relPath.
func effectiveTargets(t *testing.T, sourceDir, relPath string) []string {
t.Helper()
skills, err := ssync.DiscoverSourceSkillsAll(sourceDir)
if err != nil {
t.Fatalf("discover: %v", err)
}
for _, d := range skills {
if d.RelPath == relPath {
return d.Targets
}
}
t.Fatalf("skill %s not discovered", relPath)
return nil
}
func setSkillTarget(t *testing.T, s *Server, name, target string) {
t.Helper()
req := httptest.NewRequest(http.MethodPatch, "/api/resources/"+name+"/targets", bytes.NewBufferString(`{"target":"`+target+`"}`))
req.SetPathValue("name", name)
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandleSetSkillTargets_TrackedRepoSkill_OverridesWithoutDirtyingRepo(t *testing.T) {
s, src := newTestServer(t)
repoDir := addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" {
t.Errorf("expected effective targets [claude], got %v", got)
}
if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 {
t.Errorf("expected clean tracked repo, got:\n%s", out)
}
}
func TestHandleSetSkillTargets_TrackedRepoSkill_EmptyTargetMeansAll(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "")
// Must not fall back to the repo's frontmatter [cursor].
if got := effectiveTargets(t, src, trackedSkillRel); got != nil {
t.Errorf("expected all targets (nil), got %v", got)
}
}
func TestHandleBatchSetTargets_TrackedRepoSkills(t *testing.T) {
s, src := newTestServer(t)
repoDir := addTrackedRepoSkill(t, src)
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"_caveman","target":"claude"}`))
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 batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 1 || resp.Skipped != 0 {
t.Errorf("expected updated=1 skipped=0, got updated=%d skipped=%d", resp.Updated, resp.Skipped)
}
if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" {
t.Errorf("expected effective targets [claude], got %v", got)
}
if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 {
t.Errorf("expected clean tracked repo, got:\n%s", out)
}
}
func TestHandleUninstallRepo_RemovesTargetOverrides(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
s.skillsStore.SetTargetOverride("_other/skill", []string{"cursor"})
req := httptest.NewRequest(http.MethodDelete, "/api/repos/_caveman", nil)
req.SetPathValue("name", "_caveman")
rr := httptest.NewRecorder()
s.handleUninstallRepo(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
overrides := install.LoadTargetOverrides(src)
if _, ok := overrides[trackedSkillRel]; ok {
t.Errorf("expected override for %s to be removed, got %v", trackedSkillRel, overrides)
}
if _, ok := overrides["_other/skill"]; !ok {
t.Errorf("expected override of another repo to survive, got %v", overrides)
}
}
func TestHandleBatchUninstall_RemovesTargetOverrides(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
b, _ := json.Marshal(batchUninstallRequest{Names: []string{"_caveman"}, Force: true})
req := httptest.NewRequest(http.MethodPost, "/api/uninstall", bytes.NewReader(b))
rr := httptest.NewRecorder()
s.handleBatchUninstall(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if overrides := install.LoadTargetOverrides(src); len(overrides) != 0 {
t.Errorf("expected no target overrides after uninstall, got %v", overrides)
}
}
func TestHandleBatchSetTargets_SaveFailureReported(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
// A directory at the metadata path makes the atomic rename in Save fail.
if err := os.MkdirAll(filepath.Join(src, install.MetadataFileName), 0755); err != nil {
t.Fatalf("block metadata file: %v", err)
}
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"_caveman","target":"claude"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusInternalServerError {
t.Fatalf("expected 500, got %d: %s", rr.Code, rr.Body.String())
}
}