Release 3.0.2

This commit is contained in:
Kevin Yue committed 2026-10-12 00:26:32 +08:00
1 parent 580b81e7bb
commit 888f288c0d
54 files changed
+4007 -374

No files matched your search

+200
View File
@@ -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'
+72
View File
@@ -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()
+120
View File
@@ -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()
+176
View File
@@ -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()