BlueGit

timfa bluegit

Files

bluegit / internal / server / issues_test.go

issues_test.go

feat: voeg een issue-tracker per repository toe
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
f3222d5f History
issues_test.go 15.4 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "encoding/json"
7 "net/http"
8 "net/http/cookiejar"
9 "net/http/httptest"
10 "net/url"
11 "os/exec"
12 "path/filepath"
13 "strconv"
14 "strings"
15 "testing"
16 "time"
17
18 "gitlab.com/Timfa/bluegit/internal/access"
19 "gitlab.com/Timfa/bluegit/internal/auth"
20 "gitlab.com/Timfa/bluegit/internal/config"
21 "gitlab.com/Timfa/bluegit/internal/store"
22)
23
24func TestClosingPatterns(t *testing.T) {
25 got := closingNumbers("Closes #1", "please Fixes #2.", "```\nCloses #4\n```", "`Resolves #8`", "See #3", "Implements #2")
26 if len(got) != 2 || got[0] != 1 || got[1] != 2 {
27 t.Fatalf("nummers %v", got)
28 }
29}
30
31func TestIssues(t *testing.T) {
32 storage := t.TempDir()
33 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
34 if err != nil {
35 t.Fatal(err)
36 }
37 t.Cleanup(func() { _ = st.Close() })
38 cfg := config.Config{
39 BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage,
40 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
41 Git: config.Git{Binary: "git", DefaultBranch: "master"},
42 }
43 var bodies [][]byte
44 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
45 srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) }
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48
49 jar, _ := cookiejar.New(nil)
50 tim := &http.Client{Jar: jar}
51 page := read(t, mustGet(t, tim, ts.URL+"/login"))
52 page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
53 "csrf": {csrfOf(t, page)}, "name": {"bugs"}, "visibility": {"public"},
54 }))
55 ctx := context.Background()
56 repo, err := st.RepoByPath(ctx, "tim", "bugs")
57 if err != nil {
58 t.Fatal(err)
59 }
60 if _, err := st.CreateWebhook(ctx, store.Webhook{
61 ScopeKind: "repo", ScopeID: repo.ID, Name: "issues", Preset: "generic",
62 URLTemplate: "https://example.test/hook", Events: []string{"issue"},
63 }); err != nil {
64 t.Fatal(err)
65 }
66 page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
67 timToken := between(page, `<p class="code">`, "</p>")
68
69 ro, err := st.UpsertUser(ctx, 3, "ro", "", false)
70 if err != nil {
71 t.Fatal(err)
72 }
73 rep, err := st.UpsertUser(ctx, 4, "rep", "", false)
74 if err != nil {
75 t.Fatal(err)
76 }
77 sam, err := st.UpsertUser(ctx, 5, "sam", "", false)
78 if err != nil {
79 t.Fatal(err)
80 }
81 dev, err := st.UpsertUser(ctx, 6, "dev", "", false)
82 if err != nil {
83 t.Fatal(err)
84 }
85 if err := st.SetMember(ctx, "repo", repo.ID, "ro", access.RoleReadonly); err != nil {
86 t.Fatal(err)
87 }
88 if err := st.SetMember(ctx, "repo", repo.ID, "rep", access.RoleReporter); err != nil {
89 t.Fatal(err)
90 }
91 if err := st.SetMember(ctx, "repo", repo.ID, "dev", access.RoleDeveloper); err != nil {
92 t.Fatal(err)
93 }
94 roToken, _ := st.CreateToken(ctx, ro.ID, "ro")
95 repToken, _ := st.CreateToken(ctx, rep.ID, "rep")
96 samToken, _ := st.CreateToken(ctx, sam.ID, "sam")
97 devToken, _ := st.CreateToken(ctx, dev.ID, "dev")
98
99 res := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/labels", timToken, map[string]any{"name": "bug", "color": "#428fdc"})
100 if res.StatusCode != http.StatusCreated {
101 t.Fatalf("label %d %s", res.StatusCode, read(t, res))
102 }
103 res.Body.Close()
104 res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/milestones", timToken, map[string]any{"title": "v1", "due_on": "2026-11-01"})
105 if res.StatusCode != http.StatusCreated {
106 t.Fatalf("mijlpaal %d %s", res.StatusCode, read(t, res))
107 }
108 res.Body.Close()
109 res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/labels", roToken, map[string]any{"name": "nope"})
110 if res.StatusCode != http.StatusForbidden {
111 t.Fatalf("readonly label %d", res.StatusCode)
112 }
113 res.Body.Close()
114
115 res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", roToken, map[string]any{"title": "Geheim", "labels": []string{"bug"}})
116 if res.StatusCode != http.StatusForbidden {
117 t.Fatalf("readonly labelen %d %s", res.StatusCode, read(t, res))
118 }
119 res.Body.Close()
120 noTok := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", "", map[string]any{"title": "x"})
121 if noTok.StatusCode != http.StatusUnauthorized {
122 t.Fatalf("zonder token %d", noTok.StatusCode)
123 }
124 noTok.Body.Close()
125 jobTok := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", "bgj_fake", map[string]any{"title": "x"})
126 if jobTok.StatusCode != http.StatusUnauthorized {
127 t.Fatalf("jobtoken %d", jobTok.StatusCode)
128 }
129 jobTok.Body.Close()
130
131 res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", roToken, map[string]any{
132 "title": "Geheim", "description": "niet delen", "confidential": true,
133 })
134 body := read(t, res)
135 if res.StatusCode != http.StatusCreated || !strings.Contains(body, `"id":1`) {
136 t.Fatalf("aanmaken %d %s", res.StatusCode, body)
137 }
138 opened := issuePayload(t, bodies, "opened")
139 if opened["comment"] != nil {
140 t.Fatalf("opened heeft comment %s", mustJSON(t, opened))
141 }
142 iss := opened["issue"].(map[string]any)
143 if iss["title"] != "Geheim" || iss["confidential"] != true || iss["author"] != "ro" {
144 t.Fatalf("payload %s", mustJSON(t, iss))
145 }
146
147 res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues", samToken)
148 list := read(t, res)
149 if res.StatusCode != http.StatusOK || strings.Contains(list, "Geheim") {
150 t.Fatalf("vreemde lijst %d %s", res.StatusCode, list)
151 }
152 res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", samToken)
153 if res.StatusCode != http.StatusNotFound {
154 t.Fatalf("vreemde detail %d", res.StatusCode)
155 }
156 res.Body.Close()
157 anon := mustGet(t, http.DefaultClient, ts.URL+"/tim/bugs/-/issues/1")
158 if anon.StatusCode != http.StatusNotFound {
159 t.Fatalf("anoniem %d", anon.StatusCode)
160 }
161 anon.Body.Close()
162 res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", repToken)
163 if res.StatusCode != http.StatusOK || !strings.Contains(read(t, res), "Geheim") {
164 t.Fatal("reporter ziet het vertrouwelijke issue niet")
165 }
166
167 res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", repToken, map[string]any{
168 "labels": []string{"bug"}, "assignees": []string{"ro"}, "milestone": "v1", "due_date": "2026-12-01",
169 })
170 tagged := read(t, res)
171 if res.StatusCode != http.StatusOK || !strings.Contains(tagged, "bug") || !strings.Contains(tagged, "ro") || !strings.Contains(tagged, "v1") {
172 t.Fatalf("triage %d %s", res.StatusCode, tagged)
173 }
174 res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", devToken, map[string]any{"labels": []string{"bug"}})
175 if res.StatusCode != http.StatusOK {
176 t.Fatalf("developer %d %s", res.StatusCode, read(t, res))
177 }
178 res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues/1/notes", roToken, map[string]any{"body": "zie !4"})
179 if res.StatusCode != http.StatusCreated {
180 t.Fatalf("reactie %d %s", res.StatusCode, read(t, res))
181 }
182 commented := issuePayload(t, bodies, "commented")
183 if commented["comment"] != "zie !4" {
184 t.Fatalf("comment %s", mustJSON(t, commented))
185 }
186
187 filtered := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues?state=open&label=bug&assignee=ro&q=geheim", repToken))
188 if !strings.Contains(filtered, `"id":1`) {
189 t.Fatalf("filter %s", filtered)
190 }
191
192 roJar, _ := cookiejar.New(nil)
193 roClient := &http.Client{Jar: roJar}
194 u, _ := url.Parse(ts.URL)
195 sess, err := st.CreateSession(ctx, ro.ID, "dev", time.Now().Add(time.Hour))
196 if err != nil {
197 t.Fatal(err)
198 }
199 roJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
200 page = read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues"))
201 if !strings.Contains(page, "Issues") || !strings.Contains(page, "#1") || !strings.Contains(page, "Geheim") || !strings.Contains(page, "bug") {
202 t.Fatalf("lijst\n%s", page)
203 }
204 page = read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues/new?relate=1"))
205 if !strings.Contains(page, `name="relate"`) || !strings.Contains(page, "value=\"1\"") {
206 t.Fatalf("gerelateerd\n%s", page)
207 }
208 page = read(t, mustPost(t, roClient, ts.URL+"/tim/bugs/-/issues", url.Values{
209 "csrf": {csrfOf(t, page)}, "title": {"Tweede"}, "description": {"Zie #1 en !4"}, "relate": {"1"},
210 }))
211 if !strings.Contains(page, "#2") || !strings.Contains(page, `/tim/bugs/-/issues/1`) || !strings.Contains(page, `/tim/bugs/-/merge-requests/4`) {
212 t.Fatalf("tweede pagina\n%s", page)
213 }
214 if !strings.Contains(page, "#1 Tweede") && !strings.Contains(page, "#1") {
215 t.Fatal("koppeling ontbreekt")
216 }
217
218 mr, err := st.CreateMergeRequest(ctx, repo.ID, ro.ID, "Voorbeeld", "tekst", "topic", "master")
219 if err != nil {
220 t.Fatal(err)
221 }
222 note, err := st.AddNote(ctx, repo.ID, mr.ID, ro.ID, "dit hoort een issue")
223 if err != nil {
224 t.Fatal(err)
225 }
226 form := read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues/new?from=mr&mr=1&note="+strconv.FormatInt(note.ID, 10)))
227 if !strings.Contains(form, "dit hoort een issue") || !strings.Contains(form, "!1") {
228 t.Fatalf("prefill\n%s", form)
229 }
230 prev := read(t, mustPost(t, roClient, ts.URL+"/tim/bugs/-/markdown", url.Values{
231 "csrf": {csrfOf(t, form)}, "body": {"zie #1 en !4"},
232 }))
233 if !strings.Contains(prev, `/tim/bugs/-/issues/1`) || !strings.Contains(prev, `/tim/bugs/-/merge-requests/4`) {
234 t.Fatalf("preview %s", prev)
235 }
236
237 res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", roToken, map[string]any{"state": "closed"})
238 if res.StatusCode != http.StatusOK || !strings.Contains(read(t, res), `"status":"closed"`) {
239 t.Fatal("sluiten faalde")
240 }
241 closed := issuePayload(t, bodies, "closed")
242 if closed["issue"].(map[string]any)["status"] != "closed" {
243 t.Fatalf("webhook sluiten %s", mustJSON(t, closed))
244 }
245 closedPage := read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues?state=closed"))
246 if !strings.Contains(closedPage, "Geheim") || strings.Contains(closedPage, "Tweede") {
247 t.Fatalf("filter gesloten\n%s", closedPage)
248 }
249
250 info := read(t, mustGet(t, http.DefaultClient, ts.URL+"/-/info"))
251 for _, want := range []string{`id="issues"`, "Readonly may create issues", "Inloggen faalt", "/api/v1/repos/{owner}/{repo}/issues"} {
252 if !strings.Contains(info, want) {
253 t.Errorf("info mist %s", want)
254 }
255 }
256}
257
258func TestIssueClosesOnMerge(t *testing.T) {
259 if _, err := exec.LookPath("git"); err != nil {
260 t.Skip("git ontbreekt")
261 }
262 storage := t.TempDir()
263 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
264 if err != nil {
265 t.Fatal(err)
266 }
267 t.Cleanup(func() { _ = st.Close() })
268 cfg := config.Config{
269 BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage,
270 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
271 Git: config.Git{Binary: "git", DefaultBranch: "master"},
272 }
273 var bodies [][]byte
274 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
275 srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) }
276 ts := httptest.NewServer(srv.Handler())
277 t.Cleanup(ts.Close)
278 jar, _ := cookiejar.New(nil)
279 tim := &http.Client{Jar: jar}
280 page := read(t, mustGet(t, tim, ts.URL+"/login"))
281 page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
282 "csrf": {csrfOf(t, page)}, "name": {"bugs"}, "visibility": {"private"},
283 }))
284 page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
285 token := between(page, `<p class="code">`, "</p>")
286 ctx := context.Background()
287 repo, err := st.RepoByPath(ctx, "tim", "bugs")
288 if err != nil {
289 t.Fatal(err)
290 }
291 if _, err := st.CreateWebhook(ctx, store.Webhook{
292 ScopeKind: "repo", ScopeID: repo.ID, Name: "issues", Preset: "generic",
293 URLTemplate: "https://example.test/hook", Events: []string{"issue"},
294 }); err != nil {
295 t.Fatal(err)
296 }
297 for _, title := range []string{"een", "twee", "drie"} {
298 res := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", token, map[string]any{"title": title})
299 if res.StatusCode != http.StatusCreated {
300 t.Fatalf("issue %s %d %s", title, res.StatusCode, read(t, res))
301 }
302 res.Body.Close()
303 }
304 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/bugs.git"
305 work := t.TempDir()
306 git(t, work, "init", "-b", "master")
307 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
308 git(t, work, "config", "user.name", "tim")
309 writeFile(t, filepath.Join(work, "README.md"), "a\n")
310 git(t, work, "add", "README.md")
311 git(t, work, "commit", "-m", "start")
312 git(t, work, "remote", "add", "origin", remote)
313 git(t, work, "push", "-u", "origin", "master")
314 git(t, work, "checkout", "-b", "topic")
315 writeFile(t, filepath.Join(work, "extra.txt"), "c\n")
316 git(t, work, "add", "extra.txt")
317 git(t, work, "commit", "-m", "Fixes #1")
318 git(t, work, "push", "-u", "origin", "topic")
319
320 page = read(t, mustGet(t, tim, ts.URL+"/tim/bugs/-/merge-requests/new?source=topic&target=master"))
321 page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests", url.Values{
322 "csrf": {csrfOf(t, page)}, "source": {"topic"}, "target": {"master"},
323 "title": {"Sluit issues"}, "description": {"Closes #2"},
324 }))
325 page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests/1/notes", url.Values{
326 "csrf": {csrfOf(t, page)}, "body": {"dit wordt een issue"},
327 }))
328 if !strings.Contains(page, "/-/issues/new?from=mr") || !strings.Contains(page, "dit wordt een issue") {
329 t.Fatalf("mr-link ontbreekt\n%s", page[:min(800, len(page))])
330 }
331 page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}}))
332 if !strings.Contains(page, "merged") && !strings.Contains(page, "samengevoegd") {
333 t.Fatalf("merge\n%s", page[:min(500, len(page))])
334 }
335 one := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", token))
336 two := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/2", token))
337 if !strings.Contains(one, `"status":"closed"`) || !strings.Contains(two, `"status":"closed"`) {
338 t.Fatalf("na merge\n1 %s\n2 %s", one, two)
339 }
340 foundClosed := 0
341 for _, raw := range bodies {
342 var doc map[string]any
343 if json.Unmarshal(raw, &doc) != nil || doc["object_kind"] != "issue" {
344 continue
345 }
346 iss, _ := doc["issue"].(map[string]any)
347 if iss != nil && iss["action"] == "closed" {
348 foundClosed++
349 }
350 }
351 if foundClosed < 2 {
352 t.Fatalf("webhooks gesloten %d", foundClosed)
353 }
354
355 git(t, work, "checkout", "master")
356 git(t, work, "pull", "--ff-only", "origin", "master")
357 writeFile(t, filepath.Join(work, "README.md"), "b\n")
358 git(t, work, "add", "README.md")
359 git(t, work, "commit", "-m", "Resolves #3")
360 git(t, work, "push", "origin", "master")
361 three := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/3", token))
362 if !strings.Contains(three, `"status":"closed"`) {
363 t.Fatalf("push sluit niet %s", three)
364 }
365}
366
367func postJSON(t *testing.T, method, raw, token string, body any) *http.Response {
368 t.Helper()
369 var buf bytes.Buffer
370 if body != nil {
371 if err := json.NewEncoder(&buf).Encode(body); err != nil {
372 t.Fatal(err)
373 }
374 }
375 req, err := http.NewRequest(method, raw, &buf)
376 if err != nil {
377 t.Fatal(err)
378 }
379 if token != "" {
380 req.Header.Set("Authorization", "Bearer "+token)
381 }
382 req.Header.Set("Content-Type", "application/json")
383 res, err := http.DefaultClient.Do(req)
384 if err != nil {
385 t.Fatal(err)
386 }
387 return res
388}
389
390func issuePayload(t *testing.T, bodies [][]byte, action string) map[string]any {
391 t.Helper()
392 for i := len(bodies) - 1; i >= 0; i-- {
393 var doc map[string]any
394 if err := json.Unmarshal(bodies[i], &doc); err != nil {
395 continue
396 }
397 iss, _ := doc["issue"].(map[string]any)
398 if iss != nil && iss["action"] == action {
399 return doc
400 }
401 }
402 t.Fatalf("geen issue-actie %s", action)
403 return nil
404}