Skip to content
quarry Artifact [c879bb7230]
Login

Artifact [c879bb7230]

Artifact c879bb7230e1a19e76224bf63de7da51ad246cd2044c47ff9844c53a61a89581:


package api

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"strings"
	"testing"

	"craftdesign.group/quarry/internal/oltp"
	"craftdesign.group/quarry/internal/ops"
)

// A forge agent's delete of another person's repository waits for the
// person it answers to (RFC 0021, Deleting others' repositories).
type forgeDeleteRig struct {
	h    http.Handler
	r    *ops.Registry
	reg  *fakeRegistry
	own  *fakeOwners
	ctx  context.Context
	pctx context.Context
}

func newForgeDeleteRig(t *testing.T) *forgeDeleteRig {
	t.Helper()
	db, err := oltp.Open(filepath.Join(t.TempDir(), "o.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { db.Close() })
	for _, who := range []string{"dmestas", "jva"} {
		if err := db.AddAccount(who, "a-long-enough-password", who == "dmestas"); err != nil {
			t.Fatal(err)
		}
	}
	if err := db.NewForgeAgent("fbot", "dmestas"); err != nil {
		t.Fatal(err)
	}
	if err := db.SetSiteAdmin("fbot", true, "dmestas"); err != nil {
		t.Fatal(err)
	}
	for _, n := range []string{"mine", "adm", "theirs", "teamed", "orphan", "forgotten"} {
		if err := db.Grant("fbot", n, oltp.RepoAdmin); err != nil {
			t.Fatal(err)
		}
	}
	// orphan has no deed holder but a person who administers it;
	// forgotten has neither.
	if err := db.Grant("jva", "orphan", oltp.RepoAdmin); err != nil {
		t.Fatal(err)
	}
	if err := db.AddTeam("core", "", "", "jva"); err != nil {
		t.Fatal(err)
	}
	if err := db.SetTeamRepo("core", "teamed", "jva"); err != nil {
		t.Fatal(err)
	}
	owners := newFakeOwners()
	owners.owner["mine"], owners.owner["adm"], owners.owner["theirs"] = "fbot", "dmestas", "jva"
	names := []string{"mine", "adm", "theirs", "teamed", "orphan", "forgotten"}
	repos := map[string]*Repo{}
	for _, n := range names {
		repos[n] = &Repo{Code: "code-" + n, Chat: "code-" + n}
	}
	reg := &fakeRegistry{}
	r := ops.NewRegistry()
	if err := RegisterAll(r, Deps{Version: "v", Repos: NewRepos(repos), Registry: reg, Owners: owners, Acts: &recordedActs{},
		Accounts: adminAdapter{acctAdapter{db}}, SignOffs: testSignOffs{db}, Prefs: db, SecretBox: testBox(t), Teams: db,
		CapsFor: func(a, repo string) CapSet { return db.EffectiveCaps(a, repo) }}); err != nil {
		t.Fatal(err)
	}
	h, err := RouterWithCaps(r, "v", func(a, repo string) CapSet { return db.EffectiveCaps(a, repo) }, nil)
	if err != nil {
		t.Fatal(err)
	}
	site := ops.TokenAuth{ID: "T", Caps: func(repo string) ops.Caps { return db.EffectiveCaps("fbot", repo) },
		ForgeAgent: func() bool { return true }, Site: func() bool { return true }}
	return &forgeDeleteRig{h: h, r: r, reg: reg, own: owners,
		ctx:  ops.WithToken(ops.WithUser(context.Background(), "fbot"), site),
		pctx: ops.WithUser(context.Background(), "dmestas")}
}

func (g *forgeDeleteRig) del(ctx context.Context, repo, ask string) (int, string) {
	return g.post(ctx, "/api/v1/repos/delete", `{"name":"`+repo+`","confirm":"`+repo+`"}`, ask)
}

func (g *forgeDeleteRig) post(ctx context.Context, path, body, ask string) (int, string) {
	req := httptest.NewRequest("POST", path, strings.NewReader(body)).WithContext(ctx)
	req.Header.Set("Content-Type", "application/json")
	if ask != "" {
		req.Header.Set("Quarry-Ask", ask)
	}
	rec := httptest.NewRecorder()
	g.h.ServeHTTP(rec, req)
	return rec.Code, rec.Body.String()
}

func (g *forgeDeleteRig) waiting(t *testing.T) []SignOffRequest {
	t.Helper()
	out, err := g.r.Invoke(g.pctx, "signoff.list", signOffListIn{})
	if err != nil {
		t.Fatal(err)
	}
	return out.(signOffListOut).Requests
}

func TestAForgeAgentsDeleteOfAnotherPersonsRepoWaitsForItsPerson(t *testing.T) {
	g := newForgeDeleteRig(t)
	if c, b := g.del(g.ctx, "theirs", ""); c != 403 {
		t.Errorf("FAIL: plain delete answered %d: %s", c, b)
	}
	if len(g.reg.deleted) != 0 || len(g.waiting(t)) != 0 {
		t.Fatalf("FAIL: a plain refusal ran or filed something: %v", g.reg.deleted)
	}
	if c, b := g.del(g.ctx, "theirs", "retiring it"); c != 202 {
		t.Fatalf("FAIL: asked delete answered %d: %s", c, b)
	}
	reqs := g.waiting(t)
	if len(reqs) != 1 || reqs[0].Op != "repo.delete" || reqs[0].Repo != "theirs" || reqs[0].Agent != "fbot" || reqs[0].Owner != "dmestas" {
		t.Fatalf("FAIL: the request: %+v", reqs)
	}
	if len(g.reg.deleted) != 0 {
		t.Fatalf("FAIL: deleted before approval: %v", g.reg.deleted)
	}
	if _, err := g.r.Invoke(g.pctx, "signoff.decide", signOffDecideIn{ID: reqs[0].ID, Approve: true}); err != nil {
		t.Fatalf("FAIL: approval: %v", err)
	}
	if len(g.reg.deleted) != 1 || g.reg.deleted[0] != "theirs" {
		t.Errorf("FAIL: approval deleted %v", g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestAForgeAgentDeletesItsOwnAndItsPersonsRepos(t *testing.T) {
	g := newForgeDeleteRig(t)
	if c, b := g.del(g.ctx, "mine", ""); c != 200 {
		t.Errorf("FAIL: its own repository answered %d: %s", c, b)
	}
	if len(g.reg.deleted) != 1 || g.reg.deleted[0] != "mine" {
		t.Errorf("FAIL: deleted %v", g.reg.deleted)
	}
	// Its person's repository is the sign-off the deed already had, and
	// not the new refusal.
	if c, b := g.del(g.ctx, "adm", ""); c != 200 || !strings.Contains(b, `"state":"pending"`) {
		t.Errorf("FAIL: its person's repository answered %d: %s", c, b)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestASiteAdminPersonDeletesAnyonesRepository(t *testing.T) {
	g := newForgeDeleteRig(t)
	for _, repo := range []string{"theirs", "teamed"} {
		if c, b := g.del(g.pctx, repo, ""); c != 200 {
			t.Errorf("FAIL: %s answered %d: %s", repo, c, b)
		}
	}
	if len(g.reg.deleted) != 2 {
		t.Errorf("FAIL: deleted %v", g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestATeamRepoWithoutTheAgentOrItsPersonAmongOwnersIsAnotherPersons(t *testing.T) {
	g := newForgeDeleteRig(t)
	if c, b := g.del(g.ctx, "teamed", ""); c != 403 {
		t.Errorf("FAIL: a team's repository answered %d: %s", c, b)
	}
	if c, b := g.del(g.ctx, "teamed", "retiring it"); c != 202 {
		t.Errorf("FAIL: asked, answered %d: %s", c, b)
	}
	if len(g.reg.deleted) != 0 {
		t.Errorf("FAIL: deleted %v", g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestAForgeAgentCannotLaunderADeedByClaimingIt(t *testing.T) {
	g := newForgeDeleteRig(t)
	for _, repo := range []string{"theirs", "orphan"} {
		if c, b := g.post(g.ctx, "/api/v1/r/"+repo+"/claim", `{"account":"fbot"}`, ""); c != 403 {
			t.Errorf("FAIL: claiming %s answered %d: %s", repo, c, b)
		}
		if c, b := g.del(g.ctx, repo, ""); c != 403 {
			t.Errorf("FAIL: deleting %s answered %d: %s", repo, c, b)
		}
	}
	if g.own.owner["theirs"] != "jva" || g.own.owner["orphan"] != "" || len(g.reg.deleted) != 0 {
		t.Errorf("FAIL: deed %q/%q, deleted %v", g.own.owner["theirs"], g.own.owner["orphan"], g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestAForgeAgentCannotOrphanATeamRepoToDeleteIt(t *testing.T) {
	g := newForgeDeleteRig(t)
	if c, b := g.post(g.ctx, "/api/v1/teams/core/repo/remove", `{"name":"core","repo":"teamed"}`, ""); c != 403 {
		t.Errorf("FAIL: team.repo.remove answered %d: %s", c, b)
	}
	if c, b := g.post(g.ctx, "/api/v1/teams/core/delete", `{"name":"core","confirm":"core"}`, ""); c != 403 {
		t.Errorf("FAIL: team.delete answered %d: %s", c, b)
	}
	if c, b := g.del(g.ctx, "teamed", ""); c != 403 {
		t.Errorf("FAIL: the team's repository answered %d: %s", c, b)
	}
	// An ownerless repository a person administers is theirs; one nobody
	// holds at all is still retirable.
	if c, b := g.del(g.ctx, "orphan", ""); c != 403 {
		t.Errorf("FAIL: an administered ownerless repository answered %d: %s", c, b)
	}
	if c, b := g.del(g.ctx, "forgotten", ""); c != 200 {
		t.Errorf("FAIL: a repository nobody holds answered %d: %s", c, b)
	}
	if len(g.reg.deleted) != 1 || g.reg.deleted[0] != "forgotten" {
		t.Errorf("FAIL: deleted %v", g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestAnApprovalFailsWhenTheRepositoryChangedHandsSinceAsking(t *testing.T) {
	g := newForgeDeleteRig(t)
	if c, b := g.del(g.ctx, "theirs", "retiring it"); c != 202 {
		t.Fatalf("FAIL: asked answered %d: %s", c, b)
	}
	reqs := g.waiting(t)
	if len(reqs) != 1 {
		t.Fatalf("FAIL: requests %+v", reqs)
	}
	g.own.owner["theirs"] = "dmestas"
	if _, err := g.r.Invoke(g.pctx, "signoff.decide", signOffDecideIn{ID: reqs[0].ID, Approve: true}); !errors.Is(err, ops.ErrInvalid) {
		t.Errorf("FAIL: approved after the deed moved: %v", err)
	}
	if len(g.reg.deleted) != 0 {
		t.Errorf("FAIL: deleted %v", g.reg.deleted)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}