package scripts import ( "os" "os/exec" "path/filepath" "strings" "testing" ) func TestRewritePkgbuild(t *testing.T) { root := filepath.Join("..") for _, name := range []string{"publish-aur.sh", "aur-ssh-setup.sh", "aur-common.sh", "aur-publish-local.sh"} { cmd := exec.Command("bash", "-n", filepath.Join(root, "scripts", name)) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("%s: %v %s", name, err, out) } } publish, err := os.ReadFile(filepath.Join(root, "scripts", "publish-aur.sh")) if err != nil { t.Fatal(err) } if strings.Contains(string(publish), "CI_JOB_TOKEN") || strings.Contains(string(publish), "JOB-TOKEN") { t.Fatal("het archief hoort anoniem opgehaald te worden") } dir := t.TempDir() src, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "PKGBUILD")) if err != nil { t.Fatal(err) } dest := filepath.Join(dir, "PKGBUILD") if err := os.WriteFile(dest, src, 0o644); err != nil { t.Fatal(err) } version, commit, sum := "20261022183000", "0123456789abcdef0123456789abcdef01234567", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" cmd := exec.Command("bash", filepath.Join(root, "scripts", "publish-aur.sh"), "--rewrite-only", version, commit, sum, dest) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("rewrite: %v %s", err, out) } got, err := os.ReadFile(dest) if err != nil { t.Fatal(err) } text := string(got) for _, want := range []string{ "pkgver=" + version, "pkgrel=1", "_commit=" + commit, "sha256sums=('" + sum + "')", "https://git.timfalken.com/timfa/bluegit/-/archive/${_commit}/bluegit-${_commit}.tar.gz", } { if !strings.Contains(text, want) { t.Fatalf("mist %q in\n%s", want, text) } } hook, err := os.ReadFile(filepath.Join(root, "packaging", "aur", "bluegit.install")) if err != nil { t.Fatal(err) } hookText := string(hook) for _, want := range []string{ "systemd-sysusers bluegit.conf", "systemd-tmpfiles --create", "systemctl daemon-reload", "enable --now bluegit.service", "try-restart bluegit.service", "disable --now bluegit.service", "pre_remove", "/etc/bluegit/config.yml", "/etc/bluegit/client_secret", "BLUEGIT_AUTH_CLIENT_SECRET", "/run/systemd/system", "User=bluegit", } { if !strings.Contains(hookText, want) { t.Fatalf("hook mist %q", want) } } if strings.Contains(hookText, "rm ") { t.Fatal("hook hoort geen bestanden te verwijderen") } installBody, ok := shellFunc(hookText, "post_install") if !ok || !strings.Contains(installBody, "enable --now bluegit.service") || !strings.Contains(installBody, "systemd-tmpfiles --create") { t.Fatal("post_install start de service niet of maakt de homedir niet") } upgradeBody, ok := shellFunc(hookText, "post_upgrade") if !ok || strings.Contains(upgradeBody, "post_install") || !strings.Contains(upgradeBody, "try-restart bluegit.service") { t.Fatalf("post_upgrade hoort alleen te herstarten:\n%s", upgradeBody) } removeBody, ok := shellFunc(hookText, "pre_remove") if !ok || !strings.Contains(removeBody, "disable --now bluegit.service") { t.Fatal("pre_remove zet de service niet uit") } local, err := os.ReadFile(filepath.Join(root, "scripts", "aur-publish-local.sh")) if err != nil { t.Fatal(err) } 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"} { if strings.Contains(string(local), bad) { t.Fatalf("lokaal script noemt %s", bad) } } } func shellFunc(script, name string) (string, bool) { marker := name + "() {" i := strings.Index(script, marker) if i < 0 { return "", false } rest := script[i+len(marker):] depth := 1 for j, r := range rest { switch r { case '{': depth++ case '}': depth-- if depth == 0 { return rest[:j], true } } } return "", false } func scriptEnv(extra ...string) []string { skip := []string{ "GIT_AUTHOR_", "GIT_COMMITTER_", "GIT_DIR=", "GIT_WORK_TREE=", "GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_", "GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM=", } out := make([]string, 0, len(os.Environ())+len(extra)) for _, e := range os.Environ() { drop := false for _, p := range skip { if strings.HasPrefix(e, p) { drop = true break } } if !drop { out = append(out, e) } } return append(out, extra...) } func runCmd(t *testing.T, dir string, env []string, name string, args ...string) string { t.Helper() cmd := exec.Command(name, args...) if dir != "" { cmd.Dir = dir } cmd.Env = env out, err := cmd.CombinedOutput() if err != nil { t.Fatalf("%s %v: %v\n%s", name, args, err, out) } return string(out) } func initPublishedMaster(t *testing.T, env []string) string { t.Helper() root := t.TempDir() repo := filepath.Join(root, "repo") bare := filepath.Join(root, "origin.git") if err := os.MkdirAll(repo, 0o755); err != nil { t.Fatal(err) } runCmd(t, repo, env, "git", "init", "-b", "master") runCmd(t, repo, env, "git", "config", "user.name", "Test") runCmd(t, repo, env, "git", "config", "user.email", "test@example.com") if err := os.WriteFile(filepath.Join(repo, "README"), []byte("x\n"), 0o644); err != nil { t.Fatal(err) } runCmd(t, repo, env, "git", "add", "README") runCmd(t, repo, env, "git", "commit", "-m", "init") runCmd(t, root, env, "git", "init", "--bare", "-b", "master", bare) runCmd(t, repo, env, "git", "remote", "add", "origin", bare) runCmd(t, repo, env, "git", "push", "-u", "origin", "master") return repo } func TestAurCommitPublished(t *testing.T) { dir := t.TempDir() pkg := filepath.Join(dir, "PKGBUILD") sha := "0123456789abcdef0123456789abcdef01234567" if err := os.WriteFile(pkg, []byte("pkgver=1\npkgrel=1\n_commit="+sha+"\n"), 0o644); err != nil { t.Fatal(err) } common := filepath.Join("..", "scripts", "aur-common.sh") ask := func(commit, file string) string { t.Helper() cmd := exec.Command("bash", "-c", `source "$1"; if aur_commit_published "$2" "$3"; then echo yes; else echo no; fi`, "bash", common, file, commit) out, err := cmd.CombinedOutput() if err != nil { t.Fatalf("aur_commit_published: %v %s", err, out) } return strings.TrimSpace(string(out)) } if ask(sha, pkg) != "yes" { t.Fatal("bekende sha hoort al gepubliceerd te zijn") } if ask("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", pkg) != "no" { t.Fatal("andere sha hoort nog niet gepubliceerd te zijn") } if ask(sha, filepath.Join(dir, "missing")) != "no" { t.Fatal("ontbrekende PKGBUILD is niet gepubliceerd") } } func TestCopyPackagingAur(t *testing.T) { src := t.TempDir() dest := t.TempDir() for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} { if err := os.WriteFile(filepath.Join(src, name), []byte(name+"\n"), 0o644); err != nil { t.Fatal(err) } } script := filepath.Join("..", "scripts", "aur-publish-local.sh") cmd := exec.Command("bash", "-c", `source "$1"; copy_packaging_aur "$2" "$3"`, "bash", script, src, dest) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("kopie: %v %s", err, out) } for _, name := range []string{"PKGBUILD", "bluegit.install", ".SRCINFO"} { got, err := os.ReadFile(filepath.Join(dest, name)) if err != nil { t.Fatalf("mist %s: %v", name, err) } if string(got) != name+"\n" { t.Fatalf("%s = %q", name, got) } } } func TestLocalAurCheckOnly(t *testing.T) { env := scriptEnv( "GIT_AUTHOR_NAME=Test", "GIT_AUTHOR_EMAIL=test@example.com", "GIT_COMMITTER_NAME=Test", "GIT_COMMITTER_EMAIL=test@example.com", ) script := filepath.Join("..", "scripts", "aur-publish-local.sh") check := func(t *testing.T, repo string) (string, error) { t.Helper() cache := filepath.Join(t.TempDir(), "cache") cmd := exec.Command("bash", script, "--check-only", repo) cmd.Env = append(append([]string{}, env...), "BLUEGIT_AUR_CACHE="+cache) out, err := cmd.CombinedOutput() if _, statErr := os.Stat(cache); !os.IsNotExist(statErr) { t.Fatal("check-only raakte de AUR-werkmap") } return string(out), err } t.Run("gelijk", func(t *testing.T) { repo := initPublishedMaster(t, env) sha := strings.TrimSpace(runCmd(t, repo, env, "git", "rev-parse", "origin/master")) out, err := check(t, repo) if err != nil { t.Fatalf("check-only: %v\n%s", err, out) } if !strings.Contains(out, "Publiceren: "+sha) { t.Fatalf("sha van origin/master ontbreekt:\n%s", out) } }) t.Run("niet schoon", func(t *testing.T) { repo := initPublishedMaster(t, env) if err := os.WriteFile(filepath.Join(repo, "dirty"), []byte("z\n"), 0o644); err != nil { t.Fatal(err) } out, err := check(t, repo) if err == nil || !strings.Contains(out, "niet schoon") { t.Fatalf("vuile checkout hoorde te falen:\n%s", out) } }) t.Run("niet master", func(t *testing.T) { repo := initPublishedMaster(t, env) runCmd(t, repo, env, "git", "checkout", "-b", "other") out, err := check(t, repo) if err == nil || !strings.Contains(out, "niet op master") { t.Fatalf("andere branch hoorde te falen:\n%s", out) } }) t.Run("wijkt af", func(t *testing.T) { repo := initPublishedMaster(t, env) if err := os.WriteFile(filepath.Join(repo, "README"), []byte("y\n"), 0o644); err != nil { t.Fatal(err) } runCmd(t, repo, env, "git", "add", "README") runCmd(t, repo, env, "git", "commit", "-m", "lokaal") out, err := check(t, repo) if err == nil || !strings.Contains(out, "wijkt af van origin/master") { t.Fatalf("lokale commit hoorde te falen:\n%s", out) } }) } func TestInstallHookService(t *testing.T) { skipWithoutUserNS(t) work := t.TempDir() hook, err := filepath.Abs(filepath.Join("..", "packaging", "aur", "bluegit.install")) if err != nil { t.Fatal(err) } script := filepath.Join(work, "hooktest.sh") if err := os.WriteFile(script, []byte(installHookTest), 0o755); err != nil { t.Fatal(err) } cmd := exec.Command("unshare", "-U", "-r", "-m", "bash", script, hook, work) out, err := cmd.CombinedOutput() if err != nil || !strings.Contains(string(out), "hook-ok") { t.Fatalf("install-hook: %v\n%s", err, out) } } const installHookTest = `#!/usr/bin/env bash set -euo pipefail hook="$1" work="$2" bin="$work/bin" log="$work/log" mode="$work/mode" etc="$work/etc" mkdir -p "$bin" "$etc/bluegit" cat > "$bin/systemctl" <<'EOF' #!/bin/sh printf '%s\n' "$*" >> "$BLUEGIT_TEST_LOG" mode=$(cat "$BLUEGIT_TEST_MODE" 2>/dev/null || true) case "$mode" in bus) echo "System has not been booted with systemd." >&2 exit 1 ;; other) echo "Failed to enable unit: Unit bluegit.service not found." >&2 exit 1 ;; esac exit 0 EOF printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-sysusers" printf '#!/bin/sh\nexit 0\n' > "$bin/systemd-tmpfiles" chmod +x "$bin/systemctl" "$bin/systemd-sysusers" "$bin/systemd-tmpfiles" export BLUEGIT_TEST_LOG="$log" export BLUEGIT_TEST_MODE="$mode" export PATH="$bin:/usr/bin:/bin" mount --bind "$etc" /etc mount -t tmpfs tmpfs /run # shellcheck disable=SC1090 source "$hook" reset() { : > "$log" unset _BLUEGIT_SYSTEMD_CHECKED _BLUEGIT_SYSTEMD_OK rm -rf /etc/bluegit /run/systemd mkdir -p /etc/bluegit } echo ok > "$mode" echo "case geen-systemd" >&2 reset out=$(post_install) post_upgrade pre_remove post_remove printf '%s\n' "$out" | grep -q 'systemd draait niet' printf '%s\n' "$out" | grep -q 'clientgeheim' if [[ -s "$log" ]]; then echo "systemctl liep zonder systemd: $(cat "$log")" >&2 exit 1 fi echo "case zonder-geheim" >&2 reset mkdir -p /run/systemd/system printf 'client_secret: ""\n' > /etc/bluegit/config.yml out=$(post_install) printf '%s\n' "$out" | grep -q 'niet gestart' printf '%s\n' "$out" | grep -q '/usr/share/bluegit/storage.conf.example' if printf '%s\n' "$out" | grep -q 'systemd draait niet'; then echo "onterecht chroot" >&2 exit 1 fi grep -qx 'daemon-reload' "$log" if grep -q 'enable' "$log"; then echo "enable zonder geheim" >&2 exit 1 fi echo "case client_secret" >&2 reset mkdir -p /run/systemd/system printf 'base_url: https://git.example\n' > /etc/bluegit/config.yml printf 'geheim\n' > /etc/bluegit/client_secret out=$(post_install) if printf '%s\n' "$out" | grep -q 'niet gestart'; then echo "onverwachte melding: $out" >&2 exit 1 fi grep -qx 'daemon-reload' "$log" grep -qx 'enable --now bluegit.service' "$log" echo "case secret.env" >&2 reset mkdir -p /run/systemd/system printf 'x: y\n' > /etc/bluegit/config.yml printf ' \n' > /etc/bluegit/client_secret printf '%s\n' "BLUEGIT_AUTH_CLIENT_SECRET='geheim'" > /etc/bluegit/secret.env post_install >/dev/null grep -qx 'enable --now bluegit.service' "$log" echo "case lege-quotes" >&2 reset mkdir -p /run/systemd/system printf 'x: y\n' > /etc/bluegit/config.yml printf '%s\n' '# BLUEGIT_AUTH_CLIENT_SECRET=nope' 'BLUEGIT_AUTH_CLIENT_SECRET=""' > /etc/bluegit/secret.env post_install >/dev/null if grep -q enable "$log"; then echo "lege quotes telden als geheim" >&2 exit 1 fi echo "case zonder-config" >&2 reset mkdir -p /run/systemd/system printf 'geheim\n' > /etc/bluegit/client_secret post_install >/dev/null if grep -q enable "$log"; then echo "enable zonder config" >&2 exit 1 fi echo "case upgrade" >&2 reset mkdir -p /run/systemd/system post_upgrade >/dev/null grep -qx 'daemon-reload' "$log" grep -qx 'try-restart bluegit.service' "$log" if grep -q enable "$log"; then echo "upgrade zette de service aan" >&2 exit 1 fi echo "case verwijderen" >&2 reset mkdir -p /run/systemd/system pre_remove >/dev/null grep -qx 'disable --now bluegit.service' "$log" : > "$log" post_remove >/dev/null grep -qx 'daemon-reload' "$log" echo "case bus" >&2 reset mkdir -p /run/systemd/system echo bus > "$mode" printf 'x: y\n' > /etc/bluegit/config.yml printf 'geheim\n' > /etc/bluegit/client_secret post_install >/dev/null echo ok > "$mode" echo "case echte-fout" >&2 reset mkdir -p /run/systemd/system echo other > "$mode" if post_install >/dev/null; then echo "echte systemctl-fout werd genegeerd" >&2 exit 1 fi echo hook-ok ` func TestPkgverUsesCommitterTime(t *testing.T) { root, err := filepath.Abs(filepath.Join("..")) if err != nil { t.Fatal(err) } script := filepath.Join(root, "scripts", "publish-aur.sh") common, err := os.ReadFile(filepath.Join(root, "scripts", "aur-common.sh")) if err != nil { t.Fatal(err) } if !strings.Contains(string(common), `safe.directory="$dir"`) || !strings.Contains(string(common), `safe.directory=*`) { t.Fatal("aur-common geeft safe.directory niet mee") } out, err := gitInRepo(root, "rev-parse", "HEAD").Output() if err != nil { t.Fatal(err) } sha := strings.TrimSpace(string(out)) if got := printPkgver(t, script, sha, "2026-10-22T22:32:33Z"); got != "20261022223233" { t.Fatalf("Z: %s", got) } if got := printPkgver(t, script, sha, "2026-10-22T23:32:33+01:00"); got != "20261022223233" { t.Fatalf("offset: %s", got) } if got := printPkgver(t, script, sha, "2026-10-22T00:30:00+02:00"); got != "20261021223000" { t.Fatalf("rollover: %s", got) } got := printPkgver(t, script, sha, "") updater := gitInRepo(root, "show", "-s", "--date=format-local:%Y%m%d%H%M%S", "--format=%cd", sha) updater.Env = append(os.Environ(), "TZ=UTC") up, err := updater.Output() if err != nil { t.Fatal(err) } if got != strings.TrimSpace(string(up)) { t.Fatalf("pkgver %s wijkt af van de updater %s", got, strings.TrimSpace(string(up))) } now, err := exec.Command("date", "-u", "+%Y%m%d%H%M%S").Output() if err != nil { t.Fatal(err) } if got == strings.TrimSpace(string(now)) && got != strings.TrimSpace(string(up)) { t.Fatal("pkgver volgt de klok van de job") } } // gitInRepo zet safe.directory op de commandoregel. De testgebruiker is // op Steve niet de eigenaar van de checkout; een kale git -C sterft dan // met exit 128. func gitInRepo(dir string, args ...string) *exec.Cmd { all := append([]string{"-c", "safe.directory=" + dir, "-c", "safe.directory=*", "-C", dir}, args...) return exec.Command("git", all...) } func printPkgver(t *testing.T, script, sha, stamp string) string { t.Helper() env := make([]string, 0, len(os.Environ())) for _, e := range os.Environ() { if strings.HasPrefix(e, "CI_COMMIT_TIMESTAMP=") || strings.HasPrefix(e, "CI_COMMIT_SHA=") { continue } // De runner zet later zelf safe.directory. De test haalt die weg, // anders slaagt --print-pkgver ook zonder -c in het script. drop := false for _, p := range []string{"GIT_CONFIG_COUNT=", "GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_", "GIT_CONFIG_GLOBAL=", "GIT_CONFIG_SYSTEM="} { if strings.HasPrefix(e, p) { drop = true break } } if drop { continue } env = append(env, e) } env = append(env, "CI_COMMIT_SHA="+sha, "GIT_CONFIG_GLOBAL=/dev/null", "GIT_CONFIG_SYSTEM=/dev/null") if stamp != "" { env = append(env, "CI_COMMIT_TIMESTAMP="+stamp) } cmd := exec.Command("bash", script, "--print-pkgver") cmd.Env = env out, err := cmd.CombinedOutput() if err != nil { t.Fatalf("print-pkgver: %v %s", err, out) } return strings.TrimSpace(string(out)) } // skipWithoutUserNS slaat de test over als unshare ontbreekt of als de // kernel user namespaces weigert. In een container is de binary er vaak // wel, maar geeft unshare(CLONE_NEWUSER|CLONE_NEWNS) EPERM. func skipWithoutUserNS(t *testing.T) { t.Helper() if _, err := exec.LookPath("unshare"); err != nil { t.Skip("unshare ontbreekt") } out, err := exec.Command("unshare", "-U", "-r", "-m", "true").CombinedOutput() if err != nil { t.Skipf("user namespaces niet beschikbaar: %v: %s", err, out) } }