| 1 | package gitgraph |
| 2 | |
| 3 | import ( |
| 4 | "strings" |
| 5 | "testing" |
| 6 | ) |
| 7 | |
| 8 | func 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 | |
| 22 | func 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 | |
| 34 | func 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 | |
| 66 | func 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 | |
| 93 | func 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 | |
| 122 | func 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 | |
| 155 | func 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 | |
| 170 | func 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 | |
| 189 | func 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 | |
| 216 | func 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 | |
| 246 | func 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 | |
| 268 | func 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 | |
| 293 | func 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 | |
| 319 | func 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 | |
| 350 | func 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 | } |