package server import ( "bytes" "context" "encoding/json" "io" "net/http" "os" "os/exec" "path/filepath" "strings" "testing" "time" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/store" ) func rapi(t *testing.T, base, tok, method, path string, body any) (int, []byte) { t.Helper() var rd io.Reader if body != nil { b, _ := json.Marshal(body) rd = bytes.NewReader(b) } req, _ := http.NewRequest(method, base+"/api/v1"+path, rd) if tok != "" { req.Header.Set("Authorization", "Bearer "+tok) } if body != nil { req.Header.Set("Content-Type", "application/json") } res, err := http.DefaultClient.Do(req) if err != nil { t.Fatal(err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) return res.StatusCode, b } func issue(t *testing.T, st *store.Store, uid int64, scopes string) string { t.Helper() tok, _, err := st.IssueToken(context.Background(), uid, store.TokenRequest{Name: "t-" + scopes, Scopes: scopes}) if err != nil { t.Fatal(err) } return tok } func TestRunnerAPIAuthorization(t *testing.T) { e := newCIEnv(t) ctx := context.Background() st, base := e.st, e.ts.URL bob, _ := st.UpsertUser(ctx, 2, "bob", "", false) carol, _ := st.UpsertUser(ctx, 3, "carol", "", false) g, err := st.CreateGroup(ctx, e.user.ID, "Team", "team", "", access.RoleReadonly) if err != nil { t.Fatal(err) } _ = st.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper) _ = st.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer) timTok := issue(t, st, e.user.ID, "runners") timRead := issue(t, st, e.user.ID, "read_api") timRepo := issue(t, st, e.user.ID, "read_repository") bobTok := issue(t, st, bob.ID, "api") carolTok := issue(t, st, carol.ID, "runners") // Account: token maken, lijst, hernoemen, pauzeren, hervatten. code, b := rapi(t, base, timTok, "POST", "/user/runners/registration-token", map[string]any{}) if code != 201 || !strings.Contains(string(b), `"token":"bgrr_`) { t.Fatalf("reg token: %d", code) } var reg struct{ Token string } _ = json.Unmarshal(b, ®) rn, _, err := st.RegisterRunner(ctx, reg.Token, "tim-pc", "test") if err != nil { t.Fatal(err) } id := "/user/runners/" + itoa(rn.ID) 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"`) { t.Fatalf("list: %d %s", code, b) } if code, _ = rapi(t, base, timRead, "POST", id+"/pause", nil); code != 403 { t.Fatalf("read_api may not pause: %d", code) } if code, _ = rapi(t, base, timRepo, "GET", "/user/runners", nil); code != 403 { t.Fatalf("read_repository may not list runners: %d", code) } if code, b = rapi(t, base, timTok, "PUT", id, map[string]any{"name": "tim-laptop"}); code != 200 || !strings.Contains(string(b), "tim-laptop") { t.Fatalf("rename: %d %s", code, b) } if code, b = rapi(t, base, timTok, "POST", id+"/pause", nil); code != 200 || !strings.Contains(string(b), `"status":"paused"`) { t.Fatalf("pause: %d %s", code, b) } if code, b = rapi(t, base, timTok, "POST", id+"/resume", nil); code != 200 || !strings.Contains(string(b), `"paused":false`) { t.Fatalf("resume: %d %s", code, b) } 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") { t.Fatalf("pref: %d %s", code, b) } if code, b = rapi(t, base, timTok, "GET", id+"/jobs", nil); code != 200 || string(bytes.TrimSpace(b)) != "[]" { t.Fatalf("jobs: %d %s", code, b) } // Cross-account: bob (api-token) ziet of wijzigt tims runner niet. for _, c := range []struct{ m, p string }{{"GET", id}, {"PUT", id}, {"POST", id + "/pause"}, {"DELETE", id}, {"GET", id + "/jobs"}} { if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"name": "x"}); code != 404 { t.Fatalf("bob %s %s: %d", c.m, c.p, code) } } if code, b = rapi(t, base, bobTok, "GET", "/user/runners", nil); code != 200 || strings.Contains(string(b), "tim-laptop") { t.Fatalf("bob list: %d %s", code, b) } // Groep: carol (maintainer) mag, bob (developer) niet. if code, b = rapi(t, base, carolTok, "POST", "/groups/team/runners/registration-token", map[string]any{}); code != 201 { t.Fatalf("carol group token: %d %s", code, b) } _ = json.Unmarshal(b, ®) grn, _, err := st.RegisterRunner(ctx, reg.Token, "grp", "test") if err != nil { t.Fatal(err) } gid := "/groups/team/runners/" + itoa(grn.ID) for _, c := range []struct{ m, p string }{ {"GET", "/groups/team/runners"}, {"POST", "/groups/team/runners/registration-token"}, {"POST", gid + "/pause"}, {"DELETE", gid}, {"PUT", "/groups/team/runner-settings"}, {"PUT", "/groups/team/runner-optin"}, } { if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"builtin_first": true, "enabled": true}); code != 403 { t.Fatalf("bob (developer) %s %s: %d", c.m, c.p, code) } } // Tims account-runner is niet bereikbaar via het groepspad (en omgekeerd). if code, _ = rapi(t, base, carolTok, "GET", "/groups/team/runners/"+itoa(rn.ID), nil); code != 404 { t.Fatalf("account runner via group path: %d", code) } if code, _ = rapi(t, base, timTok, "GET", "/user/runners/"+itoa(grn.ID), nil); code != 404 { t.Fatalf("group runner via user path: %d", code) } 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`) { t.Fatalf("builtin_first: %d %s", code, b) } 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") { t.Fatalf("optin: %d %s", code, b) } // Opt-in geldt alleen voor jezelf: tim ziet zijn eigen (uit), carol staat in de lijst. if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-optin", nil); code != 200 || !strings.Contains(string(b), `"enabled":false`) { t.Fatalf("tim optin: %d %s", code, b) } if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-settings", nil); !strings.Contains(string(b), `"carol"`) { t.Fatalf("opted_in list: %d %s", code, b) } // Onbekende/privé groep voor een buitenstaander: 404. dave, _ := st.UpsertUser(ctx, 4, "dave", "", false) daveTok := issue(t, st, dave.ID, "api") if code, _ = rapi(t, base, daveTok, "GET", "/groups/team/runners", nil); code != 404 && code != 403 { t.Fatalf("dave: %d", code) } // Job-token en runner-token: geen toegang tot runnerbeheer. pid := e.pipeline() jobs, _ := st.JobsByPipeline(ctx, pid) jobTok, err := st.CreateJobToken(ctx, jobs[0].ID) if err != nil { t.Fatal(err) } reg2, _ := st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID) _, runnerTok, _ := st.RegisterRunner(ctx, reg2, "other", "test") for _, tok := range []string{jobTok, runnerTok, ""} { for _, c := range []struct{ m, p string }{{"GET", "/user/runners"}, {"POST", "/user/runners/registration-token"}, {"GET", "/groups/team/runners"}, {"PUT", "/user/runner-settings"}} { if code, _ = rapi(t, base, tok, c.m, c.p, map[string]any{}); code != 401 { t.Fatalf("token %.4s… %s %s: %d", tok, c.m, c.p, code) } } } // Verwijderen: daarna weg uit de lijst en het runner-token werkt niet meer. if code, _ = rapi(t, base, timTok, "DELETE", id, nil); code != 204 { t.Fatalf("delete: %d", code) } if code, b = rapi(t, base, timTok, "GET", "/user/runners", nil); strings.Contains(string(b), "tim-laptop") { t.Fatalf("still listed: %s", b) } } func itoa(n int64) string { return jsonNum(n) } func jsonNum(n int64) string { b, _ := json.Marshal(n); return string(b) } // Volledige agent-setup met alleen een access token: token via de API, // bluegit-runner register via env, en via de API zien dat hij online komt. func TestRunnerAgentSetupViaAPI(t *testing.T) { e := newCIEnv(t) bin := buildRunnerBinary(t) tok := issue(t, e.st, e.user.ID, "runners") code, b := rapi(t, e.ts.URL, tok, "POST", "/user/runners/registration-token", map[string]any{}) if code != 201 { t.Fatalf("reg token: %d", code) } var reg struct{ Token string } _ = json.Unmarshal(b, ®) cfg := filepath.Join(t.TempDir(), "config.yml") _ = os.WriteFile(cfg, []byte("docker: "+e.docker+"\nwork_dir: "+t.TempDir()+"\n"), 0o600) cmd := exec.Command(bin, "register", "--config", cfg) cmd.Env = append(os.Environ(), "BLUEGIT_RUNNER_URL="+e.ts.URL, "BLUEGIT_RUNNER_REGISTRATION_TOKEN="+reg.Token, "BLUEGIT_RUNNER_NAME=agent-box") if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("register: %v %s", err, out) } // Direct na registratie: in de lijst. Zet last_seen terug zodat we // zien dat "run" hem online maakt. ctx, stop := context.WithCancel(context.Background()) defer stop() run := exec.CommandContext(ctx, bin, "run", "--config", cfg) if err := run.Start(); err != nil { t.Fatal(err) } defer func() { stop(); _ = run.Wait() }() deadline := time.Now().Add(30 * time.Second) for time.Now().Before(deadline) { _, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners", nil) var rs []map[string]any _ = json.Unmarshal(b, &rs) if len(rs) == 1 && rs[0]["name"] == "agent-box" && rs[0]["status"] == "online" && rs[0]["version"] == "dev" { // En hij draait echt een job. _ = e.st.SetUserRunnerPref(context.Background(), e.user.ID, store.RunnerPrefOwnFirst) pid := e.pipeline() p := e.wait(pid, 60*time.Second) if p.Status != "success" { t.Fatalf("pipeline %s", p.Status) } _, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners/"+jsonNum(int64(rs[0]["id"].(float64)))+"/jobs", nil) if !strings.Contains(string(b), `"project":"tim/app"`) || !strings.Contains(string(b), `"success"`) { t.Fatalf("runner jobs: %s", b) } return } time.Sleep(300 * time.Millisecond) } t.Fatalf("runner not online via API: %s", b) }