package api
import (
"context"
"crypto/tls"
"encoding/base64"
"net"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"craftdesign.group/quarry/internal/pickupclient"
)
// pickupClientRun drives the real client against the real collector
// (served at the forge's own origin, https://forge.test) and returns its
// exit status, what it ran and what it printed.
func pickupClientRun(t *testing.T, coll http.Handler, key string, extra ...string) (rc int, ran [][]string, env []string, out string) {
t.Helper()
srv := httptest.NewTLSServer(coll)
defer srv.Close()
raw, err := base64.RawURLEncoding.DecodeString(key)
if err != nil {
t.Fatal(err)
}
keyFile := filepath.Join(t.TempDir(), "key")
if err := os.WriteFile(keyFile, raw, 0o600); err != nil {
t.Fatal(err)
}
client := &http.Client{Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
DialContext: func(ctx context.Context, n, _ string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, n, srv.Listener.Addr().String())
},
}}
var stdout, stderr strings.Builder
e := &pickupclient.Env{
Client: client, Stdout: &stdout, Stderr: &stderr, StateDir: t.TempDir(),
Sleep: func(context.Context, time.Duration) error { return nil },
Run: func(_ context.Context, dir string, e []string, args []string) (string, error) {
ran, env = append(ran, args), append(env, e...)
return "", nil
},
}
args := append([]string{"collect", "https://forge.test", "--key", keyFile}, extra...)
rc = pickupclient.Command(context.Background(), args, e)
if _, err := os.Stat(keyFile); rc == 0 && !os.IsNotExist(err) {
t.Errorf("FAIL: key file remains after success")
}
return rc, ran, env, stdout.String() + stderr.String()
}
func hasEnv(env []string, prefix string) bool {
for _, e := range env {
if strings.HasPrefix(e, prefix) {
return true
}
}
return false
}
// An agent's own Quarry-Ask with Quarry-Pickup: the answer's top-level
// agent is the asker.
func TestTheClientCollectsAnAgentsAskedSetupFromTheRealCollector(t *testing.T) {
g := newSetupRig(t)
key, code := newPickupKey(t)
id := g.ask("zeitgeist", pushBody, code)
if err := g.decide("dmestas", id, true); err != nil {
t.Fatal(err)
}
rc, ran, env, out := pickupClientRun(t, g.coll, key, "--clone", "dest")
if rc != 0 || len(ran) != 1 || ran[0][0] != "clone" || !sliceHas(ran[0], "suit-push") || !hasEnv(env, "ZIT_PASSWORD=qat_") {
t.Fatalf("FAIL: rc %d ran %v", rc, ran)
}
if strings.Contains(out, "qat_") {
t.Errorf("FAIL: the token was printed")
}
if !t.Failed() {
t.Log("ok")
}
}
// A claimed /setup start: the asker is "client of <person>".
func TestTheClientCollectsAClaimedStartFromTheRealCollector(t *testing.T) {
g := newStartRig(t)
key, pickup := newPickupKey(t)
code := g.begin("e-desktop", "read", pickup)
id, err := g.claim("dmestas", code, "suit", "")
if err != nil {
t.Fatal(err)
}
if err := g.decide("dmestas", id, true); err != nil {
t.Fatal(err)
}
rc, ran, env, out := pickupClientRun(t, g.coll, key, "--clone", "dest")
if rc != 0 || len(ran) != 1 || !sliceHas(ran[0], "e-desktop") || !hasEnv(env, "ZIT_PASSWORD=qat_") {
t.Fatalf("FAIL: rc %d ran %v out %q", rc, ran, out)
}
if !t.Failed() {
t.Log("ok")
}
}
func sliceHas(s []string, v string) bool {
for _, x := range s {
if x == v {
return true
}
}
return false
}
// A CI worker token names no agent. Collected for zit, the forge refuses
// it before anything is taken, so nothing is stranded and the key still
// opens it; collected with --runner-env, the client prints the runner's
// variable and runs nothing (#445; the 2026-11-18 stranded token).
func TestTheClientCollectsAWorkerTokenOnlyAsARunnerCredential(t *testing.T) {
g := newPickupRig(t)
key, code := newPickupKey(t)
status, id := g.ask(t, "mini", code)
if status != 202 || id == "" {
t.Fatalf("asking: %d", status)
}
g.decide(t, id, true)
rc, ran, _, out := pickupClientRun(t, g.coll, key, "--clone", "dest")
if rc == 0 || len(ran) != 0 {
t.Errorf("FAIL: a worker token was handed to zit: rc %d ran %v", rc, ran)
}
if strings.Contains(out, "revoke") {
t.Errorf("FAIL: the refusal stranded the credential")
}
rc, ran, _, out = pickupClientRun(t, g.coll, key, "--runner-env")
if rc != 0 || len(ran) != 0 || !strings.HasPrefix(out, "export QUARRY_RUNNER_TOKEN='") {
t.Errorf("FAIL: --runner-env did not collect the worker token: rc %d ran %v", rc, ran)
}
if !t.Failed() {
t.Log("ok")
}
}