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
db *oltp.DB
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, db: db,
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)
}
// Only what the agent holds itself is deleted directly: an
// ownerless repository is refused, held by a person or not.
for _, repo := range []string{"orphan", "forgotten"} {
if c, b := g.del(g.ctx, repo, ""); c != 403 {
t.Errorf("FAIL: ownerless %s answered %d: %s", repo, c, b)
}
}
if len(g.reg.deleted) != 0 {
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")
}
}
// The only other admin of an ownerless repository going away, by a
// revoked grant or a shut account, does not make it the agent's to
// delete.
func TestAnOwnerlessRepositoryStaysRefusedWhenItsOtherAdminIsRevokedOrDisabled(t *testing.T) {
g := newForgeDeleteRig(t)
if err := g.db.Revoke("jva", "orphan"); err != nil {
t.Fatal(err)
}
if c, b := g.del(g.ctx, "orphan", ""); c != 403 {
t.Errorf("FAIL: after the revoke it answered %d: %s", c, b)
}
if err := g.db.Grant("jva", "forgotten", oltp.RepoAdmin); err != nil {
t.Fatal(err)
}
if err := g.db.SetDisabled("jva", true); err != nil {
t.Fatal(err)
}
if c, b := g.del(g.ctx, "forgotten", ""); c != 403 {
t.Errorf("FAIL: after the disable it 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")
}
}