Skip to content
quarry Artifact [e45cd72b4e]
Login

Artifact [e45cd72b4e]

Artifact e45cd72b4ed42fbcb2819dd4fcaaf13443e26f318b872d6dc87c530057893a6b:


package pickupclient

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync/atomic"
	"testing"
	"time"
)

func fastOpts() CollectOpts {
	return CollectOpts{Wait: time.Minute, Poll: time.Millisecond}
}

// A RUNNER'S COLLECT WAITS OUT PENDING, SENDS THE KEY ONLY IN THE
// AUTHORIZATION HEADER WITH KIND RUNNER, AND RETURNS THE TOKEN AND WHAT
// THE FORGE SAYS IT IS FOR.
func TestCollectRunnerWaitsThenReturnsTheToken(t *testing.T) {
	key, code, err := NewKey()
	if err != nil || len(key) != 32 || len(code) != 64 {
		t.Fatalf("FAIL: NewKey gave %d bytes and code %q: %v", len(key), code, err)
	}
	var calls atomic.Int32
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.RawQuery != "" || r.URL.Path != "/api/v1/pickups/collect" || r.Header.Get("Quarry-Pickup-Kind") != "runner" || !strings.HasPrefix(r.Header.Get("Authorization"), "Pickup ") {
			t.Errorf("FAIL: the call was %s ?%s kind %q", r.URL.Path, r.URL.RawQuery, r.Header.Get("Quarry-Pickup-Kind"))
		}
		if calls.Add(1) < 3 {
			w.WriteHeader(http.StatusAccepted)
			w.Write([]byte(`{"state":"pending"}`))
			return
		}
		w.Write([]byte(`{"request":"r1","op":"ci.worker.token.new","agent":"runner at 1.2.3.4","repo":"suit","owner":"jva","result":{"token":{"id":"wt1"}},"secret":{"value":"wt-secret-9999"}}`))
	}))
	defer srv.Close()
	got, err := CollectRunner(context.Background(), srv.URL, key, fastOpts())
	if err != nil || got.Secret != "wt-secret-9999" || got.Repo != "suit" || got.TokenID != "wt1" || got.Agent != "runner at 1.2.3.4" || calls.Load() != 3 {
		t.Errorf("FAIL: collected %+v after %d calls: %v", got, calls.Load(), err)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// A request that ended without a token says how, as data the installer
// can act on; a credential that is not a worker token is never kept.
func TestCollectRunnerReportsHowARequestEnded(t *testing.T) {
	key, _, _ := NewKey()
	for _, tc := range []struct {
		status int
		body   string
		state  string
	}{
		{410, `{"state":"denied","error":"x"}`, "denied"},
		{410, `{"state":"expired","error":"x"}`, "expired"},
	} {
		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(tc.status)
			w.Write([]byte(tc.body))
		}))
		_, err := CollectRunner(context.Background(), srv.URL, key, fastOpts())
		var c *Closed
		if !errors.As(err, &c) || c.State != tc.state {
			t.Errorf("FAIL: %s answered %v, want a Closed %s", tc.body, err, tc.state)
		}
		srv.Close()
	}
	other := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(`{"request":"r","op":"agent.setup","repo":"","secret":{"value":"zit-secret-1"}}`))
	}))
	defer other.Close()
	if got, err := CollectRunner(context.Background(), other.URL, key, fastOpts()); err == nil || got.Secret != "" || strings.Contains(err.Error(), "zit-secret-1") {
		t.Errorf("FAIL: a credential that is not a worker token was returned: %v", err)
	}
	slow := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(202) }))
	defer slow.Close()
	o := fastOpts()
	o.Wait = 20 * time.Millisecond
	if _, err := CollectRunner(context.Background(), slow.URL, key, o); !errors.Is(err, ErrStillPending) {
		t.Errorf("FAIL: a request still waiting at the deadline gave %v", err)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}