Skip to content
quarry Artifact [00ec7efe69]
Login

Artifact [00ec7efe69]

Artifact 00ec7efe69f9e58e84b9f975b2df5f262f129f048296df19e403021b80a26e0b:


package api

import (
	"errors"
	"path/filepath"
	"testing"

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

func siteAdminOpRig(t *testing.T) (*ops.Registry, *oltp.DB, *fakeMail) {
	t.Helper()
	db, err := oltp.Open(filepath.Join(t.TempDir(), "o.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { db.Close() })
	for _, a := range []struct {
		name  string
		admin bool
	}{{"root", true}, {"ann", true}, {"bo", false}, {"cy", false}} {
		if err := db.AddAccount(a.name, "a-long-enough-password", a.admin); err != nil {
			t.Fatal(err)
		}
		if err := db.SetEmail(a.name, a.name+"@example.org"); err != nil {
			t.Fatal(err)
		}
	}
	mail := &fakeMail{}
	r := ops.NewRegistry()
	if err := RegisterAll(r, Deps{Version: "v", Accounts: adminAdapter{acctAdapter{db}}, Mail: mail,
		Repos: NewRepos(map[string]*Repo{})}); err != nil {
		t.Fatal(err)
	}
	return r, db, mail
}

func isAdmin(db *oltp.DB, who string) bool { a, _ := db.AccountByName(who); return a.Admin }

func TestSiteAdminOpSetsAndClearsForASession(t *testing.T) {
	r, db, mail := siteAdminOpRig(t)
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "bo", On: true}); err != nil {
		t.Fatalf("FAIL: set: %v", err)
	}
	if !isAdmin(db, "bo") {
		t.Error("FAIL: bo was not made a site admin")
	}
	// The one concerned and the other admins hear; the actor does not.
	if !mail.to("[email protected]") || !mail.to("[email protected]") || mail.to("[email protected]") || mail.to("[email protected]") {
		t.Errorf("FAIL: notices went to %+v", mail.sent)
	}
	mail.sent = nil
	if _, err := r.Invoke(asUser("ann"), "account.siteadmin", accountSiteAdminIn{Name: "bo"}); err != nil {
		t.Fatalf("FAIL: clear: %v", err)
	}
	if isAdmin(db, "bo") {
		t.Error("FAIL: bo kept the flag")
	}
	if !mail.to("[email protected]") || !mail.to("[email protected]") || mail.to("[email protected]") {
		t.Errorf("FAIL: clear notices went to %+v", mail.sent)
	}
	acts, _ := db.AccountActs("bo", 10)
	if len(acts) != 2 || acts[0].Op != "account.siteadmin.clear" || acts[0].Actor != "ann" ||
		acts[1].Op != "account.siteadmin.set" || acts[1].Actor != "root" {
		t.Errorf("FAIL: log = %+v", acts)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestSiteAdminOpRefusesEveryTokenAndEveryNonAdmin(t *testing.T) {
	r, db, _ := siteAdminOpRig(t)
	caps := func(string) ops.Caps { return oltp.CapSet("asy") }
	for name, tok := range map[string]ops.TokenAuth{
		"api":     {ID: "T", Caps: caps},
		"site":    {ID: "T", Caps: caps, Site: func() bool { return true }},
		"limited": {ID: "T", Caps: caps, Limited: true},
		"sync":    {ID: "S", Caps: caps, Reaches: func(string) bool { return true }},
	} {
		ctx := ops.WithToken(asUser("root"), tok)
		_, err := r.Invoke(ctx, "account.siteadmin", accountSiteAdminIn{Name: "bo", On: true})
		if !errors.Is(err, ops.ErrForbidden) {
			t.Errorf("FAIL: %s token: %v", name, err)
		}
	}
	if _, err := r.Invoke(asUser("bo"), "account.siteadmin", accountSiteAdminIn{Name: "cy", On: true}); err == nil {
		t.Error("FAIL: a non-admin made an admin")
	}
	if isAdmin(db, "bo") || isAdmin(db, "cy") {
		t.Error("FAIL: a refused call changed a flag")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestSiteAdminOpRefusesAPersonalAgentCallerAndTarget(t *testing.T) {
	r, db, _ := siteAdminOpRig(t)
	if err := db.NewAgent("bo-bot", "bo", 5); err != nil {
		t.Fatal(err)
	}
	if _, err := r.Invoke(asUser("bo-bot"), "account.siteadmin", accountSiteAdminIn{Name: "cy", On: true}); err == nil {
		t.Error("FAIL: a personal agent made an admin")
	}
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "bo-bot", On: true}); !errors.Is(err, ops.ErrInvalid) {
		t.Errorf("FAIL: a personal agent target: %v", err)
	}
	if isAdmin(db, "cy") || isAdmin(db, "bo-bot") {
		t.Error("FAIL: an agent flag changed")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// RFC 0021: a site admin sets and clears the flag on a forge agent as on
// any account, and the journal and the notices follow.
func TestSiteAdminOpSetsAndClearsAForgeAgentsFlag(t *testing.T) {
	r, db, _ := siteAdminOpRig(t)
	if err := db.NewForgeAgent("fbot", "root"); err != nil {
		t.Fatal(err)
	}
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "fbot", On: true}); err != nil {
		t.Fatalf("FAIL: set on a forge agent: %v", err)
	}
	if !isAdmin(db, "fbot") {
		t.Error("FAIL: the forge agent has no flag")
	}
	if _, err := r.Invoke(asUser("ann"), "account.siteadmin", accountSiteAdminIn{Name: "fbot"}); err != nil {
		t.Fatalf("FAIL: clear on a forge agent: %v", err)
	}
	if isAdmin(db, "fbot") {
		t.Error("FAIL: the forge agent kept the flag")
	}
	if acts, _ := db.AccountActs("fbot", 10); len(acts) != 2 {
		t.Errorf("FAIL: journal = %+v", acts)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// An agent never changes the flag, even one that holds it: a forge
// agent with the letter passes the site-admin check, so the agent check
// alone stops it.
func TestAForgeAgentHoldingTheFlagCannotChangeIt(t *testing.T) {
	r, db, _ := siteAdminOpRig(t)
	if err := db.NewForgeAgent("fbot", "root"); err != nil {
		t.Fatal(err)
	}
	if err := db.SetSiteAdmin("fbot", true, "root"); err != nil {
		t.Fatal(err)
	}
	if _, err := r.Invoke(asUser("fbot"), "account.siteadmin", accountSiteAdminIn{Name: "cy", On: true}); !errors.Is(err, ops.ErrForbidden) {
		t.Errorf("FAIL: a flagged forge agent made an admin: %v", err)
	}
	if isAdmin(db, "cy") {
		t.Error("FAIL: cy was flagged")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestSiteAdminOpRefusesADisabledTargetAndTheLastAdmin(t *testing.T) {
	r, db, mail := siteAdminOpRig(t)
	if err := db.SetDisabled("cy", true); err != nil {
		t.Fatal(err)
	}
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "cy", On: true}); !errors.Is(err, ops.ErrInvalid) {
		t.Errorf("FAIL: a disabled target: %v", err)
	}
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "ann"}); err != nil {
		t.Fatal(err)
	}
	mail.sent = nil
	if _, err := r.Invoke(asUser("root"), "account.siteadmin", accountSiteAdminIn{Name: "root"}); !errors.Is(err, ops.ErrInvalid) {
		t.Errorf("FAIL: clearing the last admin: %v", err)
	}
	if !isAdmin(db, "root") {
		t.Error("FAIL: the last admin lost the flag")
	}
	if len(mail.sent) != 0 {
		t.Errorf("FAIL: a refused change was announced: %+v", mail.sent)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestSiteAdminIsNotAskableByAnAgent(t *testing.T) {
	if askableFor("account.siteadmin", "root", accountSiteAdminIn{Name: "bo", On: true}) {
		t.Error("FAIL: the site-admin flag is askable through the sign-off flow")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// The sign-off flow runs an asked call as the person who approves it,
// so an agent asking for an account that carries the flag would be
// choosing a site admin's password or link. Refused at the ask; the
// same op without the flag stays askable.
func TestNoAskedCallCarriesTheSiteAdminFlag(t *testing.T) {
	for _, c := range []struct {
		op   string
		in   any
		want bool
	}{
		{"account.add", accountAddIn{Name: "x", Password: "p", Admin: true}, false},
		{"account.add", accountAddIn{Name: "x", Password: "p"}, true},
		{"account.invite", accountInviteIn{Name: "x", Admin: true}, false},
		{"account.invite", accountInviteIn{Name: "x"}, true},
		{"account.siteadmin", accountSiteAdminIn{Name: "x", On: true}, false},
		{"account.siteadmin", accountSiteAdminIn{Name: "x"}, false},
	} {
		if got := askableFor(c.op, "root", c.in); got != c.want {
			t.Errorf("FAIL: askable(%s, %+v) = %v, want %v", c.op, c.in, got, c.want)
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// Inviting again never changes a pending account's flag; the op says so.
func TestAReInviteThroughTheOpCannotChangeTheFlag(t *testing.T) {
	r, db, _ := siteAdminOpRig(t)
	if _, err := r.Invoke(asUser("root"), "account.invite", accountInviteIn{Name: "ghost", Email: "[email protected]", Admin: true}); err != nil {
		t.Fatal(err)
	}
	if _, err := r.Invoke(asUser("root"), "account.invite", accountInviteIn{Name: "ghost", Email: "[email protected]"}); !errors.Is(err, ops.ErrInvalid) {
		t.Errorf("FAIL: a re-invite cleared the flag: %v", err)
	}
	if !isAdmin(db, "ghost") {
		t.Error("FAIL: ghost lost the flag")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}