Skip to content

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

8.1 KB
Raw Blame
package engine

import (
	"bytes"
	"context"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"sync"
	"testing"
	"testing/fstest"
	"time"
)

func newTestFS() fstest.MapFS {
	return fstest.MapFS{
		"last30days.py":   &fstest.MapFile{Data: []byte("# last30days entry\n"), Mode: 0o644},
		"lib/__init__.py": &fstest.MapFile{Data: []byte(""), Mode: 0o644},
		"lib/env.py":      &fstest.MapFile{Data: []byte("# env helpers\n"), Mode: 0o644},
	}
}

func TestEnsureExtractsEngine(t *testing.T) {
	src := newTestFS()
	base := t.TempDir()

	cacheDir, err := Ensure(src, base, "v1")
	if err != nil {
		t.Fatalf("Ensure: %v", err)
	}
	if cacheDir != filepath.Join(base, cacheSubdir, "v1") {
		t.Fatalf("cacheDir = %q, want %q", cacheDir, filepath.Join(base, cacheSubdir, "v1"))
	}
	mustReadFile(t, filepath.Join(cacheDir, "last30days.py"), "# last30days entry\n")
	mustReadFile(t, filepath.Join(cacheDir, "lib/env.py"), "# env helpers\n")
	mustReadFile(t, filepath.Join(cacheDir, SentinelFilename), "v1")
}

func TestEnsureSkipsWhenSentinelMatches(t *testing.T) {
	src := newTestFS()
	base := t.TempDir()

	cacheDir, err := Ensure(src, base, "v1")
	if err != nil {
		t.Fatalf("first Ensure: %v", err)
	}
	target := filepath.Join(cacheDir, "last30days.py")
	info1, err := os.Stat(target)
	if err != nil {
		t.Fatalf("stat: %v", err)
	}

	// Reset the sync.Once so a second call would re-extract if not for the
	// sentinel short-circuit. Without the reset, sync.Once would skip the
	// extraction regardless of sentinel state.
	resetOnce(cacheDir)

	if _, err := Ensure(src, base, "v1"); err != nil {
		t.Fatalf("second Ensure: %v", err)
	}
	info2, err := os.Stat(target)
	if err != nil {
		t.Fatalf("stat second: %v", err)
	}
	if !info2.ModTime().Equal(info1.ModTime()) {
		t.Fatalf("expected file untouched on sentinel match; got mtime %v -> %v", info1.ModTime(), info2.ModTime())
	}
}

func TestEnsureReExtractsOnVersionChange(t *testing.T) {
	v1 := fstest.MapFS{
		"last30days.py": &fstest.MapFile{Data: []byte("v1\n"), Mode: 0o644},
	}
	v2 := fstest.MapFS{
		"last30days.py": &fstest.MapFile{Data: []byte("v2\n"), Mode: 0o644},
	}
	base := t.TempDir()

	cache1, err := Ensure(v1, base, "v1")
	if err != nil {
		t.Fatalf("Ensure v1: %v", err)
	}
	cache2, err := Ensure(v2, base, "v2")
	if err != nil {
		t.Fatalf("Ensure v2: %v", err)
	}
	if cache1 == cache2 {
		t.Fatalf("expected distinct cache dirs per version, got %q == %q", cache1, cache2)
	}
	mustReadFile(t, filepath.Join(cache1, "last30days.py"), "v1\n")
	mustReadFile(t, filepath.Join(cache2, "last30days.py"), "v2\n")
}

func TestEnsureConcurrentFirstCall(t *testing.T) {
	src := newTestFS()
	base := t.TempDir()

	const goroutines = 10
	var wg sync.WaitGroup
	wg.Add(goroutines)
	results := make([]string, goroutines)
	errs := make([]error, goroutines)
	for i := 0; i < goroutines; i++ {
		i := i
		go func() {
			defer wg.Done()
			results[i], errs[i] = Ensure(src, base, "v1")
		}()
	}
	wg.Wait()

	for i, err := range errs {
		if err != nil {
			t.Fatalf("goroutine %d: %v", i, err)
		}
	}
	for i := 1; i < goroutines; i++ {
		if results[i] != results[0] {
			t.Fatalf("goroutine 0 saw %q, goroutine %d saw %q", results[0], i, results[i])
		}
	}
	mustReadFile(t, filepath.Join(results[0], "last30days.py"), "# last30days entry\n")
}

type pausedExtractionFS struct {
	fs.FS
	base string
}

func (src pausedExtractionFS) Open(name string) (fs.File, error) {
	if name == "zeta.txt" {
		if err := os.WriteFile(filepath.Join(src.base, "ready"), nil, 0o600); err != nil {
			return nil, err
		}
		deadline := time.Now().Add(20 * time.Second)
		for {
			if _, err := os.Stat(filepath.Join(src.base, "release")); err == nil {
				break
			}
			if time.Now().After(deadline) {
				return nil, fmt.Errorf("timed out waiting to resume extraction")
			}
			time.Sleep(10 * time.Millisecond)
		}
	}
	return src.FS.Open(name)
}

func TestEnsureConcurrentProcesses(t *testing.T) {
	src := fstest.MapFS{
		"alpha.txt": &fstest.MapFile{Data: []byte("alpha")},
		"zeta.txt":  &fstest.MapFile{Data: []byte("zeta")},
	}
	if role := os.Getenv("LAST30DAYS_TEST_EXTRACT_ROLE"); role != "" {
		var source fs.FS = src
		if role == "paused" {
			source = pausedExtractionFS{FS: src, base: os.Getenv(CacheEnvOverride)}
		}
		if _, err := EnsureUserCache(source, "v1"); err != nil {
			t.Fatal(err)
		}
		return
	}

	for _, initialState := range []string{"missing", "incomplete", "stale"} {
		t.Run(initialState, func(t *testing.T) {
			base := t.TempDir()
			cacheDir := filepath.Join(base, cacheSubdir, "v1")
			if initialState != "missing" {
				if err := os.MkdirAll(cacheDir, 0o755); err != nil {
					t.Fatal(err)
				}
				if err := os.WriteFile(filepath.Join(cacheDir, "alpha.txt"), []byte("partial"), 0o644); err != nil {
					t.Fatal(err)
				}
				if initialState == "stale" {
					if err := os.WriteFile(filepath.Join(cacheDir, SentinelFilename), []byte("old-version"), 0o644); err != nil {
						t.Fatal(err)
					}
				}
			}
			executable, err := os.Executable()
			if err != nil {
				t.Fatal(err)
			}
			t.Setenv(CacheEnvOverride, base)
			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
			defer cancel()
			child := func(role string) *exec.Cmd {
				cmd := exec.CommandContext(ctx, executable, "-test.run=^TestEnsureConcurrentProcesses$")
				cmd.Env = append(os.Environ(), "LAST30DAYS_TEST_EXTRACT_ROLE="+role)
				return cmd
			}
			paused := child("paused")
			var output bytes.Buffer
			paused.Stdout = &output
			paused.Stderr = &output
			if err := paused.Start(); err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() {
				_ = paused.Process.Kill()
				if paused.ProcessState == nil {
					_ = paused.Wait()
				}
			})
			deadline := time.Now().Add(10 * time.Second)
			for {
				if _, err := os.Stat(filepath.Join(base, "ready")); err == nil {
					break
				}
				if time.Now().After(deadline) {
					t.Fatal("first process did not pause during extraction")
				}
				time.Sleep(10 * time.Millisecond)
			}
			if out, err := child("winner").CombinedOutput(); err != nil {
				t.Fatalf("second process: %v\n%s", err, out)
			}
			mustReadFile(t, filepath.Join(cacheDir, "alpha.txt"), "alpha")
			mustReadFile(t, filepath.Join(cacheDir, "zeta.txt"), "zeta")
			canary := filepath.Join(cacheDir, "winner-only.txt")
			if err := os.WriteFile(canary, []byte(base), 0o600); err != nil {
				t.Fatal(err)
			}
			if err := os.WriteFile(filepath.Join(base, "release"), nil, 0o600); err != nil {
				t.Fatal(err)
			}
			if err := paused.Wait(); err != nil {
				t.Fatalf("first process: %v\n%s", err, &output)
			}
			if _, err := EnsureUserCache(src, "v1"); err != nil {
				t.Fatalf("reuse completed cache: %v", err)
			}
			mustReadFile(t, filepath.Join(cacheDir, "alpha.txt"), "alpha")
			mustReadFile(t, filepath.Join(cacheDir, "zeta.txt"), "zeta")
			mustReadFile(t, filepath.Join(cacheDir, SentinelFilename), "v1")
			mustReadFile(t, canary, base)
		})
	}
}

func TestEnsureRejectsEmptyVersion(t *testing.T) {
	if _, err := Ensure(newTestFS(), t.TempDir(), ""); err == nil {
		t.Fatal("expected error for empty version")
	}
}

func TestEnsureReturnsErrorWhenCacheUnwritable(t *testing.T) {
	// Place the cache root at a path that cannot exist (a regular file).
	// MkdirAll will refuse and Ensure must surface a wrapped error.
	base := t.TempDir()
	blocker := filepath.Join(base, "blocker")
	if err := os.WriteFile(blocker, []byte("not a dir"), 0o644); err != nil {
		t.Fatalf("setup: %v", err)
	}

	_, err := Ensure(newTestFS(), blocker, "v1")
	if err == nil {
		t.Fatal("expected error when cache parent is not a directory")
	}
}

func TestEnsureUserCacheHonorsOverride(t *testing.T) {
	override := t.TempDir()
	t.Setenv(CacheEnvOverride, override)

	src := newTestFS()
	cacheDir, err := EnsureUserCache(src, "v1")
	if err != nil {
		t.Fatalf("EnsureUserCache: %v", err)
	}
	want := filepath.Join(override, cacheSubdir, "v1")
	if cacheDir != want {
		t.Fatalf("cacheDir = %q, want %q", cacheDir, want)
	}
	mustReadFile(t, filepath.Join(cacheDir, "last30days.py"), "# last30days entry\n")
}

func mustReadFile(t *testing.T, path, want string) {
	t.Helper()
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read %s: %v", path, err)
	}
	if string(data) != want {
		t.Fatalf("%s: got %q, want %q", path, string(data), want)
	}
}