BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing_test.go

routing_test.go

routing_test.go 7.4 KiB Download Raw
1package runner
2
3import (
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
13func 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
32func 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
44func 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
58func 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
108func 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}