Files
skillshare/internal/server/handler_diff_stream_naming_test.go
T
Willie 111dd71a53 fix(sync): let prefixed naming keep skills whose name differs from their folder (#531)
Prefixed naming rewrites name: in every copy to the entry name, so the
target folder and name: always agree. Requiring name: to equal the source
folder only skipped skills it could sync: a tracked repo that is itself a
skill lives in _<repo>, so its root SKILL.md could never pass.

Only standard naming now requires the match; name format rules still
apply to both. Sync lists the skills named this way, so a user looking
for _ooux in the target finds ooux.

The dashboard's skipped-skills hint always blamed folders that end in the
same name, even when skills were skipped for their name. The diff API now
reports naming skips apart from collisions and the hint names the cause.

Refs #530
2026-10-12 13:59:59 +08:00

143 lines
6.1 KiB
Go

package server
import (
"os"
"path/filepath"
"testing"
"skillshare/internal/config"
ssync "skillshare/internal/sync"
)
func TestComputeTargetDiff_NamingChangeReportsRename(t *testing.T) {
source, target := t.TempDir(), t.TempDir()
for _, dir := range []string{filepath.Join(source, "_emil-design", "skills", "prototype"), filepath.Join(target, "prototype")} {
if err := os.MkdirAll(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: prototype\n---\n"), 0o644); err != nil {
t.Fatal(err)
}
}
manifest := &ssync.Manifest{Managed: map[string]string{"prototype": "x"}, Naming: map[string]string{"prototype": "standard"}}
if err := ssync.WriteManifest(target, manifest); err != nil {
t.Fatal(err)
}
discovered, err := ssync.DiscoverSourceSkills(source)
if err != nil {
t.Fatal(err)
}
dt := (&Server{}).computeTargetDiff("claude", config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: target, Mode: "copy", TargetNaming: "prefixed"}}, discovered, "merge", source, nil)
if len(dt.Items) != 1 || dt.Items[0].Skill != "emil-design-prototype" || dt.Items[0].Action != "update" || dt.Items[0].Reason != "renamed from prototype (target naming changed)" {
t.Fatalf("items = %+v, want one update renaming prototype", dt.Items)
}
}
func TestComputeTargetDiff_StaleRecordedNamingIsAnUpdate(t *testing.T) {
// A sync renamed the entry and saved the manifest, then stopped before re-copying it.
source, target := t.TempDir(), t.TempDir()
src := filepath.Join(source, "_emil-design", "skills", "prototype")
for _, dir := range []string{src, filepath.Join(target, "emil-design-prototype")} {
if err := os.MkdirAll(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: prototype\n---\n"), 0o644); err != nil {
t.Fatal(err)
}
}
checksum, err := ssync.DirChecksumWithIgnore(src, nil)
if err != nil {
t.Fatal(err)
}
manifest := &ssync.Manifest{Managed: map[string]string{"emil-design-prototype": checksum}, Naming: map[string]string{"emil-design-prototype": "standard"}}
if err := ssync.WriteManifest(target, manifest); err != nil {
t.Fatal(err)
}
discovered, err := ssync.DiscoverSourceSkills(source)
if err != nil {
t.Fatal(err)
}
dt := (&Server{}).computeTargetDiff("claude", config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: target, Mode: "copy", TargetNaming: "prefixed"}}, discovered, "merge", source, nil)
if len(dt.Items) != 1 || dt.Items[0].Action != "update" || dt.Items[0].Reason != "target naming changed" {
t.Fatalf("items = %+v, want one update for the stale naming", dt.Items)
}
}
func TestComputeTargetDiff_LocalFolderOnNewNameKeepsLegacyEntry(t *testing.T) {
source, target := t.TempDir(), t.TempDir()
for _, dir := range []string{filepath.Join(source, "_emil-design", "skills", "prototype"), filepath.Join(target, "prototype"), filepath.Join(target, "emil-design-prototype")} {
if err := os.MkdirAll(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: prototype\n---\n"), 0o644); err != nil {
t.Fatal(err)
}
}
// prototype is the managed copy; emil-design-prototype is the user's folder.
manifest := &ssync.Manifest{Managed: map[string]string{"prototype": "x"}, Naming: map[string]string{"prototype": "standard"}}
if err := ssync.WriteManifest(target, manifest); err != nil {
t.Fatal(err)
}
discovered, err := ssync.DiscoverSourceSkills(source)
if err != nil {
t.Fatal(err)
}
dt := (&Server{}).computeTargetDiff("claude", config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: target, Mode: "copy", TargetNaming: "prefixed"}}, discovered, "merge", source, nil)
if len(dt.Items) != 1 || dt.Items[0].Skill != "emil-design-prototype" || dt.Items[0].Action != "kept" || dt.Items[0].Reason != ssync.KeptLegacyReason("prototype") {
t.Fatalf("items = %+v, want the local folder reported with the kept legacy entry", dt.Items)
}
}
func TestComputeTargetDiff_MergeModeCopyModeCopyIsReplacedWithLink(t *testing.T) {
source, target := t.TempDir(), t.TempDir()
for _, dir := range []string{filepath.Join(source, "alpha"), filepath.Join(target, "alpha")} {
if err := os.MkdirAll(dir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: alpha\n---\n"), 0o644); err != nil {
t.Fatal(err)
}
}
checksum, err := ssync.DirChecksumWithIgnore(filepath.Join(source, "alpha"), ssync.DefaultFileIgnorePatterns())
if err != nil {
t.Fatal(err)
}
if err := ssync.WriteManifest(target, &ssync.Manifest{Managed: map[string]string{"alpha": checksum}}); err != nil {
t.Fatal(err)
}
discovered, err := ssync.DiscoverSourceSkills(source)
if err != nil {
t.Fatal(err)
}
dt := (&Server{}).computeTargetDiff("claude", config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: target, Mode: "merge"}}, discovered, "merge", source, nil)
if len(dt.Items) != 1 || dt.Items[0].Action != "update" || dt.Items[0].Reason != ssync.CopyToLinkReason {
t.Fatalf("items = %+v, want one update replacing the copy with a link", dt.Items)
}
}
func TestComputeTargetDiff_CountsNamingSkipsApartFromCollisions(t *testing.T) {
source, target := t.TempDir(), t.TempDir()
skills := map[string]string{"a/dev": "dev", "b/dev": "dev", "odd": "not-odd"}
for dir, name := range skills {
if err := os.MkdirAll(filepath.Join(source, dir), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(source, dir, "SKILL.md"), []byte("---\nname: "+name+"\n---\n"), 0o644); err != nil {
t.Fatal(err)
}
}
discovered, err := ssync.DiscoverSourceSkills(source)
if err != nil {
t.Fatal(err)
}
dt := (&Server{}).computeTargetDiff("claude", config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: target, Mode: "copy", TargetNaming: "standard"}}, discovered, "merge", source, nil)
if dt.SkippedCount != 3 || dt.CollisionCount != 1 || dt.NamingSkippedCount != 1 {
t.Fatalf("skipped = %d, collisions = %d, naming = %d; want 3, 1, 1", dt.SkippedCount, dt.CollisionCount, dt.NamingSkippedCount)
}
}