BlueGit

timfa bluegit

Files

bluegit / internal / gitgraph / graph_test.go

graph_test.go

graph_test.go 12.0 KiB Download Raw
1package gitgraph
2
3import (
4 "strings"
5 "testing"
6)
7
8func commits(pairs ...string) []Commit {
9 // pairs: "sha:parent,parent" or "sha:" for root. Order is newest first.
10 var out []Commit
11 for _, p := range pairs {
12 sha, rest, _ := strings.Cut(p, ":")
13 var parents []string
14 if rest != "" {
15 parents = strings.Split(rest, ",")
16 }
17 out = append(out, Commit{SHA: sha, Short: sha, Subject: "msg-" + sha, Parents: parents})
18 }
19 return out
20}
21
22func TestLayoutLinear(t *testing.T) {
23 g := Layout(commits("c:b", "b:a", "a:"), nil, "master")
24 if g.Lanes != 1 {
25 t.Fatalf("lanes=%d, wil 1", g.Lanes)
26 }
27 for i, want := range []string{"c", "b", "a"} {
28 if g.Rows[i].SHA != want || g.Rows[i].Lane != 0 {
29 t.Fatalf("rij %d: %+v", i, g.Rows[i])
30 }
31 }
32}
33
34func TestLayoutFork(t *testing.T) {
35 // feature (d) en master (c) splitsen vanaf b.
36 refs := []Ref{
37 {Name: "master", SHA: "c", Kind: "branch"},
38 {Name: "feature", SHA: "d", Kind: "branch"},
39 }
40 g := Layout(commits("d:b", "c:b", "b:a", "a:"), refs, "master")
41 if g.Lanes < 2 {
42 t.Fatalf("verwacht minstens 2 lanes, kreeg %d", g.Lanes)
43 }
44 laneOf := map[string]int{}
45 for _, r := range g.Rows {
46 laneOf[r.SHA] = r.Lane
47 }
48 if laneOf["d"] == laneOf["c"] {
49 t.Fatalf("forks moeten andere lanes hebben: %v", laneOf)
50 }
51 if laneOf["b"] != laneOf["a"] {
52 t.Fatalf("stam blijft op één lane: %v", laneOf)
53 }
54 // master is blauw
55 for _, r := range g.Rows {
56 if r.SHA == "c" && r.Color != "var(--blue)" {
57 t.Fatalf("master-tip kleur %s", r.Color)
58 }
59 }
60 // merge/fork-lijn van d of c naar b
61 if !hasEdgeTo(g, "b") {
62 t.Fatalf("geen lijn naar b: %+v", g.Edges)
63 }
64}
65
66func TestLayoutMerge(t *testing.T) {
67 // m merget feature (f) in master (c).
68 refs := []Ref{
69 {Name: "master", SHA: "m", Kind: "branch"},
70 {Name: "feature", SHA: "f", Kind: "branch"},
71 }
72 g := Layout(commits("m:c,f", "f:b", "c:b", "b:a", "a:"), refs, "master")
73 if g.Lanes < 2 {
74 t.Fatalf("merge heeft een tweede lane nodig, kreeg %d", g.Lanes)
75 }
76 laneOf := map[string]int{}
77 colorOf := map[string]string{}
78 for _, r := range g.Rows {
79 laneOf[r.SHA] = r.Lane
80 colorOf[r.SHA] = r.Color
81 }
82 if laneOf["f"] == laneOf["c"] {
83 t.Fatalf("feature en master voor de merge op dezelfde lane: %v", laneOf)
84 }
85 if colorOf["m"] != "var(--blue)" {
86 t.Fatalf("merge-commit op master moet blauw zijn, kreeg %s", colorOf["m"])
87 }
88 if !hasEdgeBetween(g, "m", "f") && !hasEdgeBetween(g, "m", "c") {
89 t.Fatalf("verwacht lijnen van de merge naar beide ouders: %+v", g.Edges)
90 }
91}
92
93func TestLayoutMergeAndForkTogether(t *testing.T) {
94 // master: a-b-c-m, feature: b-d-e, m merget e.
95 refs := []Ref{
96 {Name: "master", SHA: "m", Kind: "branch"},
97 {Name: "feature", SHA: "e", Kind: "branch"},
98 {Name: "v1", SHA: "c", Kind: "tag"},
99 }
100 g := Layout(commits("m:c,e", "e:d", "d:b", "c:b", "b:a", "a:"), refs, "master")
101 if len(g.Rows) != 6 {
102 t.Fatalf("rijen=%d", len(g.Rows))
103 }
104 var hasTag, hasMaster, hasFeature bool
105 for _, r := range g.Rows {
106 for _, lb := range r.Labels {
107 switch {
108 case lb.Kind == "tag" && lb.Name == "v1":
109 hasTag = true
110 case lb.Default && lb.Name == "master":
111 hasMaster = true
112 case lb.Name == "feature":
113 hasFeature = true
114 }
115 }
116 }
117 if !hasTag || !hasMaster || !hasFeature {
118 t.Fatalf("labels ontbreken: tag=%v master=%v feature=%v", hasTag, hasMaster, hasFeature)
119 }
120}
121
122func TestColorDeterministicAndMainIsBlue(t *testing.T) {
123 if Color("master", "master") != "var(--blue)" {
124 t.Fatal("hoofdbranch moet --blue zijn")
125 }
126 if Color("main", "main") != "var(--blue)" {
127 t.Fatal("hoofdbranch main moet --blue zijn")
128 }
129 if Color("feature", "master") == "var(--blue)" {
130 t.Fatal("andere branch mag niet de hoofd-blauw zijn")
131 }
132 if Color("feature", "master") != Color("feature", "master") {
133 t.Fatal("kleur moet deterministisch zijn")
134 }
135 if Color("feature", "master") != Color("FEATURE", "master") {
136 t.Fatal("kleur is case-insensitive")
137 }
138 if Color("feature", "master") == Color("other", "master") {
139 t.Fatal("verschillende namen moeten meestal een andere kleur krijgen")
140 }
141 seen := map[string]bool{}
142 for _, n := range []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"} {
143 seen[Color(n, "master")] = true
144 }
145 if len(seen) < 2 {
146 t.Fatalf("palet wordt niet gebruikt: %v", seen)
147 }
148 for c := range seen {
149 if !strings.HasPrefix(c, "var(--graph-") {
150 t.Fatalf("onverwachte kleur %s", c)
151 }
152 }
153}
154
155func TestKeyChangesWithTips(t *testing.T) {
156 a := Key(1, map[string]string{"refs/heads/master": "aaa"}, "master", 40)
157 b := Key(1, map[string]string{"refs/heads/master": "bbb"}, "master", 40)
158 c := Key(1, map[string]string{"refs/heads/master": "aaa"}, "master", 40)
159 if a == b {
160 t.Fatal("andere tip moet andere sleutel geven")
161 }
162 if a != c {
163 t.Fatal("zelfde stand moet dezelfde sleutel geven")
164 }
165 if Key(2, map[string]string{"refs/heads/master": "aaa"}, "master", 40) == a {
166 t.Fatal("andere repo moet andere sleutel geven")
167 }
168}
169
170func hasEdgeTo(g *Graph, sha string) bool {
171 idx := -1
172 for i, r := range g.Rows {
173 if r.SHA == sha {
174 idx = i
175 break
176 }
177 }
178 if idx < 0 {
179 return false
180 }
181 for _, e := range g.Edges {
182 if e.ToRow == idx {
183 return true
184 }
185 }
186 return false
187}
188
189func hasEdgeBetween(g *Graph, from, to string) bool {
190 fi, ti := -1, -1
191 for i, r := range g.Rows {
192 if r.SHA == from {
193 fi = i
194 }
195 if r.SHA == to {
196 ti = i
197 }
198 }
199 if fi < 0 || ti < 0 {
200 return false
201 }
202 for _, e := range g.Edges {
203 if e.FromRow == fi && e.ToRow == ti {
204 return true
205 }
206 }
207 // via een tussenliggende lane (merge-boog plus verticaal)
208 for _, e := range g.Edges {
209 if e.FromRow == fi && e.ToLane == g.Rows[ti].Lane {
210 return true
211 }
212 }
213 return false
214}
215
216func TestMainlineStaysBlueOnLaneZero(t *testing.T) {
217 // Nieuwere zijtak docs bovenop master-merge mag lane 0 en blauw niet inpikken.
218 refs := []Ref{
219 {Name: "master", SHA: "m", Kind: "branch"},
220 {Name: "docs", SHA: "d", Kind: "branch"},
221 }
222 g := Layout(commits("d:m", "m:c,f", "f:b", "c:b", "b:"), refs, "master")
223 for _, r := range g.Rows {
224 switch r.SHA {
225 case "m", "c", "b":
226 if r.Color != "var(--blue)" {
227 t.Fatalf("%s moet blauw zijn, kreeg %s (class %s)", r.SHA, r.Color, r.Class)
228 }
229 if r.Lane != 0 {
230 t.Fatalf("%s moet op lane 0, kreeg %d", r.SHA, r.Lane)
231 }
232 if r.Class != "is-main" {
233 t.Fatalf("%s class=%s", r.SHA, r.Class)
234 }
235 case "d":
236 if r.Lane == 0 {
237 t.Fatalf("zijtak docs mag lane 0 niet stelen")
238 }
239 if r.Color == "var(--blue)" {
240 t.Fatalf("zijtak mag niet de hoofd-blauw zijn")
241 }
242 }
243 }
244}
245
246func TestOneCommitPerRow(t *testing.T) {
247 refs := []Ref{
248 {Name: "master", SHA: "m", Kind: "branch"},
249 {Name: "feature", SHA: "e", Kind: "branch"},
250 {Name: "docs", SHA: "d", Kind: "branch"},
251 }
252 g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
253 if len(g.Rows) != 6 {
254 t.Fatalf("rijen=%d, wil één per commit", len(g.Rows))
255 }
256 seen := map[string]int{}
257 for i, r := range g.Rows {
258 if r.SHA == "" {
259 t.Fatalf("lege commit op rij %d", i)
260 }
261 if j, ok := seen[r.SHA]; ok {
262 t.Fatalf("commit %s staat op rij %d en %d", r.SHA, j, i)
263 }
264 seen[r.SHA] = i
265 }
266}
267
268func TestTextXIsRightOfLanes(t *testing.T) {
269 refs := []Ref{
270 {Name: "master", SHA: "m", Kind: "branch"},
271 {Name: "feature", SHA: "e", Kind: "branch"},
272 {Name: "docs", SHA: "d", Kind: "branch"},
273 }
274 g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
275 if g.Lanes < 2 {
276 t.Fatalf("verwacht meerdere lanes, kreeg %d", g.Lanes)
277 }
278 maxLaneRight := 0.0
279 for i := 0; i < g.Lanes; i++ {
280 right := laneX(i) + float64(LaneW)/2
281 if right > maxLaneRight {
282 maxLaneRight = right
283 }
284 }
285 if float64(g.TextX) < maxLaneRight {
286 t.Fatalf("TextX=%d ligt niet rechts van de laatste lane (%.1f), lanes=%d", g.TextX, maxLaneRight, g.Lanes)
287 }
288 if g.PanelWidth < RefW+g.TextX {
289 t.Fatalf("PanelWidth=%d is te smal voor refs+tekst (TextX=%d)", g.PanelWidth, g.TextX)
290 }
291}
292
293func TestLaneAssignmentStable(t *testing.T) {
294 refs := []Ref{
295 {Name: "master", SHA: "m", Kind: "branch"},
296 {Name: "feature", SHA: "f", Kind: "branch"},
297 }
298 g := Layout(commits("m:c,f", "f:b", "c:b", "b:"), refs, "master")
299 laneOf := map[string]int{}
300 for _, r := range g.Rows {
301 laneOf[r.SHA] = r.Lane
302 }
303 if laneOf["m"] != 0 || laneOf["c"] != 0 || laneOf["b"] != 0 {
304 t.Fatalf("master moet lane 0 blijven: %v", laneOf)
305 }
306 if laneOf["f"] == 0 {
307 t.Fatalf("feature mag lane 0 niet gebruiken: %v", laneOf)
308 }
309 if g.Rows[0].Branch != "master" {
310 t.Fatalf("merge-commit branch=%q", g.Rows[0].Branch)
311 }
312 for _, r := range g.Rows {
313 if r.SHA == "f" && r.Branch != "feature" {
314 t.Fatalf("feature-commit branch=%q", r.Branch)
315 }
316 }
317}
318
319func TestNodeLeftMatchesLane(t *testing.T) {
320 refs := []Ref{
321 {Name: "master", SHA: "m", Kind: "branch"},
322 {Name: "feature", SHA: "f", Kind: "branch"},
323 }
324 g := Layout(commits("m:c,f", "f:b", "c:b", "b:"), refs, "master")
325 if g.Lanes < 2 {
326 t.Fatalf("verwacht meerdere lanes, kreeg %d", g.Lanes)
327 }
328 seenOffMain := false
329 for _, r := range g.Rows {
330 if r.NodeX != laneX(r.Lane) {
331 t.Fatalf("commit %s NodeX=%.1f, wil laneX(%d)=%.1f", r.SHA, r.NodeX, r.Lane, laneX(r.Lane))
332 }
333 wantLeft := RefW + int(r.NodeX-DotR)
334 if r.NodeLeft != wantLeft {
335 t.Fatalf("commit %s NodeLeft=%d, wil %d (lane %d)", r.SHA, r.NodeLeft, wantLeft, r.Lane)
336 }
337 if r.Lane != 0 {
338 seenOffMain = true
339 mainLeft := RefW + int(laneX(0)-DotR)
340 if r.NodeLeft <= mainLeft {
341 t.Fatalf("zijtak %s staat niet rechts van de hoofdlane: left=%d main=%d", r.SHA, r.NodeLeft, mainLeft)
342 }
343 }
344 }
345 if !seenOffMain {
346 t.Fatal("verwacht minstens één commit naast de hoofdlane")
347 }
348}
349
350func TestTextXClearsAllGeometry(t *testing.T) {
351 refs := []Ref{
352 {Name: "master", SHA: "m", Kind: "branch"},
353 {Name: "feature", SHA: "e", Kind: "branch"},
354 {Name: "docs", SHA: "d", Kind: "branch"},
355 }
356 g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
357 limit := float64(g.TextX - TextPad)
358 for _, r := range g.Rows {
359 if r.NodeX+DotR > limit {
360 t.Fatalf("knoop %s reikt tot %.1f, TextX-pad=%.1f", r.SHA, r.NodeX+DotR, limit)
361 }
362 }
363 for _, e := range g.Edges {
364 for _, ln := range []int{e.FromLane, e.ToLane} {
365 if laneX(ln)+1 > limit {
366 t.Fatalf("lijn op lane %d reikt tot %.1f, TextX-pad=%.1f", ln, laneX(ln)+1, limit)
367 }
368 }
369 }
370 svg := g.SVG()
371 for _, x := range svgPathXs(svg) {
372 if x > limit {
373 t.Fatalf("svg-pad heeft x=%.1f rechts van TextX-pad=%.1f: %s", x, limit, svg)
374 }
375 }
376}
377
378func TestLeafLabel(t *testing.T) {
379 cases := map[string]string{
380 "feature/commit-graph-v5": "commit-graph-v5",
381 "refs/heads/feature/commit-graph-v5": "commit-graph-v5",
382 "a/b/c": "c",
383 "master": "master",
384 "refs/tags/v1.2": "v1.2",
385 "feature/": "feature/",
386 "": "",
387 }
388 for in, want := range cases {
389 if got := LeafLabel(in); got != want {
390 t.Errorf("LeafLabel(%q)=%q, wil %q", in, got, want)
391 }
392 }
393}
394
395func TestCommitTipIncludesSubjectSHAAndAuthor(t *testing.T) {
396 got := CommitTip(Row{Commit: Commit{Subject: "merge feature", Short: "e5d0eb4b", Author: "tim"}})
397 if got != "merge feature · e5d0eb4b · tim" {
398 t.Fatalf("tip=%q", got)
399 }
400 if CommitTip(Row{Commit: Commit{Subject: "only"}}) != "only" {
401 t.Fatalf("korte tip is verkeerd")
402 }
403}
404
405func TestLayoutSetsShortLabelAndTip(t *testing.T) {
406 refs := []Ref{
407 {Name: "master", SHA: "m", Kind: "branch"},
408 {Name: "feature/commit-graph-v5", SHA: "f", Kind: "branch"},
409 }
410 g := Layout([]Commit{
411 {SHA: "f", Short: "fffffff", Subject: "work", Author: "tim", Parents: []string{"b"}},
412 {SHA: "m", Short: "mmmmmmm", Subject: "merge", Author: "tim", Parents: []string{"b"}},
413 {SHA: "b", Short: "bbbbbbb", Subject: "base", Author: "tim"},
414 }, refs, "master")
415 var found bool
416 for _, r := range g.Rows {
417 if r.Tip == "" {
418 t.Fatalf("commit %s mist tip", r.SHA)
419 }
420 for _, lb := range r.Labels {
421 if lb.Ref == "feature/commit-graph-v5" || lb.Name == "feature/commit-graph-v5" || lb.Short == "commit-graph-v5" {
422 found = true
423 if lb.Short != "commit-graph-v5" {
424 t.Fatalf("Short=%q, wil commit-graph-v5 (Name=%q Ref=%q)", lb.Short, lb.Name, lb.Ref)
425 }
426 }
427 }
428 }
429 if !found {
430 t.Fatal("feature/commit-graph-v5 label ontbreekt of Short is leeg")
431 }
432}