Skip to content
quarry Artifact [a6dc58fe2c]
Login

Artifact [a6dc58fe2c]

Artifact a6dc58fe2c70745a86f6b55865b4be1001e9fdf5939cc95619cf18089f225215:


package main

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"sync/atomic"
	"testing"
	"time"
)

const pickupTestSecret = "s3cr3t-token-value-0123456789"

type zitCall struct {
	dir  string
	env  []string
	args []string
}

type pickupRig struct {
	t      *testing.T
	dir    string
	out    bytes.Buffer
	errw   bytes.Buffer
	calls  []zitCall
	sleeps []time.Duration
	runErr error
}

func (r *pickupRig) env() *pickupEnv {
	return &pickupEnv{
		client:   &http.Client{},
		stdout:   &r.out,
		stderr:   &r.errw,
		stateDir: filepath.Join(r.dir, "state"),
		sleep: func(ctx context.Context, d time.Duration) error {
			r.sleeps = append(r.sleeps, d)
			return nil
		},
		run: func(ctx context.Context, dir string, env []string, args []string) (string, error) {
			r.calls = append(r.calls, zitCall{dir, env, args})
			return "", r.runErr
		},
	}
}

func (r *pickupRig) do(args ...string) int {
	return pickupCmd(context.Background(), args, r.env())
}

func newPickupRig(t *testing.T) *pickupRig { return &pickupRig{t: t, dir: t.TempDir()} }

func (r *pickupRig) newKey() (keyFile, code string) {
	r.t.Helper()
	keys := filepath.Join(r.dir, "keys")
	if rc := r.do("new", "--dir", keys); rc != 0 {
		r.t.Fatalf("FAIL: new exited %d", rc)
	}
	code = strings.TrimSpace(r.out.String())
	r.out.Reset()
	return filepath.Join(keys, code), code
}

// fakeForge answers the collect route as the real one does; script is
// the answers in order, the last repeating.
func fakeForge(t *testing.T, script []func(w http.ResponseWriter), seen *[]string) *httptest.Server {
	var n atomic.Int32
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		if req.Method != "POST" || !strings.HasSuffix(req.URL.Path, "/pickup") && req.URL.Path != "/api/v1/pickups/collect" {
			w.WriteHeader(404)
			return
		}
		if seen != nil {
			*seen = append(*seen, req.Header.Get("Authorization"))
		}
		i := int(n.Add(1)) - 1
		if i >= len(script) {
			i = len(script) - 1
		}
		w.Header().Set("Content-Type", "application/json")
		script[i](w)
	}))
}

func pending(w http.ResponseWriter) { w.WriteHeader(202); w.Write([]byte(`{"state":"pending"}`)) }
func gone(state string) func(http.ResponseWriter) {
	return func(w http.ResponseWriter) {
		w.WriteHeader(410)
		json.NewEncoder(w).Encode(map[string]string{"state": state, "error": "x"})
	}
}
func approved(host string) func(http.ResponseWriter) {
	return func(w http.ResponseWriter) {
		json.NewEncoder(w).Encode(map[string]any{
			"request": "r1", "op": "agent.setup", "agent": "bot", "owner": "dan",
			"result": map[string]any{"agent": "bot", "remotes": []map[string]string{{"repo": "ns/r", "url": host + "/r/ns/r", "project_code": "abc"}}},
			"secret": map[string]string{"value": pickupTestSecret},
		})
	}
}

func (r *pickupRig) noLeak() {
	r.t.Helper()
	for _, c := range r.calls {
		for _, a := range c.args {
			if strings.Contains(a, pickupTestSecret) {
				r.t.Errorf("FAIL: secret in argv %v", c.args)
			}
		}
	}
	if strings.Contains(r.out.String()+r.errw.String(), pickupTestSecret) {
		r.t.Errorf("FAIL: secret in captured output")
	}
}

func TestPickupNewWritesKey0600PrintsOnlyCode(t *testing.T) {
	r := newPickupRig(t)
	keyFile, code := r.newKey()
	st, err := os.Stat(keyFile)
	if err != nil {
		t.Fatalf("FAIL: key file: %v", err)
	}
	if st.Mode().Perm() != 0o600 {
		t.Errorf("FAIL: mode %v", st.Mode().Perm())
	}
	raw, _ := os.ReadFile(keyFile)
	sum := sha256.Sum256(raw)
	if len(raw) != 32 || hex.EncodeToString(sum[:]) != code {
		t.Errorf("FAIL: key is not 32 bytes hashing to the code")
	}
	if strings.Contains(r.out.String(), base64.RawURLEncoding.EncodeToString(raw)) {
		t.Errorf("FAIL: key printed")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupNewRefusesToOverwrite(t *testing.T) {
	r := newPickupRig(t)
	keys := filepath.Join(r.dir, "keys")
	r.do("new", "--dir", keys)
	before, _ := os.ReadDir(keys)
	r.do("new", "--dir", keys)
	after, _ := os.ReadDir(keys)
	if len(before) != 1 || len(after) != 2 {
		t.Errorf("FAIL: each new is its own file and never replaces one: %d then %d", len(before), len(after))
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupCollectPendingThenApprovedClone(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	raw, _ := os.ReadFile(keyFile)
	var seen []string
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){pending, pending, func(w http.ResponseWriter) { approved(srv.URL)(w) }}, &seen)
	defer srv.Close()
	dest := filepath.Join(r.dir, "co")
	rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", dest)
	if rc != 0 {
		t.Fatalf("FAIL: exit %d: %s", rc, r.errw.String())
	}
	if len(seen) != 3 {
		t.Errorf("FAIL: %d polls", len(seen))
	}
	want := "Pickup " + base64.RawURLEncoding.EncodeToString(raw)
	for _, a := range seen {
		if a != want {
			t.Errorf("FAIL: authorization header shape")
		}
	}
	if len(r.sleeps) != 2 || r.sleeps[0] < 10*time.Second {
		t.Errorf("FAIL: polling budget: %v", r.sleeps)
	}
	if len(r.calls) != 1 {
		t.Fatalf("FAIL: zit calls %d", len(r.calls))
	}
	c := r.calls[0]
	if c.args[0] != "clone" || c.args[1] != srv.URL+"/r/ns/r" || c.args[2] != dest {
		t.Errorf("FAIL: argv %v", c.args)
	}
	if !contains(c.args, "--user") || !contains(c.args, "bot") {
		t.Errorf("FAIL: --user missing %v", c.args)
	}
	if !contains(c.env, "ZIT_PASSWORD="+pickupTestSecret) {
		t.Errorf("FAIL: password not in env")
	}
	if _, err := os.Stat(keyFile); !os.IsNotExist(err) {
		t.Errorf("FAIL: key file remains")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func contains(s []string, v string) bool {
	for _, x := range s {
		if x == v {
			return true
		}
	}
	return false
}

func TestPickupCollectCheckout(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	co := filepath.Join(r.dir, "co")
	os.MkdirAll(co, 0o755)
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--checkout", co); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if len(r.calls) != 2 || r.calls[0].args[0] != "remote" || r.calls[1].args[0] != "pull" {
		t.Fatalf("FAIL: calls %v", r.calls)
	}
	for _, c := range r.calls {
		if c.dir != co {
			t.Errorf("FAIL: ran in %q", c.dir)
		}
	}
	if !contains(r.calls[1].env, "ZIT_PASSWORD="+pickupTestSecret) || !contains(r.calls[1].args, "bot") {
		t.Errorf("FAIL: pull login")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupTerminalStatesExitNonZero(t *testing.T) {
	for _, st := range []string{"denied", "lapsed", "expired", "failed", "collected"} {
		r := newPickupRig(t)
		keyFile, _ := r.newKey()
		srv := fakeForge(t, []func(http.ResponseWriter){gone(st)}, nil)
		rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", filepath.Join(r.dir, "x"))
		srv.Close()
		if rc != 1 {
			t.Errorf("FAIL: %s exit %d", st, rc)
		}
		if len(r.calls) != 0 {
			t.Errorf("FAIL: %s ran zit", st)
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupPendingPastWaitExits3(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	srv := fakeForge(t, []func(http.ResponseWriter){pending}, nil)
	defer srv.Close()
	e := r.env()
	clock := time.Unix(0, 0)
	e.now = func() time.Time { return clock }
	e.sleep = func(ctx context.Context, d time.Duration) error { clock = clock.Add(d); return nil }
	rc := pickupCmd(context.Background(), []string{"collect", srv.URL + "/r/ns/r", "--key", keyFile, "--clone", "x", "--wait", "35s"}, e)
	if rc != 3 {
		t.Errorf("FAIL: exit %d", rc)
	}
	if _, err := os.Stat(keyFile); err != nil {
		t.Errorf("FAIL: key must stay while pending")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickup429HonoursRetryAfter(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	busy := func(w http.ResponseWriter) { w.Header().Set("Retry-After", "42"); w.WriteHeader(429) }
	srv = fakeForge(t, []func(http.ResponseWriter){busy, func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if len(r.sleeps) != 1 || r.sleeps[0] != 42*time.Second {
		t.Errorf("FAIL: sleeps %v", r.sleeps)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupRefusesForeignHost(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	srv := fakeForge(t, []func(http.ResponseWriter){approved("https://evil.example")}, nil)
	defer srv.Close()
	rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d")
	if rc == 0 {
		t.Errorf("FAIL: foreign remote accepted")
	}
	if len(r.calls) != 0 {
		t.Errorf("FAIL: zit ran")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupRefusesRedirect(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var hit atomic.Int32
	other := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { hit.Add(1) }))
	defer other.Close()
	srv := httptest.NewServer(http.RedirectHandler(other.URL, 307))
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc == 0 || hit.Load() != 0 {
		t.Errorf("FAIL: redirect followed (rc %d hits %d)", rc, hit.Load())
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupZitFailureScrubbed(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	e := r.env()
	e.run = func(ctx context.Context, dir string, env []string, args []string) (string, error) {
		return "login " + pickupTestSecret + " refused", os.ErrInvalid
	}
	rc := pickupCmd(context.Background(), []string{"collect", srv.URL + "/r/ns/r", "--key", keyFile, "--clone", "d"}, e)
	if rc == 0 {
		t.Errorf("FAIL: exit 0 on zit failure")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupPrintEnvOnlyWhenAsked(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile); rc != 2 {
		t.Errorf("FAIL: no mode should be usage, got %d", rc)
	}
	if _, err := os.Stat(keyFile); err != nil {
		t.Errorf("FAIL: usage error consumed the key")
	}
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--print-env"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if !strings.Contains(r.out.String(), "ZIT_PASSWORD=") || !strings.Contains(r.out.String(), pickupTestSecret) {
		t.Errorf("FAIL: env line missing")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}