mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Any per-target config problem, such as a skills path that is a file or
an unknown mode, made `skillshare sync`, `sync -p` and the dashboard
refuse to sync anything. That contradicts the policy that sync runs
every target and reports the ones that failed. Sync now validates the
config as a whole first and still stops on global problems (source,
global mode or naming, git_root, extras); a target whose own settings
are invalid is skipped for skills and agents and reported as failed
("invalid config" in CLI output and --json details, part "config" in
the dashboard's failed list). Config validation on save is unchanged.
530 lines
15 KiB
Go
530 lines
15 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestValidateConfig_SourceNotExist(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: "/nonexistent/source/path",
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for nonexistent source")
|
|
}
|
|
if !strings.Contains(err.Error(), "source path does not exist") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_DefaultSource_OK(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
t.Setenv("XDG_CONFIG_HOME", tmpDir)
|
|
defaultSource := filepath.Join(tmpDir, "skillshare", "skills")
|
|
if err := os.MkdirAll(defaultSource, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &Config{
|
|
Source: "",
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
warnings, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error for default source: %v", err)
|
|
}
|
|
if len(warnings) > 0 {
|
|
t.Errorf("unexpected warnings: %v", warnings)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_SourceIsFile(t *testing.T) {
|
|
tmpFile := filepath.Join(t.TempDir(), "not-a-dir")
|
|
if err := os.WriteFile(tmpFile, []byte("x"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &Config{
|
|
Source: tmpFile,
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for file source")
|
|
}
|
|
if !strings.Contains(err.Error(), "not a directory") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_InvalidGlobalMode(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Mode: "invalid",
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid global mode")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid global sync mode") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_InvalidGlobalTargetNaming(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
TargetNaming: "weird",
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid global target naming")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid global target naming") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_InvalidGitRoot(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
GitRoot: "agnets", // typo for "agents"
|
|
Targets: map[string]TargetConfig{},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid git_root")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid git_root") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_InvalidTargetMode(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
targetDir := filepath.Join(tmpDir, "target")
|
|
os.MkdirAll(targetDir, 0755)
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Path: targetDir, Mode: "badmode"},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid target mode")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid sync mode") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_InvalidTargetNaming(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
targetDir := filepath.Join(tmpDir, "target")
|
|
os.MkdirAll(targetDir, 0755)
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Skills: &ResourceTargetConfig{Path: targetDir, TargetNaming: "odd"}},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid target naming")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid target naming") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_TargetNotExist_Accepted(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
// Missing target path is accepted — sync will auto-create and notify
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Path: filepath.Join(tmpDir, "nonexistent"), Mode: "merge"},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("expected no error for missing target (sync auto-creates), got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_TargetDeepPathNotExist_Accepted(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
// Even deeply missing paths are accepted (e.g., universal target ~/.agents/skills)
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Path: filepath.Join(tmpDir, "no", "parent", "target"), Mode: "copy"},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("expected no error for deeply missing target (sync auto-creates), got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_ValidConfig(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
targetDir := filepath.Join(tmpDir, "target")
|
|
os.MkdirAll(targetDir, 0755)
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Mode: "merge",
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Path: targetDir, Mode: "merge"},
|
|
},
|
|
}
|
|
warnings, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(warnings) > 0 {
|
|
t.Errorf("unexpected warnings: %v", warnings)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_CustomTarget_MissingPath(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{
|
|
"my-custom-ide": {Skills: &ResourceTargetConfig{Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected error for custom target without path")
|
|
}
|
|
if !strings.Contains(err.Error(), "missing path") {
|
|
t.Fatalf("expected 'missing path' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_BuiltinTarget_NoPath_OK(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{
|
|
"claude": {Skills: &ResourceTargetConfig{Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("built-in target should accept empty path: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_CustomTarget_MissingPath(t *testing.T) {
|
|
root := t.TempDir()
|
|
os.MkdirAll(filepath.Join(root, ".skillshare", "skills"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "my-custom-ide", Skills: &ResourceTargetConfig{Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, root)
|
|
if err == nil {
|
|
t.Fatal("expected error for custom project target without path")
|
|
}
|
|
if !strings.Contains(err.Error(), "missing path") {
|
|
t.Fatalf("expected 'missing path' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_SourceAliasesBuiltinTarget(t *testing.T) {
|
|
root := t.TempDir()
|
|
// Configure source to alias the built-in claude target path
|
|
os.MkdirAll(filepath.Join(root, ".claude", "skills"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Sources: ProjectSources{Skills: ".claude/skills"},
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "claude", Skills: &ResourceTargetConfig{Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, root)
|
|
if err == nil {
|
|
t.Fatal("expected overlap error when skills source aliases claude target path")
|
|
}
|
|
if !strings.Contains(err.Error(), "overlaps skills source") {
|
|
t.Fatalf("expected 'overlaps skills source' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_SourceNestsTargetPath(t *testing.T) {
|
|
root := t.TempDir()
|
|
os.MkdirAll(filepath.Join(root, "shared", "skills", "nested"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Sources: ProjectSources{Skills: "shared"},
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "custom", Skills: &ResourceTargetConfig{Path: "shared/skills/nested", Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, root)
|
|
if err == nil {
|
|
t.Fatal("expected overlap error when target nests inside source")
|
|
}
|
|
if !strings.Contains(err.Error(), "overlaps") {
|
|
t.Fatalf("expected overlap error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_BuiltinTarget_NoPath_OK(t *testing.T) {
|
|
root := t.TempDir()
|
|
os.MkdirAll(filepath.Join(root, ".skillshare", "skills"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "claude", Skills: &ResourceTargetConfig{Mode: "merge"}},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, root)
|
|
if err != nil {
|
|
t.Fatalf("built-in target should accept empty path: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_EmptyMode_OK(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
targetDir := filepath.Join(tmpDir, "target")
|
|
os.MkdirAll(targetDir, 0755)
|
|
cfg := &Config{
|
|
Source: tmpDir,
|
|
Mode: "", // empty = default merge
|
|
Targets: map[string]TargetConfig{
|
|
"test": {Path: targetDir, Mode: ""}, // empty = inherit global
|
|
},
|
|
}
|
|
warnings, err := ValidateConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(warnings) > 0 {
|
|
t.Errorf("unexpected warnings: %v", warnings)
|
|
}
|
|
}
|
|
|
|
func TestIsValidSyncMode(t *testing.T) {
|
|
tests := []struct {
|
|
mode string
|
|
want bool
|
|
}{
|
|
{"", true},
|
|
{"merge", true},
|
|
{"symlink", true},
|
|
{"copy", true},
|
|
{"invalid", false},
|
|
{"MERGE", false}, // case sensitive
|
|
}
|
|
for _, tt := range tests {
|
|
if got := IsValidSyncMode(tt.mode); got != tt.want {
|
|
t.Errorf("IsValidSyncMode(%q) = %v, want %v", tt.mode, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_InvalidMode(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
os.MkdirAll(filepath.Join(tmpDir, ".skillshare", "skills"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "claude", Mode: "badmode"},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, tmpDir)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid project target mode")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid sync mode") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_InvalidTargetNaming(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
os.MkdirAll(filepath.Join(tmpDir, ".skillshare", "skills"), 0755)
|
|
cfg := &ProjectConfig{
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "claude", Skills: &ResourceTargetConfig{TargetNaming: "bad"}},
|
|
},
|
|
}
|
|
_, err := ValidateProjectConfig(cfg, tmpDir)
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid project target naming")
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid target naming") {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEffectiveTargetNaming(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
expect string
|
|
}{
|
|
{name: "default", input: "", expect: "flat"},
|
|
{name: "flat", input: "flat", expect: "flat"},
|
|
{name: "standard", input: "standard", expect: "standard"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := EffectiveTargetNaming(tt.input); got != tt.expect {
|
|
t.Fatalf("EffectiveTargetNaming(%q) = %q, want %q", tt.input, got, tt.expect)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfig_MissingSource_Warning(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
// Don't create .skillshare/skills/
|
|
cfg := &ProjectConfig{
|
|
Targets: []ProjectTargetEntry{
|
|
{Name: "claude"},
|
|
},
|
|
}
|
|
warnings, err := ValidateProjectConfig(cfg, tmpDir)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
found := false
|
|
for _, w := range warnings {
|
|
if strings.Contains(w, "source directory does not exist yet") {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("expected source warning, got: %v", warnings)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_RejectsImportWithoutFile(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{},
|
|
Extras: []ExtraConfig{{Name: "rules", Targets: []ExtraTargetConfig{{Path: "/t", Mode: "import"}}}},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil || !strings.Contains(err.Error(), "import mode requires file") {
|
|
t.Fatalf("err = %v, want import mode requires file", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_SkillsTargetRejectsImport(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{"claude": {Mode: "import"}},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil || !strings.Contains(err.Error(), "invalid sync mode") {
|
|
t.Fatalf("err = %v, want invalid sync mode", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateTargetInstructions(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
path string
|
|
project bool
|
|
wantErr string
|
|
}{
|
|
{"global tilde", "~/.myagent/AGENTS.md", false, ""},
|
|
{"global absolute", "/opt/agent/AGENTS.md", false, ""},
|
|
{"global relative", ".myagent/AGENTS.md", false, "absolute or start with ~/"},
|
|
{"empty", " ", false, "is empty"},
|
|
{"directory", "~/.myagent/", false, "not a directory"},
|
|
{"project relative", ".myagent/AGENTS.md", true, ""},
|
|
{"project absolute", "/opt/agent/AGENTS.md", true, "relative to the project root"},
|
|
{"project tilde", "~/AGENTS.md", true, "relative to the project root"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
err := ValidateTargetInstructions(&TargetInstructionsConfig{Path: tc.path}, tc.project)
|
|
if tc.wantErr == "" && err != nil {
|
|
t.Fatalf("err = %v, want nil", err)
|
|
}
|
|
if tc.wantErr != "" && (err == nil || !strings.Contains(err.Error(), tc.wantErr)) {
|
|
t.Fatalf("err = %v, want %q", err, tc.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_RejectsRelativeInstructionsPath(t *testing.T) {
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{"myagent": {
|
|
Skills: &ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "skills")},
|
|
Instructions: &TargetInstructionsConfig{Path: "AGENTS.md"},
|
|
}},
|
|
}
|
|
_, err := ValidateConfig(cfg)
|
|
if err == nil || !strings.Contains(err.Error(), `target "myagent": instructions.path`) {
|
|
t.Fatalf("err = %v, want instructions.path error", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfigForSync_TargetProblemFailsOnlyThatTarget(t *testing.T) {
|
|
file := filepath.Join(t.TempDir(), "skills-file")
|
|
if err := os.WriteFile(file, []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &Config{
|
|
Source: t.TempDir(),
|
|
Targets: map[string]TargetConfig{
|
|
"broken": {Skills: &ResourceTargetConfig{Path: file}},
|
|
"good": {Skills: &ResourceTargetConfig{Path: filepath.Join(t.TempDir(), "skills")}},
|
|
},
|
|
}
|
|
_, invalid, err := ValidateConfigForSync(cfg)
|
|
if err != nil || len(invalid) != 1 || invalid["broken"] == nil || !strings.Contains(invalid["broken"].Error(), "path is not a directory") {
|
|
t.Fatalf("err = %v, invalid = %v; want only broken invalid", err, invalid)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfigForSync_GlobalProblemStillFails(t *testing.T) {
|
|
cfg := &Config{Source: t.TempDir(), Mode: "bogus", Targets: map[string]TargetConfig{}}
|
|
if _, _, err := ValidateConfigForSync(cfg); err == nil || !strings.Contains(err.Error(), "invalid global sync mode") {
|
|
t.Fatalf("err = %v, want invalid global sync mode", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateConfig_TargetPathIsFileStillRejected(t *testing.T) {
|
|
file := filepath.Join(t.TempDir(), "skills-file")
|
|
if err := os.WriteFile(file, []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &Config{Source: t.TempDir(), Targets: map[string]TargetConfig{"broken": {Skills: &ResourceTargetConfig{Path: file}}}}
|
|
if _, err := ValidateConfig(cfg); err == nil || !strings.Contains(err.Error(), `target "broken": path is not a directory`) {
|
|
t.Fatalf("err = %v, want target path error", err)
|
|
}
|
|
}
|
|
|
|
func TestValidateProjectConfigForSync_TargetProblemFailsOnlyThatTarget(t *testing.T) {
|
|
root := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(root, ".skillshare", "skills"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "skills-file"), []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := &ProjectConfig{Targets: []ProjectTargetEntry{
|
|
{Name: "broken", Skills: &ResourceTargetConfig{Path: "skills-file"}},
|
|
{Name: "claude"},
|
|
}}
|
|
_, invalid, err := ValidateProjectConfigForSync(cfg, root)
|
|
if err != nil || len(invalid) != 1 || invalid["broken"] == nil || !strings.Contains(invalid["broken"].Error(), "path is not a directory") {
|
|
t.Fatalf("err = %v, invalid = %v; want only broken invalid", err, invalid)
|
|
}
|
|
}
|