Files
skillshare/internal/server/handler_update_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

226 lines
7.7 KiB
Go

package server
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"skillshare/internal/install"
)
// initGitRepo creates a minimal git repo with an initial commit.
func initGitRepo(t *testing.T, dir string) {
t.Helper()
for _, args := range [][]string{
{"init"},
{"config", "user.email", "test@test.com"},
{"config", "user.name", "Test"},
} {
cmd := exec.Command("git", args...)
cmd.Dir = dir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %v failed: %s %v", args, out, err)
}
}
// Create initial commit
f := filepath.Join(dir, "README.md")
os.WriteFile(f, []byte("# init"), 0644)
for _, args := range [][]string{
{"add", "."},
{"commit", "-m", "init"},
} {
cmd := exec.Command("git", args...)
cmd.Dir = dir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %v failed: %s %v", args, out, err)
}
}
}
func TestUpdateSingle_NestedTrackedRepo_Resolves(t *testing.T) {
s, src := newTestServer(t)
// Create a nested tracked repo with a real git init
repoDir := filepath.Join(src, "org", "_team-skills")
os.MkdirAll(repoDir, 0755)
initGitRepo(t, repoDir)
result := s.updateSingle("org/_team-skills", false, true)
// Should resolve (may be up-to-date or updated, but NOT "error"/"not found")
if result.Action == "error" && strings.Contains(result.Message, "not found") {
t.Fatalf("updateSingle failed to resolve nested repo: %s", result.Message)
}
}
func TestUpdateSingle_BasenameFallback(t *testing.T) {
s, src := newTestServer(t)
// Create a top-level tracked repo with _ prefix
repoDir := filepath.Join(src, "_team-skills")
os.MkdirAll(repoDir, 0755)
initGitRepo(t, repoDir)
// Call with unprefixed basename — should resolve to _team-skills
result := s.updateSingle("team-skills", false, true)
if result.Action == "error" && strings.Contains(result.Message, "not found") {
t.Fatalf("updateSingle failed to resolve basename: %s", result.Message)
}
if result.Name != "_team-skills" && result.Name != "team-skills" {
// Name should reflect the resolved repo
t.Logf("resolved name: %s, action: %s", result.Name, result.Action)
}
}
func TestUpdateSingle_NotFound(t *testing.T) {
s, _ := newTestServer(t)
result := s.updateSingle("nonexistent-repo", false, true)
if result.Action != "error" {
t.Fatalf("expected action=error for not-found, got %q", result.Action)
}
if !strings.Contains(result.Message, "not found") && !strings.Contains(result.Message, "no update source") {
t.Fatalf("expected not-found message, got %q", result.Message)
}
}
func TestUpdateRegularSkill_NestedSkillRefreshesRootMetadataStore(t *testing.T) {
s, src := newTestServer(t)
remote := t.TempDir()
initGitRepo(t, remote)
remoteSkill := filepath.Join(remote, "skills", "agent-browser")
if err := os.MkdirAll(remoteSkill, 0755); err != nil {
t.Fatalf("create remote skill: %v", err)
}
if err := os.WriteFile(filepath.Join(remoteSkill, "SKILL.md"), []byte("---\nname: agent-browser\n---\n# Agent Browser\n"), 0644); err != nil {
t.Fatalf("write remote skill: %v", err)
}
runGit(t, remote, "add", ".")
runGit(t, remote, "commit", "-m", "add skill")
latestCommit := strings.TrimSpace(string(runGit(t, remote, "rev-parse", "--short", "HEAD")))
localSkill := filepath.Join(src, "tools", "agent-browser")
if err := os.MkdirAll(localSkill, 0755); err != nil {
t.Fatalf("create local skill: %v", err)
}
if err := os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("---\nname: agent-browser\n---\n# Old\n"), 0644); err != nil {
t.Fatalf("write local skill: %v", err)
}
store := install.NewMetadataStore()
store.Set("tools/agent-browser", &install.MetadataEntry{
Source: "file://" + remote + "//skills/agent-browser",
RepoURL: "file://" + remote,
Subdir: "skills/agent-browser",
Version: "old-version",
})
if err := store.Save(src); err != nil {
t.Fatalf("save metadata: %v", err)
}
s.skillsStore = store
result := s.updateRegularSkill("tools/agent-browser", localSkill, false, true)
if result.Action != "updated" {
t.Fatalf("expected updated action, got %q: %s", result.Action, result.Message)
}
rootStore, err := install.LoadMetadata(src)
if err != nil {
t.Fatalf("load root metadata: %v", err)
}
entry := rootStore.GetByPath("tools/agent-browser")
if entry == nil {
t.Fatal("expected root metadata entry for nested skill")
}
if entry.Version != latestCommit {
t.Fatalf("root metadata version = %q, want %q", entry.Version, latestCommit)
}
if cached := s.skillsStore.GetByPath("tools/agent-browser"); cached == nil || cached.Version != latestCommit {
t.Fatalf("server metadata cache was not refreshed, got %#v", cached)
}
if _, err := os.Stat(filepath.Join(src, "tools", install.MetadataFileName)); !os.IsNotExist(err) {
t.Fatalf("expected no nested metadata store, stat err=%v", err)
}
}
func runGit(t *testing.T, dir string, args ...string) []byte {
t.Helper()
cmd := exec.Command("git", args...)
cmd.Dir = dir
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v failed: %s %v", args, out, err)
}
return out
}
func TestUpdateRegularSkill_LocallyModifiedIsSkippedWithoutForce(t *testing.T) {
s, src := newTestServer(t)
skillPath := filepath.Join(src, "edited")
if err := os.MkdirAll(skillPath, 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillPath, "SKILL.md"), []byte("# my edit\n"), 0644); err != nil {
t.Fatal(err)
}
s.skillsStore = install.NewMetadataStore()
s.skillsStore.Set("edited", &install.MetadataEntry{
Source: "github.com/org/repo/edited",
RepoURL: "https://github.com/org/repo.git",
FileHashes: map[string]string{"SKILL.md": "sha256:original"},
})
result := s.updateRegularSkill("edited", skillPath, false, true)
if result.Action != "skipped" || !strings.Contains(result.Message, "(try force update)") {
t.Fatalf("got %q: %s, want skipped with a force hint", result.Action, result.Message)
}
}
func TestUpdateSingle_RegularSkillPriority(t *testing.T) {
s, src := newTestServer(t)
// Create both a regular skill with meta AND a tracked repo with _ prefix
skillDir := filepath.Join(src, "my-skill")
os.MkdirAll(skillDir, 0755)
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: my-skill\n---\n# Skill"), 0644)
addSkillMeta(t, src, "my-skill", "https://github.com/example/my-skill")
repoDir := filepath.Join(src, "_my-skill")
os.MkdirAll(repoDir, 0755)
initGitRepo(t, repoDir)
// updateSingle("my-skill") should try regular skill first (has meta).
// It will fail to clone (fake URL) but the point is it chose the skill path,
// not the tracked repo path. A "not found" would mean it tried the repo instead.
result := s.updateSingle("my-skill", false, true)
// The error should be about cloning (skill path), not "not found" (repo path)
if result.Action == "error" && strings.Contains(result.Message, "not found") && !strings.Contains(result.Message, "clone") {
t.Fatalf("expected regular skill to be tried first, got repo-like not-found: %s", result.Message)
}
}
func TestUpdateAgent_AzureOnPrem_UsesParseOpts(t *testing.T) {
s, _ := newTestServer(t)
s.cfg.AzureHosts = []string{"azuredevops.corp.com"}
// Verify that server.parseOpts() + ParseSourceWithOptions produces
// the correct CloneURL for an on-prem Azure agent source.
// This is the exact parse path used inside updateAgent.
source, err := install.ParseSourceWithOptions(
"https://azuredevops.corp.com/Org/Project/_git/Repo/agents/my-agent.md",
s.parseOpts(),
)
if err != nil {
t.Fatalf("ParseSourceWithOptions error: %v", err)
}
wantURL := "https://azuredevops.corp.com/Org/Project/_git/Repo"
if source.CloneURL != wantURL {
t.Errorf("CloneURL = %q, want %q", source.CloneURL, wantURL)
}
if source.Subdir != "agents/my-agent.md" {
t.Errorf("Subdir = %q, want %q", source.Subdir, "agents/my-agent.md")
}
}