Files
skillshare/tests/integration/install_branch_test.go
T
Willie e91890d2b0 test: fix all integration tests for centralized .metadata.json format
- Dual-write in WriteMeta: also writes to .metadata.json for backward compat
- Migration looks in parent dir for registry.yaml
- Group uninstall matches entries by Group field + full path
- Sync test uses MetadataStore instead of registry.yaml
- All integration tests pass (0 FAIL)
2026-04-08 14:28:57 +08:00

285 lines
9.7 KiB
Go

//go:build !online
package integration
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"skillshare/internal/install"
"skillshare/internal/testutil"
)
func TestInstallBranch_TrackedRepo(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
// Create bare repo with two branches
remoteRepo := filepath.Join(sb.Root, "remote-repo.git")
gitInit(t, remoteRepo, true)
// Clone, create content on main, push
workDir := filepath.Join(sb.Root, "work")
gitClone(t, remoteRepo, workDir)
if err := os.MkdirAll(filepath.Join(workDir, "main-skill"), 0755); err != nil {
t.Fatalf("mkdir main-skill: %v", err)
}
if err := os.WriteFile(filepath.Join(workDir, "main-skill", "SKILL.md"), []byte("---\nname: main-skill\n---\n# Main branch skill"), 0644); err != nil {
t.Fatalf("write main-skill: %v", err)
}
gitAddCommit(t, workDir, "add main-skill")
gitPush(t, workDir)
// Create 'dev' branch with different skill
cmd := exec.Command("git", "checkout", "-b", "dev")
cmd.Dir = workDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git checkout -b dev: %s %v", out, err)
}
if err := os.MkdirAll(filepath.Join(workDir, "dev-skill"), 0755); err != nil {
t.Fatalf("mkdir dev-skill: %v", err)
}
if err := os.WriteFile(filepath.Join(workDir, "dev-skill", "SKILL.md"), []byte("---\nname: dev-skill\n---\n# Dev branch skill"), 0644); err != nil {
t.Fatalf("write dev-skill: %v", err)
}
gitAddCommit(t, workDir, "add dev-skill")
pushCmd := exec.Command("git", "push", "origin", "dev")
pushCmd.Dir = workDir
if out, err := pushCmd.CombinedOutput(); err != nil {
t.Fatalf("git push origin dev: %s %v", out, err)
}
// Install tracked repo from dev branch with explicit name
result := sb.RunCLI("install", "file://"+remoteRepo, "--track", "--branch", "dev", "--name", "test-repo", "--skip-audit")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "dev-skill")
// Verify dev-skill exists
devSkillPath := filepath.Join(sb.SourcePath, "_test-repo", "dev-skill", "SKILL.md")
if _, err := os.Stat(devSkillPath); err != nil {
t.Errorf("dev-skill should exist at %s: %v", devSkillPath, err)
}
// Verify main-skill also exists (it's on dev branch too since dev branched from main)
mainSkillPath := filepath.Join(sb.SourcePath, "_test-repo", "main-skill", "SKILL.md")
if _, err := os.Stat(mainSkillPath); err != nil {
t.Errorf("main-skill should exist at %s: %v", mainSkillPath, err)
}
// Verify branch is written to .metadata.json
store, err := install.LoadMetadata(sb.SourcePath)
if err != nil {
t.Fatalf("load metadata: %v", err)
}
entry := store.Get("_test-repo")
if entry == nil {
t.Fatal("expected metadata entry for _test-repo")
}
if entry.Branch != "dev" {
t.Errorf("metadata branch = %q, want %q", entry.Branch, "dev")
}
}
func TestInstallBranch_FlagParsing(t *testing.T) {
t.Run("rejects --branch without value", func(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
result := sb.RunCLI("install", "github.com/owner/repo", "--branch")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "--branch requires a value")
})
t.Run("rejects --branch with local path", func(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
localSkill := sb.CreateSkill("my-skill", map[string]string{
"SKILL.md": "---\nname: my-skill\n---\n# Content",
})
result := sb.RunCLI("install", localSkill, "--branch", "dev")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "--branch can only be used with git")
})
t.Run("rejects empty --branch value", func(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
result := sb.RunCLI("install", "github.com/owner/repo", "--branch", " ")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "--branch requires a non-empty value")
})
}
func TestInstallBranch_RegularInstall(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
// Create bare repo with two branches
remoteRepo := filepath.Join(sb.Root, "regular-repo.git")
gitInit(t, remoteRepo, true)
workDir := filepath.Join(sb.Root, "work-regular")
gitClone(t, remoteRepo, workDir)
// main branch: one skill
os.MkdirAll(filepath.Join(workDir, "alpha"), 0755)
os.WriteFile(filepath.Join(workDir, "alpha", "SKILL.md"), []byte("---\nname: alpha\n---\n# Alpha"), 0644)
gitAddCommit(t, workDir, "add alpha")
gitPush(t, workDir)
// feature branch: additional skill
cmd := exec.Command("git", "checkout", "-b", "feature")
cmd.Dir = workDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git checkout -b feature: %s %v", out, err)
}
os.MkdirAll(filepath.Join(workDir, "beta"), 0755)
os.WriteFile(filepath.Join(workDir, "beta", "SKILL.md"), []byte("---\nname: beta\n---\n# Beta"), 0644)
gitAddCommit(t, workDir, "add beta")
pushCmd := exec.Command("git", "push", "origin", "feature")
pushCmd.Dir = workDir
if out, err := pushCmd.CombinedOutput(); err != nil {
t.Fatalf("git push origin feature: %s %v", out, err)
}
// Install from feature branch with --all
result := sb.RunCLI("install", "file://"+remoteRepo, "--branch", "feature", "--all", "--skip-audit")
result.AssertSuccess(t)
// Both alpha and beta should be installed (feature branch has both)
if _, err := os.Stat(filepath.Join(sb.SourcePath, "alpha", "SKILL.md")); err != nil {
t.Error("alpha skill should be installed")
}
if _, err := os.Stat(filepath.Join(sb.SourcePath, "beta", "SKILL.md")); err != nil {
t.Error("beta skill should be installed")
}
}
func TestInstallBranch_MetadataPersistence(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
// Create bare repo with staging branch
remoteRepo := filepath.Join(sb.Root, "meta-repo.git")
gitInit(t, remoteRepo, true)
workDir := filepath.Join(sb.Root, "work-meta")
gitClone(t, remoteRepo, workDir)
os.MkdirAll(filepath.Join(workDir, "my-skill"), 0755)
os.WriteFile(filepath.Join(workDir, "my-skill", "SKILL.md"), []byte("---\nname: my-skill\n---\n# Skill"), 0644)
gitAddCommit(t, workDir, "add skill")
gitPush(t, workDir)
cmd := exec.Command("git", "checkout", "-b", "staging")
cmd.Dir = workDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git checkout -b staging: %s %v", out, err)
}
// Need a commit on staging so it differs from main
os.WriteFile(filepath.Join(workDir, "my-skill", "SKILL.md"), []byte("---\nname: my-skill\n---\n# Skill staging"), 0644)
gitAddCommit(t, workDir, "staging commit")
pushCmd := exec.Command("git", "push", "origin", "staging")
pushCmd.Dir = workDir
if out, err := pushCmd.CombinedOutput(); err != nil {
t.Fatalf("git push: %s %v", out, err)
}
// Install from staging branch
result := sb.RunCLI("install", "file://"+remoteRepo, "--branch", "staging", "--all", "--skip-audit")
result.AssertSuccess(t)
// Check .metadata.json has branch field
store, err := install.LoadMetadata(sb.SourcePath)
if err != nil {
t.Fatalf("load metadata: %v", err)
}
entry := store.Get("my-skill")
if entry == nil {
t.Fatal("expected metadata entry for my-skill")
}
if entry.Branch != "staging" {
t.Errorf("entry.Branch = %q, want %q", entry.Branch, "staging")
}
}
func TestInstallBranch_UpdatePreservesBranch(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets: {}\n")
// Create bare repo
remoteRepo := filepath.Join(sb.Root, "update-repo.git")
gitInit(t, remoteRepo, true)
workDir := filepath.Join(sb.Root, "work-update")
gitClone(t, remoteRepo, workDir)
os.MkdirAll(filepath.Join(workDir, "updatable"), 0755)
os.WriteFile(filepath.Join(workDir, "updatable", "SKILL.md"), []byte("---\nname: updatable\n---\n# V1"), 0644)
gitAddCommit(t, workDir, "v1")
gitPush(t, workDir)
// Create dev branch
cmd := exec.Command("git", "checkout", "-b", "dev")
cmd.Dir = workDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("checkout -b dev: %s %v", out, err)
}
pushCmd := exec.Command("git", "push", "origin", "dev")
pushCmd.Dir = workDir
if out, err := pushCmd.CombinedOutput(); err != nil {
t.Fatalf("push dev: %s %v", out, err)
}
// Install from dev branch using explicit subdir notation (file:///repo//updatable)
// so meta.Source is a valid re-installable URL.
result := sb.RunCLI("install", "file://"+remoteRepo+"//updatable", "--branch", "dev", "--skip-audit")
result.AssertSuccess(t)
// Verify branch is persisted in metadata
store, err := install.LoadMetadata(sb.SourcePath)
if err != nil {
t.Fatalf("load metadata: %v", err)
}
entry := store.Get("updatable")
if entry == nil {
t.Fatal("expected metadata entry for updatable")
}
if entry.Branch != "dev" {
t.Errorf("entry.Branch = %q, want %q", entry.Branch, "dev")
}
// Push update on dev branch only
os.WriteFile(filepath.Join(workDir, "updatable", "SKILL.md"), []byte("---\nname: updatable\n---\n# V2 dev"), 0644)
gitAddCommit(t, workDir, "v2 on dev")
pushCmd = exec.Command("git", "push", "origin", "dev")
pushCmd.Dir = workDir
if out, err := pushCmd.CombinedOutput(); err != nil {
t.Fatalf("push dev v2: %s %v", out, err)
}
// Update should pull from dev branch (not main)
updateResult := sb.RunCLI("update", "updatable", "--skip-audit")
updateResult.AssertSuccess(t)
// Verify content is V2 dev
content, err := os.ReadFile(filepath.Join(sb.SourcePath, "updatable", "SKILL.md"))
if err != nil {
t.Fatalf("read skill: %v", err)
}
if !strings.Contains(string(content), "V2 dev") {
t.Errorf("expected V2 dev content, got: %s", content)
}
}