| 1 | package server |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "context" |
| 6 | "encoding/json" |
| 7 | "fmt" |
| 8 | "image" |
| 9 | "image/color" |
| 10 | "image/png" |
| 11 | "io" |
| 12 | "net/http" |
| 13 | "net/http/cookiejar" |
| 14 | "net/http/httptest" |
| 15 | "net/url" |
| 16 | "os" |
| 17 | "os/exec" |
| 18 | "path/filepath" |
| 19 | "strconv" |
| 20 | "strings" |
| 21 | "testing" |
| 22 | |
| 23 | "gitlab.com/Timfa/bluegit/internal/auth" |
| 24 | "gitlab.com/Timfa/bluegit/internal/config" |
| 25 | "gitlab.com/Timfa/bluegit/internal/gitrepo" |
| 26 | "gitlab.com/Timfa/bluegit/internal/runner" |
| 27 | "gitlab.com/Timfa/bluegit/internal/store" |
| 28 | ) |
| 29 | |
| 30 | func TestPutProjectDefaultBranch(t *testing.T) { |
| 31 | if _, err := exec.LookPath("git"); err != nil { |
| 32 | t.Skip("git ontbreekt") |
| 33 | } |
| 34 | ts, client, srv := graphTestRepo(t) |
| 35 | tok := apiToken(t, client, ts.URL) |
| 36 | code, b := rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"default_branch": "feature"}) |
| 37 | if code != 200 { |
| 38 | t.Fatalf("PUT %d %s", code, b) |
| 39 | } |
| 40 | var out map[string]any |
| 41 | if err := json.Unmarshal(b, &out); err != nil { |
| 42 | t.Fatal(err) |
| 43 | } |
| 44 | if out["default_branch"] != "feature" { |
| 45 | t.Fatalf("antwoord: %s", b) |
| 46 | } |
| 47 | repo, err := srv.Store.RepoByPath(context.Background(), "tim", "grafiek") |
| 48 | if err != nil || repo.DefaultBranch != "feature" { |
| 49 | t.Fatalf("db: %+v %v", repo, err) |
| 50 | } |
| 51 | dir := gitrepo.Dir(srv.StoragePath(), "tim", "grafiek") |
| 52 | head, err := exec.Command("git", "-C", dir, "symbolic-ref", "--short", "HEAD").Output() |
| 53 | if err != nil || strings.TrimSpace(string(head)) != "feature" { |
| 54 | t.Fatalf("HEAD %q %v", head, err) |
| 55 | } |
| 56 | code, b = rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"default_branch": "bestaat-niet"}) |
| 57 | if code != 400 { |
| 58 | t.Fatalf("ontbrekende branch: %d %s", code, b) |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | func TestProjectCIPaused(t *testing.T) { |
| 63 | if _, err := exec.LookPath("git"); err != nil { |
| 64 | t.Skip("git ontbreekt") |
| 65 | } |
| 66 | ts, client, srv := graphTestRepo(t) |
| 67 | srv.Cfg.CI.Enabled = true |
| 68 | tok := apiToken(t, client, ts.URL) |
| 69 | code, b := rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"ci_paused": true}) |
| 70 | if code != 200 || !strings.Contains(string(b), `"ci_paused":true`) { |
| 71 | t.Fatalf("pause %d %s", code, b) |
| 72 | } |
| 73 | repo, _ := srv.Store.RepoByPath(context.Background(), "tim", "grafiek") |
| 74 | if !repo.CIPaused { |
| 75 | t.Fatal("db niet gepauzeerd") |
| 76 | } |
| 77 | settings := read(t, mustGet(t, client, ts.URL+"/tim/grafiek/-/settings")) |
| 78 | if !strings.Contains(settings, `name="ci_paused"`) || !strings.Contains(settings, "checked") { |
| 79 | t.Fatalf("settings-ui mist checkbox:\n%s", settings) |
| 80 | } |
| 81 | tim, err := srv.Store.UserByUsername(context.Background(), "tim") |
| 82 | if err != nil { |
| 83 | t.Fatal(err) |
| 84 | } |
| 85 | if _, err := srv.opRunPipeline(context.Background(), tim, repo, "master", "api"); err == nil { |
| 86 | t.Fatal("handmatige run had geweigerd moeten worden") |
| 87 | } |
| 88 | if got := srv.startPipeline(context.Background(), repo, strings.Repeat("a", 40), "refs/heads/master", "tim", "push", "", nil); got != 0 { |
| 89 | t.Fatalf("push zou geen pipeline moeten queueen: %d", got) |
| 90 | } |
| 91 | code, b = rapi(t, ts.URL, tok, "POST", "/projects/tim/grafiek/pipelines", map[string]any{"ref": "master"}) |
| 92 | if code != 409 { |
| 93 | t.Fatalf("API start %d %s", code, b) |
| 94 | } |
| 95 | } |
| 96 | |
| 97 | func TestAdminRunnerStatusDockerUnreachable(t *testing.T) { |
| 98 | dir := t.TempDir() |
| 99 | bin := filepath.Join(dir, "docker") |
| 100 | script := "#!/bin/sh\necho 'Cannot connect to the Docker daemon' >&2\nexit 1\n" |
| 101 | if err := os.WriteFile(bin, []byte(script), 0o755); err != nil { |
| 102 | t.Fatal(err) |
| 103 | } |
| 104 | srv := &Server{ |
| 105 | Cfg: config.Config{BaseURL: "http://git.example", CI: config.CI{Docker: bin}}, |
| 106 | Runner: &runner.Runner{}, |
| 107 | } |
| 108 | st := srv.builtinStatus() |
| 109 | if st.Online { |
| 110 | t.Fatalf("online zou false moeten zijn: %+v", st) |
| 111 | } |
| 112 | if st.Docker.Reachable || st.Docker.Error == "" { |
| 113 | t.Fatalf("docker status: %+v", st.Docker) |
| 114 | } |
| 115 | } |
| 116 | |
| 117 | func TestRepoLogoICO(t *testing.T) { |
| 118 | if _, err := exec.LookPath("git"); err != nil { |
| 119 | t.Skip("git ontbreekt") |
| 120 | } |
| 121 | ts, client, srv := graphTestRepo(t) |
| 122 | srv.StateDir = t.TempDir() |
| 123 | page := read(t, mustGet(t, client, ts.URL+"/tim/grafiek/-/settings")) |
| 124 | body, ctype := multipartLogo(t, csrfOf(t, page), encodeICOFile(solidPNG(16, 16)), "logo.ico") |
| 125 | req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/grafiek/-/logo", body) |
| 126 | if err != nil { |
| 127 | t.Fatal(err) |
| 128 | } |
| 129 | req.Header.Set("Content-Type", ctype) |
| 130 | res, err := client.Do(req) |
| 131 | if err != nil { |
| 132 | t.Fatal(err) |
| 133 | } |
| 134 | _ = read(t, res) |
| 135 | repo, err := srv.Store.RepoByPath(context.Background(), "tim", "grafiek") |
| 136 | if err != nil || repo.LogoMIME != "image/x-icon" { |
| 137 | t.Fatalf("mime %q %v", repo.LogoMIME, err) |
| 138 | } |
| 139 | res, err = client.Get(ts.URL + "/tim/grafiek/-/logo") |
| 140 | if err != nil { |
| 141 | t.Fatal(err) |
| 142 | } |
| 143 | defer res.Body.Close() |
| 144 | if res.StatusCode != 200 || res.Header.Get("Content-Type") != "image/x-icon" { |
| 145 | t.Fatalf("serve %d %s", res.StatusCode, res.Header.Get("Content-Type")) |
| 146 | } |
| 147 | } |
| 148 | |
| 149 | func TestJobHeaderUserchipWithoutAvatar(t *testing.T) { |
| 150 | css, err := os.ReadFile("static/style.css") |
| 151 | if err != nil { |
| 152 | t.Fatal(err) |
| 153 | } |
| 154 | if !strings.Contains(string(css), ".userchip, a.userchip-link") || !strings.Contains(string(css), "inline-flex") { |
| 155 | t.Fatal("userchip-css ontbreekt") |
| 156 | } |
| 157 | storage := t.TempDir() |
| 158 | st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32()) |
| 159 | if err != nil { |
| 160 | t.Fatal(err) |
| 161 | } |
| 162 | t.Cleanup(func() { _ = st.Close() }) |
| 163 | cfg := config.Config{ |
| 164 | BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage, |
| 165 | Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"}, |
| 166 | Git: config.Git{Binary: "git", DefaultBranch: "master"}, |
| 167 | } |
| 168 | srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git"} |
| 169 | ts := httptest.NewServer(srv.Handler()) |
| 170 | t.Cleanup(ts.Close) |
| 171 | jar, _ := cookiejar.New(nil) |
| 172 | client := &http.Client{Jar: jar} |
| 173 | _ = read(t, mustGet(t, client, ts.URL+"/login")) |
| 174 | ctx := context.Background() |
| 175 | user, err := st.UserByUsername(ctx, "tim") |
| 176 | if err != nil { |
| 177 | t.Fatal(err) |
| 178 | } |
| 179 | if user.AvatarURL != "" { |
| 180 | t.Fatal("verwacht geen avatar") |
| 181 | } |
| 182 | repo, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private") |
| 183 | if err != nil { |
| 184 | t.Fatal(err) |
| 185 | } |
| 186 | pid, err := st.CreatePipeline(ctx, repo.ID, strings.Repeat("a", 40), "refs/heads/master", "push", "tim", "run", []store.NewJob{ |
| 187 | {Name: "build", Stage: "test", Script: "true"}, |
| 188 | }) |
| 189 | if err != nil { |
| 190 | t.Fatal(err) |
| 191 | } |
| 192 | jobs, _ := st.JobsByPipeline(ctx, pid) |
| 193 | if err := st.FinishJob(ctx, jobs[0].ID, "success", ""); err != nil { |
| 194 | t.Fatal(err) |
| 195 | } |
| 196 | page := read(t, mustGet(t, client, ts.URL+"/tim/demo/-/pipelines/"+strconv.FormatInt(pid, 10)+"/jobs/"+strconv.FormatInt(jobs[0].ID, 10))) |
| 197 | if !strings.Contains(page, `class="userchip"`) || !strings.Contains(page, `class="userchip-name"`) { |
| 198 | t.Fatalf("userchip ontbreekt:\n%s", page) |
| 199 | } |
| 200 | if !strings.Contains(page, ">tim<") { |
| 201 | t.Fatalf("naam ontbreekt:\n%s", page) |
| 202 | } |
| 203 | if strings.Contains(page, `class="avatarlink"`) { |
| 204 | t.Fatalf("naam mag niet in avatarlink:\n%s", page) |
| 205 | } |
| 206 | if !strings.Contains(page, tileHue("tim")) { |
| 207 | t.Fatalf("initialen-fallback zonder kleur:\n%s", page) |
| 208 | } |
| 209 | if strings.Contains(page, `<img class="avatar sm"`) { |
| 210 | t.Fatal("geen img voor gebruiker zonder avatar") |
| 211 | } |
| 212 | if os.Getenv("JOBCHIP_HOLD") != "" { |
| 213 | jobURL := ts.URL + "/tim/demo/-/pipelines/" + strconv.FormatInt(pid, 10) + "/jobs/" + strconv.FormatInt(jobs[0].ID, 10) |
| 214 | fmt.Fprintln(os.Stderr, "JOBCHIP_URL="+jobURL) |
| 215 | for _, c := range client.Jar.Cookies(mustParse(t, ts.URL)) { |
| 216 | fmt.Fprintf(os.Stderr, "JOBCHIP_COOKIE=%s=%s\n", c.Name, c.Value) |
| 217 | } |
| 218 | fmt.Fprintln(os.Stderr, "JOBCHIP_READY") |
| 219 | select {} |
| 220 | } |
| 221 | } |
| 222 | |
| 223 | func TestStoreUserAvatarSkipsManual(t *testing.T) { |
| 224 | st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), bytes32()) |
| 225 | if err != nil { |
| 226 | t.Fatal(err) |
| 227 | } |
| 228 | t.Cleanup(func() { _ = st.Close() }) |
| 229 | ctx := context.Background() |
| 230 | u, err := st.UpsertUser(ctx, 9, "ada", "", false) |
| 231 | if err != nil { |
| 232 | t.Fatal(err) |
| 233 | } |
| 234 | if err := st.SetUserAvatar(ctx, u.ID, "/users/ada/avatar", "upload", "image/png"); err != nil { |
| 235 | t.Fatal(err) |
| 236 | } |
| 237 | if _, err := st.UpsertUser(ctx, 9, "ada", "https://example/photo.png", false); err != nil { |
| 238 | t.Fatal(err) |
| 239 | } |
| 240 | got, err := st.UserByID(ctx, u.ID) |
| 241 | if err != nil { |
| 242 | t.Fatal(err) |
| 243 | } |
| 244 | if got.AvatarURL != "/users/ada/avatar" || got.AvatarSource != "upload" { |
| 245 | t.Fatalf("handmatige avatar overschreven: %+v", got) |
| 246 | } |
| 247 | } |
| 248 | |
| 249 | func TestStoreUserAvatarEntraRefresh(t *testing.T) { |
| 250 | stateDir := t.TempDir() |
| 251 | st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32()) |
| 252 | if err != nil { |
| 253 | t.Fatal(err) |
| 254 | } |
| 255 | t.Cleanup(func() { _ = st.Close() }) |
| 256 | ctx := context.Background() |
| 257 | u, err := st.UpsertUser(ctx, 11, "ada", "", false) |
| 258 | if err != nil { |
| 259 | t.Fatal(err) |
| 260 | } |
| 261 | srv := &Server{Cfg: config.Config{BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0"}, Store: st, StateDir: stateDir} |
| 262 | if err := srv.storeUserAvatar(ctx, u, solidPNG(8, 8), "entra"); err != nil { |
| 263 | t.Fatal(err) |
| 264 | } |
| 265 | got, err := st.UserByID(ctx, u.ID) |
| 266 | if err != nil || got.AvatarSource != "entra" || got.AvatarURL != "/users/ada/avatar" { |
| 267 | t.Fatalf("opslag: %+v %v", got, err) |
| 268 | } |
| 269 | ts := httptest.NewServer(srv.Handler()) |
| 270 | t.Cleanup(ts.Close) |
| 271 | res, err := http.Get(ts.URL + "/users/ada/avatar") |
| 272 | if err != nil { |
| 273 | t.Fatal(err) |
| 274 | } |
| 275 | defer res.Body.Close() |
| 276 | body, _ := io.ReadAll(res.Body) |
| 277 | if res.StatusCode != 200 || res.Header.Get("Content-Type") != "image/png" || len(body) == 0 { |
| 278 | t.Fatalf("serve %d %s %d", res.StatusCode, res.Header.Get("Content-Type"), len(body)) |
| 279 | } |
| 280 | if err := st.SetUserAvatar(ctx, u.ID, got.AvatarURL, "upload", got.AvatarMIME); err != nil { |
| 281 | t.Fatal(err) |
| 282 | } |
| 283 | fresh, _ := st.UserByID(ctx, u.ID) |
| 284 | if err := srv.storeUserAvatar(ctx, fresh, solidPNG(4, 4), "entra"); err != nil { |
| 285 | t.Fatal(err) |
| 286 | } |
| 287 | again, _ := st.UserByID(ctx, u.ID) |
| 288 | if again.AvatarSource != "upload" { |
| 289 | t.Fatalf("entra overschreef upload: %+v", again) |
| 290 | } |
| 291 | } |
| 292 | |
| 293 | func apiToken(t *testing.T, client *http.Client, base string) string { |
| 294 | t.Helper() |
| 295 | page := read(t, mustGet(t, client, base+"/settings")) |
| 296 | page = read(t, mustPost(t, client, base+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"api"}})) |
| 297 | tok := between(page, `<p class="code">`, "</p>") |
| 298 | if tok == "" { |
| 299 | t.Fatal("geen token") |
| 300 | } |
| 301 | return tok |
| 302 | } |
| 303 | |
| 304 | func solidPNG(w, h int) []byte { |
| 305 | img := image.NewNRGBA(image.Rect(0, 0, w, h)) |
| 306 | for y := 0; y < h; y++ { |
| 307 | for x := 0; x < w; x++ { |
| 308 | img.SetNRGBA(x, y, color.NRGBA{R: 31, G: 111, B: 235, A: 255}) |
| 309 | } |
| 310 | } |
| 311 | var buf bytes.Buffer |
| 312 | _ = png.Encode(&buf, img) |
| 313 | return buf.Bytes() |
| 314 | } |
| 315 | |
| 316 | func encodeICOFile(png []byte) []byte { |
| 317 | buf := make([]byte, 6+16+len(png)) |
| 318 | buf[2] = 1 |
| 319 | buf[4] = 1 |
| 320 | buf[6] = 16 |
| 321 | buf[7] = 16 |
| 322 | n := uint32(len(png)) |
| 323 | buf[14] = byte(n) |
| 324 | buf[15] = byte(n >> 8) |
| 325 | buf[16] = byte(n >> 16) |
| 326 | buf[17] = byte(n >> 24) |
| 327 | off := uint32(22) |
| 328 | buf[18] = byte(off) |
| 329 | buf[19] = byte(off >> 8) |
| 330 | copy(buf[22:], png) |
| 331 | return buf |
| 332 | } |