runner module: routing unit tests and e2e tests (builtin, separate runner, fallback)
@@ -0,0 +1,191 @@
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
_ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, true) // geen maintainer: telt niet
156
_ = s.SetRunnerOptIn(ctx, g.ID, carol.ID, true) // maintainer: telt
157
tiers, err := Tiers(ctx, s, grepo)
158
if err != nil {
159
t.Fatal(err)
160
}
161
eq(t, names(tiers), "grp", "carol-pc", "builtin")
162
_ = s.SetGroupBuiltinFirst(ctx, g.ID, true)
163
tiers, _ = Tiers(ctx, s, grepo)
164
eq(t, names(tiers), "builtin", "grp", "carol-pc")
165
166
tiers, _ = Tiers(ctx, s, trepo)
167
eq(t, names(tiers), "builtin", "tim-pc")
168
_ = s.SetUserRunnerPref(ctx, tim.ID, store.RunnerPrefOwnFirst)
169
tiers, _ = Tiers(ctx, s, trepo)
170
eq(t, names(tiers), "tim-pc", "builtin")
171
172
r := &Runner{Store: s}
173
if !r.mayRun(ctx, grn, grepo) || r.mayRun(ctx, grn, trepo) {
174
t.Fatal("group runner scope")
175
}
176
if !r.mayRun(ctx, carolRn, grepo) || r.mayRun(ctx, carolRn, trepo) {
177
t.Fatal("carol scope")
178
}
179
if r.mayRun(ctx, bobRn, trepo) {
180
t.Fatal("bob may not run tim's private repo")
181
}
182
if !r.mayRun(ctx, timRn, trepo) {
183
t.Fatal("tim runs own repo")
184
}
185
// Ingetrokken runner verdwijnt uit de volgorde en zijn token werkt niet meer.
186
if err := s.RevokeRunner(ctx, "user", tim.ID, timRn.ID); err != nil {
187
t.Fatal(err)
188
}
189
tiers, _ = Tiers(ctx, s, trepo)
190
eq(t, names(tiers), "builtin")
191
}
@@ -0,0 +1,191 @@1
package runner2
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 []string15
for _, t := range tiers {16
if t.Builtin {17
out = append(out, "builtin")18
continue19
}20
s := ""21
for i, r := range t.Runners {22
if i > 0 {23
s += "+"24
}25
s += r.Name26
}27
out = append(out, s)28
}29
return out30
}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 rn150
}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
_ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, true) // geen maintainer: telt niet156
_ = s.SetRunnerOptIn(ctx, g.ID, carol.ID, true) // maintainer: telt157
tiers, err := Tiers(ctx, s, grepo)158
if err != nil {159
t.Fatal(err)160
}161
eq(t, names(tiers), "grp", "carol-pc", "builtin")162
_ = s.SetGroupBuiltinFirst(ctx, g.ID, true)163
tiers, _ = Tiers(ctx, s, grepo)164
eq(t, names(tiers), "builtin", "grp", "carol-pc")165
166
tiers, _ = Tiers(ctx, s, trepo)167
eq(t, names(tiers), "builtin", "tim-pc")168
_ = s.SetUserRunnerPref(ctx, tim.ID, store.RunnerPrefOwnFirst)169
tiers, _ = Tiers(ctx, s, trepo)170
eq(t, names(tiers), "tim-pc", "builtin")171
172
r := &Runner{Store: s}173
if !r.mayRun(ctx, grn, grepo) || r.mayRun(ctx, grn, trepo) {174
t.Fatal("group runner scope")175
}176
if !r.mayRun(ctx, carolRn, grepo) || r.mayRun(ctx, carolRn, trepo) {177
t.Fatal("carol scope")178
}179
if r.mayRun(ctx, bobRn, trepo) {180
t.Fatal("bob may not run tim's private repo")181
}182
if !r.mayRun(ctx, timRn, trepo) {183
t.Fatal("tim runs own repo")184
}185
// Ingetrokken runner verdwijnt uit de volgorde en zijn token werkt niet meer.186
if err := s.RevokeRunner(ctx, "user", tim.ID, timRn.ID); err != nil {187
t.Fatal(err)188
}189
tiers, _ = Tiers(ctx, s, trepo)190
eq(t, names(tiers), "builtin")191
}@@ -0,0 +1,320 @@
1
package server
2
3
import (
4
"context"
5
"encoding/json"
6
"io"
7
"log/slog"
8
"net/http"
9
"net/http/httptest"
10
"os"
11
"os/exec"
12
"path/filepath"
13
"runtime"
14
"strings"
15
"testing"
16
"time"
17
18
"gitlab.com/Timfa/bluegit/internal/auth"
19
"gitlab.com/Timfa/bluegit/internal/config"
20
"gitlab.com/Timfa/bluegit/internal/gitrepo"
21
"gitlab.com/Timfa/bluegit/internal/runner"
22
"gitlab.com/Timfa/bluegit/internal/store"
23
)
24
25
// fakeDocker voert "docker run ... sh /workspace/.bluegit-job.sh" lokaal
26
// uit in de gemounte werkmap. Andere docker-commando's slagen stil.
27
const fakeDocker = `#!/bin/sh
28
[ "$1" = run ] || exit 0
29
shift
30
work=
31
while [ $# -gt 0 ]; do
32
case "$1" in
33
-v) work="${2%%:/workspace}"; shift 2;;
34
--network|-w|-e|--entrypoint|--name|--network-alias) shift 2;;
35
--rm|-d) shift;;
36
*) break;;
37
esac
38
done
39
cd "$work" || exit 1
40
sed "s#^cd /workspace\$#cd \"$work\"#" .bluegit-job.sh > .fake-job.sh
41
exec sh .fake-job.sh
42
`
43
44
type ciEnv struct {
45
t *testing.T
46
st *store.Store
47
srv *Server
48
ts *httptest.Server
49
rn *runner.Runner
50
repo store.Repo
51
sha string
52
docker string
53
user store.User
54
}
55
56
func newCIEnv(t *testing.T) *ciEnv {
57
t.Helper()
58
if runtime.GOOS == "windows" {
59
t.Skip("sh nodig")
60
}
61
for _, bin := range []string{"git", "sh", "sed"} {
62
if _, err := exec.LookPath(bin); err != nil {
63
t.Skip(bin + " ontbreekt")
64
}
65
}
66
storage := t.TempDir()
67
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
68
if err != nil {
69
t.Fatal(err)
70
}
71
t.Cleanup(func() { _ = st.Close() })
72
docker := filepath.Join(t.TempDir(), "docker")
73
if err := os.WriteFile(docker, []byte(fakeDocker), 0o755); err != nil {
74
t.Fatal(err)
75
}
76
cfg := config.Config{
77
Listen: "127.0.0.1:0", StoragePath: storage,
78
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
79
Git: config.Git{Binary: "git", DefaultBranch: "master"},
80
CI: config.CI{Enabled: true, Docker: docker},
81
}
82
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
83
ts := httptest.NewUnstartedServer(nil)
84
ts.Start()
85
t.Cleanup(ts.Close)
86
srv.Cfg.BaseURL = ts.URL
87
rn := &runner.Runner{
88
Store: st, GitBin: "git", Docker: docker, Storage: storage, BaseURL: ts.URL, Network: "bridge",
89
Name: "BlueGit runner", Timeout: time.Minute, Log: slog.New(slog.NewTextHandler(io.Discard, nil)),
90
}
91
srv.Runner = rn
92
ts.Config.Handler = srv.Handler()
93
94
ctx := context.Background()
95
tim, err := st.UpsertUser(ctx, 1, "tim", "", false)
96
if err != nil {
97
t.Fatal(err)
98
}
99
repo, err := st.CreateRepo(ctx, "user", tim.ID, "app", "", "master", "private")
100
if err != nil {
101
t.Fatal(err)
102
}
103
bare := gitrepo.Dir(storage, repo.OwnerPath, repo.Name)
104
if err := gitrepo.Init("git", bare, "master", "/bin/true"); err != nil {
105
t.Fatal(err)
106
}
107
src := t.TempDir()
108
run := func(dir string, args ...string) string {
109
cmd := exec.Command("git", args...)
110
cmd.Dir = dir
111
cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
112
out, err := cmd.CombinedOutput()
113
if err != nil {
114
t.Fatalf("git %v: %v %s", args, err, out)
115
}
116
return strings.TrimSpace(string(out))
117
}
118
run(src, "init", "-q", "-b", "master")
119
_ = os.WriteFile(filepath.Join(src, "README.md"), []byte("hello from the repo\n"), 0o644)
120
run(src, "add", ".")
121
run(src, "commit", "-qm", "init")
122
run(src, "push", "-q", bare, "master")
123
sha := run(src, "rev-parse", "HEAD")
124
return &ciEnv{t: t, st: st, srv: srv, ts: ts, rn: rn, repo: repo, sha: sha, docker: docker, user: tim}
125
}
126
127
func (e *ciEnv) pipeline() int64 {
128
e.t.Helper()
129
id, err := e.st.CreatePipeline(context.Background(), e.repo.ID, e.sha, "refs/heads/master", "push", "tim", "init", []store.NewJob{
130
{Name: "build", Stage: "build", Position: 0, Image: "alpine:3.20", Script: "cat README.md\necho built-artifact > out.txt\necho \"token-set=${CI_JOB_TOKEN:+yes}\"", ArtifactPaths: []string{"out.txt"}},
131
{Name: "test", Stage: "test", Position: 1, Image: "alpine:3.20", Script: "echo got: $(cat out.txt)", Needs: []string{"build"}, NeedsSet: true},
132
})
133
if err != nil {
134
e.t.Fatal(err)
135
}
136
return id
137
}
138
139
// tick draait de planner tot de pipeline klaar is.
140
func (e *ciEnv) wait(pid int64, limit time.Duration) store.Pipeline {
141
e.t.Helper()
142
ctx := context.Background()
143
deadline := time.Now().Add(limit)
144
for time.Now().Before(deadline) {
145
e.rn.Tick(ctx)
146
p, err := e.st.PipelineByID(ctx, e.repo.ID, pid)
147
if err != nil {
148
e.t.Fatal(err)
149
}
150
if p.Status == "success" || p.Status == "failed" || p.Status == "canceled" {
151
return p
152
}
153
time.Sleep(200 * time.Millisecond)
154
}
155
jobs, _ := e.st.JobsByPipeline(ctx, pid)
156
for _, j := range jobs {
157
e.t.Logf("job %s %s\n%s", j.Name, j.Status, j.Log)
158
}
159
e.t.Fatalf("pipeline %d not finished", pid)
160
return store.Pipeline{}
161
}
162
163
func (e *ciEnv) checkJobs(pid int64, wantRunner string, remote bool) {
164
e.t.Helper()
165
ctx := context.Background()
166
jobs, _ := e.st.JobsByPipeline(ctx, pid)
167
if len(jobs) != 2 {
168
e.t.Fatalf("jobs: %d", len(jobs))
169
}
170
for _, j := range jobs {
171
if j.Status != "success" {
172
e.t.Fatalf("job %s: %s\n%s", j.Name, j.Status, j.Log)
173
}
174
jr := e.st.JobRun(ctx, j.ID)
175
if jr.RunnerName != wantRunner || (jr.RunnerID > 0) != remote {
176
e.t.Fatalf("job %s ran on %+v, want %s remote=%v", j.Name, jr, wantRunner, remote)
177
}
178
}
179
if !strings.Contains(jobs[0].Log, "hello from the repo") || !strings.Contains(jobs[0].Log, "token-set=yes") {
180
e.t.Fatalf("build log:\n%s", jobs[0].Log)
181
}
182
if strings.Contains(jobs[0].Log, "bgj_") {
183
e.t.Fatalf("job token leaked in log:\n%s", jobs[0].Log)
184
}
185
if !strings.Contains(jobs[1].Log, "got: built-artifact") {
186
e.t.Fatalf("test log (artifact niet doorgegeven):\n%s", jobs[1].Log)
187
}
188
if !strings.Contains(jobs[0].Log, wantRunner) {
189
e.t.Fatalf("runner name not in log:\n%s", jobs[0].Log)
190
}
191
// API toont de runner.
192
if js := e.srv.jobJSON(ctx, jobs[0]); js["runner"] == nil {
193
e.t.Fatal("jobJSON without runner")
194
}
195
}
196
197
// De ingebouwde runner werkt nog zoals voorheen.
198
func TestBuiltinRunnerStillWorks(t *testing.T) {
199
e := newCIEnv(t)
200
pid := e.pipeline()
201
p := e.wait(pid, 60*time.Second)
202
if p.Status != "success" {
203
t.Fatalf("pipeline %s", p.Status)
204
}
205
e.checkJobs(pid, "BlueGit runner", false)
206
}
207
208
func buildRunnerBinary(t *testing.T) string {
209
t.Helper()
210
if _, err := exec.LookPath("go"); err != nil {
211
t.Skip("go ontbreekt")
212
}
213
bin := filepath.Join(t.TempDir(), "bluegit-runner")
214
cmd := exec.Command("go", "build", "-o", bin, "../../cmd/bluegit-runner")
215
if out, err := cmd.CombinedOutput(); err != nil {
216
t.Fatalf("build bluegit-runner: %v %s", err, out)
217
}
218
return bin
219
}
220
221
// De aparte bluegit-runner registreert zich echt en draait de jobs.
222
func TestSeparateRunnerEndToEnd(t *testing.T) {
223
e := newCIEnv(t)
224
bin := buildRunnerBinary(t)
225
ctx := context.Background()
226
if err := e.st.SetUserRunnerPref(ctx, e.user.ID, store.RunnerPrefOwnFirst); err != nil {
227
t.Fatal(err)
228
}
229
reg, err := e.st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)
230
if err != nil {
231
t.Fatal(err)
232
}
233
cfgDir := t.TempDir()
234
cfgPath := filepath.Join(cfgDir, "config.yml")
235
work := t.TempDir()
236
if err := os.WriteFile(cfgPath, []byte("docker: "+e.docker+"\nwork_dir: "+work+"\n"), 0o600); err != nil {
237
t.Fatal(err)
238
}
239
out, err := exec.Command(bin, "register", "--url", e.ts.URL, "--token", reg, "--name", "tim-laptop", "--config", cfgPath).CombinedOutput()
240
if err != nil {
241
t.Fatalf("register: %v %s", err, out)
242
}
243
cfgB, _ := os.ReadFile(cfgPath)
244
if !strings.Contains(string(cfgB), "bgr_") || !strings.Contains(string(cfgB), e.docker) {
245
t.Fatalf("config not written correctly")
246
}
247
// Het registratietoken is eenmalig.
248
if out, err := exec.Command(bin, "register", "--url", e.ts.URL, "--token", reg, "--config", filepath.Join(cfgDir, "b.yml")).CombinedOutput(); err == nil {
249
t.Fatalf("second registration succeeded: %s", out)
250
}
251
// Zonder lopende job mag het runner-token niet clonen.
252
var tok string
253
for _, line := range strings.Split(string(cfgB), "\n") {
254
if strings.HasPrefix(line, "token: ") {
255
tok = strings.TrimSpace(strings.TrimPrefix(line, "token: "))
256
}
257
}
258
req, _ := http.NewRequest(http.MethodGet, e.ts.URL+"/tim/app.git/info/refs?service=git-upload-pack", nil)
259
req.Header.Set("Authorization", "Bearer "+tok)
260
if res, err := http.DefaultClient.Do(req); err != nil || res.StatusCode == http.StatusOK {
261
t.Fatalf("runner token cloned without a job: %v", err)
262
}
263
264
runCtx, stop := context.WithCancel(ctx)
265
defer stop()
266
cmd := exec.CommandContext(runCtx, bin, "run", "--config", cfgPath)
267
var logs strings.Builder
268
cmd.Stdout, cmd.Stderr = &logs, &logs
269
if err := cmd.Start(); err != nil {
270
t.Fatal(err)
271
}
272
defer func() { stop(); _ = cmd.Wait(); t.Logf("runner output:\n%s", logs.String()) }()
273
274
pid := e.pipeline()
275
p := e.wait(pid, 90*time.Second)
276
if p.Status != "success" {
277
jobs, _ := e.st.JobsByPipeline(ctx, pid)
278
for _, j := range jobs {
279
t.Logf("%s %s\n%s", j.Name, j.Status, j.Log)
280
}
281
t.Fatalf("pipeline %s", p.Status)
282
}
283
e.checkJobs(pid, "tim-laptop", true)
284
rs, _ := e.st.ListRunners(ctx, "user", e.user.ID)
285
if len(rs) != 1 || !rs[0].Online(time.Now()) {
286
t.Fatalf("runner status: %+v", rs)
287
}
288
// Artifact van de remote job staat op de server.
289
jobs, _ := e.st.JobsByPipeline(ctx, pid)
290
if path, err := e.st.ArtifactPath(ctx, pid, jobs[0].Name, "out.txt"); err != nil {
291
t.Fatal(err)
292
} else if b, _ := os.ReadFile(path); strings.TrimSpace(string(b)) != "built-artifact" {
293
t.Fatalf("artifact: %q", b)
294
}
295
// Beheer-UI en API: de jobpagina-JSON noemt de runner.
296
js, _ := json.Marshal(e.srv.jobJSON(ctx, jobs[1]))
297
if !strings.Contains(string(js), `"tim-laptop"`) || !strings.Contains(string(js), `"remote"`) {
298
t.Fatalf("jobJSON: %s", js)
299
}
300
}
301
302
// Een runner die de job niet oppakt: na de wachttijd neemt de BlueGit-runner het over.
303
func TestSeparateRunnerFallback(t *testing.T) {
304
e := newCIEnv(t)
305
ctx := context.Background()
306
old := runner.OfferTimeout
307
runner.OfferTimeout = time.Second
308
t.Cleanup(func() { runner.OfferTimeout = old })
309
_ = e.st.SetUserRunnerPref(ctx, e.user.ID, store.RunnerPrefOwnFirst)
310
reg, _ := e.st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)
311
if _, _, err := e.st.RegisterRunner(ctx, reg, "silent", "test"); err != nil {
312
t.Fatal(err)
313
}
314
pid := e.pipeline()
315
p := e.wait(pid, 60*time.Second)
316
if p.Status != "success" {
317
t.Fatalf("pipeline %s", p.Status)
318
}
319
e.checkJobs(pid, "BlueGit runner", false)
320
}
@@ -0,0 +1,320 @@1
package server2
3
import (4
"context"5
"encoding/json"6
"io"7
"log/slog"8
"net/http"9
"net/http/httptest"10
"os"11
"os/exec"12
"path/filepath"13
"runtime"14
"strings"15
"testing"16
"time"17
18
"gitlab.com/Timfa/bluegit/internal/auth"19
"gitlab.com/Timfa/bluegit/internal/config"20
"gitlab.com/Timfa/bluegit/internal/gitrepo"21
"gitlab.com/Timfa/bluegit/internal/runner"22
"gitlab.com/Timfa/bluegit/internal/store"23
)24
25
// fakeDocker voert "docker run ... sh /workspace/.bluegit-job.sh" lokaal26
// uit in de gemounte werkmap. Andere docker-commando's slagen stil.27
const fakeDocker = `#!/bin/sh28
[ "$1" = run ] || exit 029
shift30
work=31
while [ $# -gt 0 ]; do32
case "$1" in33
-v) work="${2%%:/workspace}"; shift 2;;34
--network|-w|-e|--entrypoint|--name|--network-alias) shift 2;;35
--rm|-d) shift;;36
*) break;;37
esac38
done39
cd "$work" || exit 140
sed "s#^cd /workspace\$#cd \"$work\"#" .bluegit-job.sh > .fake-job.sh41
exec sh .fake-job.sh42
`43
44
type ciEnv struct {45
t *testing.T46
st *store.Store47
srv *Server48
ts *httptest.Server49
rn *runner.Runner50
repo store.Repo51
sha string52
docker string53
user store.User54
}55
56
func newCIEnv(t *testing.T) *ciEnv {57
t.Helper()58
if runtime.GOOS == "windows" {59
t.Skip("sh nodig")60
}61
for _, bin := range []string{"git", "sh", "sed"} {62
if _, err := exec.LookPath(bin); err != nil {63
t.Skip(bin + " ontbreekt")64
}65
}66
storage := t.TempDir()67
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())68
if err != nil {69
t.Fatal(err)70
}71
t.Cleanup(func() { _ = st.Close() })72
docker := filepath.Join(t.TempDir(), "docker")73
if err := os.WriteFile(docker, []byte(fakeDocker), 0o755); err != nil {74
t.Fatal(err)75
}76
cfg := config.Config{77
Listen: "127.0.0.1:0", StoragePath: storage,78
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},79
Git: config.Git{Binary: "git", DefaultBranch: "master"},80
CI: config.CI{Enabled: true, Docker: docker},81
}82
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}83
ts := httptest.NewUnstartedServer(nil)84
ts.Start()85
t.Cleanup(ts.Close)86
srv.Cfg.BaseURL = ts.URL87
rn := &runner.Runner{88
Store: st, GitBin: "git", Docker: docker, Storage: storage, BaseURL: ts.URL, Network: "bridge",89
Name: "BlueGit runner", Timeout: time.Minute, Log: slog.New(slog.NewTextHandler(io.Discard, nil)),90
}91
srv.Runner = rn92
ts.Config.Handler = srv.Handler()93
94
ctx := context.Background()95
tim, err := st.UpsertUser(ctx, 1, "tim", "", false)96
if err != nil {97
t.Fatal(err)98
}99
repo, err := st.CreateRepo(ctx, "user", tim.ID, "app", "", "master", "private")100
if err != nil {101
t.Fatal(err)102
}103
bare := gitrepo.Dir(storage, repo.OwnerPath, repo.Name)104
if err := gitrepo.Init("git", bare, "master", "/bin/true"); err != nil {105
t.Fatal(err)106
}107
src := t.TempDir()108
run := func(dir string, args ...string) string {109
cmd := exec.Command("git", args...)110
cmd.Dir = dir111
cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")112
out, err := cmd.CombinedOutput()113
if err != nil {114
t.Fatalf("git %v: %v %s", args, err, out)115
}116
return strings.TrimSpace(string(out))117
}118
run(src, "init", "-q", "-b", "master")119
_ = os.WriteFile(filepath.Join(src, "README.md"), []byte("hello from the repo\n"), 0o644)120
run(src, "add", ".")121
run(src, "commit", "-qm", "init")122
run(src, "push", "-q", bare, "master")123
sha := run(src, "rev-parse", "HEAD")124
return &ciEnv{t: t, st: st, srv: srv, ts: ts, rn: rn, repo: repo, sha: sha, docker: docker, user: tim}125
}126
127
func (e *ciEnv) pipeline() int64 {128
e.t.Helper()129
id, err := e.st.CreatePipeline(context.Background(), e.repo.ID, e.sha, "refs/heads/master", "push", "tim", "init", []store.NewJob{130
{Name: "build", Stage: "build", Position: 0, Image: "alpine:3.20", Script: "cat README.md\necho built-artifact > out.txt\necho \"token-set=${CI_JOB_TOKEN:+yes}\"", ArtifactPaths: []string{"out.txt"}},131
{Name: "test", Stage: "test", Position: 1, Image: "alpine:3.20", Script: "echo got: $(cat out.txt)", Needs: []string{"build"}, NeedsSet: true},132
})133
if err != nil {134
e.t.Fatal(err)135
}136
return id137
}138
139
// tick draait de planner tot de pipeline klaar is.140
func (e *ciEnv) wait(pid int64, limit time.Duration) store.Pipeline {141
e.t.Helper()142
ctx := context.Background()143
deadline := time.Now().Add(limit)144
for time.Now().Before(deadline) {145
e.rn.Tick(ctx)146
p, err := e.st.PipelineByID(ctx, e.repo.ID, pid)147
if err != nil {148
e.t.Fatal(err)149
}150
if p.Status == "success" || p.Status == "failed" || p.Status == "canceled" {151
return p152
}153
time.Sleep(200 * time.Millisecond)154
}155
jobs, _ := e.st.JobsByPipeline(ctx, pid)156
for _, j := range jobs {157
e.t.Logf("job %s %s\n%s", j.Name, j.Status, j.Log)158
}159
e.t.Fatalf("pipeline %d not finished", pid)160
return store.Pipeline{}161
}162
163
func (e *ciEnv) checkJobs(pid int64, wantRunner string, remote bool) {164
e.t.Helper()165
ctx := context.Background()166
jobs, _ := e.st.JobsByPipeline(ctx, pid)167
if len(jobs) != 2 {168
e.t.Fatalf("jobs: %d", len(jobs))169
}170
for _, j := range jobs {171
if j.Status != "success" {172
e.t.Fatalf("job %s: %s\n%s", j.Name, j.Status, j.Log)173
}174
jr := e.st.JobRun(ctx, j.ID)175
if jr.RunnerName != wantRunner || (jr.RunnerID > 0) != remote {176
e.t.Fatalf("job %s ran on %+v, want %s remote=%v", j.Name, jr, wantRunner, remote)177
}178
}179
if !strings.Contains(jobs[0].Log, "hello from the repo") || !strings.Contains(jobs[0].Log, "token-set=yes") {180
e.t.Fatalf("build log:\n%s", jobs[0].Log)181
}182
if strings.Contains(jobs[0].Log, "bgj_") {183
e.t.Fatalf("job token leaked in log:\n%s", jobs[0].Log)184
}185
if !strings.Contains(jobs[1].Log, "got: built-artifact") {186
e.t.Fatalf("test log (artifact niet doorgegeven):\n%s", jobs[1].Log)187
}188
if !strings.Contains(jobs[0].Log, wantRunner) {189
e.t.Fatalf("runner name not in log:\n%s", jobs[0].Log)190
}191
// API toont de runner.192
if js := e.srv.jobJSON(ctx, jobs[0]); js["runner"] == nil {193
e.t.Fatal("jobJSON without runner")194
}195
}196
197
// De ingebouwde runner werkt nog zoals voorheen.198
func TestBuiltinRunnerStillWorks(t *testing.T) {199
e := newCIEnv(t)200
pid := e.pipeline()201
p := e.wait(pid, 60*time.Second)202
if p.Status != "success" {203
t.Fatalf("pipeline %s", p.Status)204
}205
e.checkJobs(pid, "BlueGit runner", false)206
}207
208
func buildRunnerBinary(t *testing.T) string {209
t.Helper()210
if _, err := exec.LookPath("go"); err != nil {211
t.Skip("go ontbreekt")212
}213
bin := filepath.Join(t.TempDir(), "bluegit-runner")214
cmd := exec.Command("go", "build", "-o", bin, "../../cmd/bluegit-runner")215
if out, err := cmd.CombinedOutput(); err != nil {216
t.Fatalf("build bluegit-runner: %v %s", err, out)217
}218
return bin219
}220
221
// De aparte bluegit-runner registreert zich echt en draait de jobs.222
func TestSeparateRunnerEndToEnd(t *testing.T) {223
e := newCIEnv(t)224
bin := buildRunnerBinary(t)225
ctx := context.Background()226
if err := e.st.SetUserRunnerPref(ctx, e.user.ID, store.RunnerPrefOwnFirst); err != nil {227
t.Fatal(err)228
}229
reg, err := e.st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)230
if err != nil {231
t.Fatal(err)232
}233
cfgDir := t.TempDir()234
cfgPath := filepath.Join(cfgDir, "config.yml")235
work := t.TempDir()236
if err := os.WriteFile(cfgPath, []byte("docker: "+e.docker+"\nwork_dir: "+work+"\n"), 0o600); err != nil {237
t.Fatal(err)238
}239
out, err := exec.Command(bin, "register", "--url", e.ts.URL, "--token", reg, "--name", "tim-laptop", "--config", cfgPath).CombinedOutput()240
if err != nil {241
t.Fatalf("register: %v %s", err, out)242
}243
cfgB, _ := os.ReadFile(cfgPath)244
if !strings.Contains(string(cfgB), "bgr_") || !strings.Contains(string(cfgB), e.docker) {245
t.Fatalf("config not written correctly")246
}247
// Het registratietoken is eenmalig.248
if out, err := exec.Command(bin, "register", "--url", e.ts.URL, "--token", reg, "--config", filepath.Join(cfgDir, "b.yml")).CombinedOutput(); err == nil {249
t.Fatalf("second registration succeeded: %s", out)250
}251
// Zonder lopende job mag het runner-token niet clonen.252
var tok string253
for _, line := range strings.Split(string(cfgB), "\n") {254
if strings.HasPrefix(line, "token: ") {255
tok = strings.TrimSpace(strings.TrimPrefix(line, "token: "))256
}257
}258
req, _ := http.NewRequest(http.MethodGet, e.ts.URL+"/tim/app.git/info/refs?service=git-upload-pack", nil)259
req.Header.Set("Authorization", "Bearer "+tok)260
if res, err := http.DefaultClient.Do(req); err != nil || res.StatusCode == http.StatusOK {261
t.Fatalf("runner token cloned without a job: %v", err)262
}263
264
runCtx, stop := context.WithCancel(ctx)265
defer stop()266
cmd := exec.CommandContext(runCtx, bin, "run", "--config", cfgPath)267
var logs strings.Builder268
cmd.Stdout, cmd.Stderr = &logs, &logs269
if err := cmd.Start(); err != nil {270
t.Fatal(err)271
}272
defer func() { stop(); _ = cmd.Wait(); t.Logf("runner output:\n%s", logs.String()) }()273
274
pid := e.pipeline()275
p := e.wait(pid, 90*time.Second)276
if p.Status != "success" {277
jobs, _ := e.st.JobsByPipeline(ctx, pid)278
for _, j := range jobs {279
t.Logf("%s %s\n%s", j.Name, j.Status, j.Log)280
}281
t.Fatalf("pipeline %s", p.Status)282
}283
e.checkJobs(pid, "tim-laptop", true)284
rs, _ := e.st.ListRunners(ctx, "user", e.user.ID)285
if len(rs) != 1 || !rs[0].Online(time.Now()) {286
t.Fatalf("runner status: %+v", rs)287
}288
// Artifact van de remote job staat op de server.289
jobs, _ := e.st.JobsByPipeline(ctx, pid)290
if path, err := e.st.ArtifactPath(ctx, pid, jobs[0].Name, "out.txt"); err != nil {291
t.Fatal(err)292
} else if b, _ := os.ReadFile(path); strings.TrimSpace(string(b)) != "built-artifact" {293
t.Fatalf("artifact: %q", b)294
}295
// Beheer-UI en API: de jobpagina-JSON noemt de runner.296
js, _ := json.Marshal(e.srv.jobJSON(ctx, jobs[1]))297
if !strings.Contains(string(js), `"tim-laptop"`) || !strings.Contains(string(js), `"remote"`) {298
t.Fatalf("jobJSON: %s", js)299
}300
}301
302
// Een runner die de job niet oppakt: na de wachttijd neemt de BlueGit-runner het over.303
func TestSeparateRunnerFallback(t *testing.T) {304
e := newCIEnv(t)305
ctx := context.Background()306
old := runner.OfferTimeout307
runner.OfferTimeout = time.Second308
t.Cleanup(func() { runner.OfferTimeout = old })309
_ = e.st.SetUserRunnerPref(ctx, e.user.ID, store.RunnerPrefOwnFirst)310
reg, _ := e.st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)311
if _, _, err := e.st.RegisterRunner(ctx, reg, "silent", "test"); err != nil {312
t.Fatal(err)313
}314
pid := e.pipeline()315
p := e.wait(pid, 60*time.Second)316
if p.Status != "success" {317
t.Fatalf("pipeline %s", p.Status)318
}319
e.checkJobs(pid, "BlueGit runner", false)320
}