Files
skillshare/internal/sync/sync_test.go
T
Willie 5d5b0f3efb feat(sync): explain include filters that select no skill
The dashboard showed the CLI's raw line, "api-server@claude: include pattern
"*review*" matches no skill in the source", once per target. It named a
config field, did not say the target ends up with no skills, and gave no way
to fix it. Sync now returns these as structured entries; the Sync page
groups a project's targets into one localized notice that says what happens
and links to where the filter is edited. The CLI line also says the filter
adds nothing to the target.
2026-10-08 14:26:41 +08:00

282 lines
8.7 KiB
Go

package sync
import (
"os"
"path/filepath"
"testing"
"skillshare/internal/config"
"skillshare/internal/utils"
)
// createTempSkill creates a skill directory with a SKILL.md containing the given name.
func createTempSkill(t *testing.T, dir, relPath, skillName string) DiscoveredSkill {
t.Helper()
skillDir := filepath.Join(dir, filepath.FromSlash(relPath))
if err := os.MkdirAll(skillDir, 0755); err != nil {
t.Fatalf("mkdir %s: %v", skillDir, err)
}
content := "---\nname: " + skillName + "\n---\n# " + skillName
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(content), 0644); err != nil {
t.Fatalf("write SKILL.md: %v", err)
}
return DiscoveredSkill{
SourcePath: skillDir,
RelPath: filepath.ToSlash(relPath),
FlatName: filepath.ToSlash(relPath),
}
}
func TestResolveTargetSkillsForTarget_FlatNamingUsesFlatNames(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "dev"),
createTempSkill(t, dir, "alpha", "alpha"),
}
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget() error = %v", err)
}
if resolution.Naming != "flat" {
t.Fatalf("Naming = %q, want flat", resolution.Naming)
}
if len(resolution.Warnings) != 0 {
t.Fatalf("Warnings = %v, want none", resolution.Warnings)
}
if len(resolution.Skills) != 2 {
t.Fatalf("len(Skills) = %d, want 2", len(resolution.Skills))
}
if resolution.Skills[0].TargetName != "frontend/dev" {
t.Fatalf("first TargetName = %q, want %q", resolution.Skills[0].TargetName, "frontend/dev")
}
}
func TestResolveTargetSkillsForTarget_StandardNamingUsesSkillName(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "dev"),
}
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{TargetNaming: "standard"}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget() error = %v", err)
}
if resolution.Naming != "standard" {
t.Fatalf("Naming = %q, want standard", resolution.Naming)
}
if len(resolution.Skills) != 1 {
t.Fatalf("len(Skills) = %d, want 1", len(resolution.Skills))
}
if resolution.Skills[0].TargetName != "dev" {
t.Fatalf("TargetName = %q, want dev", resolution.Skills[0].TargetName)
}
}
func TestResolveTargetSkillsForTarget_ReportsUnmatchedInclude(t *testing.T) {
dir := t.TempDir()
skill := createTempSkill(t, dir, "frontend/dev", "dev")
skill.FlatName = utils.PathToFlatName(skill.RelPath)
skills := []DiscoveredSkill{skill}
const want = `include filter "dev" matches no skill in the source, so it adds nothing to this target ` +
`(filters use the source path name; did you mean "frontend__dev"?)`
for _, naming := range []string{"flat", "standard"} {
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{
TargetNaming: naming,
Include: []string{"dev"},
}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget(%s) error = %v", naming, err)
}
if len(resolution.Skills) != 0 {
t.Fatalf("%s: len(Skills) = %d, want 0", naming, len(resolution.Skills))
}
warnings := resolution.UnmatchedIncludeWarnings()
if len(warnings) != 1 || warnings[0] != want {
t.Fatalf("%s: warnings = %v, want [%q]", naming, warnings, want)
}
}
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{
TargetNaming: "standard",
Include: []string{"frontend__dev"},
}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget() error = %v", err)
}
if len(resolution.Skills) != 1 || resolution.Skills[0].TargetName != "dev" {
t.Fatalf("Skills = %+v, want one entry named dev", resolution.Skills)
}
if got := resolution.UnmatchedIncludeWarnings(); len(got) != 0 {
t.Fatalf("warnings = %v, want none for a pattern that selects the skill", got)
}
}
func TestResolveTargetSkillsForTarget_StandardNamingSkipsInvalidSkill(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "wrong-name"),
createTempSkill(t, dir, "alpha", "alpha"),
}
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{TargetNaming: "standard"}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget() error = %v", err)
}
if len(resolution.Skills) != 1 {
t.Fatalf("len(Skills) = %d, want 1", len(resolution.Skills))
}
if resolution.Skills[0].TargetName != "alpha" {
t.Fatalf("TargetName = %q, want alpha", resolution.Skills[0].TargetName)
}
if len(resolution.Warnings) != 1 {
t.Fatalf("Warnings = %v, want 1 warning", resolution.Warnings)
}
}
func TestResolveTargetSkillsForTarget_StandardNamingSkipsCollisions(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "dev"),
createTempSkill(t, dir, "backend/dev", "dev"),
createTempSkill(t, dir, "alpha", "alpha"),
}
resolution, err := ResolveTargetSkillsForTarget("claude", config.ResourceTargetConfig{TargetNaming: "standard"}, skills)
if err != nil {
t.Fatalf("ResolveTargetSkillsForTarget() error = %v", err)
}
if len(resolution.Collisions) != 1 {
t.Fatalf("Collisions = %v, want 1 collision", resolution.Collisions)
}
if resolution.Collisions[0].Name != "dev" {
t.Fatalf("collision name = %q, want dev", resolution.Collisions[0].Name)
}
if len(resolution.Skills) != 1 {
t.Fatalf("len(Skills) = %d, want 1", len(resolution.Skills))
}
if resolution.Skills[0].TargetName != "alpha" {
t.Fatalf("TargetName = %q, want alpha", resolution.Skills[0].TargetName)
}
}
func TestCheckNameCollisionsForTargets_NoCollisions(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "skill-a", "alpha"),
createTempSkill(t, dir, "skill-b", "beta"),
}
targets := map[string]config.TargetConfig{
"claude": {Path: "/tmp/claude", Mode: "merge"},
}
global, perTarget := CheckNameCollisionsForTargets(skills, targets)
if len(global) != 0 {
t.Errorf("expected no global collisions, got %d", len(global))
}
if len(perTarget) != 0 {
t.Errorf("expected no per-target collisions, got %d", len(perTarget))
}
}
func TestCheckNameCollisionsForTargets_GlobalCollisionIsolatedByFilter(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "codex-plan", "planner"),
createTempSkill(t, dir, "gemini-plan", "planner"),
}
targets := map[string]config.TargetConfig{
"codex-target": {
Skills: &config.ResourceTargetConfig{
Path: "/tmp/codex",
Mode: "merge",
TargetNaming: "standard",
Include: []string{"codex-*"},
},
},
"gemini-target": {
Skills: &config.ResourceTargetConfig{
Path: "/tmp/gemini",
Mode: "merge",
TargetNaming: "standard",
Include: []string{"gemini-*"},
},
},
}
global, perTarget := CheckNameCollisionsForTargets(skills, targets)
if len(global) != 1 {
t.Fatalf("expected 1 global collision, got %d", len(global))
}
if global[0].Name != "planner" {
t.Errorf("expected collision name 'planner', got '%s'", global[0].Name)
}
if len(perTarget) != 0 {
t.Errorf("expected no per-target collisions (filters isolate), got %d", len(perTarget))
}
}
func TestCheckNameCollisionsForTargets_UnresolvedPerTargetCollision(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "dev"),
createTempSkill(t, dir, "backend/dev", "dev"),
}
targets := map[string]config.TargetConfig{
"claude": {
Skills: &config.ResourceTargetConfig{
Path: "/tmp/claude",
Mode: "merge",
TargetNaming: "standard",
},
},
}
global, perTarget := CheckNameCollisionsForTargets(skills, targets)
if len(global) != 1 {
t.Fatalf("expected 1 global collision, got %d", len(global))
}
if len(perTarget) != 1 {
t.Fatalf("expected 1 per-target collision, got %d", len(perTarget))
}
if perTarget[0].TargetName != "claude" {
t.Errorf("expected target 'claude', got '%s'", perTarget[0].TargetName)
}
}
func TestCheckNameCollisionsForTargets_SymlinkModeSkipped(t *testing.T) {
dir := t.TempDir()
skills := []DiscoveredSkill{
createTempSkill(t, dir, "frontend/dev", "dev"),
createTempSkill(t, dir, "backend/dev", "dev"),
}
targets := map[string]config.TargetConfig{
"symlink-target": {
Skills: &config.ResourceTargetConfig{
Path: "/tmp/sym",
Mode: "symlink",
TargetNaming: "standard",
Include: []string{"*"},
},
},
}
global, perTarget := CheckNameCollisionsForTargets(skills, targets)
if len(global) != 1 {
t.Fatalf("expected 1 global collision, got %d", len(global))
}
if len(perTarget) != 0 {
t.Errorf("expected no per-target collisions for symlink mode, got %d", len(perTarget))
}
}