mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
Release 3.0.2
This commit is contained in:
54 files changed
+4007
-374
No files matched your search
@@ -0,0 +1,200 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
root=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd)
|
||||
collector=$root/scripts/collect-diagnostics.sh
|
||||
fixtures=$(mktemp -d "${TMPDIR:-/tmp}/gp-diagnostics-tests.XXXXXXXX")
|
||||
trap 'rm -rf "$fixtures"' 0
|
||||
trap 'exit 130' INT
|
||||
trap 'exit 143' TERM HUP
|
||||
mkdir "$fixtures/bin"
|
||||
for tool in sh awk tr cat chmod mktemp rm ps sleep; do
|
||||
ln -s "$(command -v "$tool")" "$fixtures/bin/$tool"
|
||||
done
|
||||
cat > "$fixtures/bin/uname" <<'MOCK'
|
||||
#!/bin/sh
|
||||
case "$1" in
|
||||
-s) printf '%s\n' "$TEST_OS" ;;
|
||||
-m) printf '%s\n' fixture-architecture ;;
|
||||
-r)
|
||||
case "${TEST_PROBE:-}" in
|
||||
timeout)
|
||||
sh -c 'trap "" TERM; echo $$ > "$TEST_CHILD_PID"; while :; do sleep 1; done' &
|
||||
wait ;;
|
||||
flood) awk 'BEGIN {while (1) print "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}' ;;
|
||||
*) printf '%s\n' fixture-kernel ;;
|
||||
esac ;;
|
||||
esac
|
||||
MOCK
|
||||
cat > "$fixtures/bin/id" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' 1000
|
||||
MOCK
|
||||
cat > "$fixtures/bin/gpclient" <<'MOCK'
|
||||
#!/bin/sh
|
||||
[ "$1" = --version ] || exit 2
|
||||
printf '%s\n' 'gpclient 2.6.5'
|
||||
MOCK
|
||||
cat > "$fixtures/bin/gpauth" <<'MOCK'
|
||||
#!/bin/sh
|
||||
[ "$1" = --version ] || exit 2
|
||||
printf '%s\n' 'gpauth 2.6.5'
|
||||
MOCK
|
||||
cat > "$fixtures/bin/gpgui" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' 'GUI WAS LAUNCHED' > "$TEST_GUI_MARKER"
|
||||
exit 1
|
||||
MOCK
|
||||
cat > "$fixtures/bin/lspci" <<'MOCK'
|
||||
#!/bin/sh
|
||||
cat <<'DATA'
|
||||
00:00.0 Host bridge: OMIT-BRIDGE
|
||||
00:01.0 VGA compatible controller: Fixture GPU
|
||||
Kernel driver in use: fixture-driver
|
||||
00:02.0 Network controller: OMIT-NETWORK
|
||||
Kernel driver in use: OMIT-NETWORK-DRIVER
|
||||
DATA
|
||||
MOCK
|
||||
cat > "$fixtures/bin/pciconf" <<'MOCK'
|
||||
#!/bin/sh
|
||||
cat <<'DATA'
|
||||
vgapci0@pci0:0:1:0: class=0x030000
|
||||
device = 'BSD Fixture GPU'
|
||||
nic0@pci0:0:2:0: class=0x020000
|
||||
device = 'OMIT-NETWORK'
|
||||
DATA
|
||||
MOCK
|
||||
cat > "$fixtures/bin/pcidump" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' '0:1:0: VGA Fixture GPU' '0:2:0: OMIT-NETWORK'
|
||||
MOCK
|
||||
cat > "$fixtures/bin/system_profiler" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' ' Chipset Model: Fixture Mac GPU' ' Serial Number: OMIT-SERIAL'
|
||||
MOCK
|
||||
cat > "$fixtures/bin/sw_vers" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' fixture-macos-version
|
||||
MOCK
|
||||
cat > "$fixtures/bin/sysctl" <<'MOCK'
|
||||
#!/bin/sh
|
||||
printf '%s\n' kvm
|
||||
MOCK
|
||||
cat > "$fixtures/bin/systemd-detect-virt" <<'MOCK'
|
||||
#!/bin/sh
|
||||
if [ "${TEST_PROBE:-}" = baremetal ]; then printf '%s\n' none; exit 1; fi
|
||||
printf '%s\n' kvm
|
||||
MOCK
|
||||
cat > "$fixtures/bin/pkg" <<'MOCK'
|
||||
#!/bin/sh
|
||||
[ "$1" = query ] && [ "$2" = -a ] || exit 2
|
||||
printf '%s\n' 'webkit2-gtk_41 2.52.6' 'gtk3 3.24.52' 'mesa-dri 26.2.4' 'hyprland 0.56.2' 'plasma6-plasma-workspace 6.4.4' 'private-package 1.0'
|
||||
MOCK
|
||||
cat > "$fixtures/bin/pkg_info" <<'MOCK'
|
||||
#!/bin/sh
|
||||
[ "$1" = -a ] || exit 2
|
||||
printf '%s\n' 'webkitgtk41-2.52.6 WebKitGTK browser engine' 'gtk+3-3.24.52 GTK3 toolkit' 'sway-1.11 Wayland compositor' 'private-package-1.0 Do not collect'
|
||||
MOCK
|
||||
chmod +x "$fixtures/bin/"*
|
||||
run() {
|
||||
env PATH="$fixtures/bin" HOME="$fixtures/home[regex]" TMPDIR="$fixtures" \
|
||||
TEST_OS="$1" TEST_PROBE="${2:-}" TEST_CHILD_PID="$fixtures/child.pid" \
|
||||
TEST_GUI_MARKER="$fixtures/gui-launched" \
|
||||
PRIVATE_SECRET=OMIT-SECRET DISPLAY=OMIT-DISPLAY WAYLAND_DISPLAY=OMIT-SOCKET \
|
||||
DBUS_SESSION_BUS_ADDRESS=OMIT-DBUS SSH_CONNECTION=OMIT-SSH \
|
||||
XDG_CURRENT_DESKTOP='KDE' DESKTOP_SESSION="$fixtures/home[regex]/desktop" \
|
||||
sh "$collector" --client-version embedded-version --client-path "$fixtures/home[regex]/gpclient" > "$fixtures/report"
|
||||
}
|
||||
assert_contains() {
|
||||
awk -v text="$1" 'index($0,text) {found=1} END {exit !found}' "$fixtures/report" || { printf 'Missing: %s\n' "$1" >&2; cat "$fixtures/report" >&2; exit 1; }
|
||||
}
|
||||
for os in Linux FreeBSD OpenBSD Darwin; do
|
||||
run "$os"
|
||||
assert_contains "os: ok: $os"
|
||||
assert_contains 'gpclient_version: ok: embedded-version'
|
||||
assert_contains 'gpclient_path: ok: ~/gpclient'
|
||||
assert_contains 'env.DESKTOP_SESSION: ok: ~/desktop'
|
||||
assert_contains 'env.XDG_CURRENT_DESKTOP: ok: KDE'
|
||||
assert_contains 'ssh_session: ok: yes'
|
||||
awk 'index($0,"OMIT-") {exit 1} END {if (NR != 28) exit 1}' "$fixtures/report"
|
||||
[ ! -e "$fixtures/gui-launched" ]
|
||||
awk 'index($0,"private-package") {exit 1}' "$fixtures/report"
|
||||
case "$os" in
|
||||
Linux) assert_contains 'Fixture GPU'; assert_contains 'fixture-driver' ;;
|
||||
FreeBSD) assert_contains 'BSD Fixture GPU'; assert_contains 'graphics_packages: ok: webkit2-gtk_41 2.52.6'; assert_contains 'desktop_version: ok: hyprland 0.56.2 plasma6-plasma-workspace 6.4.4' ;;
|
||||
OpenBSD) assert_contains 'VGA Fixture GPU'; assert_contains 'graphics_packages: ok: webkitgtk41-2.52.6'; assert_contains 'desktop_version: ok: sway-1.11' ;;
|
||||
Darwin) assert_contains 'Fixture Mac GPU'; assert_contains 'display_protocol: not_applicable:' ;;
|
||||
esac
|
||||
printf 'PASS: %s fixture selection and privacy\n' "$os"
|
||||
done
|
||||
env PATH="$fixtures/bin" TEST_OS=Darwin TEST_GUI_MARKER="$fixtures/gui-launched" \
|
||||
sh "$collector" --client-version fixture --gui-path "$fixtures/bin/gpgui" > "$fixtures/report"
|
||||
assert_contains "gpgui_path: ok: $fixtures/bin/gpgui"
|
||||
assert_contains 'gpgui_version: unavailable:'
|
||||
[ ! -e "$fixtures/gui-launched" ]
|
||||
printf '%s\n' 'PASS: nonbundle GUI path never borrows another installed app version'
|
||||
# Successful probes must cancel their watchdog before doing any process-tree
|
||||
# traversal. A slow snapshot used to let a finished probe become timed_out.
|
||||
mv "$fixtures/bin/ps" "$fixtures/real-ps"
|
||||
cat > "$fixtures/bin/ps" <<'MOCK'
|
||||
#!/bin/sh
|
||||
sleep 4
|
||||
exit 1
|
||||
MOCK
|
||||
chmod +x "$fixtures/bin/ps"
|
||||
run Linux
|
||||
assert_contains 'os: ok: Linux'
|
||||
assert_contains 'kernel: ok: fixture-kernel'
|
||||
assert_contains 'graphics: ok:'
|
||||
rm "$fixtures/bin/ps"
|
||||
mv "$fixtures/real-ps" "$fixtures/bin/ps"
|
||||
printf '%s\n' 'PASS: successful watchdog cancellation does not wait for process snapshots'
|
||||
run Linux baremetal
|
||||
assert_contains 'virtualization: ok: none'
|
||||
printf '%s\n' 'PASS: bare-metal virtualization status'
|
||||
long_value=$(awk 'BEGIN {for (i=0;i<700;i++) printf "x"; printf "\nsecond\tline"}')
|
||||
env PATH="$fixtures/bin" TEST_OS=Linux XDG_CURRENT_DESKTOP="$long_value" \
|
||||
sh "$collector" --client-version fixture > "$fixtures/report"
|
||||
awk 'index($0,"env.XDG_CURRENT_DESKTOP: ok: ")==1 {if (length($0)-length("env.XDG_CURRENT_DESKTOP: ok: ")>500) exit 1; found=1} END {if (NR!=28 || !found) exit 1}' "$fixtures/report"
|
||||
printf '%s\n' 'PASS: control flattening and value cap'
|
||||
# No internal version supplied: old installations use their safe --version switch.
|
||||
env PATH="$fixtures/bin" TEST_OS=Linux sh "$collector" > "$fixtures/report"
|
||||
assert_contains 'gpclient_version: ok: gpclient 2.6.5'
|
||||
printf '%s\n' 'PASS: standalone version discovery'
|
||||
run Linux timeout
|
||||
assert_contains 'kernel: timed_out:'
|
||||
child=$(cat "$fixtures/child.pid")
|
||||
# A reaped-or-zombie descendant is no longer running; some init implementations
|
||||
# do not promptly reap an orphan after its parent is killed.
|
||||
state=$(ps -p "$child" -o stat= 2>/dev/null || :)
|
||||
case "$state" in ''|Z*) ;; *) printf 'Descendant still running: %s\n' "$state" >&2; exit 1 ;; esac
|
||||
printf '%s\n' 'PASS: timeout and descendant termination'
|
||||
run Linux flood
|
||||
assert_contains 'kernel: failed:'
|
||||
[ "$(wc -c < "$fixtures/report")" -lt 65536 ]
|
||||
printf '%s\n' 'PASS: output flood is bounded'
|
||||
rm -f "$fixtures/child.pid"
|
||||
env PATH="$fixtures/bin" TEST_OS=Linux TEST_PROBE=timeout TEST_CHILD_PID="$fixtures/child.pid" \
|
||||
sh "$collector" > "$fixtures/interrupted" 2>/dev/null &
|
||||
collector_pid=$!
|
||||
for attempt in 1 2 3 4 5; do [ ! -f "$fixtures/child.pid" ] || break; sleep 1; done
|
||||
[ -f "$fixtures/child.pid" ]
|
||||
kill -TERM "$collector_pid"
|
||||
if wait "$collector_pid"; then exit 1; fi
|
||||
child=$(cat "$fixtures/child.pid")
|
||||
state=$(ps -p "$child" -o stat= 2>/dev/null || :)
|
||||
case "$state" in ''|Z*) ;; *) printf 'Interrupted descendant still running: %s\n' "$state" >&2; exit 1 ;; esac
|
||||
printf '%s\n' 'PASS: interruption terminates descendants'
|
||||
mv "$fixtures/bin/gpauth" "$fixtures/gpauth"
|
||||
run Linux
|
||||
assert_contains 'gpauth_version: unavailable:'
|
||||
mv "$fixtures/gpauth" "$fixtures/bin/gpauth"
|
||||
printf '%s\n' 'PASS: missing optional helper'
|
||||
|
||||
env PATH="$fixtures/bin" TEST_OS=Linux sh "$collector" --output "$fixtures/saved" >/dev/null
|
||||
cp "$fixtures/saved" "$fixtures/original"
|
||||
if env PATH="$fixtures/bin" TEST_OS=Linux sh "$collector" --output "$fixtures/saved" >/dev/null 2>&1; then exit 1; fi
|
||||
cmp "$fixtures/saved" "$fixtures/original"
|
||||
sh "$collector" --help > "$fixtures/help"
|
||||
[ -s "$fixtures/help" ]
|
||||
if sh "$collector" --unknown >/dev/null 2>&1; then exit 1; fi
|
||||
printf '%s\n' 'PASS: output refuses overwrite, help, argument validation'
|
||||
@@ -0,0 +1,72 @@
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
SCRIPT = Path(__file__).parents[1] / "verify-docker-publication.sh"
|
||||
AMD64 = "sha256:" + "a" * 64
|
||||
ARM64 = "sha256:" + "b" * 64
|
||||
INDEX = "sha256:" + "c" * 64
|
||||
|
||||
|
||||
def manifest(digest, architecture):
|
||||
platform_os = "unknown" if architecture == "unknown" else "linux"
|
||||
return {"digest": digest, "platform": {"os": platform_os, "architecture": architecture}}
|
||||
|
||||
|
||||
class DockerPublicationTests(unittest.TestCase):
|
||||
def run_verifier(self, images, source_index=True, selection="all"):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
digests = root / "digests"
|
||||
digests.mkdir()
|
||||
(digests / (INDEX if source_index else AMD64)[7:]).touch()
|
||||
if selection == "all":
|
||||
(digests / ARM64[7:]).touch()
|
||||
responses = {
|
||||
"example/image:3.0.1": {"manifests": images},
|
||||
"example/image@" + INDEX: {"manifests": [manifest(AMD64, "amd64"), manifest("sha256:attestation", "unknown")]},
|
||||
"example/image@" + AMD64: {"config": {}},
|
||||
"example/image@" + ARM64: {"config": {}},
|
||||
}
|
||||
(root / "responses.json").write_text(json.dumps(responses))
|
||||
docker = root / "docker"
|
||||
docker.write_text("#!/usr/bin/env python3\nimport json, os, sys\n"
|
||||
"print(json.dumps(json.load(open(os.environ['RESPONSES']))[sys.argv[4]]))\n")
|
||||
docker.chmod(0o755)
|
||||
sleep = root / "sleep"
|
||||
sleep.write_text("#!/bin/sh\nexit 0\n")
|
||||
sleep.chmod(0o755)
|
||||
env = {**os.environ, "PATH": str(root) + os.pathsep + os.environ["PATH"],
|
||||
"RESPONSES": str(root / "responses.json")}
|
||||
return subprocess.run(["bash", str(SCRIPT), "example/image:3.0.1", str(digests), selection],
|
||||
env=env, capture_output=True, text=True)
|
||||
|
||||
def test_attested_sources_match_the_published_platform_digests(self):
|
||||
result = self.run_verifier([manifest(AMD64, "amd64"), manifest(ARM64, "arm64"),
|
||||
manifest("sha256:attestation", "unknown")])
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
def test_missing_architecture_cannot_pass(self):
|
||||
result = self.run_verifier([manifest(AMD64, "amd64")])
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("did not match", result.stderr)
|
||||
|
||||
def test_another_build_of_same_platforms_cannot_pass(self):
|
||||
result = self.run_verifier([manifest("sha256:" + "d" * 64, "amd64"), manifest(ARM64, "arm64")])
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
|
||||
def test_unselected_platform_cannot_pass(self):
|
||||
result = self.run_verifier([manifest(AMD64, "amd64"), manifest(ARM64, "arm64"),
|
||||
manifest("sha256:extra", "riscv64")])
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
|
||||
def test_selected_single_architecture_is_supported(self):
|
||||
result = self.run_verifier([manifest(AMD64, "amd64")], source_index=False, selection="x86_64")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,120 @@
|
||||
import argparse
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
spec = importlib.util.spec_from_file_location("selector", Path(__file__).parents[1] / "select-publication-targets.py")
|
||||
selector = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(selector)
|
||||
|
||||
|
||||
class SelectionTests(unittest.TestCase):
|
||||
def test_unknown_and_duplicate_targets_fail(self):
|
||||
for values in (["typo"], ["fedora-44", "fedora-44"]):
|
||||
with self.assertRaises(ValueError):
|
||||
selector.selection(values, {"fedora-44", "fedora-45"})
|
||||
|
||||
def test_obs_metadata_uses_authenticated_put_without_authenticating_public_reads(self):
|
||||
response = MagicMock()
|
||||
response.__enter__.return_value.read.return_value = b"ok"
|
||||
with patch.object(selector, "urlopen", return_value=response) as opening, \
|
||||
patch.dict(selector.os.environ, {"OBS_USERNAME": "test", "OBS_PASSWORD": "test"}):
|
||||
selector.request("https://api.opensuse.org/source/project/package/_meta", b"<package/>")
|
||||
upload = opening.call_args.args[0]
|
||||
self.assertEqual(upload.get_method(), "PUT")
|
||||
self.assertIsNotNone(upload.get_header("Authorization"))
|
||||
selector.request("https://api.opensuse.org/public/source/project/package/_meta")
|
||||
public = opening.call_args.args[0]
|
||||
self.assertEqual(public.get_method(), "GET")
|
||||
self.assertIsNone(public.get_header("Authorization"))
|
||||
|
||||
def test_copr_expands_selected_distro_to_all_its_configured_architectures(self):
|
||||
args = argparse.Namespace(owner="yuezk", project="globalprotect-openconnect",
|
||||
distros=["fedora-44"], build_id=None)
|
||||
response = json.dumps({"chroot_repos": {"fedora-44-aarch64": "url", "fedora-44-x86_64": "url",
|
||||
"fedora-45-x86_64": "url"}}).encode()
|
||||
with patch.object(selector, "request", return_value=response):
|
||||
self.assertEqual(selector.copr(args), ["fedora-44-aarch64", "fedora-44-x86_64"])
|
||||
args.distros = ["fedora-typo"]
|
||||
with self.assertRaisesRegex(ValueError, "Unknown targets"):
|
||||
selector.copr(args)
|
||||
|
||||
def test_copr_recovery_uses_original_build_targets_even_if_project_changed(self):
|
||||
args = argparse.Namespace(owner="yuezk", project="globalprotect-openconnect", distros=[], build_id=42)
|
||||
response = json.dumps({"ownername": args.owner, "projectname": args.project,
|
||||
"chroots": ["fedora-43-x86_64"]}).encode()
|
||||
with patch.object(selector, "request", return_value=response) as request:
|
||||
self.assertEqual(selector.copr(args), ["fedora-43-x86_64"])
|
||||
self.assertIn("/build/42", request.call_args.args[0])
|
||||
|
||||
|
||||
class OBSSelectionTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.args = argparse.Namespace(project="home:yuezk", package="globalprotect-openconnect",
|
||||
repositories=["16.0"], verify_only=False,
|
||||
output=Path(self.directory.name) / "targets.json")
|
||||
self.targets = ["16.0/aarch64", "16.0/x86_64"]
|
||||
self.project = b'''<project><repository name="16.0"><arch>x86_64</arch><arch>aarch64</arch></repository>
|
||||
<repository name="15.6"><arch>x86_64</arch><arch>aarch64</arch></repository></project>'''
|
||||
self.package = b'''<package><title>Keep me</title><build><disable repository="old"/></build>
|
||||
<publish><disable repository="old"/><disable repository="16.0" arch="x86_64"/></publish>
|
||||
<useforbuild><disable arch="armv7l"/></useforbuild></package>'''
|
||||
|
||||
def test_metadata_changes_build_allowlist_but_keeps_other_publication_flags(self):
|
||||
metadata = selector.obs_metadata(ET.fromstring(self.package), self.targets)
|
||||
self.assertEqual(metadata.findtext("title"), "Keep me")
|
||||
self.assertIsNotNone(metadata.find("build/disable"))
|
||||
self.assertEqual([flag.attrib for flag in metadata.findall("build/enable")],
|
||||
[{"repository": "16.0", "arch": "aarch64"},
|
||||
{"repository": "16.0", "arch": "x86_64"}])
|
||||
self.assertEqual(metadata.find("publish/disable").attrib, {"repository": "old"})
|
||||
self.assertEqual(len(metadata.findall("publish/disable")), 1)
|
||||
self.assertEqual(metadata.find("useforbuild/disable").get("arch"), "armv7l")
|
||||
|
||||
def test_selection_is_applied_before_source_can_be_uploaded(self):
|
||||
before = {"16.0/x86_64": "succeeded", "16.0/aarch64": "succeeded",
|
||||
"15.6/x86_64": "succeeded", "15.6/aarch64": "succeeded"}
|
||||
after = {"16.0/x86_64": "succeeded", "16.0/aarch64": "succeeded",
|
||||
"15.6/x86_64": "disabled", "15.6/aarch64": "disabled"}
|
||||
with patch.object(selector, "request", side_effect=[self.project, self.package, b"ok"]) as request, \
|
||||
patch.object(selector, "obs_results", side_effect=[before, after]):
|
||||
selector.obs(self.args)
|
||||
self.assertEqual(json.loads(self.args.output.read_text()), self.targets)
|
||||
self.assertIn("/source/home:yuezk/globalprotect-openconnect/_meta", request.call_args.args[0])
|
||||
uploaded = ET.fromstring(request.call_args.args[1])
|
||||
self.assertEqual({flag.get("arch") for flag in uploaded.findall("build/enable")}, {"x86_64", "aarch64"})
|
||||
|
||||
def test_busy_unselected_target_prevents_mutation(self):
|
||||
states = {"16.0/x86_64": "succeeded", "16.0/aarch64": "succeeded", "15.6/aarch64": "building"}
|
||||
with patch.object(selector, "request", return_value=self.project) as request, \
|
||||
patch.object(selector, "obs_results", return_value=states):
|
||||
with self.assertRaisesRegex(ValueError, "still active"):
|
||||
selector.obs(self.args)
|
||||
self.assertEqual(request.call_count, 1)
|
||||
|
||||
def test_verify_only_does_not_mutate_to_hide_an_unselected_build(self):
|
||||
self.args.verify_only = True
|
||||
states = {"16.0/x86_64": "succeeded", "16.0/aarch64": "succeeded", "15.6/aarch64": "succeeded"}
|
||||
with patch.object(selector, "request", return_value=self.project) as request, \
|
||||
patch.object(selector, "obs_results", return_value=states):
|
||||
with self.assertRaisesRegex(ValueError, "differ"):
|
||||
selector.obs(self.args)
|
||||
self.assertEqual(request.call_count, 1)
|
||||
|
||||
def test_empty_selection_preserves_current_flags(self):
|
||||
self.args.repositories = []
|
||||
states = {"16.0/x86_64": "succeeded", "16.0/aarch64": "disabled"}
|
||||
with patch.object(selector, "request", return_value=self.project) as request, \
|
||||
patch.object(selector, "obs_results", return_value=states):
|
||||
self.assertEqual(selector.obs(self.args), ["16.0/x86_64"])
|
||||
self.assertEqual(request.call_count, 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,176 @@
|
||||
import argparse
|
||||
import gzip
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
from urllib.error import HTTPError
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
spec = importlib.util.spec_from_file_location("publication", Path(__file__).parents[1] / "wait-for-publication.py")
|
||||
publication = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(publication)
|
||||
|
||||
|
||||
def arguments(**values):
|
||||
return argparse.Namespace(owner="yuezk", project="globalprotect-openconnect",
|
||||
package="globalprotect-openconnect", version="3.0.1", revision="1", **values)
|
||||
|
||||
|
||||
class RepositoryTests(unittest.TestCase):
|
||||
def test_debian_index_requires_exact_version_and_architecture(self):
|
||||
content = b"Package: globalprotect-openconnect\nVersion: 3.0.1-ppa1\nArchitecture: arm64\n\n"
|
||||
self.assertTrue(publication.deb_present(content, "globalprotect-openconnect", "3.0.1-ppa1", "arm64"))
|
||||
self.assertFalse(publication.deb_present(content, "globalprotect-openconnect", "3.0.1", "arm64"))
|
||||
self.assertFalse(publication.deb_present(content, "globalprotect-openconnect", "3.0.1-ppa1", "amd64"))
|
||||
|
||||
def test_rpm_metadata_is_verified_before_parsing(self):
|
||||
primary = gzip.compress(b'<metadata xmlns="http://linux.duke.edu/metadata/common"/>')
|
||||
digest = hashlib.sha256(primary).hexdigest()
|
||||
repomd = ET.fromstring(f'''<repomd xmlns="http://linux.duke.edu/metadata/repo">
|
||||
<data type="primary"><location href="repodata/primary.xml.gz"/>
|
||||
<checksum type="sha256">{digest}</checksum></data></repomd>''')
|
||||
with patch.object(publication, "xml", return_value=repomd), patch.object(publication, "fetch", return_value=primary):
|
||||
self.assertEqual(publication.rpm_packages("https://repo").tag, "{http://linux.duke.edu/metadata/common}metadata")
|
||||
with patch.object(publication, "xml", return_value=repomd), patch.object(publication, "fetch", return_value=b"corrupt"):
|
||||
with self.assertRaises(publication.Pending):
|
||||
publication.rpm_packages("https://repo")
|
||||
|
||||
def test_copr_same_version_from_another_build_does_not_pass(self):
|
||||
primary = ET.fromstring('''<metadata xmlns="http://linux.duke.edu/metadata/common"><package>
|
||||
<name>globalprotect-openconnect</name><arch>x86_64</arch><version ver="3.0.1" rel="1.fc44"/>
|
||||
<location href="011106217-globalprotect-openconnect/package.rpm"/></package></metadata>''')
|
||||
with patch.object(publication, "rpm_packages", return_value=primary):
|
||||
params = ("https://repo", "globalprotect-openconnect", "3.0.1", "x86_64", lambda release: True)
|
||||
self.assertTrue(publication.rpm_present(*params, build_id=11106217))
|
||||
self.assertFalse(publication.rpm_present(*params, build_id=11106218))
|
||||
|
||||
|
||||
class LaunchpadTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.checker = publication.PPA(arguments(series="noble", architectures=["amd64", "arm64"]))
|
||||
self.checker.source = "https://api/sourcepub/1"
|
||||
self.builds = [{"arch_tag": arch, "buildstate": "Successfully built", "web_link": f"https://build/{arch}"}
|
||||
for arch in ("amd64", "arm64")]
|
||||
|
||||
def test_green_builds_do_not_mean_repository_is_published(self):
|
||||
with patch.object(publication, "api", return_value={"status": "Published"}), \
|
||||
patch.object(publication, "collection", return_value=self.builds), \
|
||||
patch.object(publication, "fetch", return_value=gzip.compress(b"")):
|
||||
with self.assertRaisesRegex(publication.Pending, "Waiting for 3.0.1"):
|
||||
self.checker.check()
|
||||
|
||||
def test_missing_architecture_does_not_pass(self):
|
||||
self.builds = self.builds[:1]
|
||||
with patch.object(publication, "api", return_value={"status": "Published"}), \
|
||||
patch.object(publication, "collection", return_value=self.builds), \
|
||||
patch.object(publication, "deb_present", return_value=True), \
|
||||
patch.object(publication, "fetch", return_value=gzip.compress(b"")):
|
||||
with self.assertRaisesRegex(publication.Pending, "arm64"):
|
||||
self.checker.check()
|
||||
|
||||
def test_failed_build_reports_external_url(self):
|
||||
self.builds[0]["buildstate"] = "Dependency wait"
|
||||
with patch.object(publication, "api", return_value={"status": "Published"}), \
|
||||
patch.object(publication, "collection", return_value=self.builds):
|
||||
with self.assertRaisesRegex(publication.Failed, "https://build/amd64"):
|
||||
self.checker.check()
|
||||
|
||||
|
||||
class OBSTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
files = Path(self.directory.name) / "files"
|
||||
files.mkdir()
|
||||
(files / "package.spec").write_bytes(b"spec")
|
||||
args = arguments(files=files)
|
||||
args.project = "home:yuezk"
|
||||
self.checker = publication.OBS(args)
|
||||
digest = hashlib.md5(b"spec").hexdigest()
|
||||
self.source = f'<directory rev="74" srcmd5="new"><entry name="package.spec" md5="{digest}"/></directory>'
|
||||
self.results = '''<resultlist><result repository="16.0" arch="x86_64" state="published">
|
||||
<status code="succeeded"/></result><result repository="disabled" arch="x86_64">
|
||||
<status code="disabled"/></result></resultlist>'''
|
||||
|
||||
def test_previous_green_build_history_is_not_current_publication(self):
|
||||
responses = [self.source, self.results, '<buildinfo><srcmd5>new</srcmd5></buildinfo>',
|
||||
'<buildhistory><entry srcmd5="old" versrel="3.0.1-1"/></buildhistory>']
|
||||
with patch.object(publication, "xml", side_effect=[ET.fromstring(value) for value in responses]):
|
||||
with self.assertRaisesRegex(publication.Pending, "build history"):
|
||||
self.checker.check()
|
||||
|
||||
def test_current_revision_with_published_metadata_passes(self):
|
||||
responses = [self.source, self.results, '<buildinfo><srcmd5>new</srcmd5></buildinfo>',
|
||||
'<buildhistory><entry srcmd5="new" versrel="3.0.1-1"/></buildhistory>']
|
||||
with patch.object(publication, "xml", side_effect=[ET.fromstring(value) for value in responses]), \
|
||||
patch.object(publication, "rpm_present", return_value=True):
|
||||
self.assertIn("1 targets", self.checker.check())
|
||||
|
||||
def test_source_changed_during_wait_fails(self):
|
||||
self.checker.source = "old"
|
||||
with patch.object(publication, "xml", return_value=ET.fromstring(self.source)):
|
||||
with self.assertRaisesRegex(publication.Failed, "source changed"):
|
||||
self.checker.check()
|
||||
|
||||
def test_no_enabled_targets_cannot_pass(self):
|
||||
with patch.object(publication, "xml", side_effect=[ET.fromstring(self.source), ET.fromstring("<resultlist/>")]):
|
||||
with self.assertRaisesRegex(publication.Failed, "no enabled"):
|
||||
self.checker.check()
|
||||
|
||||
def test_enabled_target_outside_selection_fails(self):
|
||||
path = Path(self.directory.name) / "targets.json"
|
||||
path.write_text(json.dumps(["16.0/aarch64"]))
|
||||
self.checker.args.targets_file = path
|
||||
self.checker.targets = {("16.0", "aarch64")}
|
||||
with patch.object(publication, "xml", side_effect=[ET.fromstring(self.source), ET.fromstring(self.results)]):
|
||||
with self.assertRaisesRegex(publication.Failed, "unselected targets"):
|
||||
self.checker.check()
|
||||
|
||||
def test_selected_target_disabled_fails(self):
|
||||
self.checker.targets = {("disabled", "x86_64")}
|
||||
with patch.object(publication, "xml", side_effect=[ET.fromstring(self.source), ET.fromstring(self.results)]):
|
||||
with self.assertRaisesRegex(publication.Failed, "selected target.*disabled"):
|
||||
self.checker.check()
|
||||
|
||||
|
||||
class CoprTests(unittest.TestCase):
|
||||
def test_unselected_chroot_cannot_be_hidden_by_verification(self):
|
||||
checker = publication.Copr(arguments(build_id=42, chroots=["fedora-44-x86_64"]))
|
||||
build = {"ownername": "yuezk", "projectname": "globalprotect-openconnect",
|
||||
"chroots": ["fedora-44-x86_64", "fedora-44-aarch64"]}
|
||||
with patch.object(publication, "api", return_value=build):
|
||||
with self.assertRaisesRegex(publication.Failed, "targets differ"):
|
||||
checker.check()
|
||||
|
||||
def test_build_from_another_project_fails(self):
|
||||
checker = publication.Copr(arguments(build_id=42))
|
||||
with patch.object(publication, "api", return_value={"ownername": "other", "projectname": "other"}):
|
||||
with self.assertRaisesRegex(publication.Failed, "another project"):
|
||||
checker.check()
|
||||
|
||||
def test_failed_build_reports_id_and_url(self):
|
||||
checker = publication.Copr(arguments(build_id=42))
|
||||
with patch.object(publication, "api", return_value={"ownername": "yuezk", "projectname": "globalprotect-openconnect", "state": "failed"}):
|
||||
with self.assertRaisesRegex(publication.Failed, "/build/42/"):
|
||||
checker.check()
|
||||
|
||||
|
||||
class WaitTests(unittest.TestCase):
|
||||
def test_transient_error_then_publication(self):
|
||||
with patch.object(publication.time, "sleep"), patch.object(publication.time, "monotonic", return_value=0):
|
||||
callback = unittest.mock.Mock(side_effect=[HTTPError("https://api", 503, "", {}, None), "published"])
|
||||
self.assertEqual(publication.wait(callback, 60, 5), "published")
|
||||
|
||||
def test_timeout_reports_last_external_status(self):
|
||||
with patch.object(publication.time, "monotonic", side_effect=[0, 61]):
|
||||
callback = unittest.mock.Mock(side_effect=publication.Pending("build 42 is running"))
|
||||
with self.assertRaisesRegex(publication.Failed, "build 42 is running"):
|
||||
publication.wait(callback, 60, 5)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user