Files
skillshare/internal/sync/pull_test.go
T
Willie 6adeea6409 fix(install,collect): keep a tracked source inside its destination; reject special SKILL.md files
--track --force removed the destination before cloning, so a local source
nested below it (or given as an explicit file:// URL) was deleted along with
any unpushed work, and the clone then failed. Resolve the source and refuse
when it is the destination or lies under it, for dry runs too.

HasSkillFile used a not-a-directory test, so a FIFO named SKILL.md counted as
a skill and the collect copy blocked on it. Require a regular file; a
symlinked SKILL.md still resolves through os.Stat.
2026-10-10 00:15:50 +08:00

384 lines
11 KiB
Go

package sync
import (
"os"
"path/filepath"
"testing"
)
func TestFindLocalSkills_EmptyTarget(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
os.MkdirAll(tgt, 0755)
skills, err := FindLocalSkills(tgt, src, "merge")
if err != nil {
t.Fatal(err)
}
if len(skills) != 0 {
t.Errorf("expected 0 skills in empty target, got %d", len(skills))
}
}
func TestFindLocalSkills_SymlinkTarget(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
// Target is symlink to source — symlink mode, no local skills
if err := os.Symlink(src, tgt); err != nil {
t.Fatal(err)
}
skills, err := FindLocalSkills(tgt, src, "symlink")
if err != nil {
t.Fatal(err)
}
if len(skills) != 0 {
t.Errorf("expected 0 skills for symlink target, got %d", len(skills))
}
}
func TestFindLocalSkills_MergeMode(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
skillSrc := filepath.Join(src, "synced")
os.MkdirAll(skillSrc, 0755)
os.MkdirAll(tgt, 0755)
// One symlinked skill (from sync)
if err := os.Symlink(skillSrc, filepath.Join(tgt, "synced")); err != nil {
t.Fatal(err)
}
// One local skill (user-created)
localSkill := filepath.Join(tgt, "my-local")
os.MkdirAll(localSkill, 0755)
os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("local skill"), 0644)
skills, err := FindLocalSkills(tgt, src, "merge")
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 local skill, got %d", len(skills))
}
if skills[0].Name != "my-local" {
t.Errorf("expected local skill name 'my-local', got %q", skills[0].Name)
}
}
func TestFindLocalSkills_SkipsCopyManaged(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
os.MkdirAll(tgt, 0755)
// Create a copy-mode managed skill
managedSkill := filepath.Join(tgt, "managed")
os.MkdirAll(managedSkill, 0755)
os.WriteFile(filepath.Join(managedSkill, "SKILL.md"), []byte("managed"), 0644)
// Write manifest marking it as managed
m := &Manifest{Managed: map[string]string{"managed": "abc123"}}
if err := WriteManifest(tgt, m); err != nil {
t.Fatal(err)
}
// Also create a truly local skill
localSkill := filepath.Join(tgt, "local-only")
os.MkdirAll(localSkill, 0755)
os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("local skill"), 0644)
skills, err := FindLocalSkills(tgt, src, "copy")
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 local skill (skipping managed), got %d", len(skills))
}
if skills[0].Name != "local-only" {
t.Errorf("expected 'local-only', got %q", skills[0].Name)
}
}
func TestFindLocalSkills_CopyToMergeSwitch(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
os.MkdirAll(tgt, 0755)
// Simulate: skills were synced in copy mode, manifest still has them
copiedSkill := filepath.Join(tgt, "copied")
os.MkdirAll(copiedSkill, 0755)
os.WriteFile(filepath.Join(copiedSkill, "SKILL.md"), []byte("copied"), 0644)
m := &Manifest{Managed: map[string]string{"copied": "abc123"}}
if err := WriteManifest(tgt, m); err != nil {
t.Fatal(err)
}
// Mode changed to merge — stale manifest entries should be ignored
skills, err := FindLocalSkills(tgt, src, "merge")
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill after copy→merge switch, got %d", len(skills))
}
if skills[0].Name != "copied" {
t.Errorf("expected 'copied', got %q", skills[0].Name)
}
}
func TestFindLocalSkills_EmptyModePassedDirectly(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
os.MkdirAll(tgt, 0755)
// Physical dir with copy-mode manifest
os.MkdirAll(filepath.Join(tgt, "skill-a"), 0755)
os.WriteFile(filepath.Join(tgt, "skill-a", "SKILL.md"), []byte("a"), 0644)
m := &Manifest{Managed: map[string]string{"skill-a": "abc123"}}
if err := WriteManifest(tgt, m); err != nil {
t.Fatal(err)
}
// Empty mode means the caller didn't resolve the global default.
// FindLocalSkills treats "" as non-copy, so manifest is ignored.
// Callers are responsible for resolving "" → global mode before calling.
skills, err := FindLocalSkills(tgt, src, "")
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill with raw empty mode, got %d", len(skills))
}
}
func TestPullSkill_NewSkill(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
localSkill := filepath.Join(tgt, "my-skill")
os.MkdirAll(localSkill, 0755)
os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("# My Skill"), 0644)
skill := LocalSkillInfo{
Name: "my-skill",
Path: localSkill,
}
if err := PullSkill(skill, src, false); err != nil {
t.Fatal(err)
}
// Verify skill was copied to source
if _, err := os.Stat(filepath.Join(src, "my-skill", "SKILL.md")); err != nil {
t.Error("expected SKILL.md to exist in source after pull")
}
}
func TestPullSkill_NestedDirectories(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
// Create a skill with nested subdirectories in the target
localSkill := filepath.Join(tgt, "my-skill")
os.MkdirAll(filepath.Join(localSkill, "prompts"), 0755)
os.MkdirAll(filepath.Join(localSkill, "templates", "react"), 0755)
os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("# My Skill"), 0644)
os.WriteFile(filepath.Join(localSkill, "prompts", "default.md"), []byte("prompt content"), 0644)
os.WriteFile(filepath.Join(localSkill, "templates", "base.md"), []byte("base template"), 0644)
os.WriteFile(filepath.Join(localSkill, "templates", "react", "component.md"), []byte("react template"), 0644)
skill := LocalSkillInfo{
Name: "my-skill",
Path: localSkill,
}
if err := PullSkill(skill, src, false); err != nil {
t.Fatal(err)
}
// Verify ALL files were copied, including nested ones
checks := []struct {
path string
want string
}{
{"my-skill/SKILL.md", "# My Skill"},
{"my-skill/prompts/default.md", "prompt content"},
{"my-skill/templates/base.md", "base template"},
{"my-skill/templates/react/component.md", "react template"},
}
for _, c := range checks {
data, err := os.ReadFile(filepath.Join(src, c.path))
if err != nil {
t.Errorf("expected %s to exist in source after pull: %v", c.path, err)
continue
}
if string(data) != c.want {
t.Errorf("%s: got %q, want %q", c.path, string(data), c.want)
}
}
}
func TestPullSkill_GitRepoSkipsGit(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
// Simulate a git-cloned repo in the target (like superpowers)
localSkill := filepath.Join(tgt, "superpowers")
os.MkdirAll(filepath.Join(localSkill, ".git", "objects"), 0755)
os.MkdirAll(filepath.Join(localSkill, "agents", "brainstorming"), 0755)
os.MkdirAll(filepath.Join(localSkill, "commands", "commit"), 0755)
os.MkdirAll(filepath.Join(localSkill, "docs"), 0755)
// .git files
os.WriteFile(filepath.Join(localSkill, ".git", "HEAD"), []byte("ref: refs/heads/main"), 0644)
os.WriteFile(filepath.Join(localSkill, ".git", "config"), []byte("[core]"), 0644)
// Skill files
os.WriteFile(filepath.Join(localSkill, "agents", "brainstorming", "SKILL.md"), []byte("# Brainstorming"), 0644)
os.WriteFile(filepath.Join(localSkill, "commands", "commit", "SKILL.md"), []byte("# Commit"), 0644)
os.WriteFile(filepath.Join(localSkill, "docs", "README.md"), []byte("# Docs"), 0644)
os.WriteFile(filepath.Join(localSkill, "gemini-extension.js"), []byte("// ext"), 0644)
skill := LocalSkillInfo{
Name: "superpowers",
Path: localSkill,
}
if err := PullSkill(skill, src, false); err != nil {
t.Fatal(err)
}
// Verify skill files were copied
checks := []struct {
path string
want string
}{
{"superpowers/agents/brainstorming/SKILL.md", "# Brainstorming"},
{"superpowers/commands/commit/SKILL.md", "# Commit"},
{"superpowers/docs/README.md", "# Docs"},
{"superpowers/gemini-extension.js", "// ext"},
}
for _, c := range checks {
data, err := os.ReadFile(filepath.Join(src, c.path))
if err != nil {
t.Errorf("expected %s to exist in source after pull: %v", c.path, err)
continue
}
if string(data) != c.want {
t.Errorf("%s: got %q, want %q", c.path, string(data), c.want)
}
}
// Verify .git was NOT copied
if _, err := os.Stat(filepath.Join(src, "superpowers", ".git")); !os.IsNotExist(err) {
t.Error(".git directory should NOT be copied to source")
}
}
func TestPullSkill_AlreadyExists(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
// Skill exists in both source and target
os.MkdirAll(filepath.Join(src, "my-skill"), 0755)
localSkill := filepath.Join(tgt, "my-skill")
os.MkdirAll(localSkill, 0755)
skill := LocalSkillInfo{
Name: "my-skill",
Path: localSkill,
}
err := PullSkill(skill, src, false)
if err == nil {
t.Error("expected error when skill already exists")
}
}
func TestPullSkill_ForceOverwrite(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
// Skill exists in source with old content
os.MkdirAll(filepath.Join(src, "my-skill"), 0755)
os.WriteFile(filepath.Join(src, "my-skill", "SKILL.md"), []byte("old"), 0644)
// Skill in target with new content
localSkill := filepath.Join(tgt, "my-skill")
os.MkdirAll(localSkill, 0755)
os.WriteFile(filepath.Join(localSkill, "SKILL.md"), []byte("new"), 0644)
skill := LocalSkillInfo{
Name: "my-skill",
Path: localSkill,
}
if err := PullSkill(skill, src, true); err != nil {
t.Fatal(err)
}
// Verify source was overwritten with target content
data, err := os.ReadFile(filepath.Join(src, "my-skill", "SKILL.md"))
if err != nil {
t.Fatal(err)
}
if string(data) != "new" {
t.Errorf("expected 'new' content after force pull, got %q", string(data))
}
}
func TestFindLocalSkills_SkipsDirWithoutSkillMd(t *testing.T) {
tmp := t.TempDir()
src := filepath.Join(tmp, "source")
tgt := filepath.Join(tmp, "target")
os.MkdirAll(src, 0755)
os.MkdirAll(filepath.Join(tgt, "scratch-dir"), 0755)
os.MkdirAll(filepath.Join(tgt, "dir-named-skill-md", "SKILL.md"), 0755)
os.MkdirAll(filepath.Join(tgt, "my-local"), 0755)
os.WriteFile(filepath.Join(tgt, "my-local", "SKILL.md"), []byte("local skill"), 0644)
skills, err := FindLocalSkills(tgt, src, "merge")
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 || skills[0].Name != "my-local" {
t.Fatalf("expected only my-local, got %+v", skills)
}
}
func TestHasSkillFile_RejectsDirectoryNamedSkillMd(t *testing.T) {
dir := t.TempDir()
if err := os.Mkdir(filepath.Join(dir, "SKILL.md"), 0755); err != nil {
t.Fatal(err)
}
if HasSkillFile(dir) {
t.Error("a directory named SKILL.md is not a skill file")
}
}