BlueGit

timfa bluegit

Files

bluegit / internal / server / runners_api_test.go

runners_api_test.go

runners_api_test.go 10.3 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "encoding/json"
7 "io"
8 "net/http"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/access"
17 "gitlab.com/Timfa/bluegit/internal/store"
18)
19
20func rapi(t *testing.T, base, tok, method, path string, body any) (int, []byte) {
21 t.Helper()
22 var rd io.Reader
23 if body != nil {
24 b, _ := json.Marshal(body)
25 rd = bytes.NewReader(b)
26 }
27 req, _ := http.NewRequest(method, base+"/api/v1"+path, rd)
28 if tok != "" {
29 req.Header.Set("Authorization", "Bearer "+tok)
30 }
31 if body != nil {
32 req.Header.Set("Content-Type", "application/json")
33 }
34 res, err := http.DefaultClient.Do(req)
35 if err != nil {
36 t.Fatal(err)
37 }
38 defer res.Body.Close()
39 b, _ := io.ReadAll(res.Body)
40 return res.StatusCode, b
41}
42
43func issue(t *testing.T, st *store.Store, uid int64, scopes string) string {
44 t.Helper()
45 tok, _, err := st.IssueToken(context.Background(), uid, store.TokenRequest{Name: "t-" + scopes, Scopes: scopes})
46 if err != nil {
47 t.Fatal(err)
48 }
49 return tok
50}
51
52func TestRunnerAPIAuthorization(t *testing.T) {
53 e := newCIEnv(t)
54 ctx := context.Background()
55 st, base := e.st, e.ts.URL
56 bob, _ := st.UpsertUser(ctx, 2, "bob", "", false)
57 carol, _ := st.UpsertUser(ctx, 3, "carol", "", false)
58 g, err := st.CreateGroup(ctx, e.user.ID, "Team", "team", "", access.RoleReadonly)
59 if err != nil {
60 t.Fatal(err)
61 }
62 _ = st.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper)
63 _ = st.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer)
64
65 timTok := issue(t, st, e.user.ID, "runners")
66 timRead := issue(t, st, e.user.ID, "read_api")
67 timRepo := issue(t, st, e.user.ID, "read_repository")
68 bobTok := issue(t, st, bob.ID, "api")
69 carolTok := issue(t, st, carol.ID, "runners")
70
71 // Account: token maken, lijst, hernoemen, pauzeren, hervatten.
72 code, b := rapi(t, base, timTok, "POST", "/user/runners/registration-token", map[string]any{})
73 if code != 201 || !strings.Contains(string(b), `"token":"bgrr_`) {
74 t.Fatalf("reg token: %d", code)
75 }
76 var reg struct{ Token string }
77 _ = json.Unmarshal(b, &reg)
78 rn, _, err := st.RegisterRunner(ctx, reg.Token, "tim-pc", "test")
79 if err != nil {
80 t.Fatal(err)
81 }
82 id := "/user/runners/" + itoa(rn.ID)
83 if code, b = rapi(t, base, timRead, "GET", "/user/runners", nil); code != 200 || !strings.Contains(string(b), `"tim-pc"`) || !strings.Contains(string(b), `"last_seen"`) {
84 t.Fatalf("list: %d %s", code, b)
85 }
86 if code, _ = rapi(t, base, timRead, "POST", id+"/pause", nil); code != 403 {
87 t.Fatalf("read_api may not pause: %d", code)
88 }
89 if code, _ = rapi(t, base, timRepo, "GET", "/user/runners", nil); code != 403 {
90 t.Fatalf("read_repository may not list runners: %d", code)
91 }
92 if code, b = rapi(t, base, timTok, "PUT", id, map[string]any{"name": "tim-laptop"}); code != 200 || !strings.Contains(string(b), "tim-laptop") {
93 t.Fatalf("rename: %d %s", code, b)
94 }
95 if code, b = rapi(t, base, timTok, "POST", id+"/pause", nil); code != 200 || !strings.Contains(string(b), `"status":"paused"`) {
96 t.Fatalf("pause: %d %s", code, b)
97 }
98 if code, b = rapi(t, base, timTok, "POST", id+"/resume", nil); code != 200 || !strings.Contains(string(b), `"paused":false`) {
99 t.Fatalf("resume: %d %s", code, b)
100 }
101 if code, b = rapi(t, base, timTok, "PUT", "/user/runner-settings", map[string]any{"preference": "own_first"}); code != 200 || !strings.Contains(string(b), "own_first") {
102 t.Fatalf("pref: %d %s", code, b)
103 }
104 if code, b = rapi(t, base, timTok, "GET", id+"/jobs", nil); code != 200 || string(bytes.TrimSpace(b)) != "[]" {
105 t.Fatalf("jobs: %d %s", code, b)
106 }
107
108 // Cross-account: bob (api-token) ziet of wijzigt tims runner niet.
109 for _, c := range []struct{ m, p string }{{"GET", id}, {"PUT", id}, {"POST", id + "/pause"}, {"DELETE", id}, {"GET", id + "/jobs"}} {
110 if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"name": "x"}); code != 404 {
111 t.Fatalf("bob %s %s: %d", c.m, c.p, code)
112 }
113 }
114 if code, b = rapi(t, base, bobTok, "GET", "/user/runners", nil); code != 200 || strings.Contains(string(b), "tim-laptop") {
115 t.Fatalf("bob list: %d %s", code, b)
116 }
117
118 // Groep: carol (maintainer) mag, bob (developer) niet.
119 if code, b = rapi(t, base, carolTok, "POST", "/groups/team/runners/registration-token", map[string]any{}); code != 201 {
120 t.Fatalf("carol group token: %d %s", code, b)
121 }
122 _ = json.Unmarshal(b, &reg)
123 grn, _, err := st.RegisterRunner(ctx, reg.Token, "grp", "test")
124 if err != nil {
125 t.Fatal(err)
126 }
127 gid := "/groups/team/runners/" + itoa(grn.ID)
128 for _, c := range []struct{ m, p string }{
129 {"GET", "/groups/team/runners"}, {"POST", "/groups/team/runners/registration-token"},
130 {"POST", gid + "/pause"}, {"DELETE", gid}, {"PUT", "/groups/team/runner-settings"},
131 } {
132 if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"builtin_first": true, "enabled": true}); code != 403 {
133 t.Fatalf("bob (developer) %s %s: %d", c.m, c.p, code)
134 }
135 }
136 // Opt-in voor je eigen runners mag elk groepslid (alleen voor jezelf).
137 if code, b = rapi(t, base, bobTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 200 || !strings.Contains(string(b), "bob") {
138 t.Fatalf("bob (developer) optin: %d %s", code, b)
139 }
140 if code, _ = rapi(t, base, bobTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": false}); code != 200 {
141 t.Fatalf("bob optout: %d", code)
142 }
143 // Tims account-runner is niet bereikbaar via het groepspad (en omgekeerd).
144 if code, _ = rapi(t, base, carolTok, "GET", "/groups/team/runners/"+itoa(rn.ID), nil); code != 404 {
145 t.Fatalf("account runner via group path: %d", code)
146 }
147 if code, _ = rapi(t, base, timTok, "GET", "/user/runners/"+itoa(grn.ID), nil); code != 404 {
148 t.Fatalf("group runner via user path: %d", code)
149 }
150 if code, b = rapi(t, base, carolTok, "PUT", "/groups/team/runner-settings", map[string]any{"builtin_first": true}); code != 200 || !strings.Contains(string(b), `"builtin_first":true`) {
151 t.Fatalf("builtin_first: %d %s", code, b)
152 }
153 if code, b = rapi(t, base, carolTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 200 || !strings.Contains(string(b), `"enabled":true`) || !strings.Contains(string(b), "carol") {
154 t.Fatalf("optin: %d %s", code, b)
155 }
156 // Opt-in geldt alleen voor jezelf: tim ziet zijn eigen (uit), carol staat in de lijst.
157 if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-optin", nil); code != 200 || !strings.Contains(string(b), `"enabled":false`) {
158 t.Fatalf("tim optin: %d %s", code, b)
159 }
160 if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-settings", nil); !strings.Contains(string(b), `"carol"`) {
161 t.Fatalf("opted_in list: %d %s", code, b)
162 }
163 // Onbekende/privé groep voor een buitenstaander: 404.
164 dave, _ := st.UpsertUser(ctx, 4, "dave", "", false)
165 daveTok := issue(t, st, dave.ID, "api")
166 if code, _ = rapi(t, base, daveTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 404 && code != 403 {
167 t.Fatalf("dave optin: %d", code)
168 }
169 if code, _ = rapi(t, base, daveTok, "GET", "/groups/team/runners", nil); code != 404 && code != 403 {
170 t.Fatalf("dave: %d", code)
171 }
172
173 // Job-token en runner-token: geen toegang tot runnerbeheer.
174 pid := e.pipeline()
175 jobs, _ := st.JobsByPipeline(ctx, pid)
176 jobTok, err := st.CreateJobToken(ctx, jobs[0].ID)
177 if err != nil {
178 t.Fatal(err)
179 }
180 reg2, _ := st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)
181 _, runnerTok, _ := st.RegisterRunner(ctx, reg2, "other", "test")
182 for _, tok := range []string{jobTok, runnerTok, ""} {
183 for _, c := range []struct{ m, p string }{{"GET", "/user/runners"}, {"POST", "/user/runners/registration-token"}, {"GET", "/groups/team/runners"}, {"PUT", "/user/runner-settings"}} {
184 if code, _ = rapi(t, base, tok, c.m, c.p, map[string]any{}); code != 401 {
185 t.Fatalf("token %.4s… %s %s: %d", tok, c.m, c.p, code)
186 }
187 }
188 }
189
190 // Verwijderen: daarna weg uit de lijst en het runner-token werkt niet meer.
191 if code, _ = rapi(t, base, timTok, "DELETE", id, nil); code != 204 {
192 t.Fatalf("delete: %d", code)
193 }
194 if code, b = rapi(t, base, timTok, "GET", "/user/runners", nil); strings.Contains(string(b), "tim-laptop") {
195 t.Fatalf("still listed: %s", b)
196 }
197}
198
199func itoa(n int64) string { return jsonNum(n) }
200
201func jsonNum(n int64) string { b, _ := json.Marshal(n); return string(b) }
202
203// Volledige agent-setup met alleen een access token: token via de API,
204// bluegit-runner register via env, en via de API zien dat hij online komt.
205func TestRunnerAgentSetupViaAPI(t *testing.T) {
206 e := newCIEnv(t)
207 bin := buildRunnerBinary(t)
208 tok := issue(t, e.st, e.user.ID, "runners")
209 code, b := rapi(t, e.ts.URL, tok, "POST", "/user/runners/registration-token", map[string]any{})
210 if code != 201 {
211 t.Fatalf("reg token: %d", code)
212 }
213 var reg struct{ Token string }
214 _ = json.Unmarshal(b, &reg)
215 cfg := filepath.Join(t.TempDir(), "config.yml")
216 _ = os.WriteFile(cfg, []byte("docker: "+e.docker+"\nwork_dir: "+t.TempDir()+"\n"), 0o600)
217 cmd := exec.Command(bin, "register", "--config", cfg)
218 cmd.Env = append(os.Environ(), "BLUEGIT_RUNNER_URL="+e.ts.URL, "BLUEGIT_RUNNER_REGISTRATION_TOKEN="+reg.Token, "BLUEGIT_RUNNER_NAME=agent-box")
219 if out, err := cmd.CombinedOutput(); err != nil {
220 t.Fatalf("register: %v %s", err, out)
221 }
222 // Direct na registratie: in de lijst. Zet last_seen terug zodat we
223 // zien dat "run" hem online maakt.
224 ctx, stop := context.WithCancel(context.Background())
225 defer stop()
226 run := exec.CommandContext(ctx, bin, "run", "--config", cfg)
227 if err := run.Start(); err != nil {
228 t.Fatal(err)
229 }
230 defer func() { stop(); _ = run.Wait() }()
231 deadline := time.Now().Add(30 * time.Second)
232 for time.Now().Before(deadline) {
233 _, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners", nil)
234 var rs []map[string]any
235 _ = json.Unmarshal(b, &rs)
236 if len(rs) == 1 && rs[0]["name"] == "agent-box" && rs[0]["status"] == "online" && rs[0]["version"] == "dev" {
237 // En hij draait echt een job.
238 _ = e.st.SetUserRunnerPref(context.Background(), e.user.ID, store.RunnerPrefOwnFirst)
239 pid := e.pipeline()
240 p := e.wait(pid, 60*time.Second)
241 if p.Status != "success" {
242 t.Fatalf("pipeline %s", p.Status)
243 }
244 _, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners/"+jsonNum(int64(rs[0]["id"].(float64)))+"/jobs", nil)
245 if !strings.Contains(string(b), `"project":"tim/app"`) || !strings.Contains(string(b), `"success"`) {
246 t.Fatalf("runner jobs: %s", b)
247 }
248 return
249 }
250 time.Sleep(300 * time.Millisecond)
251 }
252 t.Fatalf("runner not online via API: %s", b)
253}