| 1 | package runner |
| 2 | |
| 3 | import ( |
| 4 | "context" |
| 5 | "path/filepath" |
| 6 | "testing" |
| 7 | "time" |
| 8 | |
| 9 | "gitlab.com/Timfa/bluegit/internal/access" |
| 10 | "gitlab.com/Timfa/bluegit/internal/store" |
| 11 | ) |
| 12 | |
| 13 | func names(tiers []Tier) []string { |
| 14 | var out []string |
| 15 | for _, t := range tiers { |
| 16 | if t.Builtin { |
| 17 | out = append(out, "builtin") |
| 18 | continue |
| 19 | } |
| 20 | s := "" |
| 21 | for i, r := range t.Runners { |
| 22 | if i > 0 { |
| 23 | s += "+" |
| 24 | } |
| 25 | s += r.Name |
| 26 | } |
| 27 | out = append(out, s) |
| 28 | } |
| 29 | return out |
| 30 | } |
| 31 | |
| 32 | func eq(t *testing.T, got []string, want ...string) { |
| 33 | t.Helper() |
| 34 | if len(got) != len(want) { |
| 35 | t.Fatalf("got %v, want %v", got, want) |
| 36 | } |
| 37 | for i := range got { |
| 38 | if got[i] != want[i] { |
| 39 | t.Fatalf("got %v, want %v", got, want) |
| 40 | } |
| 41 | } |
| 42 | } |
| 43 | |
| 44 | func TestOrder(t *testing.T) { |
| 45 | own := []store.Runner{{ID: 1, Name: "laptop"}} |
| 46 | grp := []store.Runner{{ID: 2, Name: "grp"}} |
| 47 | opt := []store.Runner{{ID: 3, Name: "maint"}} |
| 48 | eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, own, nil, nil)), "laptop", "builtin") |
| 49 | eq(t, names(Order("user", store.RunnerPrefBuiltinFirst, false, own, nil, nil)), "builtin", "laptop") |
| 50 | eq(t, names(Order("user", "", false, own, nil, nil)), "builtin", "laptop") |
| 51 | eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, nil, nil, nil)), "builtin") |
| 52 | eq(t, names(Order("group", "", false, nil, grp, opt)), "grp", "maint", "builtin") |
| 53 | eq(t, names(Order("group", "", true, nil, grp, opt)), "builtin", "grp", "maint") |
| 54 | eq(t, names(Order("group", "", false, nil, nil, opt)), "maint", "builtin") |
| 55 | eq(t, names(Order("group", "", false, nil, grp, nil)), "grp", "builtin") |
| 56 | } |
| 57 | |
| 58 | func TestAdvance(t *testing.T) { |
| 59 | now := time.Now() |
| 60 | on := store.Runner{ID: 1, Name: "on", LastSeen: now} |
| 61 | off := store.Runner{ID: 2, Name: "off", LastSeen: now.Add(-time.Hour)} |
| 62 | remoteOn := Tier{Runners: []store.Runner{on}} |
| 63 | remoteOff := Tier{Runners: []store.Runner{off}} |
| 64 | builtin := Tier{Builtin: true} |
| 65 | |
| 66 | // Eigen runners eerst, runner online: blijft op de runner wachten. |
| 67 | st := Advance([]Tier{remoteOn, builtin}, 0, time.Time{}, now, true) |
| 68 | if st.Builtin || st.Tier != 0 || !st.Moved { |
| 69 | t.Fatalf("own first online: %+v", st) |
| 70 | } |
| 71 | // Na de wachttijd gaat de job naar de BlueGit-runner. |
| 72 | st = Advance([]Tier{remoteOn, builtin}, 0, now.Add(-OfferTimeout-time.Second), now, true) |
| 73 | if !st.Builtin || st.Tier != 1 { |
| 74 | t.Fatalf("own first timeout: %+v", st) |
| 75 | } |
| 76 | // Runner offline: meteen door. |
| 77 | st = Advance([]Tier{remoteOff, builtin}, 0, time.Time{}, now, true) |
| 78 | if !st.Builtin || st.Tier != 1 { |
| 79 | t.Fatalf("offline: %+v", st) |
| 80 | } |
| 81 | // BlueGit-runner eerst maar vol: door naar de eigen runner. |
| 82 | st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, false) |
| 83 | if st.Builtin || st.Tier != 1 || !st.Moved { |
| 84 | t.Fatalf("builtin busy: %+v", st) |
| 85 | } |
| 86 | // BlueGit-runner eerst en vrij: direct. |
| 87 | st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, true) |
| 88 | if !st.Builtin || st.Tier != 0 { |
| 89 | t.Fatalf("builtin free: %+v", st) |
| 90 | } |
| 91 | // Groep: groepsrunner offline, maintainer-runner online → wacht daar. |
| 92 | st = Advance([]Tier{remoteOff, remoteOn, builtin}, 0, time.Time{}, now, true) |
| 93 | if st.Builtin || st.Tier != 1 { |
| 94 | t.Fatalf("group fallback: %+v", st) |
| 95 | } |
| 96 | // Alles bezet en offline: rondje, eindigt weer bij een trede, start niets. |
| 97 | st = Advance([]Tier{builtin, remoteOff}, 0, time.Time{}, now, false) |
| 98 | if st.Builtin { |
| 99 | t.Fatalf("nothing free: %+v", st) |
| 100 | } |
| 101 | // Wrap: maintainer-runner timeout, builtin vol → terug naar de groepsrunner (online). |
| 102 | st = Advance([]Tier{remoteOn, builtin}, 1, now, now, false) |
| 103 | if st.Builtin || st.Tier != 0 { |
| 104 | t.Fatalf("wrap: %+v", st) |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | func TestTiersAndPrivacy(t *testing.T) { |
| 109 | dir := t.TempDir() |
| 110 | s, err := store.Open(filepath.Join(dir, "b.db"), make([]byte, 32)) |
| 111 | if err != nil { |
| 112 | t.Fatal(err) |
| 113 | } |
| 114 | defer s.Close() |
| 115 | ctx := context.Background() |
| 116 | tim, _ := s.UpsertUser(ctx, 1, "tim", "", false) |
| 117 | bob, _ := s.UpsertUser(ctx, 2, "bob", "", false) |
| 118 | carol, _ := s.UpsertUser(ctx, 3, "carol", "", false) |
| 119 | g, err := s.CreateGroup(ctx, tim.ID, "Team", "team", "", access.RoleReadonly) |
| 120 | if err != nil { |
| 121 | t.Fatal(err) |
| 122 | } |
| 123 | if err := s.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper); err != nil { |
| 124 | t.Fatal(err) |
| 125 | } |
| 126 | if err := s.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer); err != nil { |
| 127 | t.Fatal(err) |
| 128 | } |
| 129 | grepo, err := s.CreateRepo(ctx, "group", g.ID, "app", "", "master", "private") |
| 130 | if err != nil { |
| 131 | t.Fatal(err) |
| 132 | } |
| 133 | trepo, err := s.CreateRepo(ctx, "user", tim.ID, "secret", "", "master", "private") |
| 134 | if err != nil { |
| 135 | t.Fatal(err) |
| 136 | } |
| 137 | reg := func(kind string, id int64, name string) store.Runner { |
| 138 | tok, err := s.CreateRunnerRegToken(ctx, kind, id, id) |
| 139 | if err != nil { |
| 140 | t.Fatal(err) |
| 141 | } |
| 142 | rn, _, err := s.RegisterRunner(ctx, tok, name, "test") |
| 143 | if err != nil { |
| 144 | t.Fatal(err) |
| 145 | } |
| 146 | if _, _, err := s.RegisterRunner(ctx, tok, "again", "test"); err == nil { |
| 147 | t.Fatal("registration token reused") |
| 148 | } |
| 149 | return rn |
| 150 | } |
| 151 | grn := reg("group", g.ID, "grp") |
| 152 | bobRn := reg("user", bob.ID, "bob-pc") |
| 153 | carolRn := reg("user", carol.ID, "carol-pc") |
| 154 | timRn := reg("user", tim.ID, "tim-pc") |
| 155 | dave, _ := s.UpsertUser(ctx, 4, "dave", "", false) |
| 156 | reg("user", dave.ID, "dave-pc") |
| 157 | _ = s.SetRunnerOptIn(ctx, g.ID, dave.ID, true) // geen lid, geen leesrecht: telt niet |
| 158 | tiers, err := Tiers(ctx, s, grepo, false) |
| 159 | if err != nil { |
| 160 | t.Fatal(err) |
| 161 | } |
| 162 | eq(t, names(tiers), "grp", "builtin") |
| 163 | _ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, true) // lid (developer): telt |
| 164 | tiers, _ = Tiers(ctx, s, grepo, false) |
| 165 | eq(t, names(tiers), "grp", "bob-pc", "builtin") |
| 166 | // Ingetrokken lidmaatschap: meteen weg, ook al staat de toestemming nog. |
| 167 | if err := s.RemoveMember(ctx, "group", g.ID, "bob"); err != nil { |
| 168 | t.Fatal(err) |
| 169 | } |
| 170 | tiers, _ = Tiers(ctx, s, grepo, false) |
| 171 | eq(t, names(tiers), "grp", "builtin") |
| 172 | _ = s.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper) |
| 173 | _ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, false) |
| 174 | _ = s.SetRunnerOptIn(ctx, g.ID, carol.ID, true) // maintainer: telt |
| 175 | tiers, _ = Tiers(ctx, s, grepo, false) |
| 176 | eq(t, names(tiers), "grp", "carol-pc", "builtin") |
| 177 | _ = s.SetGroupBuiltinFirst(ctx, g.ID, true) |
| 178 | tiers, _ = Tiers(ctx, s, grepo, false) |
| 179 | eq(t, names(tiers), "builtin", "grp", "carol-pc") |
| 180 | |
| 181 | tiers, _ = Tiers(ctx, s, trepo, false) |
| 182 | eq(t, names(tiers), "builtin", "tim-pc") |
| 183 | _ = s.SetUserRunnerPref(ctx, tim.ID, store.RunnerPrefOwnFirst) |
| 184 | tiers, _ = Tiers(ctx, s, trepo, false) |
| 185 | eq(t, names(tiers), "tim-pc", "builtin") |
| 186 | |
| 187 | // Gepauzeerd: valt uit de volgorde, blijft in de lijst. |
| 188 | paused := true |
| 189 | if _, err := s.UpdateRunner(ctx, "user", carol.ID, carolRn.ID, nil, &paused); err != nil { |
| 190 | t.Fatal(err) |
| 191 | } |
| 192 | _ = s.SetGroupBuiltinFirst(ctx, g.ID, false) |
| 193 | tiers, _ = Tiers(ctx, s, grepo, false) |
| 194 | eq(t, names(tiers), "grp", "builtin") |
| 195 | if rs, _ := s.ListRunners(ctx, "user", carol.ID); len(rs) != 1 || !rs[0].Paused { |
| 196 | t.Fatal("paused runner listed") |
| 197 | } |
| 198 | if _, err := s.UpdateRunner(ctx, "user", tim.ID, carolRn.ID, nil, &paused); err == nil { |
| 199 | t.Fatal("tim paused carol's runner") |
| 200 | } |
| 201 | |
| 202 | r := &Runner{Store: s} |
| 203 | if !r.mayRun(ctx, grn, grepo, false) || r.mayRun(ctx, grn, trepo, false) { |
| 204 | t.Fatal("group runner scope") |
| 205 | } |
| 206 | if !r.mayRun(ctx, carolRn, grepo, false) || r.mayRun(ctx, carolRn, trepo, false) { |
| 207 | t.Fatal("carol scope") |
| 208 | } |
| 209 | if r.mayRun(ctx, bobRn, trepo, false) { |
| 210 | t.Fatal("bob may not run tim's private repo") |
| 211 | } |
| 212 | if !r.mayRun(ctx, timRn, trepo, false) { |
| 213 | t.Fatal("tim runs own repo") |
| 214 | } |
| 215 | // Ingetrokken runner verdwijnt uit de volgorde en zijn token werkt niet meer. |
| 216 | if err := s.RevokeRunner(ctx, "user", tim.ID, timRn.ID); err != nil { |
| 217 | t.Fatal(err) |
| 218 | } |
| 219 | tiers, _ = Tiers(ctx, s, trepo, false) |
| 220 | eq(t, names(tiers), "builtin") |
| 221 | } |