mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
- 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)
285 lines
9.7 KiB
Go
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)
|
|
}
|
|
}
|