| 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 | } |