feat: prepare 3.2.0 with Local Proxy and gateway IP preference

This commit is contained in:
Kevin Yue committed 2026-10-22 23:52:58 +08:00
1 parent 69d67721a6
commit 915c130c70
47 files changed
+3965 -233

No files matched your search

+1 -1
View File
@@ -24,7 +24,7 @@ for platform in linux bsd; do
installed="$stage/custom/gp"
test -x "$installed/bin/gpclient"
test -x "$installed/libexec/gpclient/gp-vpnc-script-installer"
grep -q 'Exec="/custom/gp/bin/gpclient" ' "$installed/share/applications/gpgui.desktop"
grep -Fxq 'Exec=/custom/gp/bin/gpclient launch-gui %u' "$installed/share/applications/gpgui.desktop"
grep -q '>/custom/gp/bin/gpservice<' "$installed/share/polkit-1/actions/com.yuezk.gpgui.policy"
grep -q '>/custom/gp/libexec/gpclient/gp-hip-script-installer<' "$installed/share/polkit-1/actions/com.yuezk.gpgui.policy"
! grep -F "$stage" "$installed/share/applications/gpgui.desktop"
+215
View File
@@ -0,0 +1,215 @@
import json
import os
from pathlib import Path
import re
import subprocess
import sys
import tempfile
import textwrap
import unittest
ROOT = Path(__file__).resolve().parents[2]
def run_block(path, step=None):
source = (ROOT / path).read_text()
if step:
source = source.split('- name: ' + step + '\n', 1)[1]
match = re.search(r'(?m)^( +)run: \|\n', source)
indent = len(match[1]) + 2
lines = []
for line in source[match.end():].splitlines():
if line.strip() and len(line) - len(line.lstrip()) < indent:
break
lines.append(line[indent:])
return '\n'.join(lines)
class PrivateOutputTests(unittest.TestCase):
def test_private_checkout_supports_branch_tag_and_sha_without_retaining_token(self):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
origin = root / 'origin'
subprocess.run(['git', 'init', '-b', 'main', str(origin)], check=True, capture_output=True)
git_env = dict(os.environ, GIT_AUTHOR_NAME='Test', GIT_AUTHOR_EMAIL='[email protected]',
GIT_COMMITTER_NAME='Test', GIT_COMMITTER_EMAIL='[email protected]')
subprocess.run(['git', '-C', str(origin), 'commit', '--allow-empty', '-m', 'PRIVATE_SUBJECT'],
env=git_env, check=True, capture_output=True)
subprocess.run(['git', '-C', str(origin), 'tag', 'v1.0.0'], check=True)
sha = subprocess.check_output(['git', '-C', str(origin), 'rev-parse', 'HEAD'], text=True).strip()
config = root / 'gitconfig'
config.write_text(f'[url "{origin.as_uri()}"]\n insteadOf = https://github.com/yuezk/gpgui\n')
for index, ref in enumerate(('main', 'v1.0.0', sha)):
destination = root / f'checkout-{index}'
env = dict(os.environ, GIT_CONFIG_GLOBAL=str(config), PRIVATE_TOKEN='test-token',
PRIVATE_REF=ref, PRIVATE_PATH=str(destination))
result = subprocess.run(['bash', '-e', '-o', 'pipefail', '-c',
run_block('.github/actions/checkout-private/action.yaml')],
env=env, text=True, capture_output=True)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertNotIn('PRIVATE_SUBJECT', result.stdout + result.stderr)
self.assertNotIn('test-token', (destination / '.git/config').read_text())
self.assertNotIn('extraheader', (destination / '.git/config').read_text())
actual = subprocess.check_output(['git', '-C', str(destination), 'rev-parse', 'HEAD'], text=True)
self.assertEqual(actual.strip(), sha)
def test_private_commands_hide_stdout_and_stderr_and_preserve_failure(self):
cases = [
('.github/workflows/build.yaml', 'Build macOS release artifacts'),
('.github/workflows/build.yaml', 'Build gpgui frontend'),
('.github/workflows/build-gpgui-linux.yaml', 'Build gpgui in Docker'),
('.github/workflows/publish-update-feeds.yaml', 'Install Worker tooling'),
('.github/workflows/publish-update-feeds.yaml', 'Deploy update feed worker'),
('.github/actions/checkout-private/action.yaml', None),
]
for path, step in cases:
for status in (0, 19):
with self.subTest(step=step, status=status), tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
stub = '#!/bin/sh\necho PRIVATE_STDOUT\necho PRIVATE_STDERR >&2\necho \"MACOS_STAGE: Signing\"\necho \"MACOS_STAGE: Signing PRIVATE_DETAIL\"\nexit "$TEST_STATUS"\n'
for command in ('git', 'docker', 'pnpm', 'source/gpgui/scripts/build-macos.sh'):
executable = root / command
executable.parent.mkdir(parents=True, exist_ok=True)
executable.write_text(stub)
executable.chmod(0o755)
(root / 'gpgui-frontend/gpgui/apps/desktop').mkdir(parents=True)
(root / 'gpgui/apps/update-feed-worker/public').mkdir(parents=True)
(root / 'updates').mkdir()
(root / 'updates/appcast.xml').write_text('fixture')
env = dict(os.environ, PATH=f'{root}:{os.environ["PATH"]}',
TEST_STATUS=str(status), CHANNEL='snapshot', GPGUI_BUILDER='fixture',
RUNNER_TEMP=str(root), UPDATES_WORKER_NAME='fixture',
PRIVATE_TOKEN='test-token', PRIVATE_REF='test-ref', PRIVATE_PATH='private')
result = subprocess.run(['bash', '-e', '-c', run_block(path, step)],
cwd=root, env=env, text=True, capture_output=True)
self.assertEqual(result.returncode, status, result.stdout + result.stderr)
self.assertNotIn('PRIVATE_STD', result.stdout + result.stderr)
self.assertNotIn('PRIVATE_DETAIL', result.stdout + result.stderr)
if step == 'Build macOS release artifacts':
self.assertIn('::notice::MACOS_STAGE: Signing', result.stdout)
self.assertNotIn('test-token', result.stdout + result.stderr)
self.assertIn('passed' if status == 0 else 'failed', result.stdout)
class PrivateTestStageTests(unittest.TestCase):
def run_stages(self, mode):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
docker = root / 'docker'
docker.write_text(textwrap.dedent('''\
#!/usr/bin/env python3
import json, os, sys, time
with open(os.environ['CALLS'], 'a') as output:
output.write(json.dumps(sys.argv[1:]) + '\\n')
print('PRIVATE_STDOUT')
print('PRIVATE_STDERR', file=sys.stderr)
if 'cargo' in sys.argv and '--no-run' not in sys.argv:
if os.environ['MODE'] == 'hang':
time.sleep(60)
if os.environ['MODE'] == 'fail':
sys.exit(19)
'''))
timeout = root / 'timeout'
timeout.write_text(textwrap.dedent('''\
#!/usr/bin/env python3
import subprocess, sys
assert sys.argv[1].startswith('--kill-after=')
assert sys.argv[2].endswith(('m', 's'))
try:
result = subprocess.run(sys.argv[3:], timeout=2)
sys.exit(result.returncode)
except subprocess.TimeoutExpired:
sys.exit(124)
'''))
for executable in (docker, timeout):
executable.write_text(executable.read_text().replace("#!/usr/bin/env python3", f"#!{sys.executable}"))
executable.chmod(0o755)
calls = root / 'calls.jsonl'
env = dict(os.environ, PATH=f'{root}:{os.environ["PATH"]}', MODE=mode, CALLS=str(calls))
result = subprocess.run(['bash', str(ROOT / 'scripts/test-private-desktop.sh'), str(root)],
env=env, text=True, capture_output=True, timeout=10)
self.assertNotIn('PRIVATE_STD', result.stdout + result.stderr)
recorded = [json.loads(line) for line in calls.read_text().splitlines()]
self.assertEqual(recorded[-1][:2], ['rm', '--force'])
return result
def test_success_reports_each_stage(self):
result = self.run_stages('success')
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertEqual(result.stdout.count(': started'), 7)
self.assertEqual(result.stdout.count(': passed'), 7)
self.assertIn('Compile Rust tests: passed', result.stdout)
self.assertIn('Rust tests: passed', result.stdout)
def test_failure_names_stage_and_preserves_exit(self):
result = self.run_stages('fail')
self.assertEqual(result.returncode, 19)
self.assertIn('Rust tests: failed', result.stdout)
self.assertNotRegex(result.stdout, r'(?m)^Rust tests: passed')
def test_hung_tests_report_timeout_and_cleanup(self):
result = self.run_stages('hang')
self.assertEqual(result.returncode, 124)
self.assertIn('Rust tests: timed out', result.stdout)
self.assertNotRegex(result.stdout, r'(?m)^Rust tests: passed')
class MacOSArtifactSelectionTests(unittest.TestCase):
def select(self, jobs, artifacts=None):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
gh = root / 'gh'
gh.write_text(textwrap.dedent('''\
#!/usr/bin/env python3
import json, os, re, sys
endpoint = sys.argv[3]
if endpoint.endswith('/artifacts'):
records = json.loads(os.environ['ARTIFACTS'])
else:
attempt = re.search(r'/attempts/([0-9]+)/jobs', endpoint)[1]
records = json.loads(os.environ['JOBS']).get(attempt, [])
for record in records:
print(json.dumps(record))
'''))
gh.chmod(0o755)
env = dict(os.environ, PATH=f'{root}:{os.environ["PATH"]}', JOBS=json.dumps(jobs),
ARTIFACTS=json.dumps(artifacts if artifacts is not None else [
{'name': 'macos-release-42.1.macos', 'expired': False}]))
return subprocess.run(['bash', str(ROOT / 'scripts/select-macos-artifact.sh'), 'owner/repo', '42', '3'],
env=env, capture_output=True, text=True)
def job(self, conclusion='success', status='completed'):
return {'name': 'build-macos', 'status': status, 'conclusion': conclusion}
def test_unrelated_reruns_reuse_successful_macos_attempt(self):
result = self.select({'1': [self.job()]})
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout.strip(), 'macos-release-42.1.macos')
def test_newer_macos_execution_wins(self):
result = self.select({'1': [self.job()], '3': [self.job()]}, [
{'name': f'macos-release-42.{attempt}.macos', 'expired': False} for attempt in (1, 3)])
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout.strip(), 'macos-release-42.3.macos')
def test_never_falls_back_past_failed_cancelled_skipped_or_running_macos(self):
for conclusion, status in [('failure', 'completed'), ('cancelled', 'completed'),
('skipped', 'completed'), (None, 'in_progress')]:
with self.subTest(conclusion=conclusion):
result = self.select({'1': [self.job()], '2': [self.job(conclusion, status)]})
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, '')
def test_missing_expired_or_duplicate_artifacts_are_rejected(self):
valid = {'name': 'macos-release-42.1.macos', 'expired': False}
for artifacts in ([], [dict(valid, expired=True)], [valid, valid]):
with self.subTest(artifacts=artifacts):
self.assertNotEqual(self.select({'1': [self.job()]}, artifacts).returncode, 0)
def test_missing_macos_job_is_rejected(self):
self.assertNotEqual(self.select({}).returncode, 0)
if __name__ == '__main__':
unittest.main()
@@ -0,0 +1,116 @@
import subprocess
import tempfile
import unittest
from pathlib import Path
REPOSITORY = "yuezk/GlobalProtect-openconnect"
SCRIPT = Path(__file__).parents[1] / "validate-macos-appcast.py"
def item(version, short_version, archive, channel=None):
channel_xml = f"<sparkle:channel>{channel}</sparkle:channel>" if channel else ""
return f"""
<item>
<sparkle:version>{version}</sparkle:version>
<sparkle:shortVersionString>{short_version}</sparkle:shortVersionString>
{channel_xml}
<enclosure url="{archive}" length="100" sparkle:edSignature="signature" />
</item>
"""
def appcast(*items):
return f"""<?xml version="1.0" encoding="utf-8"?>
<rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle">
<channel>{''.join(items)}</channel>
</rss>
"""
class ValidateMacosAppcastTests(unittest.TestCase):
def run_validator(self, content, *arguments):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "appcast.xml"
path.write_text(content, encoding="utf-8")
return subprocess.run(
["python3", str(SCRIPT), *arguments, str(path), "--repository", REPOSITORY],
check=False,
capture_output=True,
text=True,
)
def test_reports_candidate_status(self):
archive = f"https://github.com/{REPOSITORY}/releases/download/v2.6.4/GPConnect_2.6.4_arm64.zip"
content = appcast(item("806.1", "2.6.4", archive))
same = self.run_validator(
content, "status", "--build-version", "806.1"
)
newer = self.run_validator(
content, "status", "--build-version", "807.1"
)
older = self.run_validator(
content, "status", "--build-version", "805.1"
)
self.assertEqual((same.returncode, same.stdout.strip()), (0, "same"))
self.assertEqual((newer.returncode, newer.stdout.strip()), (0, "newer"))
self.assertEqual((older.returncode, older.stdout.strip()), (0, "older"))
def test_validates_stable_and_snapshot_items(self):
stable = f"https://github.com/{REPOSITORY}/releases/download/v2.6.4/GPConnect_2.6.4_arm64.zip"
snapshot = (
f"https://github.com/{REPOSITORY}/releases/download/snapshot/"
"GPConnect_2.6.4-snapshot.807.1_arm64.zip"
)
content = appcast(
item("806.1", "2.6.4", stable),
item("807.1", "2.6.4", snapshot, "snapshot"),
)
result = self.run_validator(
content,
"validate",
"--build-version",
"807.1",
"--short-version",
"2.6.4",
"--channel",
"snapshot",
"--archive-url",
snapshot,
)
self.assertEqual(result.returncode, 0, result.stderr)
def test_compares_builds_across_channels(self):
stable = f"https://github.com/{REPOSITORY}/releases/download/v2.6.4/GPConnect_2.6.4_arm64.zip"
snapshot = (
f"https://github.com/{REPOSITORY}/releases/download/snapshot/"
"GPConnect_2.6.4-snapshot.807.1_arm64.zip"
)
content = appcast(
item("2.6.4", "2.6.4", stable),
item("807.1", "2.6.4", snapshot, "snapshot"),
)
result = self.run_validator(
content, "status", "--build-version", "2.7.0"
)
self.assertEqual((result.returncode, result.stdout.strip()), (0, "older"))
def test_rejects_external_archive_urls(self):
content = appcast(item("806.1", "2.6.4", "https://example.com/update.zip"))
result = self.run_validator(
content, "status", "--build-version", "807.1"
)
self.assertNotEqual(result.returncode, 0)
self.assertIn("unexpected update archive URL", result.stderr)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,99 @@
import hashlib
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
spec = importlib.util.spec_from_file_location("macos_release", Path(__file__).parents[1] / "validate-macos-release.py")
release = importlib.util.module_from_spec(spec)
spec.loader.exec_module(release)
class MacOSReleaseTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.directory = Path(self.temp.name)
self.commit = "a" * 40
self.metadata = {"gp_ref": "b" * 40, "gpgui_ref": "d" * 40, "workflow_sha": self.commit, "channel": "stable",
"release_tag": "v3.0.1", "artifact_version": "3.0.1",
"request_id": "42.1.macos", "build_version": "903.1", "assets": {}}
for extension in ("dmg", "zip"):
name = f"GPConnect_3.0.1_arm64.{extension}"
content = b"signed artifact"
digest = hashlib.sha256(content).hexdigest()
(self.directory / name).write_bytes(content)
checksum = f"{digest} {name}\n".encode()
(self.directory / (name + ".sha256")).write_bytes(checksum)
self.metadata["assets"][name] = digest
self.metadata["assets"][name + ".sha256"] = hashlib.sha256(checksum).hexdigest()
self.save()
def save(self):
(self.directory / "release-build.json").write_text(json.dumps(self.metadata))
def test_matching_build_passes(self):
self.assertEqual(release.validate(self.directory, "v3.0.1", self.commit), self.metadata)
def test_another_release_cannot_use_this_build(self):
with self.assertRaisesRegex(ValueError, "release tag"):
release.validate(self.directory, "v3.0.2", self.commit)
def test_another_run_commit_cannot_use_this_build(self):
with self.assertRaisesRegex(ValueError, "public workflow"):
release.validate(self.directory, "v3.0.1", "c" * 40)
def test_source_commit_cannot_replace_workflow_identity(self):
with self.assertRaisesRegex(ValueError, "public workflow"):
release.validate(self.directory, "v3.0.1", self.metadata["gp_ref"])
def test_invalid_workflow_commit_is_rejected(self):
self.metadata["workflow_sha"] = "short"
self.save()
with self.assertRaisesRegex(ValueError, "Invalid workflow_sha"):
release.validate(self.directory, "v3.0.1", "short")
def test_corrupt_download_is_rejected(self):
(self.directory / "GPConnect_3.0.1_arm64.zip").write_bytes(b"changed")
with self.assertRaisesRegex(ValueError, "checksum mismatch"):
release.validate(self.directory, "v3.0.1", self.commit)
def test_unexpected_file_is_rejected(self):
(self.directory / "unexpected.dmg").write_bytes(b"extra")
with self.assertRaisesRegex(ValueError, "Unexpected"):
release.validate(self.directory, "v3.0.1", self.commit)
def test_missing_checksum_is_rejected(self):
self.metadata["assets"].pop("GPConnect_3.0.1_arm64.zip.sha256")
self.save()
with self.assertRaisesRegex(ValueError, "exactly"):
release.validate(self.directory, "v3.0.1", self.commit)
def test_snapshot_requires_matching_build_identity(self):
self.metadata.update(channel="snapshot", release_tag="snapshot",
artifact_version="3.0.1-snapshot.903.2")
self.save()
with self.assertRaisesRegex(ValueError, "snapshot artifact version"):
release.validate(self.directory, "snapshot", self.commit)
def test_matching_snapshot_passes(self):
version = "3.0.1-snapshot.903.1"
assets = {}
for name in self.metadata["assets"]:
file = self.directory / name
new_name = name.replace("3.0.1", version)
content = file.read_bytes()
if name.endswith(".sha256"):
content = content.replace(b"3.0.1", version.encode())
file.unlink()
(self.directory / new_name).write_bytes(content)
assets[new_name] = hashlib.sha256(content).hexdigest()
self.metadata.update(channel="snapshot", release_tag="snapshot",
artifact_version=version, assets=assets)
self.save()
self.assertEqual(release.validate(self.directory, "snapshot", self.commit), self.metadata)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,177 @@
import importlib.util
import json
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
MODULE_PATH = Path(__file__).parents[1] / "validate-update-manifest.py"
SPEC = importlib.util.spec_from_file_location("validate_update_manifest", MODULE_PATH)
MODULE = importlib.util.module_from_spec(SPEC)
assert SPEC.loader is not None
SPEC.loader.exec_module(MODULE)
REPOSITORY = "yuezk/GlobalProtect-openconnect"
class UpdateManifestTests(unittest.TestCase):
def stable(self, version="2.6.5"):
return {
"version": version,
"releasedAt": "2026-08-01",
"releaseUrl": f"https://github.com/{REPOSITORY}/releases/tag/v{version}",
"platforms": ["linux", "freebsd", "openbsd"],
"highlights": ["Stable release."],
}
def snapshot(self, base_version="2.6.5", build="17.1"):
return {
"baseVersion": base_version,
"build": build,
"releasedAt": "2026-08-07",
"releaseUrl": f"https://github.com/{REPOSITORY}/releases/tag/snapshot",
"platforms": ["linux", "freebsd", "openbsd"],
"highlights": ["Development snapshot."],
}
def manifest(self):
return {"schemaVersion": 1, "stable": self.stable(), "snapshot": self.snapshot()}
def generate(self, directory, channel, version, build=None, input_manifest=None):
directory = Path(directory)
highlights = directory / f"{channel}-highlights.txt"
output = directory / "latest.json"
highlights.write_text(f"{channel.title()} change.\n", encoding="utf-8")
args = type(
"Args",
(),
{
"repository": REPOSITORY,
"channel": channel,
"version": version,
"build": build,
"platform": None,
"released_at": "2026-08-07",
"highlights_file": highlights,
"input": input_manifest,
"output": output,
},
)()
MODULE.generate(args)
return json.loads(output.read_text(encoding="utf-8"))
def test_validates_catalog_with_both_channels(self):
result = MODULE.validate_manifest(self.manifest(), REPOSITORY)
self.assertEqual(result["stable"]["version"], "2.6.5")
self.assertEqual(result["snapshot"]["build"], "17.1")
def test_accepts_catalog_with_one_channel(self):
manifest = self.manifest()
manifest["stable"] = None
MODULE.validate_manifest(manifest, REPOSITORY)
def test_rejects_empty_catalog_and_unknown_fields(self):
with self.assertRaisesRegex(ValueError, "stable or snapshot"):
MODULE.validate_manifest({"schemaVersion": 1, "stable": None, "snapshot": None}, REPOSITORY)
manifest = self.manifest()
manifest["extra"] = True
with self.assertRaisesRegex(ValueError, "top-level"):
MODULE.validate_manifest(manifest, REPOSITORY)
def test_rejects_invalid_channel_urls(self):
manifest = self.manifest()
manifest["stable"]["releaseUrl"] = f"https://github.com/{REPOSITORY}/releases/tag/snapshot"
with self.assertRaisesRegex(ValueError, "stable releaseUrl"):
MODULE.validate_manifest(manifest, REPOSITORY)
manifest = self.manifest()
manifest["snapshot"]["releaseUrl"] = f"https://github.com/{REPOSITORY}/releases/tag/v2.6.5"
with self.assertRaisesRegex(ValueError, "snapshot releaseUrl"):
MODULE.validate_manifest(manifest, REPOSITORY)
def test_rejects_invalid_snapshot_build(self):
for build in ("", "17.beta", "01.1", "1.2.3.4", f"{2**64}.1"):
with self.subTest(build=build):
manifest = self.manifest()
manifest["snapshot"]["build"] = build
with self.assertRaisesRegex(ValueError, "snapshot build"):
MODULE.validate_manifest(manifest, REPOSITORY)
def test_rejects_version_components_larger_than_the_client_supports(self):
manifest = self.manifest()
manifest["stable"] = self.stable(f"{2**64}.0.0")
with self.assertRaisesRegex(ValueError, "integer range"):
MODULE.validate_manifest(manifest, REPOSITORY)
def test_rejects_unknown_and_duplicate_platforms(self):
manifest = self.manifest()
manifest["stable"]["platforms"] = ["linux", "netbsd"]
with self.assertRaisesRegex(ValueError, "unsupported"):
MODULE.validate_manifest(manifest, REPOSITORY)
manifest["stable"]["platforms"] = ["linux", "linux"]
with self.assertRaisesRegex(ValueError, "duplicates"):
MODULE.validate_manifest(manifest, REPOSITORY)
def test_generates_and_merges_channels(self):
with tempfile.TemporaryDirectory() as directory:
generated = self.generate(directory, "stable", "2.6.5")
self.assertIsNone(generated["snapshot"])
self.assertEqual(generated["stable"]["platforms"], ["linux", "freebsd", "openbsd"])
current = Path(directory) / "current.json"
current.write_text(json.dumps(generated), encoding="utf-8")
generated = self.generate(directory, "snapshot", "2.6.5", "17.1", current)
self.assertEqual(generated["stable"]["version"], "2.6.5")
self.assertEqual(generated["snapshot"]["baseVersion"], "2.6.5")
self.assertEqual(generated["snapshot"]["build"], "17.1")
def test_cli_limits_stable_to_published_platforms_and_preserves_snapshot(self):
with tempfile.TemporaryDirectory() as directory:
directory = Path(directory)
current = directory / "current.json"
current.write_text(json.dumps(self.manifest()), encoding="utf-8")
highlights = directory / "highlights.txt"
highlights.write_text("Refreshed client icons.\n", encoding="utf-8")
output = directory / "latest.json"
result = subprocess.run(
[sys.executable, str(MODULE_PATH), "generate", "--repository", REPOSITORY,
"--channel", "stable", "--version", "3.0.5", "--platform", "linux",
"--released-at", "2026-10-13", "--highlights-file", str(highlights),
"--input", str(current), "--output", str(output)],
capture_output=True, text=True,
)
self.assertEqual(result.returncode, 0, result.stderr)
generated = json.loads(output.read_text(encoding="utf-8"))
self.assertEqual(generated["stable"]["platforms"], ["linux"])
self.assertEqual(generated["snapshot"], self.snapshot())
def test_rejects_stable_and_snapshot_rollbacks(self):
with tempfile.TemporaryDirectory() as directory:
current = Path(directory) / "current.json"
current.write_text(json.dumps(self.manifest()), encoding="utf-8")
with self.assertRaisesRegex(ValueError, "stable version"):
self.generate(directory, "stable", "2.6.4", input_manifest=current)
with self.assertRaisesRegex(ValueError, "snapshot release"):
self.generate(directory, "snapshot", "2.6.5", "16.1", current)
def test_allows_new_stable_to_supersede_snapshot_base(self):
with tempfile.TemporaryDirectory() as directory:
current = Path(directory) / "current.json"
current.write_text(json.dumps(self.manifest()), encoding="utf-8")
generated = self.generate(directory, "stable", "2.6.6", input_manifest=current)
self.assertEqual(generated["stable"]["version"], "2.6.6")
self.assertEqual(generated["snapshot"]["baseVersion"], "2.6.5")
if __name__ == "__main__":
unittest.main()