Files
skillshare/internal/sync/sync_test.go
T
star-nebula 4e3b2b269a fix(sync): report include patterns that match no skill (#326)
Target include/exclude patterns are matched with filepath.Match against the
source-path flat name, while target_naming: standard shows the bare SKILL.md
name in the target directory. A pattern written with the name the target shows
selects nothing, so sync prunes the entries a working pattern had linked, and
the only trace is the echoed include: line, which never says that any of those
patterns matched zero skills.

Add FindUnmatchedIncludes and render one diagnostic per include pattern that
selects no discovered skill, suggesting the flat names whose last path segment
is the pattern. exclude is left alone: an exclusion that blocks nothing is the
normal state of a spare filter, while an include that selects nothing is always
a mistake and is the destructive direction. The diagnostic goes to DiagOutput,
so --json output is unchanged, and no filtering, naming, or pruning behavior
moves.

Closes #325
2026-10-02 15:54:53 +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 pattern "dev" matches no skill in the source ` +
`(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))
}
}