Files
pipelines/internal/server/run_environment_test.go
alan cedfc22e45 Pipeline runs use the workspace's directory environment
Resolve the run workspace's environment with workenv (direnv, parent
.envrc, mise; same account rule as Claude chats) at run start and resume,
and apply it to Pi stage processes, a per-environment Pipelines-owned
OpenCode stage service (keyed by a hash of the change, reused across runs,
idle ones stopped after PIPELINES_OPENCODE_STAGE_IDLE_TIMEOUT, revived per
registration), delivery-gate checks and merges, plain-stage opencode CLI
calls and file-change capture git reads. Record the directory, .envrc
files, sources and variable names (never values) on the run detail; a
blocked .envrc becomes a run warning.
2026-11-04 18:08:42 +00:00

117 lines
4.4 KiB
Go

package server
import (
"context"
"encoding/json"
"os"
"path/filepath"
"slices"
"strings"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/stage"
"git.a-wan.net/alan/pipelines/internal/workenv"
"git.a-wan.net/alan/pipelines/internal/workenv/workenvtest"
)
func envValue(env []string, key string) (string, bool) {
for i := len(env) - 1; i >= 0; i-- {
if k, v, ok := strings.Cut(env[i], "="); ok && k == key {
return v, true
}
}
return "", false
}
// runInWorkspace runs the one-stage template in workspace and returns what the
// stage saw in its context and the stored run.
func runInWorkspace(t *testing.T, workspace string) (workenv.Environment, *protocol.RunDetail) {
t.Helper()
ctx, r, id := concurrentStore(t)
r.dirEnv = &workenv.Resolver{Timeout: 10 * time.Second}
var seen workenv.Environment
r.execute = func(ctx context.Context, def stage.Definition, _ stage.Values) (stage.Result, error) {
seen, _ = workenv.FromContext(ctx)
return stage.Result{Outcome: "success"}, nil
}
run, err := r.start(protocol.Message{PipelineID: id, Version: 1, RequestKey: "env-" + filepath.Base(workspace), Workspace: workspace, Input: map[string]any{"prompt": "task"}})
if err != nil {
t.Fatal(err)
}
r.wg.Wait()
detail, err := r.store.GetRun(ctx, run.ID)
if err != nil {
t.Fatal(err)
}
return seen, detail
}
func TestRunAppliesAndRecordsWorkspaceEnvironment(t *testing.T) {
workenvtest.InstallDirenv(t)
t.Setenv("ANTHROPIC_API_KEY", "server-key")
project, _ := filepath.EvalSymlinks(t.TempDir())
workspace := filepath.Join(project, "repos", "worktrees", "item")
if err := os.MkdirAll(workspace, 0o755); err != nil {
t.Fatal(err)
}
secret := "value-that-must-not-be-recorded"
workenvtest.WriteEnvrc(t, project, true, map[string]*string{"CLAUDE_CONFIG_DIR": workenvtest.Str(filepath.Join(project, ".claude-profile")), "SCRATCH_VAR": workenvtest.Str(secret)})
seen, detail := runInWorkspace(t, workspace)
if v, _ := envValue(seen.Env, "SCRATCH_VAR"); v != secret {
t.Fatal("stage context did not carry the workspace environment")
}
if _, ok := envValue(seen.Env, "ANTHROPIC_API_KEY"); ok {
t.Fatal("inherited credential kept although the directory chooses the account")
}
recorded := detail.Environment
if recorded == nil || recorded.Directory != workspace || recorded.ServiceKey == "" || !slices.Equal(recorded.Set, []string{"CLAUDE_CONFIG_DIR", "SCRATCH_VAR"}) ||
!slices.Contains(recorded.Dropped, "ANTHROPIC_API_KEY") || !slices.Equal(recorded.Files, []string{filepath.Join(project, ".envrc")}) || !slices.Equal(recorded.Sources, []string{"direnv"}) {
t.Fatalf("recorded environment = %+v", recorded)
}
data, _ := json.Marshal(detail)
if strings.Contains(string(data), secret) || strings.Contains(string(data), "server-key") {
t.Fatal("run detail carries an environment value")
}
}
func TestRunWarnsAboutBlockedWorkspaceEnvrc(t *testing.T) {
workenvtest.InstallDirenv(t)
project, _ := filepath.EvalSymlinks(t.TempDir())
workspace := filepath.Join(project, "item")
os.Mkdir(workspace, 0o755)
workenvtest.WriteEnvrc(t, project, false, map[string]*string{"SCRATCH_VAR": workenvtest.Str("x")})
seen, detail := runInWorkspace(t, workspace)
if seen.Applies() {
t.Fatal("blocked .envrc applied")
}
if detail.Status != "succeeded" {
t.Fatalf("status %s", detail.Status)
}
found := false
for _, warning := range detail.Warnings {
found = found || (strings.Contains(warning, "Workspace environment") && strings.Contains(warning, filepath.Join(project, ".envrc")) && strings.Contains(warning, "direnv allow"))
}
if !found || detail.Environment == nil || len(detail.Environment.Warnings) != 1 {
t.Fatalf("no blocked .envrc warning: %v", detail.Warnings)
}
}
func TestDeliveryCheckSeesRunEnvironment(t *testing.T) {
workenvtest.InstallDirenv(t)
project := t.TempDir()
workenvtest.WriteEnvrc(t, project, true, map[string]*string{"SCRATCH_VAR": workenvtest.Str("from-envrc")})
env := (&workenv.Resolver{Timeout: 10 * time.Second}).Environment(context.Background(), project, os.Environ())
ctx := workenv.WithEnvironment(context.Background(), env)
candidate := t.TempDir()
if err := runDeliveryCheck(ctx, candidate, `test "$SCRATCH_VAR" = from-envrc && test "$PWD" = "`+candidate+`"`); err != nil {
t.Fatal(err)
}
if err := runDeliveryCheck(context.Background(), candidate, `test -z "$SCRATCH_VAR"`); err != nil {
t.Fatal("a check without a run environment saw it:", err)
}
}