BlueGit

timfa bluegit

Files

bluegit / scripts / aur_test.go

aur_test.go

fix: geef de bouwgebruiker een homedir en een cache in de werkmap
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
1c1a6b9b History
aur_test.go 17.1 KiB Download Raw
1package scripts
2
3import (
4 "os"
5 "os/exec"
6 "path/filepath"
7 "strings"
8 "testing"
9)
10
11func TestRewritePkgbuild(t *testing.T) {
12 root := filepath.Join("..")
13 for _, name := range []string{"publish-aur.sh", "aur-ssh-setup.sh", "aur-common.sh", "aur-publish-local.sh"} {
14 cmd := exec.Command("bash", "-n", filepath.Join(root, "scripts", name))
15 if out, err := cmd.CombinedOutput(); err != nil {
16 t.Fatalf("%s: %v %s", name, err, out)
17 }
18 }
19 publish, err := os.ReadFile(filepath.Join(root, "scripts", "publish-aur.sh"))
20 if err != nil {
21 t.Fatal(err)
22 }
23 if strings.Contains(string(publish), "CI_JOB_TOKEN") || strings.Contains(string(publish), "JOB-TOKEN") {
24 t.Fatal("het archief hoort anoniem opgehaald te worden")
25 }
26 dir := t.TempDir()
27 src, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "PKGBUILD"))
28 if err != nil {
29 t.Fatal(err)
30 }
31 dest := filepath.Join(dir, "PKGBUILD")
32 if err := os.WriteFile(dest, src, 0o644); err != nil {
33 t.Fatal(err)
34 }
35 version, commit, sum := "20261022183000", "0123456789abcdef0123456789abcdef01234567", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
36 cmd := exec.Command("bash", filepath.Join(root, "scripts", "publish-aur.sh"), "--rewrite-only", version, commit, sum, dest)
37 if out, err := cmd.CombinedOutput(); err != nil {
38 t.Fatalf("rewrite: %v %s", err, out)
39 }
40 got, err := os.ReadFile(dest)
41 if err != nil {
42 t.Fatal(err)
43 }
44 text := string(got)
45 for _, want := range []string{
46 "pkgver=" + version,
47 "pkgrel=1",
48 "_commit=" + commit,
49 "sha256sums=('" + sum + "')",
50 "https://gitlab.com/Timfa/bluegit/-/archive/${_commit}/bluegit-${_commit}.tar.gz",
51 } {
52 if !strings.Contains(text, want) {
53 t.Fatalf("mist %q in\n%s", want, text)
54 }
55 }
56 hook, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "bluegit.install"))
57 if err != nil {
58 t.Fatal(err)
59 }
60 hookText := string(hook)
61 for _, want := range []string{
62 "systemd-sysusers bluegit.conf",
63 "systemd-tmpfiles --create",
64 "systemctl daemon-reload",
65 "enable --now bluegit.service",
66 "try-restart bluegit.service",
67 "disable --now bluegit.service",
68 "pre_remove",
69 "/etc/bluegit/config.yml",
70 "/etc/bluegit/client_secret",
71 "BLUEGIT_AUTH_CLIENT_SECRET",
72 "/run/systemd/system",
73 "User=bluegit",
74 } {
75 if !strings.Contains(hookText, want) {
76 t.Fatalf("hook mist %q", want)
77 }
78 }
79 if strings.Contains(hookText, "rm ") {
80 t.Fatal("hook hoort geen bestanden te verwijderen")
81 }
82 installBody, ok := shellFunc(hookText, "post_install")
83 if !ok || !strings.Contains(installBody, "enable --now bluegit.service") || !strings.Contains(installBody, "systemd-tmpfiles --create") {
84 t.Fatal("post_install start de service niet of maakt de homedir niet")
85 }
86 upgradeBody, ok := shellFunc(hookText, "post_upgrade")
87 if !ok || strings.Contains(upgradeBody, "post_install") || !strings.Contains(upgradeBody, "try-restart bluegit.service") {
88 t.Fatalf("post_upgrade hoort alleen te herstarten:\n%s", upgradeBody)
89 }
90 removeBody, ok := shellFunc(hookText, "pre_remove")
91 if !ok || !strings.Contains(removeBody, "disable --now bluegit.service") {
92 t.Fatal("pre_remove zet de service niet uit")
93 }
94 local, err := os.ReadFile(filepath.Join(root, "scripts", "aur-publish-local.sh"))
95 if err != nil {
96 t.Fatal(err)
97 }
98 for _, bad := range []string{"CI_COMMIT_SHA", "CI_JOB_TOKEN", "JOB-TOKEN", "AUR_SSH_PRIVATE_KEY", "AUR_GIT_AUTHOR", "GIT_SSH_COMMAND", "aur-ssh-setup"} {
99 if strings.Contains(string(local), bad) {
100 t.Fatalf("lokaal script noemt %s", bad)
101 }
102 }
103}
104
105func shellFunc(script, name string) (string, bool) {
106 marker := name + "() {"
107 i := strings.Index(script, marker)
108 if i < 0 {
109 return "", false
110 }
111 rest := script[i+len(marker):]
112 depth := 1
113 for j, r := range rest {
114 switch r {
115 case '{':
116 depth++
117 case '}':
118 depth--
119 if depth == 0 {
120 return rest[:j], true
121 }
122 }
123 }
124 return "", false
125}
126
127func scriptEnv(extra ...string) []string {
128 skip := []string{
129 "GIT_AUTHOR_", "GIT_COMMITTER_", "GIT_DIR=", "GIT_WORK_TREE=",
130 "GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_",
131 "GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM=",
132 }
133 out := make([]string, 0, len(os.Environ())+len(extra))
134 for _, e := range os.Environ() {
135 drop := false
136 for _, p := range skip {
137 if strings.HasPrefix(e, p) {
138 drop = true
139 break
140 }
141 }
142 if !drop {
143 out = append(out, e)
144 }
145 }
146 return append(out, extra...)
147}
148
149func runCmd(t *testing.T, dir string, env []string, name string, args ...string) string {
150 t.Helper()
151 cmd := exec.Command(name, args...)
152 if dir != "" {
153 cmd.Dir = dir
154 }
155 cmd.Env = env
156 out, err := cmd.CombinedOutput()
157 if err != nil {
158 t.Fatalf("%s %v: %v\n%s", name, args, err, out)
159 }
160 return string(out)
161}
162
163func initPublishedMaster(t *testing.T, env []string) string {
164 t.Helper()
165 root := t.TempDir()
166 repo := filepath.Join(root, "repo")
167 bare := filepath.Join(root, "origin.git")
168 if err := os.MkdirAll(repo, 0o755); err != nil {
169 t.Fatal(err)
170 }
171 runCmd(t, repo, env, "git", "init", "-b", "master")
172 runCmd(t, repo, env, "git", "config", "user.name", "Test")
173 runCmd(t, repo, env, "git", "config", "user.email", "test@example.com")
174 if err := os.WriteFile(filepath.Join(repo, "README"), []byte("x\n"), 0o644); err != nil {
175 t.Fatal(err)
176 }
177 runCmd(t, repo, env, "git", "add", "README")
178 runCmd(t, repo, env, "git", "commit", "-m", "init")
179 runCmd(t, root, env, "git", "init", "--bare", "-b", "master", bare)
180 runCmd(t, repo, env, "git", "remote", "add", "origin", bare)
181 runCmd(t, repo, env, "git", "push", "-u", "origin", "master")
182 return repo
183}
184
185func TestAurCommitPublished(t *testing.T) {
186 dir := t.TempDir()
187 pkg := filepath.Join(dir, "PKGBUILD")
188 sha := "0123456789abcdef0123456789abcdef01234567"
189 if err := os.WriteFile(pkg, []byte("pkgver=1\npkgrel=1\n_commit="+sha+"\n"), 0o644); err != nil {
190 t.Fatal(err)
191 }
192 common := filepath.Join("..", "scripts", "aur-common.sh")
193 ask := func(commit, file string) string {
194 t.Helper()
195 cmd := exec.Command("bash", "-c", `source "$1"; if aur_commit_published "$2" "$3"; then echo yes; else echo no; fi`, "bash", common, file, commit)
196 out, err := cmd.CombinedOutput()
197 if err != nil {
198 t.Fatalf("aur_commit_published: %v %s", err, out)
199 }
200 return strings.TrimSpace(string(out))
201 }
202 if ask(sha, pkg) != "yes" {
203 t.Fatal("bekende sha hoort al gepubliceerd te zijn")
204 }
205 if ask("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", pkg) != "no" {
206 t.Fatal("andere sha hoort nog niet gepubliceerd te zijn")
207 }
208 if ask(sha, filepath.Join(dir, "missing")) != "no" {
209 t.Fatal("ontbrekende PKGBUILD is niet gepubliceerd")
210 }
211}
212
213func TestCopyPackagingAur(t *testing.T) {
214 src := t.TempDir()
215 dest := t.TempDir()
216 for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} {
217 if err := os.WriteFile(filepath.Join(src, name), []byte(name+"\n"), 0o644); err != nil {
218 t.Fatal(err)
219 }
220 }
221 script := filepath.Join("..", "scripts", "aur-publish-local.sh")
222 cmd := exec.Command("bash", "-c", `source "$1"; copy_packaging_aur "$2" "$3"`, "bash", script, src, dest)
223 if out, err := cmd.CombinedOutput(); err != nil {
224 t.Fatalf("kopie: %v %s", err, out)
225 }
226 for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} {
227 got, err := os.ReadFile(filepath.Join(dest, name))
228 if err != nil {
229 t.Fatalf("mist %s: %v", name, err)
230 }
231 if string(got) != name+"\n" {
232 t.Fatalf("%s = %q", name, got)
233 }
234 }
235}
236
237func TestLocalAurCheckOnly(t *testing.T) {
238 env := scriptEnv(
239 "GIT_AUTHOR_NAME=Test",
240 "GIT_AUTHOR_EMAIL=test@example.com",
241 "GIT_COMMITTER_NAME=Test",
242 "GIT_COMMITTER_EMAIL=test@example.com",
243 )
244 script := filepath.Join("..", "scripts", "aur-publish-local.sh")
245 check := func(t *testing.T, repo string) (string, error) {
246 t.Helper()
247 cache := filepath.Join(t.TempDir(), "cache")
248 cmd := exec.Command("bash", script, "--check-only", repo)
249 cmd.Env = append(append([]string{}, env...), "BLUEGIT_AUR_CACHE="+cache)
250 out, err := cmd.CombinedOutput()
251 if _, statErr := os.Stat(cache); !os.IsNotExist(statErr) {
252 t.Fatal("check-only raakte de AUR-werkmap")
253 }
254 return string(out), err
255 }
256
257 t.Run("gelijk", func(t *testing.T) {
258 repo := initPublishedMaster(t, env)
259 sha := strings.TrimSpace(runCmd(t, repo, env, "git", "rev-parse", "origin/master"))
260 out, err := check(t, repo)
261 if err != nil {
262 t.Fatalf("check-only: %v\n%s", err, out)
263 }
264 if !strings.Contains(out, "Publiceren: "+sha) {
265 t.Fatalf("sha van origin/master ontbreekt:\n%s", out)
266 }
267 })
268 t.Run("niet schoon", func(t *testing.T) {
269 repo := initPublishedMaster(t, env)
270 if err := os.WriteFile(filepath.Join(repo, "dirty"), []byte("z\n"), 0o644); err != nil {
271 t.Fatal(err)
272 }
273 out, err := check(t, repo)
274 if err == nil || !strings.Contains(out, "niet schoon") {
275 t.Fatalf("vuile checkout hoorde te falen:\n%s", out)
276 }
277 })
278 t.Run("niet master", func(t *testing.T) {
279 repo := initPublishedMaster(t, env)
280 runCmd(t, repo, env, "git", "checkout", "-b", "other")
281 out, err := check(t, repo)
282 if err == nil || !strings.Contains(out, "niet op master") {
283 t.Fatalf("andere branch hoorde te falen:\n%s", out)
284 }
285 })
286 t.Run("wijkt af", func(t *testing.T) {
287 repo := initPublishedMaster(t, env)
288 if err := os.WriteFile(filepath.Join(repo, "README"), []byte("y\n"), 0o644); err != nil {
289 t.Fatal(err)
290 }
291 runCmd(t, repo, env, "git", "add", "README")
292 runCmd(t, repo, env, "git", "commit", "-m", "lokaal")
293 out, err := check(t, repo)
294 if err == nil || !strings.Contains(out, "wijkt af van origin/master") {
295 t.Fatalf("lokale commit hoorde te falen:\n%s", out)
296 }
297 })
298}
299
300func TestInstallHookService(t *testing.T) {
301 skipWithoutUserNS(t)
302 work := t.TempDir()
303 hook, err := filepath.Abs(filepath.Join("..", "packaging", "aur", "bluegit.install"))
304 if err != nil {
305 t.Fatal(err)
306 }
307 script := filepath.Join(work, "hooktest.sh")
308 if err := os.WriteFile(script, []byte(installHookTest), 0o755); err != nil {
309 t.Fatal(err)
310 }
311 cmd := exec.Command("unshare", "-U", "-r", "-m", "bash", script, hook, work)
312 out, err := cmd.CombinedOutput()
313 if err != nil || !strings.Contains(string(out), "hook-ok") {
314 t.Fatalf("install-hook: %v\n%s", err, out)
315 }
316}
317
318const installHookTest = `#!/usr/bin/env bash
319set -euo pipefail
320hook="$1"
321work="$2"
322bin="$work/bin"
323log="$work/log"
324mode="$work/mode"
325etc="$work/etc"
326mkdir -p "$bin" "$etc/bluegit"
327
328cat > "$bin/systemctl" <<'EOF'
329#!/bin/sh
330printf '%s\n' "$*" >> "$BLUEGIT_TEST_LOG"
331mode=$(cat "$BLUEGIT_TEST_MODE" 2>/dev/null || true)
332case "$mode" in
333 bus)
334 echo "System has not been booted with systemd." >&2
335 exit 1
336 ;;
337 other)
338 echo "Failed to enable unit: Unit bluegit.service not found." >&2
339 exit 1
340 ;;
341esac
342exit 0
343EOF
344printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-sysusers"
345printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-tmpfiles"
346chmod +x "$bin/systemctl" "$bin/systemd-sysusers" "$bin/systemd-tmpfiles"
347
348export BLUEGIT_TEST_LOG="$log"
349export BLUEGIT_TEST_MODE="$mode"
350export PATH="$bin:/usr/bin:/bin"
351
352mount --bind "$etc" /etc
353mount -t tmpfs tmpfs /run
354# shellcheck disable=SC1090
355source "$hook"
356
357reset() {
358 : > "$log"
359 unset _BLUEGIT_SYSTEMD_CHECKED _BLUEGIT_SYSTEMD_OK
360 rm -rf /etc/bluegit /run/systemd
361 mkdir -p /etc/bluegit
362}
363
364echo ok > "$mode"
365
366echo "case geen-systemd" >&2
367reset
368out=$(post_install)
369post_upgrade
370pre_remove
371post_remove
372printf '%s\n' "$out" | grep -q 'systemd draait niet'
373printf '%s\n' "$out" | grep -q 'clientgeheim'
374if [[ -s "$log" ]]; then
375 echo "systemctl liep zonder systemd: $(cat "$log")" >&2
376 exit 1
377fi
378
379echo "case zonder-geheim" >&2
380reset
381mkdir -p /run/systemd/system
382printf 'client_secret: ""\n' > /etc/bluegit/config.yml
383out=$(post_install)
384printf '%s\n' "$out" | grep -q 'niet gestart'
385printf '%s\n' "$out" | grep -q '/usr/share/bluegit/storage.conf.example'
386if printf '%s\n' "$out" | grep -q 'systemd draait niet'; then
387 echo "onterecht chroot" >&2
388 exit 1
389fi
390grep -qx 'daemon-reload' "$log"
391if grep -q 'enable' "$log"; then
392 echo "enable zonder geheim" >&2
393 exit 1
394fi
395
396echo "case client_secret" >&2
397reset
398mkdir -p /run/systemd/system
399printf 'base_url: https://git.example\n' > /etc/bluegit/config.yml
400printf 'geheim\n' > /etc/bluegit/client_secret
401out=$(post_install)
402if printf '%s\n' "$out" | grep -q 'niet gestart'; then
403 echo "onverwachte melding: $out" >&2
404 exit 1
405fi
406grep -qx 'daemon-reload' "$log"
407grep -qx 'enable --now bluegit.service' "$log"
408
409echo "case secret.env" >&2
410reset
411mkdir -p /run/systemd/system
412printf 'x: y\n' > /etc/bluegit/config.yml
413printf ' \n' > /etc/bluegit/client_secret
414printf '%s\n' "BLUEGIT_AUTH_CLIENT_SECRET='geheim'" > /etc/bluegit/secret.env
415post_install >/dev/null
416grep -qx 'enable --now bluegit.service' "$log"
417
418echo "case lege-quotes" >&2
419reset
420mkdir -p /run/systemd/system
421printf 'x: y\n' > /etc/bluegit/config.yml
422printf '%s\n' '# BLUEGIT_AUTH_CLIENT_SECRET=nope' 'BLUEGIT_AUTH_CLIENT_SECRET=""' > /etc/bluegit/secret.env
423post_install >/dev/null
424if grep -q enable "$log"; then
425 echo "lege quotes telden als geheim" >&2
426 exit 1
427fi
428
429echo "case zonder-config" >&2
430reset
431mkdir -p /run/systemd/system
432printf 'geheim\n' > /etc/bluegit/client_secret
433post_install >/dev/null
434if grep -q enable "$log"; then
435 echo "enable zonder config" >&2
436 exit 1
437fi
438
439echo "case upgrade" >&2
440reset
441mkdir -p /run/systemd/system
442post_upgrade >/dev/null
443grep -qx 'daemon-reload' "$log"
444grep -qx 'try-restart bluegit.service' "$log"
445if grep -q enable "$log"; then
446 echo "upgrade zette de service aan" >&2
447 exit 1
448fi
449
450echo "case verwijderen" >&2
451reset
452mkdir -p /run/systemd/system
453pre_remove >/dev/null
454grep -qx 'disable --now bluegit.service' "$log"
455: > "$log"
456post_remove >/dev/null
457grep -qx 'daemon-reload' "$log"
458
459echo "case bus" >&2
460reset
461mkdir -p /run/systemd/system
462echo bus > "$mode"
463printf 'x: y\n' > /etc/bluegit/config.yml
464printf 'geheim\n' > /etc/bluegit/client_secret
465post_install >/dev/null
466echo ok > "$mode"
467
468echo "case echte-fout" >&2
469reset
470mkdir -p /run/systemd/system
471echo other > "$mode"
472if post_install >/dev/null; then
473 echo "echte systemctl-fout werd genegeerd" >&2
474 exit 1
475fi
476
477echo hook-ok
478`
479
480func TestPkgverUsesCommitterTime(t *testing.T) {
481 root, err := filepath.Abs(filepath.Join(".."))
482 if err != nil {
483 t.Fatal(err)
484 }
485 script := filepath.Join(root, "scripts", "publish-aur.sh")
486 common, err := os.ReadFile(filepath.Join(root, "scripts", "aur-common.sh"))
487 if err != nil {
488 t.Fatal(err)
489 }
490 if !strings.Contains(string(common), `safe.directory="$dir"`) || !strings.Contains(string(common), `safe.directory=*`) {
491 t.Fatal("aur-common geeft safe.directory niet mee")
492 }
493 out, err := gitInRepo(root, "rev-parse", "HEAD").Output()
494 if err != nil {
495 t.Fatal(err)
496 }
497 sha := strings.TrimSpace(string(out))
498 if got := printPkgver(t, script, sha, "2026-10-22T22:32:33Z"); got != "20261022223233" {
499 t.Fatalf("Z: %s", got)
500 }
501 if got := printPkgver(t, script, sha, "2026-10-22T23:32:33+01:00"); got != "20261022223233" {
502 t.Fatalf("offset: %s", got)
503 }
504 if got := printPkgver(t, script, sha, "2026-10-22T00:30:00+02:00"); got != "20261021223000" {
505 t.Fatalf("rollover: %s", got)
506 }
507
508 got := printPkgver(t, script, sha, "")
509 updater := gitInRepo(root, "show", "-s", "--date=format-local:%Y%m%d%H%M%S", "--format=%cd", sha)
510 updater.Env = append(os.Environ(), "TZ=UTC")
511 up, err := updater.Output()
512 if err != nil {
513 t.Fatal(err)
514 }
515 if got != strings.TrimSpace(string(up)) {
516 t.Fatalf("pkgver %s wijkt af van de updater %s", got, strings.TrimSpace(string(up)))
517 }
518 now, err := exec.Command("date", "-u", "+%Y%m%d%H%M%S").Output()
519 if err != nil {
520 t.Fatal(err)
521 }
522 if got == strings.TrimSpace(string(now)) && got != strings.TrimSpace(string(up)) {
523 t.Fatal("pkgver volgt de klok van de job")
524 }
525}
526
527// gitInRepo zet safe.directory op de commandoregel. De testgebruiker is
528// op Steve niet de eigenaar van de checkout; een kale git -C sterft dan
529// met exit 128.
530func gitInRepo(dir string, args ...string) *exec.Cmd {
531 all := append([]string{"-c", "safe.directory=" + dir, "-c", "safe.directory=*", "-C", dir}, args...)
532 return exec.Command("git", all...)
533}
534
535func printPkgver(t *testing.T, script, sha, stamp string) string {
536 t.Helper()
537 env := make([]string, 0, len(os.Environ()))
538 for _, e := range os.Environ() {
539 if strings.HasPrefix(e, "CI_COMMIT_TIMESTAMP=") || strings.HasPrefix(e, "CI_COMMIT_SHA=") {
540 continue
541 }
542 // De runner zet later zelf safe.directory. De test haalt die weg,
543 // anders slaagt --print-pkgver ook zonder -c in het script.
544 drop := false
545 for _, p := range []string{"GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_", "GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM="} {
546 if strings.HasPrefix(e, p) {
547 drop = true
548 break
549 }
550 }
551 if drop {
552 continue
553 }
554 env = append(env, e)
555 }
556 env = append(env, "CI_COMMIT_SHA="+sha, "GIT_CONFIG_GLOBAL=/dev/null", "GIT_CONFIG_SYSTEM=/dev/null")
557 if stamp != "" {
558 env = append(env, "CI_COMMIT_TIMESTAMP="+stamp)
559 }
560 cmd := exec.Command("bash", script, "--print-pkgver")
561 cmd.Env = env
562 out, err := cmd.CombinedOutput()
563 if err != nil {
564 t.Fatalf("print-pkgver: %v %s", err, out)
565 }
566 return strings.TrimSpace(string(out))
567}
568
569// skipWithoutUserNS slaat de test over als unshare ontbreekt of als de
570// kernel user namespaces weigert. In een container is de binary er vaak
571// wel, maar geeft unshare(CLONE_NEWUSER|CLONE_NEWNS) EPERM.
572func skipWithoutUserNS(t *testing.T) {
573 t.Helper()
574 if _, err := exec.LookPath("unshare"); err != nil {
575 t.Skip("unshare ontbreekt")
576 }
577 out, err := exec.Command("unshare", "-U", "-r", "-m", "true").CombinedOutput()
578 if err != nil {
579 t.Skipf("user namespaces niet beschikbaar: %v: %s", err, out)
580 }
581}