mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
Without file-link privilege (Windows without Developer Mode) merge mode copies agents and tracks the copies it wrote. A file a tool already had with the same bytes as the source was not tracked, so it was kept, and --force kept it too: the identical-content check ran before the force check. init's "kept local agents: X (sync agents --force replaces them)" then named a file --force could never take over, on every run. With --force the file is now recorded as skillshare's, so later syncs update it. Without --force nothing changes. Also: the five-name cap written twice is one helper, sync.ListNames, and doctor.md says when a recorded broken link is reported as a broken symlink (the behavior from #942).
464 lines
16 KiB
Go
464 lines
16 KiB
Go
package sync
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/resource"
|
|
)
|
|
|
|
// withoutFileLinks simulates Windows without Developer Mode.
|
|
func withoutFileLinks(t *testing.T) {
|
|
t.Helper()
|
|
t.Cleanup(SetFileLinksForTest(false))
|
|
}
|
|
|
|
func isRegularFile(t *testing.T, path string) bool {
|
|
t.Helper()
|
|
info, err := os.Lstat(path)
|
|
return err == nil && info.Mode().IsRegular()
|
|
}
|
|
|
|
func agentFixture(t *testing.T) (src, tgt string, agents []resource.DiscoveredResource) {
|
|
t.Helper()
|
|
src, tgt = t.TempDir(), t.TempDir()
|
|
os.WriteFile(filepath.Join(src, "tutor.md"), []byte("v1"), 0644)
|
|
agents = []resource.DiscoveredResource{{FlatName: "tutor.md", AbsPath: filepath.Join(src, "tutor.md")}}
|
|
return src, tgt, agents
|
|
}
|
|
|
|
func TestSyncAgents_MergeCopiesAndUpdatesWithoutFileLinks(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
target := filepath.Join(tgt, "tutor.md")
|
|
|
|
if _, err := SyncAgents(agents, src, tgt, "merge", false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
os.WriteFile(agents[0].AbsPath, []byte("v2"), 0644)
|
|
res, err := SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !isRegularFile(t, target) || readFile(t, target) != "v2" || len(res.Updated) != 1 {
|
|
t.Errorf("target = %q regular=%v, result = %+v; want an updated copy", readFile(t, target), isRegularFile(t, target), res)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeWithoutFileLinksReplacesLinkWithCopy(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
target := filepath.Join(tgt, "tutor.md")
|
|
os.Symlink(agents[0].AbsPath, target)
|
|
|
|
if _, err := SyncAgents(agents, src, tgt, "merge", false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !isRegularFile(t, target) || readFile(t, agents[0].AbsPath) != "v1" {
|
|
t.Error("link to the source file was not replaced by a copy")
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeWithoutFileLinksKeepsLocalAgents(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
os.WriteFile(filepath.Join(tgt, "tutor.md"), []byte("mine"), 0644)
|
|
os.WriteFile(filepath.Join(tgt, "local.md"), []byte("local"), 0644)
|
|
|
|
res, err := SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
PruneOrphanAgentLinks(tgt, src, agents, false)
|
|
|
|
if readFile(t, filepath.Join(tgt, "tutor.md")) != "mine" || readFile(t, filepath.Join(tgt, "local.md")) != "local" || len(res.Skipped) != 1 {
|
|
t.Errorf("local agents changed; result = %+v", res)
|
|
}
|
|
}
|
|
|
|
func TestPruneOrphanAgentLinks_RemovesTrackedCopies(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
SyncAgents(agents, src, tgt, "merge", false, false)
|
|
|
|
removed, _ := PruneOrphanAgentLinks(tgt, src, nil, false)
|
|
|
|
if _, err := os.Stat(filepath.Join(tgt, "tutor.md")); len(removed) != 1 || !os.IsNotExist(err) {
|
|
t.Errorf("removed = %v, want the orphaned copy pruned", removed)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeRelinksCopiesOnceFileLinksWork(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
restore := SetFileLinksForTest(false)
|
|
SyncAgents(agents, src, tgt, "merge", false, false)
|
|
restore()
|
|
|
|
if _, err := SyncAgents(agents, src, tgt, "merge", false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if isRegularFile(t, filepath.Join(tgt, "tutor.md")) {
|
|
t.Error("copy was not relinked after file links became available")
|
|
}
|
|
}
|
|
|
|
func TestSyncExtraFile_LinkModesCopyWithoutFileLinks(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
for _, mode := range []string{"merge", "symlink"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
src, tgt := setupExtraFileTest(t, "# agents")
|
|
f := NewExtraFile(src, "AGENTS.md", tgt, "", mode)
|
|
|
|
res, err := SyncExtraFile(f, false, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
target := filepath.Join(tgt, "AGENTS.md")
|
|
if f.Mode != "copy" || !isRegularFile(t, target) || readFile(t, target) != "# agents" || len(res.Warnings) != 1 {
|
|
t.Errorf("mode = %q, regular = %v, warnings = %v; want a copy", f.Mode, isRegularFile(t, target), res.Warnings)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSyncExtraFile_WithoutFileLinksReplacesLinkWithCopy(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt := setupExtraFileTest(t, "# agents")
|
|
target := filepath.Join(tgt, "AGENTS.md")
|
|
os.Symlink(filepath.Join(src, "AGENTS.md"), target)
|
|
f := NewExtraFile(src, "AGENTS.md", tgt, "", "merge")
|
|
|
|
if _, err := SyncExtraFile(f, false, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !isRegularFile(t, target) || ExtraFileStatus(f) != "synced" {
|
|
t.Errorf("regular = %v, status = %q; want a synced copy", isRegularFile(t, target), ExtraFileStatus(f))
|
|
}
|
|
}
|
|
|
|
func TestSyncExtra_MergeCopiesUpdatesAndPrunesWithoutFileLinks(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt := setupExtrasTest(t, map[string]string{"a.md": "v1", "b.md": "b"})
|
|
if _, err := syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
os.WriteFile(filepath.Join(src, "a.md"), []byte("v2"), 0644)
|
|
os.Remove(filepath.Join(src, "b.md"))
|
|
|
|
res, err := syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, bErr := os.Stat(filepath.Join(tgt, "b.md"))
|
|
if readFile(t, filepath.Join(tgt, "a.md")) != "v2" || !os.IsNotExist(bErr) || res.Pruned != 1 {
|
|
t.Errorf("a.md = %q, b.md err = %v, result = %+v; want updated and pruned copies", readFile(t, filepath.Join(tgt, "a.md")), bErr, res)
|
|
}
|
|
}
|
|
|
|
func TestRestoreExtraTarget_WithoutFileLinksPutsBackUserFile(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt := setupExtraFileTest(t, "# agents")
|
|
target := filepath.Join(tgt, "AGENTS.md")
|
|
os.WriteFile(target, []byte("mine"), 0644)
|
|
f := NewExtraFile(src, "AGENTS.md", tgt, "", "merge")
|
|
SyncExtraFile(f, false, "")
|
|
|
|
if _, err := RestoreExtraTarget(f); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if got := readFile(t, target); got != "mine" {
|
|
t.Errorf("restored %q, want the pre-attach file", got)
|
|
}
|
|
}
|
|
|
|
func TestSyncExtraFile_CopyReplacesOwnStaleCopySilently(t *testing.T) {
|
|
for _, mode := range []string{"copy", "merge"} { // merge copies without file links
|
|
t.Run(mode, func(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt := setupExtraFileTest(t, "v1")
|
|
target := filepath.Join(tgt, "AGENTS.md")
|
|
f := NewExtraFile(src, "AGENTS.md", tgt, "", mode)
|
|
SyncExtraFile(f, false, "")
|
|
os.WriteFile(filepath.Join(src, "AGENTS.md"), []byte("v2"), 0644)
|
|
|
|
res, err := SyncExtraFile(f, false, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for _, w := range res.Warnings {
|
|
if strings.Contains(w, "backed up") {
|
|
t.Errorf("unexpected warning %q", w)
|
|
}
|
|
}
|
|
if readFile(t, target) != "v2" || len(driftBackups(t, target)) != 0 {
|
|
t.Errorf("target = %q, drift = %v; want v2 and no drift backup", readFile(t, target), driftBackups(t, target))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSyncExtraFile_CopyStillBacksUpUserEdit(t *testing.T) {
|
|
src, tgt := setupExtraFileTest(t, "v1")
|
|
target := filepath.Join(tgt, "AGENTS.md")
|
|
f := NewExtraFile(src, "AGENTS.md", tgt, "", "copy")
|
|
SyncExtraFile(f, false, "")
|
|
os.WriteFile(target, []byte("edited"), 0644)
|
|
|
|
if _, err := SyncExtraFile(f, false, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if got := driftBackups(t, target); len(got) != 1 || got[0] != "edited" {
|
|
t.Errorf("drift = %v, want the edit", got)
|
|
}
|
|
}
|
|
|
|
func TestSyncedAgentCopies_CountsOnlyCurrentCopies(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if n := SyncedAgentCopies(tgt, agents); n != 1 {
|
|
t.Fatalf("after sync = %d, want 1", n)
|
|
}
|
|
|
|
os.WriteFile(agents[0].AbsPath, []byte("v2"), 0644)
|
|
|
|
if n := SyncedAgentCopies(tgt, agents); n != 0 {
|
|
t.Errorf("stale copy counted: %d, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestSyncedExtensionOutputs_CountsTrackedRenamedOutputs(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
spec := &ExtensionSpec{Run: []string{"cat"}, Dir: src, Name: "id", OutputExt: "toml"}
|
|
if _, err := SyncAgentsTransform(agents, src, tgt, "copy", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n := SyncedAgentCopies(tgt, agents); n != 0 {
|
|
t.Fatalf("source-name count = %d, want 0 (output is tutor.toml)", n)
|
|
}
|
|
if n := SyncedExtensionOutputs(tgt, agents); n != 1 {
|
|
t.Fatalf("after sync = %d, want 1", n)
|
|
}
|
|
|
|
os.WriteFile(filepath.Join(tgt, "tutor.toml"), []byte("edited"), 0644)
|
|
|
|
if n := SyncedExtensionOutputs(tgt, agents); n != 0 {
|
|
t.Errorf("edited output counted: %d, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestSyncedExtensionOutputs_OneOutputPerAgent(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
spec := &ExtensionSpec{Run: []string{"cat"}, Dir: src, Name: "id", OutputExt: "toml"}
|
|
if _, err := SyncAgentsTransform(agents, src, tgt, "copy", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// A second agent flattening to the same name must not reuse the one output.
|
|
twins := append(agents, agents[0])
|
|
|
|
if n := SyncedExtensionOutputs(tgt, twins); n != 1 {
|
|
t.Errorf("colliding agents = %d, want 1", n)
|
|
}
|
|
}
|
|
|
|
func TestSyncedExtensionOutputs_ChangedSourceIsDrift(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
spec := &ExtensionSpec{Run: []string{"cat"}, Dir: src, Name: "id", OutputExt: "toml"}
|
|
if _, err := SyncAgentsTransform(agents, src, tgt, "copy", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
os.WriteFile(agents[0].AbsPath, []byte("v2"), 0644)
|
|
|
|
if n := SyncedExtensionOutputs(tgt, agents); n != 0 {
|
|
t.Fatalf("output of an old source counted: %d, want 0", n)
|
|
}
|
|
if _, err := SyncAgentsTransform(agents, src, tgt, "copy", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n := SyncedExtensionOutputs(tgt, agents); n != 1 {
|
|
t.Errorf("after resync = %d, want 1", n)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeWithoutFileLinksPreservesIdenticalLocalFile(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
p := filepath.Join(tgt, "tutor.md")
|
|
os.WriteFile(p, []byte("v1"), 0644)
|
|
if _, err := SyncAgents(agents, src, tgt, "merge", false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PruneOrphanAgentLinks(tgt, src, nil, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(p); err != nil {
|
|
t.Fatalf("pre-existing local file deleted: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSyncExtra_MergeWithoutFileLinksPreservesIdenticalLocalFile(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt := t.TempDir(), t.TempDir()
|
|
os.WriteFile(filepath.Join(src, "a.md"), []byte("local"), 0644)
|
|
p := filepath.Join(tgt, "a.md")
|
|
os.WriteFile(p, []byte("local"), 0644)
|
|
if _, err := syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
os.Remove(filepath.Join(src, "a.md"))
|
|
if _, err := syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(p); err != nil {
|
|
t.Fatalf("pre-existing local file deleted: %v", err)
|
|
}
|
|
}
|
|
|
|
// One failed removal must not stop the remaining orphans from being pruned.
|
|
func TestCopyTracker_PruneOrphansContinuesAfterRemoveFailure(t *testing.T) {
|
|
skipUnlessPermissionsEnforced(t)
|
|
dir := t.TempDir()
|
|
locked := filepath.Join(dir, "locked")
|
|
os.MkdirAll(locked, 0755)
|
|
os.WriteFile(filepath.Join(locked, "a.md"), []byte("a"), 0644)
|
|
os.WriteFile(filepath.Join(dir, "b.md"), []byte("b"), 0644)
|
|
tracker := loadCopyTracker(dir)
|
|
tracker.record(filepath.Join("locked", "a.md"))
|
|
tracker.record("b.md")
|
|
os.Chmod(locked, 0555)
|
|
t.Cleanup(func() { os.Chmod(locked, 0755) })
|
|
|
|
removed, err := tracker.pruneOrphans(nil, false)
|
|
if err == nil {
|
|
t.Error("expected an error for the locked copy")
|
|
}
|
|
if len(removed) != 1 || removed[0] != "b.md" {
|
|
t.Errorf("expected b.md pruned despite the failure, got %v", removed)
|
|
}
|
|
}
|
|
|
|
func TestCopyTracker_PruneOrphansPreservesOwnershipOnRemoveFailure(t *testing.T) {
|
|
if runtime.GOOS != "linux" {
|
|
t.Skip("requires a read-only proc file")
|
|
}
|
|
tracker := loadCopyTracker("/proc")
|
|
tracker.record("version")
|
|
if !tracker.owns("version") {
|
|
t.Fatal("expected readable proc file")
|
|
}
|
|
tracker.changed = false
|
|
removed, err := tracker.pruneOrphans(nil, false)
|
|
if err == nil || !strings.Contains(err.Error(), "failed to remove orphaned copy version") {
|
|
t.Fatalf("expected removal error, got %v", err)
|
|
}
|
|
if len(removed) != 0 || !tracker.owns("version") || tracker.changed {
|
|
t.Fatalf("failed removal lost ownership or reported success: removed=%v changed=%v", removed, tracker.changed)
|
|
}
|
|
}
|
|
|
|
func TestCopyFallbackMissingManifestIsSyncedButUnowned(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
SyncAgents(agents, src, tgt, "merge", false, false)
|
|
os.Remove(filepath.Join(tgt, ".skillshare-manifest.json"))
|
|
res, err := SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if err != nil || len(res.Linked) != 0 || len(res.Skipped) != 1 {
|
|
t.Errorf("result=%+v err=%v", res, err)
|
|
}
|
|
if n := SyncedAgentCopies(tgt, agents); n != 1 {
|
|
t.Errorf("synced=%d", n)
|
|
}
|
|
PruneOrphanAgentLinks(tgt, src, nil, false)
|
|
if got := readFile(t, filepath.Join(tgt, "tutor.md")); got != "v1" {
|
|
t.Fatal(got)
|
|
}
|
|
src, tgt = setupExtrasTest(t, map[string]string{"a.md": "a"})
|
|
syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{})
|
|
os.Remove(filepath.Join(tgt, ".skillshare-manifest.json"))
|
|
extra, err := syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{})
|
|
if err != nil || extra.Synced != 0 || extra.Skipped != 1 || extra.Preserved != 1 {
|
|
t.Errorf("result=%+v err=%v", extra, err)
|
|
}
|
|
if status := CheckSyncStatus([]string{"a.md"}, src, tgt, "merge", false, ""); status != "synced" {
|
|
t.Errorf("status=%q", status)
|
|
}
|
|
os.Remove(filepath.Join(src, "a.md"))
|
|
syncExtraDir(src, tgt, "merge", config.ExtraTargetConfig{}, nil, ExtraSyncOptions{})
|
|
if got := readFile(t, filepath.Join(tgt, "a.md")); got != "a" {
|
|
t.Fatal(got)
|
|
}
|
|
}
|
|
|
|
func TestExtensionOutputStatus_ReportsOrphanOutputs(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
spec := &ExtensionSpec{Run: []string{"cat"}, Dir: src, Name: "id", OutputExt: "toml"}
|
|
if _, err := SyncAgentsTransform(agents, src, tgt, "copy", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
synced, orphans := ExtensionOutputStatus(tgt, nil)
|
|
|
|
if len(synced) != 0 || len(orphans) != 1 || orphans[0] != "tutor.toml" {
|
|
t.Errorf("orphans = %v, want [tutor.toml]", orphans)
|
|
}
|
|
}
|
|
|
|
// Refs #415: a plain copy tracked before the extension was enabled has no
|
|
// source fingerprint, so it must not pass for a converted output.
|
|
func TestExtensionOutputStatus_PlainCopyIsNotConverted(t *testing.T) {
|
|
src, tgt, agents := agentFixture(t)
|
|
if _, err := SyncAgents(agents, src, tgt, "copy", false, false, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
synced, _ := ExtensionOutputStatus(tgt, agents)
|
|
|
|
if synced[0] {
|
|
t.Error("tracked plain copy tutor.md counted as a converted output")
|
|
}
|
|
}
|
|
|
|
// A file that already matches the source but that skillshare did not write is
|
|
// kept as the user's. --force takes it over, so later syncs update it and it is
|
|
// no longer reported as kept.
|
|
func TestSyncAgents_MergeWithoutFileLinksForceTakesOverIdenticalFile(t *testing.T) {
|
|
withoutFileLinks(t)
|
|
src, tgt, agents := agentFixture(t)
|
|
os.WriteFile(filepath.Join(tgt, "tutor.md"), []byte("v1"), 0644)
|
|
|
|
kept, err := SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
forced, err := SyncAgents(agents, src, tgt, "merge", false, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
os.WriteFile(filepath.Join(src, "tutor.md"), []byte("v2"), 0644)
|
|
after, err := SyncAgents(agents, src, tgt, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(kept.Skipped) != 1 || len(forced.Skipped) != 0 || len(forced.Updated) != 1 {
|
|
t.Errorf("kept = %+v, forced = %+v; want kept without force and taken over with it", kept, forced)
|
|
}
|
|
if got := readFile(t, filepath.Join(tgt, "tutor.md")); got != "v2" || len(after.Skipped) != 0 {
|
|
t.Errorf("after takeover the file is %q and sync reported %+v; want it updated to v2", got, after)
|
|
}
|
|
}
|