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")
}
}