Files
kandev/apps/backend/internal/agent/runtime/lifecycle/skill/inject_test.go
T
2026-07-06 22:19:52 +01:00

257 lines
7.6 KiB
Go

package skill
import (
"os"
"path/filepath"
"strings"
"testing"
)
// ensureGit creates a minimal .git directory structure.
func ensureGit(t *testing.T, dir string) {
t.Helper()
if err := os.MkdirAll(filepath.Join(dir, ".git", "info"), 0o755); err != nil {
t.Fatal(err)
}
}
func TestInjectSkills_WritesUnderProjectSkillDir(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
skills := []Skill{
{Slug: "code-review", Content: "# Code Review"},
{Slug: "memory", Content: "# Memory"},
}
if err := injectSkills(worktree, ".claude/skills", skills); err != nil {
t.Fatalf("injectSkills: %v", err)
}
for _, slug := range []string{"code-review", "memory"} {
path := filepath.Join(worktree, ".claude", "skills", "kandev-"+slug, "SKILL.md")
if _, err := os.Stat(path); err != nil {
t.Errorf("missing %s: %v", path, err)
}
}
}
func TestInjectSkills_SkipsSupportFilesUnderSymlinkParent(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
outside := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "kandev-code-review")
if err := os.MkdirAll(skillDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.Symlink(outside, filepath.Join(skillDir, "references")); err != nil {
t.Fatal(err)
}
err := writeSkillFiles(skillDir, []SkillFile{{
Path: "references/escape.md",
Content: "outside",
}})
if err != nil {
t.Fatalf("writeSkillFiles: %v", err)
}
if _, err := os.Stat(filepath.Join(outside, "escape.md")); !os.IsNotExist(err) {
t.Fatalf("support file escaped through symlink parent: %v", err)
}
}
func TestInjectSkills_WritesSupportFilesUnderSymlinkedSkillDir(t *testing.T) {
realSkillDir := filepath.Join(t.TempDir(), "real", "kandev-code-review")
if err := os.MkdirAll(realSkillDir, 0o755); err != nil {
t.Fatal(err)
}
linkParent := filepath.Join(t.TempDir(), "links")
if err := os.MkdirAll(linkParent, 0o755); err != nil {
t.Fatal(err)
}
symlinkSkillDir := filepath.Join(linkParent, "kandev-code-review")
if err := os.Symlink(realSkillDir, symlinkSkillDir); err != nil {
t.Fatal(err)
}
err := writeSkillFiles(symlinkSkillDir, []SkillFile{{
Path: "references/tasks.md",
Content: "tasks",
}})
if err != nil {
t.Fatalf("writeSkillFiles: %v", err)
}
got, err := os.ReadFile(filepath.Join(realSkillDir, "references", "tasks.md"))
if err != nil {
t.Fatalf("read support file: %v", err)
}
if string(got) != "tasks" {
t.Fatalf("support file content = %q, want tasks", got)
}
}
func TestInjectSkills_AddsFrontmatterWhenMissing(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "kandev-team-admin", Content: "# Team\n\nUse the team commands."},
}); err != nil {
t.Fatalf("injectSkills: %v", err)
}
data, err := os.ReadFile(filepath.Join(worktree, ".agents", "skills", "kandev-kandev-team-admin", "SKILL.md"))
if err != nil {
t.Fatalf("read SKILL.md: %v", err)
}
got := string(data)
if !strings.HasPrefix(got, "---\nname: kandev-team-admin\ndescription: kandev-team-admin\n---\n") {
t.Fatalf("SKILL.md missing synthesized frontmatter:\n%s", got)
}
if !strings.Contains(got, "# Team\n\nUse the team commands.") {
t.Errorf("SKILL.md missing original body:\n%s", got)
}
}
func TestInjectSkills_PreservesExistingFrontmatter(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
content := "---\nname: custom\ndescription: existing\n---\n# Body"
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "custom", Content: content},
}); err != nil {
t.Fatalf("injectSkills: %v", err)
}
data, err := os.ReadFile(filepath.Join(worktree, ".agents", "skills", "kandev-custom", "SKILL.md"))
if err != nil {
t.Fatalf("read SKILL.md: %v", err)
}
if string(data) != content {
t.Errorf("existing frontmatter should be preserved, got %q", string(data))
}
}
func TestInjectSkills_CleanSlateRemovesPreviousKandevDirs(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "skill-a", Content: "# A"},
{Slug: "skill-b", Content: "# B"},
}); err != nil {
t.Fatalf("first inject: %v", err)
}
// Re-inject with only A — B's directory must be gone.
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "skill-a", Content: "# A"},
}); err != nil {
t.Fatalf("second inject: %v", err)
}
skillsDir := filepath.Join(worktree, ".agents", "skills")
if _, err := os.Stat(filepath.Join(skillsDir, "kandev-skill-b")); !os.IsNotExist(err) {
t.Errorf("deassigned kandev-skill-b should be removed")
}
if _, err := os.Stat(filepath.Join(skillsDir, "kandev-skill-a", "SKILL.md")); err != nil {
t.Errorf("still-assigned kandev-skill-a should exist: %v", err)
}
}
func TestInjectSkills_PreservesUserSkills(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
userSkill := filepath.Join(worktree, ".claude", "skills", "team-skill")
if err := os.MkdirAll(userSkill, 0o755); err != nil {
t.Fatal(err)
}
if err := injectSkills(worktree, ".claude/skills", []Skill{
{Slug: "code-review", Content: "# CR"},
}); err != nil {
t.Fatalf("injectSkills: %v", err)
}
if _, err := os.Stat(userSkill); err != nil {
t.Errorf("user-managed skill should be preserved: %v", err)
}
}
func TestInjectSkills_SkipsInvalidSlug(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "../escape", Content: "evil"},
{Slug: "ok-slug", Content: "# ok"},
}); err != nil {
t.Fatalf("injectSkills: %v", err)
}
if _, err := os.Stat(filepath.Join(worktree, ".agents", "skills", "kandev-ok-slug", "SKILL.md")); err != nil {
t.Errorf("valid slug should land: %v", err)
}
// The invalid slug must not have produced any directory.
entries, _ := os.ReadDir(filepath.Join(worktree, ".agents", "skills"))
for _, e := range entries {
if strings.Contains(e.Name(), "escape") {
t.Errorf("invalid slug %q wrote a directory", e.Name())
}
}
}
func TestEnsureGitExclude_AppendsPatternIdempotent(t *testing.T) {
worktree := t.TempDir()
ensureGit(t, worktree)
for i := 0; i < 3; i++ {
if err := ensureGitExclude(worktree, ".claude/skills"); err != nil {
t.Fatalf("call %d: %v", i, err)
}
}
data, err := os.ReadFile(filepath.Join(worktree, ".git", "info", "exclude"))
if err != nil {
t.Fatalf("read exclude: %v", err)
}
pattern := ".claude/skills/kandev-*"
if got := strings.Count(string(data), pattern); got != 1 {
t.Errorf("pattern appears %d times, want 1; got %q", got, string(data))
}
}
func TestEnsureGitExclude_LinkedWorktreeGitFile(t *testing.T) {
mainGitDir := t.TempDir()
if err := os.MkdirAll(filepath.Join(mainGitDir, "info"), 0o755); err != nil {
t.Fatal(err)
}
worktree := t.TempDir()
gitFile := filepath.Join(worktree, ".git")
if err := os.WriteFile(gitFile, []byte("gitdir: "+mainGitDir+"\n"), 0o644); err != nil {
t.Fatal(err)
}
if err := ensureGitExclude(worktree, ".agents/skills"); err != nil {
t.Fatalf("ensureGitExclude: %v", err)
}
data, err := os.ReadFile(filepath.Join(mainGitDir, "info", "exclude"))
if err != nil {
t.Fatalf("read exclude: %v", err)
}
if !strings.Contains(string(data), ".agents/skills/kandev-*") {
t.Errorf("pattern not appended: %q", string(data))
}
}
func TestInjectSkills_NoGitDirIsNotFatal(t *testing.T) {
worktree := t.TempDir() // no .git
if err := injectSkills(worktree, ".agents/skills", []Skill{
{Slug: "ok", Content: "# ok"},
}); err != nil {
t.Fatalf("injectSkills: %v", err)
}
if _, err := os.Stat(filepath.Join(worktree, ".agents", "skills", "kandev-ok", "SKILL.md")); err != nil {
t.Errorf("skill should still land without .git: %v", err)
}
}