BlueGit

timfa bluegit

Files

bluegit / scripts / aur_test.go

aur_test.go

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