mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
The unmatched include warning from #326 was written straight to DiagOutput. The dashboard sync never showed it because DiagOutput is the server's stdout, and an interactive CLI sync could redraw its progress area over it. Return the warnings with the merge and copy results so SyncSkillTarget adds them to the target's warnings, which both the CLI and the API already report. Prefix them with the target name, since the API returns one list for all targets. A top-level skill name has no path separator, so the suggestion cut off its first character and suggested "alpha" for a typo like "lpha". Compare the whole name in that case. Refs #325
908 lines
32 KiB
Go
908 lines
32 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/backup"
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/oplog"
|
|
ssync "skillshare/internal/sync"
|
|
)
|
|
|
|
func TestHandleSync_MergeMode(t *testing.T) {
|
|
tgtPath := filepath.Join(t.TempDir(), "claude-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"claude": tgtPath})
|
|
addSkill(t, src, "alpha")
|
|
|
|
body := `{"dryRun":false}`
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(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 struct {
|
|
Results []map[string]any `json:"results"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if len(resp.Results) != 1 {
|
|
t.Fatalf("expected 1 sync result, got %d", len(resp.Results))
|
|
}
|
|
if resp.Results[0]["target"] != "claude" {
|
|
t.Errorf("expected target 'claude', got %v", resp.Results[0]["target"])
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_BacksUpTargetsFirst(t *testing.T) {
|
|
tgtPath := filepath.Join(t.TempDir(), "claude-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"claude": tgtPath})
|
|
addSkill(t, src, "alpha")
|
|
addSkill(t, tgtPath, "local-only")
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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())
|
|
}
|
|
|
|
if backups, err := backup.List(); err != nil || len(backups) != 1 {
|
|
t.Fatalf("expected one pre-sync backup, got %d (err: %v)", len(backups), err)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_IgnoredSkillNotPrunedFromRegistry(t *testing.T) {
|
|
tgtPath := filepath.Join(t.TempDir(), "claude-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"claude": tgtPath})
|
|
|
|
// Create a skill with install metadata (so it appears in registry)
|
|
addSkill(t, src, "kept-skill")
|
|
addSkillMeta(t, src, "kept-skill", "github.com/user/kept")
|
|
|
|
// Create another skill that will be ignored
|
|
addSkill(t, src, "ignored-skill")
|
|
addSkillMeta(t, src, "ignored-skill", "github.com/user/ignored")
|
|
|
|
// Add .skillignore to exclude the second skill
|
|
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("ignored-skill\n"), 0644)
|
|
|
|
// Pre-populate store with both entries and persist to disk
|
|
// (server auto-reloads metadata from disk on each request)
|
|
s.skillsStore = install.NewMetadataStore()
|
|
s.skillsStore.Set("kept-skill", &install.MetadataEntry{Source: "github.com/user/kept"})
|
|
s.skillsStore.Set("ignored-skill", &install.MetadataEntry{Source: "github.com/user/ignored"})
|
|
if err := s.skillsStore.Save(src); err != nil {
|
|
t.Fatalf("failed to save metadata: %v", err)
|
|
}
|
|
|
|
// Run sync (non-dry-run)
|
|
body := `{"dryRun":false}`
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(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())
|
|
}
|
|
|
|
// Both entries should survive — ignored skill still exists on disk
|
|
names := s.skillsStore.List()
|
|
if len(names) != 2 {
|
|
t.Fatalf("expected 2 metadata entries after sync, got %d: %v", len(names), names)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_NoTargets(t *testing.T) {
|
|
s, _ := newTestServer(t) // no targets configured
|
|
|
|
body := `{}`
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(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 struct {
|
|
Results []any `json:"results"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if len(resp.Results) != 0 {
|
|
t.Errorf("expected 0 results for no targets, got %d", len(resp.Results))
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_AgentPrunesOrphanWhenSourceEmpty(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
|
|
agentSource := filepath.Join(t.TempDir(), "agents")
|
|
agentTarget := filepath.Join(t.TempDir(), "claude-agents")
|
|
if err := os.MkdirAll(agentSource, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent source: %v", err)
|
|
}
|
|
if err := os.MkdirAll(agentTarget, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent target: %v", err)
|
|
}
|
|
orphanPath := filepath.Join(agentTarget, "tutor.md")
|
|
if err := os.Symlink(filepath.Join(agentSource, "tutor.md"), orphanPath); err != nil {
|
|
t.Fatalf("seed orphan agent symlink: %v", err)
|
|
}
|
|
|
|
s.cfg.AgentsSource = agentSource
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: agentTarget},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatalf("save config: %v", err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"kind":"agent"}`))
|
|
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())
|
|
}
|
|
|
|
if _, err := os.Lstat(orphanPath); !os.IsNotExist(err) {
|
|
t.Fatalf("expected orphan agent symlink to be pruned, got err=%v", err)
|
|
}
|
|
|
|
var resp struct {
|
|
Results []struct {
|
|
Target string `json:"target"`
|
|
Pruned []string `json:"pruned"`
|
|
} `json:"results"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatalf("unmarshal sync response: %v", err)
|
|
}
|
|
|
|
if len(resp.Results) != 1 {
|
|
t.Fatalf("expected 1 sync result, got %d", len(resp.Results))
|
|
}
|
|
if resp.Results[0].Target != "claude" {
|
|
t.Fatalf("expected claude target, got %q", resp.Results[0].Target)
|
|
}
|
|
if len(resp.Results[0].Pruned) != 1 || resp.Results[0].Pruned[0] != "tutor.md" {
|
|
t.Fatalf("expected pruned tutor.md, got %+v", resp.Results[0].Pruned)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_AgentsRespectTargetExcludeFilter(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
|
|
agentSource := filepath.Join(t.TempDir(), "agents")
|
|
agentTarget := filepath.Join(t.TempDir(), "claude-agents")
|
|
if err := os.MkdirAll(agentSource, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent source: %v", err)
|
|
}
|
|
if err := os.MkdirAll(agentTarget, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent target: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(agentSource, "tutor.md"), []byte("# Tutor"), 0o644); err != nil {
|
|
t.Fatalf("write agent: %v", err)
|
|
}
|
|
|
|
s.cfg.AgentsSource = agentSource
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{
|
|
Path: agentTarget,
|
|
Exclude: []string{"*"},
|
|
},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatalf("save config: %v", err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"kind":"agent"}`))
|
|
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())
|
|
}
|
|
if _, err := os.Lstat(filepath.Join(agentTarget, "tutor.md")); !os.IsNotExist(err) {
|
|
t.Fatalf("excluded agent should not be synced, got err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_AgentsPruneExcludedTargetAgent(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
|
|
agentSource := filepath.Join(t.TempDir(), "agents")
|
|
agentTarget := filepath.Join(t.TempDir(), "claude-agents")
|
|
if err := os.MkdirAll(agentSource, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent source: %v", err)
|
|
}
|
|
if err := os.MkdirAll(agentTarget, 0o755); err != nil {
|
|
t.Fatalf("mkdir agent target: %v", err)
|
|
}
|
|
sourceAgent := filepath.Join(agentSource, "tutor.md")
|
|
if err := os.WriteFile(sourceAgent, []byte("# Tutor"), 0o644); err != nil {
|
|
t.Fatalf("write agent: %v", err)
|
|
}
|
|
targetAgent := filepath.Join(agentTarget, "tutor.md")
|
|
if err := os.Symlink(sourceAgent, targetAgent); err != nil {
|
|
t.Fatalf("seed synced agent: %v", err)
|
|
}
|
|
|
|
s.cfg.AgentsSource = agentSource
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{
|
|
Path: agentTarget,
|
|
Exclude: []string{"*"},
|
|
},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatalf("save config: %v", err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"kind":"agent"}`))
|
|
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())
|
|
}
|
|
if _, err := os.Lstat(targetAgent); !os.IsNotExist(err) {
|
|
t.Fatalf("excluded synced agent should be pruned, got err=%v", err)
|
|
}
|
|
}
|
|
|
|
// newAgentSyncServer returns a server whose agents source holds tutor.md.
|
|
func newAgentSyncServer(t *testing.T) (*Server, string, string) {
|
|
t.Helper()
|
|
s, src := newTestServer(t)
|
|
agentSource := filepath.Join(t.TempDir(), "agents")
|
|
if err := os.MkdirAll(agentSource, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(agentSource, "tutor.md"), []byte("# Tutor"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.cfg.AgentsSource = agentSource
|
|
return s, src, agentSource
|
|
}
|
|
|
|
func TestHandleSync_AgentTargetFailureCountsInLog(t *testing.T) {
|
|
s, _, _ := newAgentSyncServer(t)
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-agents"), Include: []string{"["}},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"kind":"agent"}`))
|
|
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 struct {
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !slices.ContainsFunc(resp.Warnings, func(w string) bool {
|
|
return strings.HasPrefix(w, "agent sync failed for claude: invalid agent filter: ")
|
|
}) {
|
|
t.Fatalf("expected invalid filter warning, got %v", resp.Warnings)
|
|
}
|
|
entries, err := oplog.Read(config.ConfigPath(), oplog.OpsFile, 1)
|
|
if err != nil || len(entries) != 1 {
|
|
t.Fatalf("read ops log: %v (%d entries)", err, len(entries))
|
|
}
|
|
if e := entries[0]; e.Status != "error" || e.Args["targets_failed"] != float64(1) {
|
|
t.Fatalf("expected error sync with targets_failed 1, got status %q args %v", e.Status, e.Args)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_LogCountsEachFailedTargetOnce(t *testing.T) {
|
|
s, src, _ := newAgentSyncServer(t)
|
|
addSkill(t, src, "alpha")
|
|
s.cfg.Targets["both"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "both-skills"), Include: []string{"["}},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "both-agents"), Include: []string{"["}},
|
|
}
|
|
s.cfg.Targets["agent-only"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "agent-only-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "agent-only-agents"), Include: []string{"["}},
|
|
}
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-agents")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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())
|
|
}
|
|
entries, err := oplog.Read(config.ConfigPath(), oplog.OpsFile, 1)
|
|
if err != nil || len(entries) != 1 {
|
|
t.Fatalf("read ops log: %v (%d entries)", err, len(entries))
|
|
}
|
|
e := entries[0]
|
|
got, _ := json.Marshal(e.Args["failed_targets"])
|
|
if e.Status != "partial" || e.Args["targets_failed"] != float64(2) || e.Args["targets_total"] != float64(3) || string(got) != `["agent-only","both"]` {
|
|
t.Fatalf("expected partial sync with 2 of 3 targets failed (agent-only, both), got status %q args %v", e.Status, e.Args)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_AgentsSkipTargetWithoutAgentsPathSilently(t *testing.T) {
|
|
s, _, _ := newAgentSyncServer(t)
|
|
s.cfg.Targets["custom-tool"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "custom-skills")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"kind":"agent"}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 0 || len(resp.Warnings) != 0 {
|
|
t.Fatalf("expected silent skip, got results %+v warnings %v", resp.Results, resp.Warnings)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_MergesAgentsIntoSkillsRow(t *testing.T) {
|
|
s, src, _ := newAgentSyncServer(t)
|
|
addSkill(t, src, "alpha")
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-agents")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 1 || !slices.Equal(resp.Results[0].Linked, []string{"alpha", "tutor.md"}) {
|
|
t.Fatalf("expected one claude row linking alpha and tutor.md, got %+v", resp.Results)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ProjectSyncsOnlyThatProjectsSkills(t *testing.T) {
|
|
global := filepath.Join(t.TempDir(), "claude-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"claude": global})
|
|
addSkill(t, src, "team-a")
|
|
root := filepath.Join(filepath.Dir(src), "app")
|
|
addProject(t, s, root)
|
|
|
|
rr := projectRequest(t, s, http.MethodPost, "/api/sync", `{"project":"`+root+`"}`)
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
if _, err := os.Stat(filepath.Join(root, ".claude", "skills", "team-a")); err != nil {
|
|
t.Fatalf("project target not synced: %v", err)
|
|
}
|
|
if _, err := os.Lstat(filepath.Join(global, "team-a")); !os.IsNotExist(err) {
|
|
t.Fatalf("global target was synced, err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ProjectSyncsOnlyThatProjectsAgents(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
agentSource := filepath.Join(t.TempDir(), "agents")
|
|
globalAgents := filepath.Join(t.TempDir(), "claude-agents")
|
|
for _, dir := range []string{agentSource, globalAgents} {
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := os.WriteFile(filepath.Join(agentSource, "tutor.md"), []byte("# Tutor"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.cfg.AgentsSource = agentSource
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: globalAgents},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
root := filepath.Join(filepath.Dir(src), "app")
|
|
if err := os.MkdirAll(root, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
body := `{"create":true,"root":"` + root + `","targets":["claude"],"agents":{"mode":"merge","include":[],"exclude":[]}}`
|
|
if rr := projectRequest(t, s, http.MethodPut, "/api/projects", body); rr.Code != http.StatusOK {
|
|
t.Fatalf("add project: %d %s", rr.Code, rr.Body)
|
|
}
|
|
|
|
rr := projectRequest(t, s, http.MethodPost, "/api/sync", `{"kind":"agent","project":"`+root+`"}`)
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
if _, err := os.Lstat(filepath.Join(root, ".claude", "agents", "tutor.md")); err != nil {
|
|
t.Fatalf("project agent not synced: %v", err)
|
|
}
|
|
if _, err := os.Lstat(filepath.Join(globalAgents, "tutor.md")); !os.IsNotExist(err) {
|
|
t.Fatalf("global agent was synced, err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_UnknownProjectIsRejected(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
rr := projectRequest(t, s, http.MethodPost, "/api/sync", `{"project":"`+filepath.Join(filepath.Dir(src), "nope")+`"}`)
|
|
if rr.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d: %s", rr.Code, rr.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ReportsPathOverlapCount(t *testing.T) {
|
|
shared := filepath.Join(t.TempDir(), "agents-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"universal": shared, "codex": shared})
|
|
addSkill(t, src, "alpha")
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"dryRun":true}`))
|
|
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 struct {
|
|
PathOverlap int `json:"path_overlap"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if resp.PathOverlap != 2 {
|
|
t.Errorf("path_overlap = %d, want 2", resp.PathOverlap)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ReportsFolderConflicts(t *testing.T) {
|
|
shared := filepath.Join(t.TempDir(), "agents-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"universal": shared, "codex": shared})
|
|
addSkill(t, src, "alpha")
|
|
s.cfg.Targets["universal"] = config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: shared, Exclude: []string{"feature-radar*"}}}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatalf("failed to save config: %v", err)
|
|
}
|
|
|
|
for _, tc := range []struct{ method, url, body string }{
|
|
{http.MethodPost, "/api/sync", `{"dryRun":true}`},
|
|
{http.MethodGet, "/api/diff", ""},
|
|
} {
|
|
req := httptest.NewRequest(tc.method, tc.url, strings.NewReader(tc.body))
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
if rr.Code != http.StatusOK {
|
|
t.Fatalf("%s: expected 200, got %d: %s", tc.url, rr.Code, rr.Body.String())
|
|
}
|
|
var resp struct {
|
|
PathOverlap int `json:"path_overlap"`
|
|
FolderConflicts []config.SkillsFolderConflict `json:"folder_conflicts"`
|
|
}
|
|
json.Unmarshal(rr.Body.Bytes(), &resp)
|
|
if len(resp.FolderConflicts) != 1 {
|
|
t.Fatalf("%s: expected 1 folder conflict, got %+v", tc.url, resp.FolderConflicts)
|
|
}
|
|
c := resp.FolderConflicts[0]
|
|
if c.Keep != "universal" || len(c.Stop) != 1 || c.Stop[0] != "codex" {
|
|
t.Errorf("%s: conflict = %+v, want keep universal, stop codex", tc.url, c)
|
|
}
|
|
if resp.PathOverlap != 0 {
|
|
t.Errorf("%s: overlap fully explained by the conflict, got path_overlap %d", tc.url, resp.PathOverlap)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_SkillTargetFailureKeepsSyncingOthers(t *testing.T) {
|
|
s, src, _ := newAgentSyncServer(t)
|
|
addSkill(t, src, "alpha")
|
|
s.cfg.Targets["broken"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "broken-skills"), Include: []string{"["}},
|
|
}
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-agents")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 1 || resp.Results[0].Target != "claude" || !slices.Equal(resp.Results[0].Linked, []string{"alpha", "tutor.md"}) {
|
|
t.Fatalf("expected only the claude row with alpha and tutor.md, got %+v", resp.Results)
|
|
}
|
|
if !slices.ContainsFunc(resp.Warnings, func(w string) bool {
|
|
return strings.HasPrefix(w, "broken: sync failed: ")
|
|
}) {
|
|
t.Fatalf("expected sync failed warning for broken, got %v", resp.Warnings)
|
|
}
|
|
entries, err := oplog.Read(config.ConfigPath(), oplog.OpsFile, 1)
|
|
if err != nil || len(entries) != 1 {
|
|
t.Fatalf("read ops log: %v (%d entries)", err, len(entries))
|
|
}
|
|
if e := entries[0]; e.Status != "partial" || e.Args["targets_failed"] != float64(1) {
|
|
t.Fatalf("expected partial sync with targets_failed 1, got status %q args %v", e.Status, e.Args)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_EverySkillTargetFailingIsReported(t *testing.T) {
|
|
s, _ := newTestServer(t)
|
|
file := filepath.Join(t.TempDir(), "skills-file")
|
|
if err := os.WriteFile(file, []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.cfg.Targets["broken"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "broken-skills"), Include: []string{"["}},
|
|
}
|
|
s.cfg.Targets["invalid"] = config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: file}}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Failed []syncFailure `json:"failed"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
parts := map[string]string{}
|
|
for _, f := range resp.Failed {
|
|
parts[f.Target] = f.Part
|
|
}
|
|
if len(resp.Failed) != 2 || parts["broken"] != "skill" || parts["invalid"] != "config" {
|
|
t.Fatalf("expected broken (skill) and invalid (config) failed, got %+v", resp.Failed)
|
|
}
|
|
entries, err := oplog.Read(config.ConfigPath(), oplog.OpsFile, 1)
|
|
if err != nil || len(entries) != 1 {
|
|
t.Fatalf("read ops log: %v (%d entries)", err, len(entries))
|
|
}
|
|
if e := entries[0]; e.Status != "error" || e.Args["targets_failed"] != float64(2) {
|
|
t.Fatalf("expected error sync with targets_failed 2, got status %q args %v", e.Status, e.Args)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_SkillPruneFailureIsWarning(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "alpha")
|
|
tgtPath := filepath.Join(t.TempDir(), "copy-skills")
|
|
// The manifest lives inside the orphan it lists, so pruning the orphan
|
|
// leaves the manifest write nowhere to go.
|
|
if err := os.MkdirAll(filepath.Join(tgtPath, "orphan"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tgtPath, "orphan", "manifest.json"), []byte(`{"managed":{"orphan":"x"}}`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(filepath.Join("orphan", "manifest.json"), filepath.Join(tgtPath, ssync.ManifestFile)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.cfg.Targets["copier"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: tgtPath, Mode: "copy"},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !slices.ContainsFunc(resp.Warnings, func(w string) bool {
|
|
return strings.HasPrefix(w, "copier: prune failed: failed to write manifest: ")
|
|
}) {
|
|
t.Fatalf("expected prune failed warning, got %v", resp.Warnings)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_SkillPruneWarningsAreReported(t *testing.T) {
|
|
tgtPath := filepath.Join(t.TempDir(), "claude-skills")
|
|
s, src := newTestServerWithTargets(t, map[string]string{"claude": tgtPath})
|
|
addSkill(t, src, "alpha")
|
|
external := t.TempDir()
|
|
if err := os.Symlink(external, filepath.Join(tgtPath, "outside")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !slices.ContainsFunc(resp.Warnings, func(w string) bool {
|
|
return strings.HasPrefix(w, "outside: symlink to external location")
|
|
}) {
|
|
t.Fatalf("expected external symlink prune warning, got %v", resp.Warnings)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_UnmatchedIncludeIsReported(t *testing.T) {
|
|
s, src := newTestServer(t)
|
|
addSkill(t, src, "alpha")
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills"), Include: []string{"missing"}},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := `claude: include pattern "missing" matches no skill in the source`
|
|
if !slices.Contains(resp.Warnings, want) {
|
|
t.Fatalf("warnings = %q, want %q", resp.Warnings, want)
|
|
}
|
|
}
|
|
|
|
// newSymlinkConflictServer sets up a symlink-mode target whose path links to
|
|
// another folder, next to a merge target that syncs fine.
|
|
func newSymlinkConflictServer(t *testing.T) (s *Server, src, linkPath, elsewhere string) {
|
|
t.Helper()
|
|
s, src = newTestServer(t)
|
|
addSkill(t, src, "alpha")
|
|
elsewhere = t.TempDir()
|
|
linkPath = filepath.Join(t.TempDir(), "linked-skills")
|
|
if err := os.Symlink(elsewhere, linkPath); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.cfg.Targets["linked"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: linkPath, Mode: "symlink"},
|
|
}
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s, src, linkPath, elsewhere
|
|
}
|
|
|
|
func TestHandleSync_SymlinkConflictFailsTargetWithoutForce(t *testing.T) {
|
|
s, _, linkPath, elsewhere := newSymlinkConflictServer(t)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
Warnings []string `json:"warnings"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := "linked: sync failed: conflict - symlink points to " + elsewhere + " (use --force to override)"
|
|
if !slices.Contains(resp.Warnings, want) {
|
|
t.Fatalf("expected %q, got %v", want, resp.Warnings)
|
|
}
|
|
if len(resp.Results) != 1 || resp.Results[0].Target != "claude" {
|
|
t.Fatalf("expected only the claude row, got %+v", resp.Results)
|
|
}
|
|
if got, _ := os.Readlink(linkPath); got != elsewhere {
|
|
t.Fatalf("expected the conflicting symlink kept, points to %q", got)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ReportsFailedTargetsApartFromWarnings(t *testing.T) {
|
|
s, _, _, elsewhere := newSymlinkConflictServer(t)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
rr := httptest.NewRecorder()
|
|
s.handler.ServeHTTP(rr, req)
|
|
|
|
var resp struct {
|
|
Failed []syncFailure `json:"failed"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
errText := "conflict - symlink points to " + elsewhere + " (use --force to override)"
|
|
want := []syncFailure{{Target: "linked", Part: "skill", Error: errText, Message: "linked: sync failed: " + errText, Conflict: true}}
|
|
if !slices.Equal(resp.Failed, want) {
|
|
t.Fatalf("expected %+v, got %+v", want, resp.Failed)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_SymlinkConflictReplacedWithForce(t *testing.T) {
|
|
s, src, linkPath, _ := newSymlinkConflictServer(t)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{"force":true}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 2 {
|
|
t.Fatalf("expected rows for both targets, got %+v", resp.Results)
|
|
}
|
|
if ssync.CheckStatus(linkPath, src) != ssync.StatusLinked {
|
|
t.Fatalf("expected %s linked to the source after force", linkPath)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_InvalidTargetConfigFailsOnlyThatTarget(t *testing.T) {
|
|
s, src, _ := newAgentSyncServer(t)
|
|
addSkill(t, src, "alpha")
|
|
file := filepath.Join(t.TempDir(), "skills-file")
|
|
if err := os.WriteFile(file, []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
brokenAgents := filepath.Join(t.TempDir(), "broken-agents")
|
|
s.cfg.Targets["broken"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: file},
|
|
Agents: &config.ResourceTargetConfig{Path: brokenAgents},
|
|
}
|
|
s.cfg.Targets["claude"] = config.TargetConfig{
|
|
Skills: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-skills")},
|
|
Agents: &config.ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "claude-agents")},
|
|
}
|
|
if err := s.cfg.Save(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
Warnings []string `json:"warnings"`
|
|
Failed []syncFailure `json:"failed"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 1 || resp.Results[0].Target != "claude" || !slices.Equal(resp.Results[0].Linked, []string{"alpha", "tutor.md"}) {
|
|
t.Fatalf("expected only the claude row with alpha and tutor.md, got %+v", resp.Results)
|
|
}
|
|
if len(resp.Failed) != 1 || resp.Failed[0].Target != "broken" || resp.Failed[0].Part != "config" ||
|
|
!strings.Contains(resp.Failed[0].Error, "path is not a directory") || !slices.Contains(resp.Warnings, resp.Failed[0].Message) {
|
|
t.Fatalf("expected one config failure for broken also in warnings, got failed %+v warnings %v", resp.Failed, resp.Warnings)
|
|
}
|
|
if _, err := os.Stat(brokenAgents); !os.IsNotExist(err) {
|
|
t.Fatalf("expected no agent sync into the invalid target, stat err = %v", err)
|
|
}
|
|
entries, err := oplog.Read(config.ConfigPath(), oplog.OpsFile, 1)
|
|
if err != nil || len(entries) != 1 {
|
|
t.Fatalf("read ops log: %v (%d entries)", err, len(entries))
|
|
}
|
|
got, _ := json.Marshal(entries[0].Args["failed_targets"])
|
|
if e := entries[0]; e.Status != "partial" || e.Args["targets_failed"] != float64(1) || string(got) != `["broken"]` {
|
|
t.Fatalf("expected partial sync with broken failed, got status %q args %v", e.Status, e.Args)
|
|
}
|
|
}
|
|
|
|
func TestHandleSync_ProjectTargetWithoutPathFailsAlone(t *testing.T) {
|
|
projectRoot := t.TempDir()
|
|
src := filepath.Join(projectRoot, ".skillshare", "skills")
|
|
addSkill(t, src, "alpha")
|
|
projectCfg := &config.ProjectConfig{Targets: []config.ProjectTargetEntry{{Name: "claude"}, {Name: "custom"}}}
|
|
if err := projectCfg.Save(projectRoot); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s := NewProject(&config.Config{Source: src, Mode: "merge"}, projectCfg, projectRoot, "127.0.0.1:0", "", "")
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/sync", strings.NewReader(`{}`))
|
|
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 struct {
|
|
Results []syncTargetResult `json:"results"`
|
|
Failed []syncFailure `json:"failed"`
|
|
}
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Results) != 1 || resp.Results[0].Target != "claude" {
|
|
t.Fatalf("expected claude to sync, got %+v", resp.Results)
|
|
}
|
|
if len(resp.Failed) != 1 || resp.Failed[0].Target != "custom" || resp.Failed[0].Part != "config" || !strings.Contains(resp.Failed[0].Error, "missing path") {
|
|
t.Fatalf("expected one config failure for custom, got %+v", resp.Failed)
|
|
}
|
|
}
|