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