mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Many integration and handler tests re-checked rules that internal/ packages already test, duplicated each other, or ran no product code at all (a few re-implemented the logic inline, two could never fail). They slowed the suite without catching anything new. Delete those, keeping tests for CLI wiring, JSON output, exit codes, project/global mode and cmd-only logic. Move the agents/extras overlap check into sync.AgentTargetPaths so the CLI and the server share one implementation and it is covered by unit tests instead of seven integration tests.
1483 lines
48 KiB
Go
1483 lines
48 KiB
Go
//go:build !online
|
|
|
|
package integration
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/testutil"
|
|
)
|
|
|
|
// TestExtras_Init_Global verifies that "extras init" creates the source directory
|
|
// and persists the extra entry in the global config.
|
|
func TestExtras_Init_Global(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Need at least a minimal config so config.Load() succeeds.
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Created extras/rules/")
|
|
|
|
// Verify source directory was created under extras/
|
|
sourceDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
if _, err := os.Stat(sourceDir); os.IsNotExist(err) {
|
|
t.Errorf("expected extras source dir %s to exist", sourceDir)
|
|
}
|
|
|
|
// Verify config.yaml now contains extras section
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "extras:") {
|
|
t.Errorf("expected config to contain 'extras:', got:\n%s", configContent)
|
|
}
|
|
if !strings.Contains(configContent, "rules") {
|
|
t.Errorf("expected config to contain 'rules', got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Init_InvalidName verifies that names with invalid characters are rejected.
|
|
func TestExtras_Init_InvalidName(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "init", "../bad", "--target", "/tmp/x", "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "invalid")
|
|
}
|
|
|
|
// TestExtras_Init_ReservedName verifies that reserved names (e.g. "skills") are rejected.
|
|
func TestExtras_Init_ReservedName(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "init", "skills", "--target", "/tmp/x", "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "reserved")
|
|
}
|
|
|
|
// TestExtras_List_Empty verifies that "extras list" reports nothing when no extras are configured.
|
|
func TestExtras_List_Empty(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "list", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "No extras configured")
|
|
}
|
|
|
|
// TestExtras_List_WithExtras verifies that "extras list" shows extra name and file count.
|
|
func TestExtras_List_WithExtras(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
// Create extras source directory with files.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
|
|
os.WriteFile(filepath.Join(rulesSource, "testing.md"), []byte("# Testing"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "list", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// The count and extra name should be present.
|
|
result.AssertAnyOutputContains(t, "1 extra")
|
|
result.AssertAnyOutputContains(t, "rules")
|
|
// File count should be shown in the source line.
|
|
result.AssertAnyOutputContains(t, "2 files")
|
|
}
|
|
|
|
// TestExtras_Remove verifies that "extras remove --force" removes the entry from config
|
|
// while leaving source files intact.
|
|
func TestExtras_Remove(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
// Create extras source with a file.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "remove", "rules", "--force", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Config should no longer contain the extras entry.
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configContent, "name: rules") {
|
|
t.Errorf("expected config to no longer contain 'name: rules', got:\n%s", configContent)
|
|
}
|
|
|
|
// Source files should still exist.
|
|
sourceFile := filepath.Join(rulesSource, "coding.md")
|
|
if !sb.FileExists(sourceFile) {
|
|
t.Error("source file should be preserved after remove")
|
|
}
|
|
}
|
|
|
|
// TestExtras_Init_Duplicate verifies that initialising an extra with an already-used
|
|
// name is rejected.
|
|
func TestExtras_Init_Duplicate(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
// Config already has an extra named "rules".
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "already exists")
|
|
}
|
|
|
|
// TestExtras_Init_Force_Global verifies that "extras init --force" overwrites
|
|
// an existing extra in global mode.
|
|
func TestExtras_Init_Force_Global(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
oldTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
newTarget := filepath.Join(sb.Home, ".cursor", "rules")
|
|
os.MkdirAll(oldTarget, 0755)
|
|
os.MkdirAll(newTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
// Config already has an extra named "rules" pointing to oldTarget.
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + oldTarget + `
|
|
`)
|
|
|
|
// Re-init with --force and a different target.
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", newTarget, "--force", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Created extras/rules/")
|
|
|
|
// Config should contain the new target, not the old one.
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, newTarget) {
|
|
t.Errorf("expected config to contain new target %s, got:\n%s", newTarget, configContent)
|
|
}
|
|
if strings.Contains(configContent, oldTarget) {
|
|
t.Errorf("expected config to NOT contain old target %s, got:\n%s", oldTarget, configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Init_Force_Project verifies that "extras init --force -p" overwrites
|
|
// an existing extra in project mode.
|
|
func TestExtras_Init_Force_Project(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
projectRoot := sb.SetupProjectDir("claude")
|
|
|
|
oldTarget := filepath.Join(projectRoot, ".claude", "rules")
|
|
newTarget := filepath.Join(projectRoot, ".claude", "prompts")
|
|
os.MkdirAll(oldTarget, 0755)
|
|
os.MkdirAll(newTarget, 0755)
|
|
|
|
// Project config already has an extra named "rules".
|
|
sb.WriteProjectConfig(projectRoot, `targets:
|
|
- claude
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: `+oldTarget+`
|
|
`)
|
|
|
|
// Re-init with --force and a different target.
|
|
result := sb.RunCLIInDir(projectRoot, "extras", "init", "rules", "--target", newTarget, "--force", "-p")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Created .skillshare/extras/rules/")
|
|
|
|
// Project config should contain the new target, not the old one.
|
|
projConfigPath := filepath.Join(projectRoot, ".skillshare", "config.yaml")
|
|
configContent := sb.ReadFile(projConfigPath)
|
|
if !strings.Contains(configContent, newTarget) {
|
|
t.Errorf("expected project config to contain new target %s, got:\n%s", newTarget, configContent)
|
|
}
|
|
if strings.Contains(configContent, oldTarget) {
|
|
t.Errorf("expected project config to NOT contain old target %s, got:\n%s", oldTarget, configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Init_SourceNotSupportedInProjectMode verifies that --source is
|
|
// rejected in project mode with a clear error message.
|
|
func TestExtras_Init_ProjectSourceMustBeRelative(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
projectRoot := sb.SetupProjectDir("claude")
|
|
|
|
target := filepath.Join(projectRoot, ".claude", "rules")
|
|
os.MkdirAll(target, 0755)
|
|
|
|
result := sb.RunCLIInDir(projectRoot, "extras", "init", "rules",
|
|
"--target", target,
|
|
"--source", "/some/custom/path",
|
|
"-p")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "must be relative to the project root")
|
|
}
|
|
|
|
// TestExtras_Source_Show verifies that "extras source" shows the current extras_source.
|
|
func TestExtras_Source_Show(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
customExtras := filepath.Join(sb.Home, "custom-extras")
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
extras_source: ` + customExtras + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "source", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "extras_source")
|
|
result.AssertAnyOutputContains(t, "custom-extras")
|
|
}
|
|
|
|
// TestExtras_Source_ShowDefault verifies that "extras source" shows the default
|
|
// path when extras_source is not explicitly set.
|
|
func TestExtras_Source_ShowDefault(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "source", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "(default)")
|
|
}
|
|
|
|
// TestExtras_Source_Set verifies that "extras source <path>" updates extras_source
|
|
// in the global config.
|
|
func TestExtras_Source_Set(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
newExtras := filepath.Join(sb.Home, "new-extras")
|
|
|
|
result := sb.RunCLI("extras", "source", newExtras, "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Set extras_source")
|
|
|
|
// Verify config was updated
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, newExtras) {
|
|
t.Errorf("expected config to contain %s, got:\n%s", newExtras, configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Source_ProjectModeRejected verifies that "extras source -p" is rejected.
|
|
func TestExtras_Source_ProjectModeRejected(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
projectRoot := sb.SetupProjectDir("claude")
|
|
|
|
result := sb.RunCLIInDir(projectRoot, "extras", "source", "-p")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "not supported in project mode")
|
|
}
|
|
|
|
// TestExtras_Collect verifies that "extras collect" moves local (non-symlink) files
|
|
// from a target directory into the extras source and replaces them with symlinks.
|
|
func TestExtras_Collect(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create extras source directory.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
|
|
// Create target directory with a local (non-symlink) file.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
localFile := filepath.Join(rulesTarget, "local-rule.md")
|
|
os.WriteFile(localFile, []byte("# Local Rule"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "collect", "rules", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Collected")
|
|
|
|
// File should now exist in source.
|
|
sourceFile := filepath.Join(rulesSource, "local-rule.md")
|
|
if !sb.FileExists(sourceFile) {
|
|
t.Error("collected file should exist in extras source directory")
|
|
}
|
|
|
|
// Original location should now be a symlink.
|
|
if !sb.IsSymlink(localFile) {
|
|
t.Error("original file should be replaced with a symlink after collect")
|
|
}
|
|
|
|
// Symlink should point to the source file.
|
|
if got := sb.SymlinkTarget(localFile); got != sourceFile {
|
|
t.Errorf("symlink target = %q, want %q", got, sourceFile)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Collect_DryRun verifies that "extras collect --dry-run" reports what
|
|
// would be collected without actually moving any files.
|
|
func TestExtras_Collect_DryRun(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create extras source directory.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
|
|
// Create target directory with a local file.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
localFile := filepath.Join(rulesTarget, "dry-rule.md")
|
|
os.WriteFile(localFile, []byte("# Dry Rule"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "collect", "rules", "--dry-run", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Would collect")
|
|
|
|
// File should NOT have been moved to source.
|
|
sourceFile := filepath.Join(rulesSource, "dry-rule.md")
|
|
if sb.FileExists(sourceFile) {
|
|
t.Error("dry run should not move file to source")
|
|
}
|
|
|
|
// Original file should still be a regular file, not a symlink.
|
|
if sb.IsSymlink(localFile) {
|
|
t.Error("dry run should not replace file with symlink")
|
|
}
|
|
}
|
|
|
|
// TestExtras_Collect_ForceCopyMode verifies that "extras collect --force" pulls
|
|
// target edits back over an existing source file, and that copy-mode targets
|
|
// keep regular files instead of becoming symlinks.
|
|
func TestExtras_Collect_ForceCopyMode(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
sourceFile := filepath.Join(rulesSource, "rule.md")
|
|
os.WriteFile(sourceFile, []byte("# Old"), 0644)
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
localFile := filepath.Join(rulesTarget, "rule.md")
|
|
os.WriteFile(localFile, []byte("# Edited in target"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
mode: copy
|
|
`)
|
|
|
|
// Trailing slash: --from must still match the configured copy-mode target.
|
|
result := sb.RunCLI("extras", "collect", "rules", "--from", rulesTarget+"/", "--force", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
if got := sb.ReadFile(sourceFile); got != "# Edited in target" {
|
|
t.Errorf("source content = %q, want target edit", got)
|
|
}
|
|
if sb.IsSymlink(localFile) {
|
|
t.Error("copy-mode target should stay a regular file after collect")
|
|
}
|
|
}
|
|
|
|
// TestExtras_Status verifies that "status" shows extras information when extras are configured.
|
|
func TestExtras_Status(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create extras source with files.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
|
|
os.WriteFile(filepath.Join(rulesSource, "testing.md"), []byte("# Testing"), 0644)
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("status", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// Status should show an "Extras" section.
|
|
result.AssertAnyOutputContains(t, "Extras")
|
|
// Should report file count and target path.
|
|
result.AssertRowContains(t, "rules", "~/.claude/rules 2 files")
|
|
}
|
|
|
|
// TestExtras_DiffExtras verifies that "diff" automatically shows extras that need syncing.
|
|
func TestExtras_DiffExtras(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create extras source with a file.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "pending.md"), []byte("# Pending"), 0644)
|
|
|
|
// Create target directory but do NOT sync yet.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("diff", "--no-tui", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// Output should show the extras diff section.
|
|
result.AssertAnyOutputContains(t, "Extras")
|
|
// Should indicate file needs syncing.
|
|
result.AssertAnyOutputContains(t, "pending.md")
|
|
}
|
|
|
|
// TestExtras_SyncExtras_JSON verifies that "sync extras --json" produces valid JSON
|
|
// output with an extras array.
|
|
func TestExtras_SyncExtras_JSON(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create extras source with a file.
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("sync", "extras", "--json", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// Verify JSON structure.
|
|
if !strings.Contains(result.Stdout, `"extras"`) {
|
|
t.Errorf("expected JSON to contain 'extras' key, got:\n%s", result.Stdout)
|
|
}
|
|
if !strings.Contains(result.Stdout, `"rules"`) {
|
|
t.Errorf("expected JSON to contain 'rules' entry, got:\n%s", result.Stdout)
|
|
}
|
|
if !strings.Contains(result.Stdout, `"duration"`) {
|
|
t.Errorf("expected JSON to contain 'duration' key, got:\n%s", result.Stdout)
|
|
}
|
|
}
|
|
|
|
// TestExtras_SyncAll_Project verifies that "sync --all -p" syncs both skills and extras
|
|
// in project mode.
|
|
func TestExtras_SyncAll_Project(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Set up a project directory with a claude target.
|
|
projectRoot := sb.SetupProjectDir("claude")
|
|
|
|
// Create a project skill.
|
|
sb.CreateProjectSkill(projectRoot, "proj-skill", map[string]string{
|
|
"SKILL.md": "# Project Skill",
|
|
})
|
|
|
|
// Create project extras source.
|
|
extrasSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules")
|
|
os.MkdirAll(extrasSource, 0755)
|
|
os.WriteFile(filepath.Join(extrasSource, "proj-rule.md"), []byte("# Project Rule"), 0644)
|
|
|
|
// Create extras target directory.
|
|
extrasTarget := filepath.Join(projectRoot, ".claude", "rules")
|
|
os.MkdirAll(extrasTarget, 0755)
|
|
|
|
// Write project config with both skills target and extras using absolute path.
|
|
sb.WriteProjectConfig(projectRoot, `targets:
|
|
- claude
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: `+extrasTarget+`
|
|
`)
|
|
|
|
result := sb.RunCLIInDir(projectRoot, "sync", "--all", "-p")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify extras were synced (symlink created in target).
|
|
ruleLink := filepath.Join(extrasTarget, "proj-rule.md")
|
|
if !sb.IsSymlink(ruleLink) {
|
|
t.Errorf("project extras should be synced as symlink after sync --all -p\nstdout: %s\nstderr: %s",
|
|
result.Stdout, result.Stderr)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Doctor verifies that "doctor" reports a missing extras source directory as an error.
|
|
func TestExtras_Doctor(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
// Config references extras "rules" but we do NOT create the source directory.
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("doctor", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// Doctor should report the missing extras source.
|
|
result.AssertAnyOutputContains(t, "rules")
|
|
result.AssertAnyOutputContains(t, "missing")
|
|
}
|
|
|
|
// TestExtras_Migration verifies that "sync extras" migrates a legacy flat extras directory
|
|
// (configDir/name/) to the new location (configDir/extras/name/).
|
|
func TestExtras_Migration(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create the OLD-style (legacy) directory: configDir/rules/ (not extras/rules/).
|
|
configDir := filepath.Join(sb.Home, ".config", "skillshare")
|
|
legacySource := filepath.Join(configDir, "rules")
|
|
os.MkdirAll(legacySource, 0755)
|
|
os.WriteFile(filepath.Join(legacySource, "legacy.md"), []byte("# Legacy Rule"), 0644)
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("sync", "extras", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// After migration, the new location should exist and legacy should be gone.
|
|
newSource := filepath.Join(configDir, "extras", "rules")
|
|
if _, err := os.Stat(newSource); os.IsNotExist(err) {
|
|
t.Errorf("expected migrated directory at %s to exist", newSource)
|
|
}
|
|
if _, err := os.Stat(legacySource); err == nil {
|
|
t.Errorf("expected legacy directory %s to be removed after migration", legacySource)
|
|
}
|
|
|
|
// The file should be accessible from the new location.
|
|
migratedFile := filepath.Join(newSource, "legacy.md")
|
|
if !sb.FileExists(migratedFile) {
|
|
t.Error("migrated file should exist in new extras directory")
|
|
}
|
|
|
|
// File should be synced as symlink in target.
|
|
ruleLink := filepath.Join(rulesTarget, "legacy.md")
|
|
if !sb.IsSymlink(ruleLink) {
|
|
t.Error("migrated file should be synced as symlink in target")
|
|
}
|
|
}
|
|
|
|
// TestExtras_Mode_SingleTarget verifies that "extras mode" changes the sync mode
|
|
// of an extra's target when the extra has only one target (auto-resolved).
|
|
func TestExtras_Mode_SingleTarget(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
// Change mode from merge (default) to copy
|
|
result := sb.RunCLI("extras", "rules", "--mode", "copy", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "copy")
|
|
|
|
// Verify config was updated
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "mode: copy") {
|
|
t.Errorf("expected config to contain 'mode: copy', got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Mode_Shorthand verifies the shorthand form:
|
|
// "extras <name> --mode <mode>" (without the "mode" subcommand).
|
|
func TestExtras_Mode_Shorthand(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
// Use shorthand: extras rules --mode symlink
|
|
result := sb.RunCLI("extras", "rules", "--mode", "symlink", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "symlink")
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "mode: symlink") {
|
|
t.Errorf("expected config to contain 'mode: symlink', got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Mode_WithTarget verifies that "extras <name> --mode" with --target
|
|
// changes the mode on a specific target when multiple targets exist.
|
|
func TestExtras_Mode_WithTarget(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget1 := filepath.Join(sb.Home, ".claude", "rules")
|
|
rulesTarget2 := filepath.Join(sb.Home, ".cursor", "rules")
|
|
os.MkdirAll(rulesTarget1, 0755)
|
|
os.MkdirAll(rulesTarget2, 0755)
|
|
|
|
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(rulesSource, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget1 + `
|
|
- path: ` + rulesTarget2 + `
|
|
`)
|
|
|
|
// Change mode of second target only
|
|
result := sb.RunCLI("extras", "rules", "--target", rulesTarget2, "--mode", "copy", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
// The second target should have mode: copy, first should remain default (merge)
|
|
if !strings.Contains(configContent, "mode: copy") {
|
|
t.Errorf("expected config to contain 'mode: copy' for second target, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Mode_FlattenFolderExtra verifies that a flatten-only change on a
|
|
// plain folder extra passes the full extra validation.
|
|
func TestExtras_Mode_FlattenFolderExtra(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
mode: copy
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "rules", "--flatten", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
if configContent := sb.ReadFile(sb.ConfigPath); !strings.Contains(configContent, "flatten: true") {
|
|
t.Errorf("expected config to contain 'flatten: true', got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtras_Mode_MultipleTargets_NoTarget verifies that "extras <name> --mode" errors
|
|
// when the extra has multiple targets and --target is not specified.
|
|
func TestExtras_Mode_MultipleTargets_NoTarget(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget1 := filepath.Join(sb.Home, ".claude", "rules")
|
|
rulesTarget2 := filepath.Join(sb.Home, ".cursor", "rules")
|
|
os.MkdirAll(rulesTarget1, 0755)
|
|
os.MkdirAll(rulesTarget2, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget1 + `
|
|
- path: ` + rulesTarget2 + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "rules", "--mode", "copy", "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "--target")
|
|
}
|
|
|
|
// TestExtras_Mode_InvalidMode verifies that an invalid mode is rejected.
|
|
func TestExtras_Mode_InvalidMode(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
extras:
|
|
- name: rules
|
|
targets:
|
|
- path: ` + rulesTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "rules", "--mode", "invalid", "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "invalid")
|
|
}
|
|
|
|
// TestExtras_Mode_UnknownExtra verifies that mode change on non-existent extra fails.
|
|
func TestExtras_Mode_UnknownExtra(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeTarget + `
|
|
`)
|
|
|
|
result := sb.RunCLI("extras", "nonexistent", "--mode", "copy", "-g")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "not found")
|
|
}
|
|
|
|
// TestInit_WritesSourcesMap verifies that fresh "init" emits the new
|
|
// `sources:` map (v0.19.16+) with skills and agents entries, and does NOT
|
|
// write the legacy top-level source / agents_source / extras_source fields.
|
|
// The extras parent directory is provided at runtime by
|
|
// Config.EffectiveExtrasSource() — it does not need to be persisted.
|
|
func TestInit_WritesSourcesMap(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file to simulate fresh state
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run a fully non-interactive init
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
|
|
// New format: must contain `sources:` map with skills/agents entries.
|
|
if !strings.Contains(configContent, "sources:") {
|
|
t.Errorf("expected config to contain 'sources:' map, got:\n%s", configContent)
|
|
}
|
|
if !strings.Contains(configContent, "skills: "+sb.SourcePath) {
|
|
t.Errorf("expected sources.skills to point to %s, got:\n%s", sb.SourcePath, configContent)
|
|
}
|
|
expectedAgents := filepath.Join(filepath.Dir(sb.SourcePath), "agents")
|
|
if !strings.Contains(configContent, "agents: "+expectedAgents) {
|
|
t.Errorf("expected sources.agents to point to %s, got:\n%s", expectedAgents, configContent)
|
|
}
|
|
|
|
// Legacy fields must NOT be written by fresh init.
|
|
if strings.Contains(configContent, "\nsource:") {
|
|
t.Errorf("expected no legacy 'source:' field, got:\n%s", configContent)
|
|
}
|
|
if strings.Contains(configContent, "extras_source:") {
|
|
t.Errorf("expected no legacy 'extras_source:' field, got:\n%s", configContent)
|
|
}
|
|
if strings.Contains(configContent, "agents_source:") {
|
|
t.Errorf("expected no legacy 'agents_source:' field, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtrasInit_PreservesEmptyExtrasSource verifies that "extras init" does
|
|
// NOT silently backfill the legacy extras_source field when it was absent.
|
|
// Config.EffectiveExtrasSource() handles the runtime fallback, so writing the
|
|
// derived path into the user's config would surprise them with an unexpected
|
|
// diff. The extras source directory must still be created on disk.
|
|
func TestExtrasInit_PreservesEmptyExtrasSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
|
|
// Write config WITHOUT extras_source
|
|
sb.WriteConfig(fmt.Sprintf("source: %s\ntargets:\n claude:\n path: %s",
|
|
sb.SourcePath, claudeTarget))
|
|
|
|
// Verify extras_source is absent before
|
|
configBefore := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configBefore, "extras_source:") {
|
|
t.Fatalf("precondition: expected no extras_source, got:\n%s", configBefore)
|
|
}
|
|
|
|
// Run extras init
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify extras_source was NOT silently backfilled.
|
|
configAfter := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configAfter, "extras_source:") {
|
|
t.Errorf("expected no extras_source backfill, got:\n%s", configAfter)
|
|
}
|
|
|
|
// But the derived extras source directory must still exist on disk so
|
|
// the new extra has somewhere to live.
|
|
expected := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules")
|
|
if _, err := os.Stat(expected); err != nil {
|
|
t.Errorf("expected extras source directory %s to exist: %v", expected, err)
|
|
}
|
|
}
|
|
|
|
// TestExtrasInit_WithExtrasSource verifies that when extras_source is set in config,
|
|
// "extras init" creates the source dir under the custom extras_source path.
|
|
func TestExtrasInit_WithExtrasSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
customExtras := filepath.Join(sb.Home, "custom-extras")
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
|
|
sb.WriteConfig("source: " + sb.SourcePath + "\nextras_source: " + customExtras + "\ntargets:\n claude:\n path: " + claudeTarget)
|
|
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Source directory should be created under extras_source, not the default location.
|
|
rulesDir := filepath.Join(customExtras, "rules")
|
|
if _, err := os.Stat(rulesDir); os.IsNotExist(err) {
|
|
t.Errorf("expected extras source dir at %s\nstdout: %s\nstderr: %s", rulesDir, result.Stdout, result.Stderr)
|
|
}
|
|
|
|
// The default location should NOT have been created.
|
|
defaultDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
if _, err := os.Stat(defaultDir); err == nil {
|
|
t.Errorf("default extras dir %s should not exist when extras_source is set", defaultDir)
|
|
}
|
|
}
|
|
|
|
// TestExtrasInit_WithPerExtraSource verifies that --source flag writes the per-extra
|
|
// source path to config and creates the source directory at that location.
|
|
func TestExtrasInit_WithPerExtraSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
customSource := filepath.Join(sb.Home, "my-rules")
|
|
os.MkdirAll(customSource, 0o755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
|
|
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets:\n claude:\n path: " + claudeTarget)
|
|
|
|
result := sb.RunCLI("extras", "init", "rules",
|
|
"--target", rulesTarget,
|
|
"--source", customSource,
|
|
"-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Config should contain the per-extra source path.
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, customSource) {
|
|
t.Errorf("expected config to contain source %s, got:\n%s", customSource, configContent)
|
|
}
|
|
}
|
|
|
|
// TestExtrasList_SourceType verifies JSON output includes correct source_type
|
|
// for per-extra source overrides.
|
|
func TestExtrasList_SourceType(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
customSource := filepath.Join(sb.Home, "my-rules")
|
|
os.MkdirAll(customSource, 0o755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets:\n claude:\n path: " + claudeTarget + "\nextras:\n - name: rules\n source: " + customSource + "\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("extras", "list", "--json", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "per-extra")
|
|
}
|
|
|
|
// TestExtrasSourcePriority verifies the 3-level source resolution priority chain:
|
|
// per-extra source > extras_source > default.
|
|
func TestExtrasSourcePriority(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
perExtra := filepath.Join(sb.Home, "per-extra-rules")
|
|
globalExtras := filepath.Join(sb.Home, "global-extras")
|
|
os.MkdirAll(perExtra, 0o755)
|
|
os.MkdirAll(filepath.Join(globalExtras, "commands"), 0o755)
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
commandsTarget := filepath.Join(sb.Home, ".claude", "commands")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
os.MkdirAll(commandsTarget, 0o755)
|
|
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\nextras_source: " + globalExtras +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n source: " + perExtra +
|
|
"\n targets:\n - path: " + rulesTarget +
|
|
"\n - name: commands\n targets:\n - path: " + commandsTarget)
|
|
|
|
result := sb.RunCLI("extras", "list", "--json", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// "rules" has per-extra source → source_type should be "per-extra"
|
|
result.AssertAnyOutputContains(t, "per-extra")
|
|
// "commands" falls back to extras_source → source_type should be "extras_source"
|
|
result.AssertAnyOutputContains(t, "extras_source")
|
|
}
|
|
|
|
// TestExtrasList_DefaultSourceType verifies that "extras list --json" shows
|
|
// source_type "default" when neither extras_source nor per-extra source is set.
|
|
func TestExtrasList_DefaultSourceType(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
// Create default extras source directory with a file so it reports as existing.
|
|
defaultSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
os.MkdirAll(defaultSource, 0o755)
|
|
os.WriteFile(filepath.Join(defaultSource, "coding.md"), []byte("# Coding"), 0o644)
|
|
|
|
// Config with extras but NO extras_source and NO per-extra source.
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("extras", "list", "--json", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, `"source_type"`)
|
|
result.AssertAnyOutputContains(t, `"default"`)
|
|
}
|
|
|
|
// TestExtrasSync_WithPerExtraSource verifies that sync uses the per-extra source path
|
|
// instead of the default location.
|
|
func TestExtrasSync_WithPerExtraSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
|
|
// Create a custom source directory with a file.
|
|
customSource := filepath.Join(sb.Home, "my-rules")
|
|
os.MkdirAll(customSource, 0o755)
|
|
os.WriteFile(filepath.Join(customSource, "custom.md"), []byte("# Custom Rule"), 0o644)
|
|
|
|
// Create target directory.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
// Config with per-extra source pointing to custom location.
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n source: " + customSource +
|
|
"\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("sync", "extras", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify symlink was created in target.
|
|
customLink := filepath.Join(rulesTarget, "custom.md")
|
|
if !sb.IsSymlink(customLink) {
|
|
t.Errorf("custom.md should be a symlink in target after sync\nstdout: %s\nstderr: %s",
|
|
result.Stdout, result.Stderr)
|
|
}
|
|
|
|
// Verify symlink points to the custom source, not the default.
|
|
expectedTarget := filepath.Join(customSource, "custom.md")
|
|
if got := sb.SymlinkTarget(customLink); got != expectedTarget {
|
|
t.Errorf("symlink target = %q, want %q", got, expectedTarget)
|
|
}
|
|
}
|
|
|
|
// TestExtrasSync_WithExtrasSource verifies that sync uses extras_source when set.
|
|
func TestExtrasSync_WithExtrasSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
|
|
// Create custom extras_source directory with the extra's subdirectory.
|
|
globalExtras := filepath.Join(sb.Home, "custom-extras")
|
|
rulesSource := filepath.Join(globalExtras, "rules")
|
|
os.MkdirAll(rulesSource, 0o755)
|
|
os.WriteFile(filepath.Join(rulesSource, "global-extra.md"), []byte("# Global Extra"), 0o644)
|
|
|
|
// Create target directory.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
// Config with extras_source set (no per-extra source).
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\nextras_source: " + globalExtras +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("sync", "extras", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify symlink was created from the extras_source location.
|
|
link := filepath.Join(rulesTarget, "global-extra.md")
|
|
if !sb.IsSymlink(link) {
|
|
t.Errorf("global-extra.md should be a symlink after sync\nstdout: %s\nstderr: %s",
|
|
result.Stdout, result.Stderr)
|
|
}
|
|
|
|
expectedTarget := filepath.Join(rulesSource, "global-extra.md")
|
|
if got := sb.SymlinkTarget(link); got != expectedTarget {
|
|
t.Errorf("symlink target = %q, want %q", got, expectedTarget)
|
|
}
|
|
}
|
|
|
|
// TestExtrasCollect_WithPerExtraSource verifies that collect moves files into
|
|
// the per-extra source directory, not the default location.
|
|
func TestExtrasCollect_WithPerExtraSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
|
|
// Create empty custom source directory.
|
|
customSource := filepath.Join(sb.Home, "my-rules")
|
|
os.MkdirAll(customSource, 0o755)
|
|
|
|
// Create target directory with a real (non-symlink) file.
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
localFile := filepath.Join(rulesTarget, "local-rule.md")
|
|
os.WriteFile(localFile, []byte("# Local Rule"), 0o644)
|
|
|
|
// Config with per-extra source.
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n source: " + customSource +
|
|
"\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("extras", "collect", "rules", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Collected")
|
|
|
|
// File should now exist in the custom source, not the default.
|
|
collectedFile := filepath.Join(customSource, "local-rule.md")
|
|
if !sb.FileExists(collectedFile) {
|
|
t.Errorf("collected file should exist in custom source %s", customSource)
|
|
}
|
|
|
|
// Default source location should NOT have the file.
|
|
defaultSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules", "local-rule.md")
|
|
if sb.FileExists(defaultSource) {
|
|
t.Error("file should NOT be collected to the default source when per-extra source is set")
|
|
}
|
|
|
|
// Original location should now be a symlink pointing to custom source.
|
|
if !sb.IsSymlink(localFile) {
|
|
t.Error("original file should be replaced with a symlink after collect")
|
|
}
|
|
if got := sb.SymlinkTarget(localFile); got != collectedFile {
|
|
t.Errorf("symlink target = %q, want %q", got, collectedFile)
|
|
}
|
|
}
|
|
|
|
// TestExtrasDoctor_WithCustomSource verifies that doctor reports the correct
|
|
// custom source path when per-extra source is configured.
|
|
func TestExtrasDoctor_WithCustomSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
// Config with per-extra source pointing to a non-existent directory.
|
|
nonExistentSource := filepath.Join(sb.Home, "does-not-exist-rules")
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n source: " + nonExistentSource +
|
|
"\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("doctor", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
// Doctor should mention the custom path in its extras check.
|
|
result.AssertAnyOutputContains(t, "rules")
|
|
result.AssertAnyOutputContains(t, "missing")
|
|
}
|
|
|
|
// TestExtrasRemove_WithPerExtraSource verifies that remove works correctly
|
|
// when per-extra source is configured.
|
|
func TestExtrasRemove_WithPerExtraSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0o755)
|
|
|
|
// Create custom source directory with a file.
|
|
customSource := filepath.Join(sb.Home, "my-rules")
|
|
os.MkdirAll(customSource, 0o755)
|
|
os.WriteFile(filepath.Join(customSource, "coding.md"), []byte("# Coding"), 0o644)
|
|
|
|
// Config with per-extra source.
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget +
|
|
"\nextras:\n - name: rules\n source: " + customSource +
|
|
"\n targets:\n - path: " + rulesTarget)
|
|
|
|
result := sb.RunCLI("extras", "remove", "rules", "--force", "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Config should no longer contain the extras entry.
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configContent, "name: rules") {
|
|
t.Errorf("expected config to no longer contain 'name: rules', got:\n%s", configContent)
|
|
}
|
|
|
|
// Source files should still exist (remove only removes from config).
|
|
if !sb.FileExists(filepath.Join(customSource, "coding.md")) {
|
|
t.Error("source file in custom path should be preserved after remove")
|
|
}
|
|
}
|
|
|
|
// TestExtrasSync_SkipsMissingSourceDir verifies that "sync extras" skips an
|
|
// extra whose source directory does not exist, with a hint, instead of
|
|
// creating it.
|
|
func TestExtrasSync_SkipsMissingSourceDir(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Set extras_source to a non-existent directory
|
|
customExtras := filepath.Join(sb.Home, "new-extras-dir")
|
|
// Don't create it — sync should skip the extra
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
os.MkdirAll(rulesTarget, 0755)
|
|
|
|
sb.WriteConfig(fmt.Sprintf("source: %s\nextras_source: %s\ntargets:\n claude:\n path: %s\nextras:\n - name: rules\n targets:\n - path: %s",
|
|
sb.SourcePath, customExtras, claudeTarget, rulesTarget))
|
|
|
|
result := sb.RunCLI("sync", "extras", "-g")
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify source dir was not created
|
|
rulesDir := filepath.Join(customExtras, "rules")
|
|
if _, err := os.Stat(rulesDir); !os.IsNotExist(err) {
|
|
t.Errorf("sync must not create source dir at %s, stat err = %v", rulesDir, err)
|
|
}
|
|
|
|
// Verify output explains the skip
|
|
result.AssertAnyOutputContains(t, "source folder not found")
|
|
result.AssertAnyOutputContains(t, "Create it to start syncing rules")
|
|
}
|
|
|
|
// TestExtrasInit_WithExtrasSource_AutoCreatesDir verifies that "extras init"
|
|
// creates the source directory under extras_source even if the extras_source
|
|
// directory itself doesn't exist yet.
|
|
func TestExtrasInit_WithExtrasSource_AutoCreatesDir(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeTarget := sb.CreateTarget("claude")
|
|
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
|
|
|
|
// extras_source points to a path where parent exists but extras_source itself doesn't.
|
|
customExtras := filepath.Join(sb.Home, "brand-new-extras")
|
|
// Intentionally do NOT create customExtras — init should create it.
|
|
|
|
sb.WriteConfig("source: " + sb.SourcePath +
|
|
"\nextras_source: " + customExtras +
|
|
"\ntargets:\n claude:\n path: " + claudeTarget)
|
|
|
|
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// The directory should have been auto-created at extras_source/rules.
|
|
rulesDir := filepath.Join(customExtras, "rules")
|
|
if _, err := os.Stat(rulesDir); os.IsNotExist(err) {
|
|
t.Errorf("expected extras source dir at %s to be auto-created\nstdout: %s\nstderr: %s",
|
|
rulesDir, result.Stdout, result.Stderr)
|
|
}
|
|
|
|
// The default location should NOT have been created.
|
|
defaultDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
if _, err := os.Stat(defaultDir); err == nil {
|
|
t.Errorf("default extras dir %s should not exist when extras_source is set", defaultDir)
|
|
}
|
|
}
|
|
|
|
// Identical local files are kept; only differing files need --force.
|
|
func TestExtrasSyncPreservedLocalMessage(t *testing.T) {
|
|
for _, content := range []string{"same", "different"} {
|
|
t.Run(content, func(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
source := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
|
|
target := filepath.Join(sb.Home, ".claude", "rules")
|
|
for _, path := range []string{source, target} {
|
|
if err := os.MkdirAll(path, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := os.WriteFile(filepath.Join(source, "a.md"), []byte("same"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(target, "a.md"), []byte(content), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sb.WriteConfig("source: " + sb.SourcePath + "\nextras:\n - name: rules\n targets:\n - path: " + target + "\n mode: merge\n")
|
|
result := sb.RunCLI("sync", "extras", "-g")
|
|
result.AssertSuccess(t)
|
|
if content == "same" {
|
|
result.AssertAnyOutputContains(t, "1 local preserved")
|
|
if strings.Contains(result.Stdout+result.Stderr, "use --force") {
|
|
t.Fatal(result.Stdout + result.Stderr)
|
|
}
|
|
} else {
|
|
result.AssertAnyOutputContains(t, "1 files skipped (use --force to override)")
|
|
}
|
|
if got := sb.ReadFile(filepath.Join(target, "a.md")); got != content {
|
|
t.Fatalf("local file changed: %q", got)
|
|
}
|
|
})
|
|
}
|
|
}
|