AI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary
Python ai-promptsai-skillblueskyclaudeclaude-codeclawhubdeep-researchhackernewsinstagramopenclawpolymarketrecencyredditresearchsocial-mediatiktoktrendstwitterweb-searchyoutube
package engine
import (
"context"
"errors"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"time"
)
func fakePython(t *testing.T, dir, name, version string) string {
t.Helper()
if runtime.GOOS == "windows" {
t.Skip("POSIX executable fixture")
}
path := filepath.Join(dir, name)
body := "#!/bin/sh\nif [ \"$1\" = '-I' ]; then printf '%s\\n' '" + version + "'; else printf 'research completed'; fi\n"
if err := os.WriteFile(path, []byte(body), 0755); err != nil {
t.Fatal(err)
}
return path
}
func TestPythonDiscoveryFallback(t *testing.T) {
for _, name := range []string{"python3", "python3.12", "python3.99", "python"} {
t.Run(name, func(t *testing.T) {
unsetPythonOverride(t)
first, second := t.TempDir(), t.TempDir()
fakePython(t, first, "python3", "3.9")
want := fakePython(t, second, name, "3.12")
t.Setenv("PATH", first+string(os.PathListSeparator)+second)
got, err := resolvePython("")
if err != nil || got != want {
t.Fatalf("got %q, %v; want %q", got, err, want)
}
result, err := Run(context.Background(), RunOptions{CacheDir: stageCache(t)})
if err != nil || string(result.Stdout) != "research completed" {
t.Fatalf("Run = %+v, %v", result, err)
}
})
}
}
func TestPythonDiscoveryPreservesDefault(t *testing.T) {
unsetPythonOverride(t)
dir := t.TempDir()
want := fakePython(t, dir, "python3", "3.12")
fakePython(t, dir, "python3.14", "3.14")
t.Setenv("PATH", dir)
got, err := resolvePython("")
if err != nil || got != want {
t.Fatalf("got %q, %v", got, err)
}
}
func TestPythonOverrideVerifiedWithoutFallback(t *testing.T) {
dir := t.TempDir()
fakePython(t, dir, "python3", "3.14")
t.Setenv("PATH", dir)
for _, version := range []string{"3.9", "invalid", "4.0", "3.12", "3.99"} {
t.Run(version, func(t *testing.T) {
explicit := fakePython(t, t.TempDir(), "selected-python", version)
t.Setenv(PythonEnvOverride, explicit)
got, err := resolvePython("")
if version == "3.12" || version == "3.99" {
if err != nil || got != explicit {
t.Fatalf("got %q, %v", got, err)
}
} else if err == nil || got != "" || !strings.Contains(err.Error(), PythonEnvOverride) {
t.Fatalf("invalid override fell back: %q, %v", got, err)
}
})
}
t.Setenv(PythonEnvOverride, filepath.Join(dir, "missing"))
if _, err := resolvePython(""); err == nil {
t.Fatal("missing override fell back")
}
}
func TestPythonDiscoveryExcludesRelativePathsAndConfigHelpers(t *testing.T) {
unsetPythonOverride(t)
dir := t.TempDir()
fakePython(t, dir, "python3-config", "3.14")
fakePython(t, dir, "python3.14-config", "3.14")
fakePython(t, dir, "python3", "3.14")
t.Chdir(dir)
t.Setenv("GODEBUG", "execerrdot=0")
t.Setenv("PATH", ".")
t.Setenv(PythonEnvOverride, "./python3")
if _, err := resolvePython(""); err == nil {
t.Fatal("accepted relative override")
}
unsetPythonOverride(t)
if _, err := resolvePython(""); err == nil {
t.Fatal("accepted relative PATH")
}
if err := os.Remove(filepath.Join(dir, "python3")); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", dir)
if _, err := resolvePython(""); err == nil {
t.Fatal("accepted config helper")
}
}
func TestPythonProbeCancellation(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("POSIX executable fixture")
}
path := filepath.Join(t.TempDir(), "python3")
if err := os.WriteFile(path, []byte("#!/bin/sh\nexec /bin/sleep 10\n"), 0755); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
start := time.Now()
if err := checkPythonVersion(ctx, path); err == nil {
t.Fatal("expected timeout")
}
if time.Since(start) > time.Second {
t.Fatal("probe ignored cancellation")
}
}
func unsetPythonOverride(t *testing.T) {
t.Helper()
t.Setenv(PythonEnvOverride, "")
if err := os.Unsetenv(PythonEnvOverride); err != nil {
t.Fatal(err)
}
}
func TestDiscoveryFilesystemCancellation(t *testing.T) {
release := make(chan struct{})
defer close(release)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
start := time.Now()
_, err := discoveryOperation(ctx, func() (string, error) { <-release; return "", nil })
if err != context.DeadlineExceeded || time.Since(start) > time.Second {
t.Fatalf("filesystem cancellation: %v", err)
}
}
func TestDiscoveryStopsBeforeLaterDirectory(t *testing.T) {
unsetPythonOverride(t)
first, second := t.TempDir(), t.TempDir()
want := fakePython(t, first, "python3", "3.12")
t.Setenv("PATH", first+string(os.PathListSeparator)+second)
got, err := resolvePythonWithCandidates(context.Background(), "", func(dir string) []string {
if dir == second {
t.Error("scanned later directory after valid interpreter")
}
return pythonCandidates(dir)
})
if err != nil || got != want {
t.Fatalf("got %q, %v", got, err)
}
}
func TestDiscoveryCancelsStalledDirectory(t *testing.T) {
unsetPythonOverride(t)
t.Setenv("PATH", t.TempDir())
release := make(chan struct{})
defer close(release)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
start := time.Now()
_, err := resolvePythonWithCandidates(ctx, "", func(string) []string { <-release; return nil })
if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > time.Second {
t.Fatalf("stalled discovery ignored cancellation: %v", err)
}
}
func TestRunDiscoveryPreservesCancellation(t *testing.T) {
for _, wantErr := range []error{context.Canceled, context.DeadlineExceeded} {
t.Run(wantErr.Error(), func(t *testing.T) {
unsetPythonOverride(t)
dir := t.TempDir()
fakePython(t, dir, "python3", "3.12")
t.Setenv("PATH", dir)
var ctx context.Context
var cancel context.CancelFunc
if wantErr == context.DeadlineExceeded {
ctx, cancel = context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
} else {
ctx, cancel = context.WithCancel(context.Background())
}
cancel()
_, err := Run(ctx, RunOptions{CacheDir: stageCache(t)})
if !errors.Is(err, wantErr) {
t.Fatalf("Run error = %v, want %v", err, wantErr)
}
})
}
}
func TestPythonCandidatesCaseInsensitiveNames(t *testing.T) {
dir := t.TempDir()
for _, name := range []string{"PYTHON.exe", "python3.12.Exe", "Python3.EXE", "python3.11.exe"} {
if err := os.WriteFile(filepath.Join(dir, name), nil, 0755); err != nil {
t.Fatal(err)
}
}
defer func(prev bool) { caseInsensitiveNames = prev }(caseInsensitiveNames)
caseInsensitiveNames = true
got := pythonCandidates(dir)
want := []string{
filepath.Join(dir, "Python3.EXE"),
filepath.Join(dir, "python3.12.Exe"),
filepath.Join(dir, "PYTHON.exe"),
}
if strings.Join(got, "|") != strings.Join(want, "|") {
t.Fatalf("case-insensitive candidates = %q, want %q", got, want)
}
caseInsensitiveNames = false
if got := pythonCandidates(dir); len(got) != 0 {
t.Fatalf("case-sensitive candidates = %q, want none", got)
}
}