Files
skillshare/internal/config/config_validate_test.go
T
Willie 5dfd63d5e9 fix(sync): fail only the target whose config is invalid
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.
2026-09-30 03:27:20 +08:00

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)
}
}