Skip to content

AI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary

6.8 KB
Raw Blame
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)
	}
}