BlueGit

timfa bluegit

Files

bluegit / internal / server / kvt_feedback_test.go

kvt_feedback_test.go

kvt_feedback_test.go 10.4 KiB Download Raw
1package server
2
3import (
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
30func 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
62func 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
97func 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
117func 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
149func 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
223func 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
249func 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
293func 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
304func 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
316func 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}