Files
skillshare/internal/testutil/testutil.go
T
Willie 3345fd677e refactor: unify gemini and antigravity targets under antigravity
- Update antigravity global path to shared ~/.gemini/skills
- Update antigravity project path from .agent to .agents
- Add aliases: gemini, gemini-cli, antigravity-cli
- Remove standalone gemini target (now an alias)
- Update testutil.CreateTarget to match new path
2026-05-20 13:44:40 +08:00

333 lines
9.5 KiB
Go

// Package testutil provides utilities for integration testing
package testutil
import (
"os"
"path/filepath"
"testing"
)
// Sandbox represents an isolated test environment
type Sandbox struct {
T *testing.T
Root string // Root temp directory
Home string // Simulated home directory
ConfigPath string // Config file path
SourcePath string // Skills source directory
OrigEnv map[string]string // Original environment
BinaryPath string // Path to skillshare binary
}
// NewSandbox creates a new isolated test environment
func NewSandbox(t *testing.T) *Sandbox {
t.Helper()
root := t.TempDir()
home := filepath.Join(root, "home")
sb := &Sandbox{
T: t,
Root: root,
Home: home,
ConfigPath: filepath.Join(home, ".config", "skillshare", "config.yaml"),
SourcePath: filepath.Join(home, ".config", "skillshare", "skills"),
OrigEnv: make(map[string]string),
}
// Get binary path from environment or use default
sb.BinaryPath = os.Getenv("SKILLSHARE_TEST_BINARY")
if sb.BinaryPath == "" {
// Try to find it relative to the project root
// This works when running from the project directory
cwd, _ := os.Getwd()
candidates := []string{
filepath.Join(cwd, "bin", "skillshare"),
filepath.Join(cwd, "..", "..", "bin", "skillshare"),
filepath.Join(cwd, "bin", "skillshare.exe"),
filepath.Join(cwd, "..", "..", "bin", "skillshare.exe"),
}
for _, path := range candidates {
if _, err := os.Stat(path); err == nil {
sb.BinaryPath = path
break
}
}
}
// Create directory structure
dirs := []string{
filepath.Join(home, ".config", "skillshare"),
filepath.Join(home, ".config", "skillshare", "skills"),
filepath.Join(home, ".local", "share", "skillshare", "backups"),
filepath.Join(home, ".local", "share", "skillshare", "trash"),
filepath.Join(home, ".local", "state", "skillshare", "logs"),
filepath.Join(home, ".claude"),
filepath.Join(home, ".codex"),
filepath.Join(home, ".cursor"),
}
for _, dir := range dirs {
if err := os.MkdirAll(dir, 0755); err != nil {
t.Fatalf("failed to create directory %s: %v", dir, err)
}
}
// Override environment
sb.SetEnv("HOME", home)
sb.SetEnv("SKILLSHARE_CONFIG", sb.ConfigPath)
// Point XDG variables into the sandbox so config.BaseDir()/DataDir()/
// StateDir() resolve to sandbox paths. Without this, CI runners that
// set XDG_CONFIG_HOME (e.g. ubuntu-latest) cause the subprocess to
// write files outside the sandbox.
sb.SetEnv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
sb.SetEnv("XDG_DATA_HOME", filepath.Join(home, ".local", "share"))
sb.SetEnv("XDG_STATE_HOME", filepath.Join(home, ".local", "state"))
return sb
}
// SetEnv sets an environment variable, saving the original
func (sb *Sandbox) SetEnv(key, value string) {
sb.T.Helper()
sb.OrigEnv[key] = os.Getenv(key)
os.Setenv(key, value)
}
// Cleanup restores original environment
func (sb *Sandbox) Cleanup() {
for key, value := range sb.OrigEnv {
if value == "" {
os.Unsetenv(key)
} else {
os.Setenv(key, value)
}
}
}
// CreateSkill creates a test skill in the source directory
func (sb *Sandbox) CreateSkill(name string, files map[string]string) string {
sb.T.Helper()
skillDir := filepath.Join(sb.SourcePath, name)
if err := os.MkdirAll(skillDir, 0755); err != nil {
sb.T.Fatalf("failed to create skill directory: %v", err)
}
for filename, content := range files {
path := filepath.Join(skillDir, filename)
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
sb.T.Fatalf("failed to write file %s: %v", path, err)
}
}
return skillDir
}
// CreateNestedSkill creates a test skill at a nested path in the source directory.
// The relPath can use / as separator, e.g., "personal/writing/email" or "_team-repo/frontend/ui"
func (sb *Sandbox) CreateNestedSkill(relPath string, files map[string]string) string {
sb.T.Helper()
skillDir := filepath.Join(sb.SourcePath, filepath.FromSlash(relPath))
if err := os.MkdirAll(skillDir, 0755); err != nil {
sb.T.Fatalf("failed to create nested skill directory: %v", err)
}
for filename, content := range files {
path := filepath.Join(skillDir, filename)
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
sb.T.Fatalf("failed to write file %s: %v", path, err)
}
}
return skillDir
}
// CreateTarget creates a target directory
func (sb *Sandbox) CreateTarget(name string) string {
sb.T.Helper()
var path string
switch name {
case "claude":
path = filepath.Join(sb.Home, ".claude", "skills")
case "codex":
path = filepath.Join(sb.Home, ".codex", "skills")
case "cursor":
path = filepath.Join(sb.Home, ".cursor", "skills")
case "antigravity", "gemini":
path = filepath.Join(sb.Home, ".gemini", "skills")
case "opencode":
path = filepath.Join(sb.Home, ".config", "opencode", "skills")
default:
path = filepath.Join(sb.Home, "."+name, "skills")
}
if err := os.MkdirAll(path, 0755); err != nil {
sb.T.Fatalf("failed to create target: %v", err)
}
return path
}
// WriteConfig writes a config file
func (sb *Sandbox) WriteConfig(cfg string) {
sb.T.Helper()
dir := filepath.Dir(sb.ConfigPath)
if err := os.MkdirAll(dir, 0755); err != nil {
sb.T.Fatalf("failed to create config directory: %v", err)
}
if err := os.WriteFile(sb.ConfigPath, []byte(cfg), 0644); err != nil {
sb.T.Fatalf("failed to write config: %v", err)
}
}
// FileExists checks if a file exists
func (sb *Sandbox) FileExists(path string) bool {
_, err := os.Stat(path)
return err == nil
}
// IsSymlink checks if path is a symlink
func (sb *Sandbox) IsSymlink(path string) bool {
info, err := os.Lstat(path)
if err != nil {
return false
}
return info.Mode()&os.ModeSymlink != 0
}
// SymlinkTarget returns the target of a symlink
func (sb *Sandbox) SymlinkTarget(path string) string {
target, err := os.Readlink(path)
if err != nil {
return ""
}
return target
}
// ReadFile reads and returns file contents
func (sb *Sandbox) ReadFile(path string) string {
sb.T.Helper()
content, err := os.ReadFile(path)
if err != nil {
sb.T.Fatalf("failed to read file %s: %v", path, err)
}
return string(content)
}
// WriteFile writes content to a file
func (sb *Sandbox) WriteFile(path, content string) {
sb.T.Helper()
dir := filepath.Dir(path)
if err := os.MkdirAll(dir, 0755); err != nil {
sb.T.Fatalf("failed to create directory %s: %v", dir, err)
}
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
sb.T.Fatalf("failed to write file %s: %v", path, err)
}
}
// CreateSymlink creates a symbolic link
func (sb *Sandbox) CreateSymlink(target, link string) {
sb.T.Helper()
dir := filepath.Dir(link)
if err := os.MkdirAll(dir, 0755); err != nil {
sb.T.Fatalf("failed to create directory %s: %v", dir, err)
}
if err := os.Symlink(target, link); err != nil {
sb.T.Fatalf("failed to create symlink %s -> %s: %v", link, target, err)
}
}
// SetupProjectDir creates a project directory with .skillshare/ structure.
// Returns the project root path.
func (sb *Sandbox) SetupProjectDir(targets ...string) string {
sb.T.Helper()
projectRoot := filepath.Join(sb.Root, "project")
skillshareDir := filepath.Join(projectRoot, ".skillshare")
skillsDir := filepath.Join(skillshareDir, "skills")
for _, dir := range []string{skillsDir} {
if err := os.MkdirAll(dir, 0755); err != nil {
sb.T.Fatalf("failed to create %s: %v", dir, err)
}
}
// Write empty .gitignore
if err := os.WriteFile(filepath.Join(skillshareDir, ".gitignore"), []byte(""), 0644); err != nil {
sb.T.Fatalf("failed to create .gitignore: %v", err)
}
// Build config
cfg := "targets:\n"
for _, t := range targets {
cfg += " - " + t + "\n"
}
if err := os.WriteFile(filepath.Join(skillshareDir, "config.yaml"), []byte(cfg), 0644); err != nil {
sb.T.Fatalf("failed to write config: %v", err)
}
// Create target directories
knownPaths := map[string]string{
"claude": ".claude/skills",
"claude-code": ".claude/skills", // legacy alias
"cursor": ".agents/skills",
"codex": ".agents/skills",
}
for _, t := range targets {
if p, ok := knownPaths[t]; ok {
os.MkdirAll(filepath.Join(projectRoot, p), 0755)
}
}
return projectRoot
}
// CreateProjectSkill creates a skill inside .skillshare/skills/.
func (sb *Sandbox) CreateProjectSkill(projectRoot, name string, files map[string]string) string {
sb.T.Helper()
skillDir := filepath.Join(projectRoot, ".skillshare", "skills", name)
if err := os.MkdirAll(skillDir, 0755); err != nil {
sb.T.Fatalf("failed to create project skill: %v", err)
}
for filename, content := range files {
path := filepath.Join(skillDir, filename)
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
sb.T.Fatalf("failed to write %s: %v", path, err)
}
}
return skillDir
}
// WriteProjectConfig writes a config.yaml to .skillshare/config.yaml.
func (sb *Sandbox) WriteProjectConfig(projectRoot, cfg string) {
sb.T.Helper()
dir := filepath.Join(projectRoot, ".skillshare")
if err := os.MkdirAll(dir, 0755); err != nil {
sb.T.Fatalf("failed to create .skillshare: %v", err)
}
path := filepath.Join(dir, "config.yaml")
if err := os.WriteFile(path, []byte(cfg), 0644); err != nil {
sb.T.Fatalf("failed to write project config: %v", err)
}
}
// ListDir returns the names of files in a directory
func (sb *Sandbox) ListDir(path string) []string {
sb.T.Helper()
entries, err := os.ReadDir(path)
if err != nil {
sb.T.Fatalf("failed to read directory %s: %v", path, err)
}
names := make([]string, len(entries))
for i, entry := range entries {
names[i] = entry.Name()
}
return names
}