Files
skillshare/tests/integration/sync_copy_test.go
T
Willie 3743a1ef3f fix(sync): honor file ignore patterns in copy mode
Apply config ignore patterns to copy-mode file traversal, checksum, mtime, CLI diff, and server sync/diff paths.

Add default ignores for .DS_Store, .git, and __pycache__ in global and project init configs.

Tests: go test ./... -count=1
2026-06-29 10:30:11 +08:00

620 lines
16 KiB
Go

//go:build !online
package integration
import (
"encoding/json"
"os"
"path/filepath"
"runtime"
"testing"
"skillshare/internal/sync"
"skillshare/internal/testutil"
)
// --- basic copy mode ---
func TestSync_CopyMode_CopiesSkills(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "---\nname: skill-a\n---\n# Skill A",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
copied := filepath.Join(targetPath, "skill-a")
if !sb.FileExists(filepath.Join(copied, "SKILL.md")) {
t.Error("skill-a should be copied to target")
}
if sb.IsSymlink(copied) {
t.Error("skill-a should be a real directory, not a symlink")
}
// Manifest should exist
manifestPath := filepath.Join(targetPath, sync.ManifestFile)
if !sb.FileExists(manifestPath) {
t.Error("manifest file should exist")
}
// Verify manifest content
var manifest sync.Manifest
data, _ := os.ReadFile(manifestPath)
if err := json.Unmarshal(data, &manifest); err != nil {
t.Fatalf("failed to parse manifest: %v", err)
}
if _, ok := manifest.Managed["skill-a"]; !ok {
t.Error("manifest should contain skill-a")
}
}
func TestSync_CopyMode_IgnoresConfiguredArtifacts(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
skillDir := sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "---\nname: skill-a\n---\n# Skill A",
})
if err := os.MkdirAll(filepath.Join(skillDir, "scripts", "__pycache__"), 0755); err != nil {
t.Fatalf("failed to create __pycache__: %v", err)
}
if err := os.WriteFile(filepath.Join(skillDir, "scripts", "__pycache__", "tool.pyc"), []byte("cache"), 0644); err != nil {
t.Fatalf("failed to write pyc: %v", err)
}
if err := os.MkdirAll(filepath.Join(skillDir, "tmp"), 0755); err != nil {
t.Fatalf("failed to create tmp: %v", err)
}
if err := os.WriteFile(filepath.Join(skillDir, "tmp", "note.txt"), []byte("temporary"), 0644); err != nil {
t.Fatalf("failed to write tmp file: %v", err)
}
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
ignore:
- tmp/
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
if sb.FileExists(filepath.Join(targetPath, "skill-a", "scripts", "__pycache__", "tool.pyc")) {
t.Error("__pycache__ artifact should not be copied")
}
if sb.FileExists(filepath.Join(targetPath, "skill-a", "tmp", "note.txt")) {
t.Error("configured ignored directory should not be copied")
}
}
func TestSync_CopyMode_SkipsUnchanged(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Skill A",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync
sb.RunCLI("sync").AssertSuccess(t)
// Second sync — should skip
result := sb.RunCLI("sync")
result.AssertSuccess(t)
result.AssertOutputContains(t, "skipped")
}
func TestSync_CopyMode_UpdatesChanged(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
skillDir := sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Original",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync
sb.RunCLI("sync").AssertSuccess(t)
// Modify source skill
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("# Modified"), 0644)
// Second sync — should update
result := sb.RunCLI("sync")
result.AssertSuccess(t)
result.AssertOutputContains(t, "updated")
// Verify target has new content
got := sb.ReadFile(filepath.Join(targetPath, "skill-a", "SKILL.md"))
if got != "# Modified" {
t.Errorf("target content should be updated, got: %s", got)
}
}
func TestSync_CopyMode_ForceOverwrites(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Source",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync
sb.RunCLI("sync").AssertSuccess(t)
// Force sync — should overwrite even though unchanged
result := sb.RunCLI("sync", "--force")
result.AssertSuccess(t)
// With force, unchanged skills show as updated (not skipped)
result.AssertOutputContains(t, "updated")
result.AssertOutputNotContains(t, "up to date")
}
func TestSync_CopyMode_ReplacesNonDirectoryManagedEntry(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Source",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync creates managed directory + manifest
sb.RunCLI("sync").AssertSuccess(t)
// Replace managed directory with a regular file
os.RemoveAll(filepath.Join(targetPath, "skill-a"))
os.WriteFile(filepath.Join(targetPath, "skill-a"), []byte("not-a-dir"), 0644)
// Sync should repair the invalid entry
result := sb.RunCLI("sync")
result.AssertSuccess(t)
result.AssertOutputContains(t, "updated")
skillPath := filepath.Join(targetPath, "skill-a")
info, err := os.Stat(skillPath)
if err != nil {
t.Fatalf("skill should exist after repair: %v", err)
}
if !info.IsDir() {
t.Fatal("skill should be restored as a directory")
}
if !sb.FileExists(filepath.Join(skillPath, "SKILL.md")) {
t.Error("restored directory should contain SKILL.md")
}
}
func TestSync_CopyMode_PreservesLocalSkills(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("shared-skill", map[string]string{
"SKILL.md": "# Shared",
})
targetPath := sb.CreateTarget("claude")
// Place a local skill directly in target
localDir := filepath.Join(targetPath, "local-only")
os.MkdirAll(localDir, 0755)
os.WriteFile(filepath.Join(localDir, "SKILL.md"), []byte("# Local"), 0644)
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
// Local skill should be preserved
if !sb.FileExists(filepath.Join(localDir, "SKILL.md")) {
t.Error("local skill should be preserved")
}
}
func TestSync_CopyMode_NestedSkills(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateNestedSkill("_team/frontend/ui", map[string]string{
"SKILL.md": "# UI Skill",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
// Should use flat name
flatDir := filepath.Join(targetPath, "_team__frontend__ui")
if !sb.FileExists(filepath.Join(flatDir, "SKILL.md")) {
t.Error("nested skill should be copied with flat name")
}
if sb.IsSymlink(flatDir) {
t.Error("should be a real copy, not symlink")
}
}
func TestSync_CopyMode_SymlinkedDirectoryInSkill(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("symlink behavior differs on Windows")
}
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
skillDir := sb.CreateSkill("ui-ux-pro-max", map[string]string{
"SKILL.md": "# UI UX Pro Max",
})
realData := filepath.Join(skillDir, "real-data")
if err := os.MkdirAll(realData, 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(realData, "payload.txt"), []byte("hello"), 0644); err != nil {
t.Fatal(err)
}
if err := os.Symlink("real-data", filepath.Join(skillDir, "data")); err != nil {
t.Skipf("symlink not supported in this environment: %v", err)
}
targetPath := sb.CreateTarget("copilot")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
copilot:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
copiedDataPath := filepath.Join(targetPath, "ui-ux-pro-max", "data")
if sb.IsSymlink(copiedDataPath) {
t.Error("copy mode should materialize symlinked directories as real directories")
}
if !sb.FileExists(filepath.Join(copiedDataPath, "payload.txt")) {
t.Error("symlinked directory content should be copied")
}
// Regression check: checksum path should also succeed on subsequent sync.
sb.RunCLI("sync").AssertSuccess(t)
}
func TestSync_CopyMode_Pruning(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# A"})
sb.CreateSkill("skill-b", map[string]string{"SKILL.md": "# B"})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync
sb.RunCLI("sync").AssertSuccess(t)
// Remove skill-b from source
os.RemoveAll(filepath.Join(sb.SourcePath, "skill-b"))
// Second sync — should prune skill-b
result := sb.RunCLI("sync")
result.AssertSuccess(t)
if sb.FileExists(filepath.Join(targetPath, "skill-b")) {
t.Error("skill-b should be pruned from target")
}
if !sb.FileExists(filepath.Join(targetPath, "skill-a", "SKILL.md")) {
t.Error("skill-a should remain")
}
// Manifest should not contain skill-b
var manifest sync.Manifest
data, _ := os.ReadFile(filepath.Join(targetPath, sync.ManifestFile))
json.Unmarshal(data, &manifest)
if _, ok := manifest.Managed["skill-b"]; ok {
t.Error("manifest should not contain pruned skill-b")
}
}
func TestSync_CopyMode_IncludeExclude(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("team-alpha", map[string]string{"SKILL.md": "# Alpha"})
sb.CreateSkill("team-beta", map[string]string{"SKILL.md": "# Beta"})
sb.CreateSkill("personal", map[string]string{"SKILL.md": "# Personal"})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
include:
- "team-*"
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
if !sb.FileExists(filepath.Join(targetPath, "team-alpha", "SKILL.md")) {
t.Error("team-alpha should be copied")
}
if !sb.FileExists(filepath.Join(targetPath, "team-beta", "SKILL.md")) {
t.Error("team-beta should be copied")
}
if sb.FileExists(filepath.Join(targetPath, "personal")) {
t.Error("personal should NOT be copied (excluded by include filter)")
}
}
func TestSync_CopyMode_DryRun(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# A"})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync", "--dry-run")
result.AssertSuccess(t)
// Should not actually copy
if sb.FileExists(filepath.Join(targetPath, "skill-a")) {
t.Error("dry run should not copy files")
}
// Manifest should not be created
if sb.FileExists(filepath.Join(targetPath, sync.ManifestFile)) {
t.Error("dry run should not create manifest")
}
}
// --- mode conversion ---
func TestSync_ModeConversion_MergeToCopy(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# A"})
targetPath := sb.CreateTarget("claude")
// Start with merge mode
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: merge
`)
sb.RunCLI("sync").AssertSuccess(t)
// Verify it's a symlink
if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) {
t.Fatal("merge mode should create symlink")
}
// Switch to copy mode
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
result := sb.RunCLI("sync")
result.AssertSuccess(t)
// Should now be a real copy, not symlink
skillPath := filepath.Join(targetPath, "skill-a")
if sb.IsSymlink(skillPath) {
t.Error("should be a real copy after conversion")
}
if !sb.FileExists(filepath.Join(skillPath, "SKILL.md")) {
t.Error("skill content should exist")
}
if !sb.FileExists(filepath.Join(targetPath, sync.ManifestFile)) {
t.Error("manifest should be created")
}
}
func TestSync_ModeConversion_CopyToMerge(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# A"})
targetPath := sb.CreateTarget("claude")
// Start with copy mode
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
sb.RunCLI("sync").AssertSuccess(t)
// Switch to merge mode with force (to replace copied dirs with symlinks)
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: merge
`)
result := sb.RunCLI("sync", "--force")
result.AssertSuccess(t)
// Should now be a symlink
if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) {
t.Error("should be a symlink after copy→merge conversion with --force")
}
// Manifest should exist with merge-mode value ("symlink") replacing copy-mode checksum
m, err := sync.ReadManifest(targetPath)
if err != nil {
t.Fatal(err)
}
if v, ok := m.Managed["skill-a"]; !ok {
t.Error("manifest should contain skill-a after copy→merge conversion")
} else if v != "symlink" {
t.Errorf("manifest value should be 'symlink' after conversion, got %q", v)
}
}
// --- mtime cache ---
func TestSync_CopyMode_MtimeCache(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Skill A",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync — copies skill
result := sb.RunCLI("sync")
result.AssertSuccess(t)
// Verify manifest has mtimes
var manifest sync.Manifest
data, _ := os.ReadFile(filepath.Join(targetPath, sync.ManifestFile))
if err := json.Unmarshal(data, &manifest); err != nil {
t.Fatalf("failed to parse manifest: %v", err)
}
if manifest.Mtimes == nil {
t.Fatal("manifest should have Mtimes map")
}
if _, ok := manifest.Mtimes["skill-a"]; !ok {
t.Fatal("manifest should have mtime for skill-a")
}
if manifest.Mtimes["skill-a"] == 0 {
t.Fatal("mtime should be non-zero")
}
// Second sync without changes — should skip via mtime fast-path
result2 := sb.RunCLI("sync")
result2.AssertSuccess(t)
result2.AssertOutputContains(t, "skipped")
}
func TestSync_CopyMode_MtimeCache_ForceBypassesMtime(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.CreateSkill("skill-a", map[string]string{
"SKILL.md": "# Skill A",
})
targetPath := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + targetPath + `
mode: copy
`)
// First sync
sb.RunCLI("sync").AssertSuccess(t)
// Force sync — should NOT use mtime shortcut
result := sb.RunCLI("sync", "--force")
result.AssertSuccess(t)
result.AssertOutputContains(t, "updated")
}
// --- project mode copy ---
func TestSync_CopyMode_Project(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
projectRoot := sb.SetupProjectDir("claude")
sb.CreateProjectSkill(projectRoot, "my-skill", map[string]string{
"SKILL.md": "# My Skill",
})
// Override project config to use copy mode
sb.WriteProjectConfig(projectRoot, `targets:
- name: claude
mode: copy
`)
result := sb.RunCLIInDir(projectRoot, "sync", "-p")
result.AssertSuccess(t)
copied := filepath.Join(projectRoot, ".claude", "skills", "my-skill")
if !sb.FileExists(filepath.Join(copied, "SKILL.md")) {
t.Error("skill should be copied in project mode")
}
if sb.IsSymlink(copied) {
t.Error("should be a real copy, not symlink")
}
}