Skip to content
quarry Artifact [63f7d887a0]
Login

Artifact [63f7d887a0]

Artifact 63f7d887a07c0098e082488327f7660afeceed8958ba1d57e994a6480b7d5abc:


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
}