BlueGit

timfa bluegit

Files

bluegit / internal / server / commit_page_test.go

commit_page_test.go

feat: toon een commit zoals GitLab
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
dc9d9b26 History
commit_page_test.go 9.8 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "net/http/cookiejar"
7 "net/http/httptest"
8 "net/url"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14
15 "gitlab.com/Timfa/bluegit/internal/auth"
16 "gitlab.com/Timfa/bluegit/internal/config"
17 "gitlab.com/Timfa/bluegit/internal/gitrepo"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func TestPresentCommitTree(t *testing.T) {
22 files := []gitrepo.PatchFile{
23 {Status: "added", Path: "src/util.go", Added: 2, Lines: []gitrepo.DiffLine{{Kind: "add", New: 1, Text: "func util() {}"}}},
24 {Status: "renamed", Path: "a2.txt", OldPath: "a.txt"},
25 {Status: "added", Path: "huge.txt", Added: largeChange + 1, Lines: []gitrepo.DiffLine{{Kind: "add", New: 1, Text: "x"}}},
26 }
27 d := presentCommitDiff("tim/demo", "abcdef1234567890", []string{"1234abcd1234abcd1234abcd1234abcd1234abcd"}, files)
28 if d.FilesN != 3 || len(d.Parents) != 1 || d.Parents[0].Short != "1234abcd" {
29 t.Fatalf("kop: %+v", d)
30 }
31 if !d.Files[2].Collapsed || d.Files[0].Collapsed {
32 t.Fatalf("inklappen: util %v huge %v", d.Files[0].Collapsed, d.Files[2].Collapsed)
33 }
34 if !strings.Contains(string(d.Files[0].Lines[0].HTML), "hl-k") {
35 t.Fatalf("geen highlight: %s", d.Files[0].Lines[0].HTML)
36 }
37 if d.Files[0].Pairs[0].RKind != "add" || d.Files[0].Pairs[0].RNo != 1 || d.Files[0].Pairs[0].LKind != "" {
38 t.Fatalf("paar: %+v", d.Files[0].Pairs)
39 }
40 var dirs, nested bool
41 for _, row := range d.Tree {
42 if row.Dir && row.Name == "src" && row.Depth == 0 {
43 dirs = true
44 }
45 if row.Name == "util.go" && row.Depth == 1 && row.Anchor != "" {
46 nested = true
47 }
48 }
49 if !dirs || !nested {
50 t.Fatalf("boom: %+v", d.Tree)
51 }
52 if !strings.Contains(d.Files[0].FileURL, "/tim/demo/-/blob/src/util.go?rev=abcdef1234567890") {
53 t.Fatal(d.Files[0].FileURL)
54 }
55}
56
57func TestCommitDetailPage(t *testing.T) {
58 if _, err := exec.LookPath("git"); err != nil {
59 t.Skip("git ontbreekt")
60 }
61 storage := t.TempDir()
62 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
63 if err != nil {
64 t.Fatal(err)
65 }
66 t.Cleanup(func() { _ = st.Close() })
67 cfg := config.Config{
68 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
69 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
70 Git: config.Git{Binary: "git", DefaultBranch: "master"},
71 }
72 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
73 ts := httptest.NewServer(srv.Handler())
74 t.Cleanup(ts.Close)
75 jar, _ := cookiejar.New(nil)
76 client := &http.Client{Jar: jar}
77 res, err := client.Get(ts.URL + "/login")
78 if err != nil {
79 t.Fatal(err)
80 }
81 page := read(t, res)
82 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
83 "csrf": {csrfOf(t, page)}, "name": {"diffdemo"}, "visibility": {"public"},
84 })
85 if err != nil {
86 t.Fatal(err)
87 }
88 page = read(t, res)
89 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"laptop"}})
90 if err != nil {
91 t.Fatal(err)
92 }
93 token := between(read(t, res), `<p class="code">`, "</p>")
94 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/diffdemo.git"
95 work := t.TempDir()
96 git(t, work, "init", "-b", "master")
97 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
98 git(t, work, "config", "user.name", "tim")
99 git(t, work, "config", "commit.gpgsign", "false")
100 writeFile(t, filepath.Join(work, "a.txt"), "alpha\n")
101 writeFile(t, filepath.Join(work, "b.txt"), "beta\n")
102 writeFile(t, filepath.Join(work, "keep.go"), "package p\n\nfunc keep() {}\n")
103 git(t, work, "add", ".")
104 git(t, work, "commit", "-m", "begin")
105 root := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
106 writeFile(t, filepath.Join(work, "keep.go"), "package p\n\nfunc keep() {}\nfunc extra() {}\n")
107 if err := os.Remove(filepath.Join(work, "b.txt")); err != nil {
108 t.Fatal(err)
109 }
110 writeFile(t, filepath.Join(work, "c.txt"), strings.Repeat("x", 180)+"\n")
111 writeFile(t, filepath.Join(work, "note file.txt"), "spatie\n")
112 writeFile(t, filepath.Join(work, "src", "util.go"), "package src\n\nfunc util() {}\n")
113 var huge strings.Builder
114 for i := 0; i < 220; i++ {
115 huge.WriteString("regel\n")
116 }
117 writeFile(t, filepath.Join(work, "huge.txt"), huge.String())
118 writeFile(t, filepath.Join(work, "bin.dat"), "a\x00b\n")
119 git(t, work, "add", "-A")
120 git(t, work, "mv", "a.txt", "a2.txt")
121 git(t, work, "commit", "-m", "wijzig bestanden", "-m", "tweede alinea")
122 mixed := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
123 git(t, work, "remote", "add", "origin", remote)
124 git(t, work, "push", "-u", "origin", "master")
125 git(t, work, "checkout", "-b", "side")
126 writeFile(t, filepath.Join(work, "side.txt"), "zijtak\n")
127 git(t, work, "add", "side.txt")
128 git(t, work, "commit", "-m", "zijtak")
129 git(t, work, "checkout", "master")
130 git(t, work, "merge", "--no-ff", "side", "-m", "voeg zijtak samen")
131 merge := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
132 git(t, work, "push", "origin", "master")
133
134 ctx := context.Background()
135 repo, err := st.RepoByPath(ctx, "tim", "diffdemo")
136 if err != nil {
137 t.Fatal(err)
138 }
139 pipeID, err := st.CreatePipeline(ctx, repo.ID, mixed, "refs/heads/master", "push", "tim", "wijzig bestanden", []store.NewJob{
140 {Name: "lint", Stage: "test", Script: "exit 0"},
141 })
142 if err != nil {
143 t.Fatal(err)
144 }
145 jobs, _ := st.JobsByPipeline(ctx, pipeID)
146 for _, j := range jobs {
147 if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil {
148 t.Fatal(err)
149 }
150 }
151 if status, err := st.RefreshPipelineStatus(ctx, pipeID); err != nil || status != "success" {
152 t.Fatalf("pipeline: %s %v", status, err)
153 }
154
155 res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
156 if err != nil {
157 t.Fatal(err)
158 }
159 body := read(t, res)
160 for _, want := range []string{
161 "wijzig bestanden", "tweede alinea", "Authored",
162 `data-copy="` + mixed + `"`,
163 "/tim/diffdemo/-/commit/" + root,
164 "Parent",
165 `class="status passed"`, "Passed",
166 "a.txt", "a2.txt", "renamed",
167 "b.txt", "deleted",
168 "note file.txt", "added",
169 "Binary file", "The contents of this binary file are not shown.",
170 `data-path="huge.txt"`, `data-collapsed="1"`, "Show diff",
171 `data-path="keep.go"`, `data-collapsed="0"`, "Hide diff",
172 "hl-k", "func", "src", "util.go",
173 `data-diff-mode="side"`, "Side-by-side",
174 "/assets/commit-mode.js", `class="d1"`,
175 strings.Repeat("x", 180),
176 "Changed files",
177 } {
178 if !strings.Contains(body, want) {
179 t.Errorf("pagina mist %q", want)
180 }
181 }
182 if strings.Contains(body, "commit.show") {
183 t.Fatal("vertaling ontbreekt")
184 }
185 keep := section(body, `data-path="keep.go"`)
186 if !strings.Contains(keep, `class="ln">1</span>`) || !strings.Contains(keep, "kind-add") || !strings.Contains(keep, "extra") || !strings.Contains(keep, "hl-k") {
187 i := strings.Index(body, `data-path="keep.go"`)
188 j := strings.Index(body[i:], "</section>")
189 k := strings.Index(body[i:], "kind-add")
190 t.Fatalf("keep.go mist delen ln=%v add=%v extra=%v hl=%v section-op=%d add-op=%d keep-len=%d",
191 strings.Contains(keep, `class="ln">1</span>`), strings.Contains(keep, "kind-add"),
192 strings.Contains(keep, "extra"), strings.Contains(keep, "hl-k"), j, k, len(keep))
193 }
194 gone := section(body, `data-path="b.txt"`)
195 if !strings.Contains(gone, "kind-del") || !strings.Contains(gone, `class="ln">1</span>`) {
196 t.Fatal("b.txt mist het verwijderde regelnummer")
197 }
198
199 res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + merge)
200 if err != nil {
201 t.Fatal(err)
202 }
203 mergePage := read(t, res)
204 if !strings.Contains(mergePage, "Parents") || !strings.Contains(mergePage, "/tim/diffdemo/-/commit/"+mixed) || !strings.Contains(mergePage, `data-path="side.txt"`) {
205 t.Fatal("mergepagina mist parents of side.txt")
206 }
207 if strings.Contains(mergePage, `data-path="huge.txt"`) || strings.Contains(mergePage, `data-path="keep.go"`) {
208 t.Fatal("merge-diff toont meer dan de eerste parent")
209 }
210
211 res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + root)
212 if err != nil {
213 t.Fatal(err)
214 }
215 rootPage := read(t, res)
216 if strings.Contains(rootPage, "Parent") || !strings.Contains(rootPage, `data-path="a.txt"`) || !strings.Contains(rootPage, "added") {
217 t.Fatal("rootcommit klopt niet")
218 }
219
220 res, err = client.Get(ts.URL + "/settings")
221 if err != nil {
222 t.Fatal(err)
223 }
224 settings := read(t, res)
225 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, settings)}, "language": {"nl"}})
226 if err != nil {
227 t.Fatal(err)
228 }
229 _ = read(t, res)
230 res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
231 if err != nil {
232 t.Fatal(err)
233 }
234 nl := read(t, res)
235 for _, want := range []string{"Toon diff", "hernoemd", "Bovenliggende commit", "Naast elkaar", "Gewijzigde bestanden", "Binair bestand"} {
236 if !strings.Contains(nl, want) {
237 t.Errorf("Nederlands mist %q", want)
238 }
239 }
240 if strings.Contains(nl, "Show diff") {
241 t.Fatal("Engelse diffknop bleef staan")
242 }
243
244 res, err = client.Get(ts.URL + "/settings")
245 if err != nil {
246 t.Fatal(err)
247 }
248 settings = read(t, res)
249 res, err = client.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, settings)}, "language": {"cuneiform"}})
250 if err != nil {
251 t.Fatal(err)
252 }
253 _ = read(t, res)
254 res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
255 if err != nil {
256 t.Fatal(err)
257 }
258 signs := read(t, res)
259 if strings.Contains(signs, "Show diff") || strings.Contains(signs, "Toon diff") || !strings.Contains(signs, mixed) || !strings.Contains(signs, "𒀀") {
260 t.Fatal("spijkerschrift of hash klopt niet")
261 }
262}
263
264func gitOutOK(t *testing.T, dir string, args ...string) string {
265 t.Helper()
266 out, err := gitOut(dir, args...)
267 if err != nil {
268 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
269 }
270 return out
271}
272
273func section(body, marker string) string {
274 i := strings.Index(body, marker)
275 if i < 0 {
276 return ""
277 }
278 rest := body[i:]
279 j := strings.Index(rest, "</section>")
280 if j < 0 {
281 return rest
282 }
283 return rest[:j]
284}