The file beside the token that kept its scopes went with C4, and with it the re-mint of a token carrying a scope beyond the tools' (write:admin). The value written through own-put now holds the token and its scopes; a token minted with other scopes, or a value naming none, is minted again unasked and the one it replaces deleted at the forge. The Go bundles read the token out of that value. The lost test is back as a row of the scope test in test/token.test.ts. Builds: design 47 H2 §808; H-A-439
139 lines
5.5 KiB
Go
139 lines
5.5 KiB
Go
package main
|
|
|
|
// The commit and the reads act as the tools' own account (novox/hq ADR 0365 §2, issue 469): the token the module
|
|
// keeps for `mesh-tools` in the vault (design 47 H2 §808), never the admin login. That account is no repository's administrator, so the forge
|
|
// refuses it the protection rules (403, as gitea's reqAdmin does); the commit then judges an existing branch by the
|
|
// protection the forge says it applies, and leaves a branch not made yet to the forge's own judgement.
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/seal"
|
|
|
|
"gitea/internal/forgehttp"
|
|
)
|
|
|
|
const toolsToken = "tools-token-never-shown"
|
|
|
|
// vaultHolding is the vault seat's get answering account's token sealed to the key it is asked with; "" holds none.
|
|
func vaultHolding(t *testing.T, account, token string) *forgehttp.VaultToken {
|
|
t.Helper()
|
|
v, err := forgehttp.NewVaultToken(account, func(address string, args any) (json.RawMessage, error) {
|
|
a := args.(map[string]any)
|
|
if address != forgehttp.VaultGet || a["name"] != forgehttp.VaultName(account) {
|
|
return nil, fmt.Errorf("asked %s for %v", address, a["name"])
|
|
}
|
|
if token == "" {
|
|
return nil, fmt.Errorf("the vault holds no secret named %s", a["name"])
|
|
}
|
|
// The value the minter writes: the token and the scopes it was minted with (H-A-439).
|
|
value, _ := json.Marshal(map[string]any{"token": token, "scopes": []string{"write:repository", "write:issue", "read:user", "read:package"}})
|
|
box, err := seal.Seal(string(value), a["public_key"].(string))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return json.Marshal(map[string]any{"name": a["name"], "generation": 1, "sealed": box})
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return v
|
|
}
|
|
|
|
// asTools serves the fake forge to a bundle holding the token the vault hands: only the tools' token is taken, the
|
|
// rules are refused as to a non-administrator, and the branches named protected say so as the forge does.
|
|
func asTools(t *testing.T, f *fakeForge, protected map[string]string, held string) (*Forge, *[]string) {
|
|
var seen []string
|
|
const repo = "/api/v1/repos/acme/app"
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
seen = append(seen, r.Method+" "+r.URL.Path)
|
|
if _, _, basic := r.BasicAuth(); basic || r.Header.Get("Authorization") != "token "+toolsToken {
|
|
http.Error(w, "unauthorized", 401)
|
|
return
|
|
}
|
|
if r.URL.Path == repo+"/branch_protections" {
|
|
http.Error(w, `{"message":"token does not have the administration of this repository"}`, 403)
|
|
return
|
|
}
|
|
if name := strings.TrimPrefix(r.URL.Path, repo+"/branches/"); r.Method == "GET" && name != r.URL.Path {
|
|
if rule, ok := protected[name]; ok {
|
|
_, _ = w.Write([]byte(`{"name":"` + name + `","commit":{"id":"c0"},"protected":true,"effective_branch_protection_name":"` + rule + `"}`))
|
|
return
|
|
}
|
|
}
|
|
r.SetBasicAuth("mesh-admin", f.password) // the fake's own door, past the token checked above
|
|
f.handle(w, r)
|
|
}))
|
|
t.Cleanup(srv.Close)
|
|
return &Forge{Client: forgehttp.Client{URL: srv.URL, Token: vaultHolding(t, "mesh-tools", held), Account: "mesh-tools"}}, &seen
|
|
}
|
|
|
|
func TestTheToolsAccountCommitsOnANewBranchWithItsTokenThoughTheRulesAreNotItsToRead(t *testing.T) {
|
|
f := newFake(t)
|
|
forge, _ := asTools(t, f, nil, toolsToken)
|
|
got, err := commit(context.Background(), forge, ask(t, map[string]any{"branch": "fix/365",
|
|
"files": filesArg(map[string]any{"path": "x", "content": "x"})}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(f.writes) != 1 || !got.Created {
|
|
t.Fatalf("%d writes, %+v", len(f.writes), got)
|
|
}
|
|
}
|
|
|
|
func TestTheToolsAccountIsRefusedAProtectedBranchTheForgeSaysItGuardsAndTheDefaultBranch(t *testing.T) {
|
|
for branch, rule := range map[string]string{"release/1.0": "release/*", "fix/1-old": "fix/1-old", "main": ""} {
|
|
f := newFake(t)
|
|
protected := map[string]string{}
|
|
if rule != "" {
|
|
protected[branch] = rule
|
|
}
|
|
forge, _ := asTools(t, f, protected, toolsToken)
|
|
_, err := commit(context.Background(), forge, ask(t, map[string]any{"branch": branch,
|
|
"files": filesArg(map[string]any{"path": "x", "content": "x"})}))
|
|
if err == nil || !strings.Contains(err.Error(), "refused") || !strings.Contains(err.Error(), "ADR 0266") {
|
|
t.Errorf("%s: %v", branch, err)
|
|
}
|
|
if rule != "" && !strings.Contains(err.Error(), rule) {
|
|
t.Errorf("%s: the rule %s is not named: %v", branch, rule, err)
|
|
}
|
|
if len(f.writes)+len(f.patches) != 0 {
|
|
t.Errorf("%s: something was written", branch)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNoTokenIsSentWhileTheVaultHoldsNoneForTheAccount(t *testing.T) {
|
|
f := newFake(t)
|
|
// Design 47 H2 §808: the token is read through the vault seat's get; while the module has minted none, nothing goes.
|
|
forge, seen := asTools(t, f, nil, "")
|
|
_, err := commit(context.Background(), forge, ask(t, map[string]any{"branch": "fix/365",
|
|
"files": filesArg(map[string]any{"path": "x", "content": "x"})}))
|
|
if err == nil || !strings.Contains(err.Error(), "not kept yet") {
|
|
t.Fatalf("%v", err)
|
|
}
|
|
if len(*seen) != 0 {
|
|
t.Fatalf("the forge was asked %v", *seen)
|
|
}
|
|
}
|
|
|
|
func TestTheBundleReadsItsTokenFromTheVaultAndNeedsNoAdminLogin(t *testing.T) {
|
|
t.Setenv("MESH_GITEA_URL", "http://127.0.0.1:3000")
|
|
t.Setenv("MESH_GITEA_TOOLS_USER", "")
|
|
t.Setenv("MESH_GITEA_ADMIN_USER", "")
|
|
t.Setenv("MESH_GITEA_ADMIN_PASSWORD_FILE", "")
|
|
f, err := ForgeFromEnv()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if f.Token == nil || f.Token.Account != "mesh-tools" || f.Account != "mesh-tools" || f.User != "" || f.PasswordFile != "" {
|
|
t.Fatalf("%+v", f.Client)
|
|
}
|
|
}
|