mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
These packages were left out of the windows-test job because of failures that came from test assumptions (POSIX paths, permission bits, HOME, bash shims posing as git), not product behavior. Fix them and add the packages to the list so they stay green. Two failures were real product bugs: - swapStagedIntoSource named its backup like the temp that sourcefs.MoveIn creates beside it. On a coarse clock (Windows) both names matched, the failed move removed the temp and with it the backup, and the old skill was lost. - MetadataStore.GetByPath looked up OS-native paths in slash-form keys, so `update --group` missed nested skills on Windows. The test sandbox now also sets USERPROFILE, which os.UserHomeDir reads on Windows; tests were reading the real profile. Refs #344
338 lines
9.7 KiB
Go
338 lines
9.7 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("USERPROFILE", home) // os.UserHomeDir on Windows
|
|
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":
|
|
path = filepath.Join(sb.Home, ".gemini", "config", "skills")
|
|
case "antigravity-cli":
|
|
path = filepath.Join(sb.Home, ".gemini", "antigravity-cli", "skills")
|
|
case "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
|
|
}
|