mirror of
https://github.com/kiddin9/op-packages.git
synced 2026-11-18 06:23:02 +08:00
🗽 Sync 2026-10-23 00:46:23
This commit is contained in:
1 parent
6032a57538
commit
2b29b0c4e1
112 files changed
+1859
-6208
No files matched your search
@@ -0,0 +1,171 @@
|
||||
"""Exercise feed publication against a local Git remote and an isolated hook."""
|
||||
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
from contextlib import redirect_stdout
|
||||
from unittest.mock import MagicMock, patch
|
||||
from urllib.error import HTTPError
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / '.github/scripts/publish_update_branch.py'
|
||||
SPEC = importlib.util.spec_from_file_location('update_branch', SCRIPT)
|
||||
PUBLISH = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(PUBLISH)
|
||||
HOOK = 'https://api.cloudflare.com/client/v4/pages/webhooks/deploy_hooks/test-secret-id'
|
||||
|
||||
|
||||
class UpdateBranchTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.directory = Path(self.temp.name)
|
||||
self.remote = self.directory / 'remote.git'
|
||||
self.repository = self.directory / 'checkout'
|
||||
self.site = self.directory / 'site'
|
||||
self.run_git('init', '--bare', str(self.remote))
|
||||
self.run_git('init', '-b', 'main', str(self.repository))
|
||||
self.git('config', 'user.name', 'Test Maintainer')
|
||||
self.git('config', 'user.email', 'test@example.invalid')
|
||||
(self.repository / 'README').write_text('Source branch\n')
|
||||
self.git('add', 'README')
|
||||
self.git('commit', '-m', 'Initial source')
|
||||
self.git('remote', 'add', 'origin', str(self.remote))
|
||||
self.git('push', 'origin', 'main')
|
||||
self.original = self.git('rev-parse', 'HEAD').strip()
|
||||
(self.site / 'updates').mkdir(parents=True)
|
||||
(self.site / '.nojekyll').touch()
|
||||
(self.site / '404.html').write_text('<title>Not found</title>\n')
|
||||
(self.site / '_headers').write_text('/updates/stable.json\n Cache-Control: max-age=300\n')
|
||||
(self.site / 'updates/stable.json').write_text(json.dumps({'schema': 1, 'tag': 'v3.1.0', 'notes': '更新'}))
|
||||
|
||||
def run_git(self, *arguments):
|
||||
return subprocess.check_output(['git', *arguments], stderr=subprocess.PIPE).decode()
|
||||
|
||||
def git(self, *arguments):
|
||||
return self.run_git('-C', str(self.repository), *arguments)
|
||||
|
||||
def remote_git(self, *arguments):
|
||||
return self.run_git('--git-dir', str(self.remote), *arguments)
|
||||
|
||||
def publish(self):
|
||||
return PUBLISH.publish(self.site, self.repository)
|
||||
|
||||
def test_first_publication_creates_only_the_feed_branch_and_preserves_dirty_checkout(self):
|
||||
(self.repository / 'README').write_text('Staged maintainer work\n')
|
||||
self.git('add', 'README')
|
||||
(self.repository / 'README').write_text('Unstaged maintainer work\n')
|
||||
before = self.git('status', '--porcelain')
|
||||
staged = self.git('diff', '--cached')
|
||||
commit, changed = self.publish()
|
||||
self.assertTrue(changed)
|
||||
self.assertEqual(self.git('status', '--porcelain'), before)
|
||||
self.assertEqual(self.git('diff', '--cached'), staged)
|
||||
self.assertEqual(self.git('rev-parse', 'HEAD').strip(), self.original)
|
||||
self.assertEqual(self.remote_git('rev-parse', 'main').strip(), self.original)
|
||||
self.assertEqual(self.remote_git('rev-list', '--parents', '-1', commit).split(), [commit])
|
||||
for path in self.site.rglob('*'):
|
||||
if path.is_file():
|
||||
self.assertEqual(self.remote_git('show', f'updates:{path.relative_to(self.site).as_posix()}'), path.read_text())
|
||||
self.assertEqual(self.remote_git('show', 'updates:.argon-update-feed').encode(), PUBLISH.MARKER)
|
||||
self.assertNotIn('README', self.remote_git('ls-tree', '-r', '--name-only', 'updates').splitlines())
|
||||
|
||||
def test_republication_preserves_history_and_identical_artifacts_are_idempotent(self):
|
||||
first, changed = self.publish()
|
||||
repeated, changed = self.publish()
|
||||
self.assertFalse(changed)
|
||||
self.assertEqual(repeated, first)
|
||||
(self.site / 'updates/stable.json').write_text(json.dumps({'schema': 1, 'tag': 'v3.1.1'}))
|
||||
second, changed = self.publish()
|
||||
self.assertTrue(changed)
|
||||
self.assertNotEqual(second, first)
|
||||
self.assertEqual(self.remote_git('rev-parse', 'updates^').strip(), first)
|
||||
self.assertEqual(self.remote_git('rev-list', '--count', 'updates').strip(), '2')
|
||||
|
||||
def test_unchanged_publication_still_triggers_an_optional_hook_for_retries(self):
|
||||
first, _ = self.publish()
|
||||
response = MagicMock()
|
||||
response.__enter__.return_value.status = 200
|
||||
with patch('sys.argv', [str(SCRIPT), '--site', str(self.site), '--repository', str(self.repository)]), \
|
||||
patch.dict(PUBLISH.os.environ, {'CF_PAGES_DEPLOY_HOOK': HOOK}), \
|
||||
patch.object(PUBLISH, 'urlopen', return_value=response) as request, redirect_stdout(io.StringIO()):
|
||||
PUBLISH.main()
|
||||
request.assert_called_once()
|
||||
self.assertEqual(self.remote_git('rev-parse', 'updates').strip(), first)
|
||||
|
||||
def test_unrelated_existing_updates_branch_is_not_replaced(self):
|
||||
self.git('push', 'origin', 'main:updates')
|
||||
with self.assertRaisesRegex(ValueError, 'not managed'):
|
||||
self.publish()
|
||||
self.assertEqual(self.remote_git('rev-parse', 'updates').strip(), self.original)
|
||||
|
||||
def test_concurrent_remote_change_is_rejected_without_force(self):
|
||||
first, _ = self.publish()
|
||||
tree = self.git('rev-parse', f'{first}^{{tree}}').strip()
|
||||
competitor = PUBLISH.git(self.repository, 'commit-tree', tree, '-p', first,
|
||||
data=b'Concurrent feed publication\n').stdout.decode().strip()
|
||||
(self.site / 'updates/stable.json').write_text(json.dumps({'schema': 1, 'tag': 'v3.1.1'}))
|
||||
original_git = PUBLISH.git
|
||||
|
||||
def concurrent_git(repository, *arguments, **kwargs):
|
||||
if arguments[0] == 'push':
|
||||
original_git(repository, 'push', 'origin', f'{competitor}:refs/heads/updates')
|
||||
return original_git(repository, *arguments, **kwargs)
|
||||
|
||||
with patch.object(PUBLISH, 'git', side_effect=concurrent_git), self.assertRaises(subprocess.CalledProcessError):
|
||||
self.publish()
|
||||
self.assertEqual(self.remote_git('rev-parse', 'updates').strip(), competitor)
|
||||
|
||||
def test_unexpected_or_linked_artifact_files_are_not_published(self):
|
||||
extra = self.site / 'unrelated.txt'
|
||||
extra.write_text('Do not publish')
|
||||
with self.assertRaises(ValueError):
|
||||
self.publish()
|
||||
extra.unlink()
|
||||
manifest = self.site / 'updates/stable.json'
|
||||
target = self.directory / 'external.json'
|
||||
manifest.rename(target)
|
||||
manifest.symlink_to(target)
|
||||
with self.assertRaises(ValueError):
|
||||
self.publish()
|
||||
self.assertEqual(self.remote_git('branch', '--list', 'updates'), '')
|
||||
|
||||
|
||||
class DeployHookTests(unittest.TestCase):
|
||||
def test_missing_hook_uses_git_integration_without_a_request(self):
|
||||
with patch.object(PUBLISH, 'urlopen') as request:
|
||||
self.assertFalse(PUBLISH.trigger_hook(''))
|
||||
request.assert_not_called()
|
||||
|
||||
def test_hook_sends_a_post_without_api_credentials_or_artifacts(self):
|
||||
response = MagicMock()
|
||||
response.__enter__.return_value.status = 200
|
||||
with patch.object(PUBLISH, 'urlopen', return_value=response) as request:
|
||||
self.assertTrue(PUBLISH.trigger_hook(HOOK))
|
||||
sent = request.call_args.args[0]
|
||||
self.assertEqual(sent.full_url, HOOK)
|
||||
self.assertEqual(sent.get_method(), 'POST')
|
||||
self.assertEqual(sent.data, b'')
|
||||
self.assertIsNone(sent.get_header('Authorization'))
|
||||
self.assertEqual(request.call_args.kwargs['timeout'], 30)
|
||||
|
||||
def test_http_errors_do_not_disclose_the_hook_url(self):
|
||||
with patch.object(PUBLISH, 'urlopen', side_effect=HTTPError(HOOK, 403, 'Forbidden', {}, None)):
|
||||
with self.assertRaises(RuntimeError) as failure:
|
||||
PUBLISH.trigger_hook(HOOK)
|
||||
self.assertNotIn(HOOK, str(failure.exception))
|
||||
self.assertNotIn('test-secret-id', str(failure.exception))
|
||||
|
||||
def test_other_endpoints_and_urls_containing_credentials_are_rejected(self):
|
||||
for url in ['http://api.cloudflare.com/client/v4/pages/webhooks/deploy_hooks/test',
|
||||
'https://unrelated.invalid/hook', HOOK + '?token=secret', HOOK + '#fragment',
|
||||
HOOK.replace('api.cloudflare.com', 'user:secret@api.cloudflare.com')]:
|
||||
with self.subTest(url=url), self.assertRaises(ValueError):
|
||||
PUBLISH.trigger_hook(url)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -9,7 +9,8 @@ import time
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
API = 'https://api.github.com/repos/jerrykuku/luci-theme-argon/releases/latest'
|
||||
PRIMARY = 'https://primary.argon.test/updates/stable.json'
|
||||
FALLBACK = 'https://fallback.argon.test/updates/stable.json'
|
||||
|
||||
|
||||
class UpdateRpcTests(unittest.TestCase):
|
||||
@@ -29,7 +30,12 @@ version) test "$COMPARE_FAIL" != 1 || exit 1; [ "$3" = "$4" ] && printf '=\\n' |
|
||||
add) printf '%s\\n' "$@" >> "$MUTATIONS"; test "$INSTALL_FAIL" != 1 || { echo 'database locked'; exit 1; }; test "$WRONG_VERSION" = 1 || printf '3.0.0-r2' > "$INSTALLED"; echo 'Theme installed' ;;
|
||||
esac
|
||||
''',
|
||||
'opkg': '''case "$1" in
|
||||
'opkg': '''if [ "$OPKG_QUERY_GUARD" = 1 ]; then
|
||||
exec 8>"$MUTATIONS.lock"
|
||||
flock -n 8 || exit 75
|
||||
sleep .05
|
||||
fi
|
||||
case "$1" in
|
||||
status) v=$OPKG_VERSION; [ ! -f "$INSTALLED" ] || v=$(cat "$INSTALLED"); test -n "$v" || exit 1; printf 'Package: luci-theme-argon\\nVersion: %s\\nStatus: install ok installed\\n' "$v" ;;
|
||||
compare-versions) [ "$3" = "<<" ] && [ "$COMPARE_FAIL" != 1 ] && [ "$2" != "$4" ] && [ "$2" != 3.0.0-20261015 ] ;;
|
||||
install) printf '%s\\n' "$@" >> "$MUTATIONS"; test "$INSTALL_FAIL" != 1 || { echo 'database locked'; exit 1; }; test "$WRONG_VERSION" = 1 || printf '3.0.0-2' > "$INSTALLED"; echo 'Theme installed' ;;
|
||||
@@ -40,10 +46,16 @@ esac
|
||||
test "$FETCH_FAIL" != 1 || exit 8
|
||||
while [ "$#" -gt 0 ]; do
|
||||
if [ "$1" = -O ]; then shift; destination=$1; fi
|
||||
url=$1
|
||||
shift
|
||||
done
|
||||
case "$destination" in
|
||||
*release.json) cp "$PAYLOAD" "$destination" ;;
|
||||
*manifest.json)
|
||||
sleep "${MANIFEST_DELAY:-0}"
|
||||
case "$url" in
|
||||
*primary.argon.test*) test "$PRIMARY_FAIL" != 1 || exit 8; cp "${PRIMARY_PAYLOAD:-$PAYLOAD}" "$destination" ;;
|
||||
*) cp "$PAYLOAD" "$destination" ;;
|
||||
esac ;;
|
||||
*) sleep "${DOWNLOAD_DELAY:-0}"; test "$DOWNLOAD_FAIL" != 1 || exit 8; cp "$PACKAGE_DATA" "$destination" ;;
|
||||
esac
|
||||
'''
|
||||
@@ -95,8 +107,11 @@ json_set_namespace() {{
|
||||
json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
''')
|
||||
self.script = self.directory / 'rpc.sh'
|
||||
sources = self.directory / 'sources.json'
|
||||
sources.write_text(json.dumps({'primary': PRIMARY, 'fallback': FALLBACK}))
|
||||
self.script.write_text((ROOT / 'root/usr/libexec/rpcd/luci.argon_update').read_text()
|
||||
.replace('/usr/share/libubox/jshn.sh', str(shim))
|
||||
.replace('/usr/share/argon/update-sources.json', str(sources))
|
||||
.replace('/var/run/argon-update/release.json', str(self.cache))
|
||||
.replace('/var/run/argon-update', str(self.directory / 'state')))
|
||||
self.env = dict(os.environ, PATH=str(fakebin) + os.pathsep + os.environ['PATH'],
|
||||
@@ -104,12 +119,12 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
REQUESTS=str(self.requests), FETCH_FAIL='0', INSTALLED=str(self.directory / 'installed'),
|
||||
MUTATIONS=str(self.directory / 'mutations'), PACKAGE_DATA=str(self.directory / 'package'))
|
||||
(self.directory / 'package').write_bytes(b'argon-package')
|
||||
self.release = {'tag_name': 'v3.0.0', 'draft': False, 'prerelease': False,
|
||||
'published_at': '2026-10-16T01:00:00Z', 'body': '## 更新\n- 修复布局。',
|
||||
'assets': [{'name': name, 'digest': 'sha256:' + hashlib.sha256(b'argon-package').hexdigest(), 'size': 13} for name in [
|
||||
'luci-theme-argon-3.0.0-r1.apk', 'luci-theme-argon_3.0.0_all.ipk',
|
||||
'luci-theme-argon-3.0.0-r2.apk', 'luci-theme-argon_3.0.0-2_all.ipk',
|
||||
'luci-theme-argon-3.0.0-r1.apk', 'luci-theme-argon_3.0.0_all.ipk']]}
|
||||
self.release = {'schema': 1, 'repository': 'jerrykuku/luci-theme-argon', 'tag': 'v3.0.0',
|
||||
'published_at': '2026-10-16T01:00:00Z', 'notes': '## 更新\n- 修复布局。',
|
||||
'ipk': 'luci-theme-argon_3.0.0-2_all.ipk', 'apk': 'luci-theme-argon-3.0.0-r2.apk',
|
||||
'ipk_sha256': hashlib.sha256(b'argon-package').hexdigest(),
|
||||
'apk_sha256': hashlib.sha256(b'argon-package').hexdigest(),
|
||||
'ipk_size': 13, 'apk_size': 13}
|
||||
self.payload.write_text(json.dumps(self.release))
|
||||
|
||||
def call(self, method, **arguments):
|
||||
@@ -133,16 +148,18 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
self.env['OPKG_VERSION'] = ''
|
||||
self.assertEqual(self.call('get')['current_version'], '')
|
||||
|
||||
def test_check_uses_official_url_and_highest_matching_revision(self):
|
||||
def test_check_uses_configured_static_source_and_ignores_rpc_urls(self):
|
||||
result = self.call('check', url='http://untrusted.invalid/', version='99.0.0')
|
||||
self.assertEqual(result['result'], 0)
|
||||
self.assertEqual(result['apk'], 'luci-theme-argon-3.0.0-r2.apk')
|
||||
self.assertEqual(result['ipk'], 'luci-theme-argon_3.0.0-2_all.ipk')
|
||||
self.assertEqual(result['notes'], self.release['body'])
|
||||
self.assertEqual(result['notes'], self.release['notes'])
|
||||
self.assertEqual(result['current_version'], '3.0.0-r1')
|
||||
requests = self.requests.read_text()
|
||||
self.assertIn(API, requests)
|
||||
self.assertIn('Cache-Control: no-cache', requests)
|
||||
self.assertIn(PRIMARY, requests)
|
||||
self.assertNotIn(FALLBACK, requests)
|
||||
self.assertNotIn('api.github.com', requests)
|
||||
self.assertNotIn('Cache-Control: no-cache', requests)
|
||||
self.assertNotIn('untrusted.invalid', requests)
|
||||
self.assertEqual(self.cache.stat().st_mode & 0o777, 0o600)
|
||||
|
||||
@@ -154,9 +171,77 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
self.assertEqual(self.requests.read_text(), before)
|
||||
self.assertEqual(self.call('get')['tag'], 'v3.0.0')
|
||||
|
||||
def test_primary_failure_and_invalid_primary_each_fall_back_to_one_complete_manifest(self):
|
||||
invalid = self.directory / 'invalid.json'
|
||||
invalid.write_text(json.dumps(dict(self.release, apk_sha256='invalid', notes='wrong source')))
|
||||
for patch in [{'PRIMARY_FAIL': '1'}, {'PRIMARY_PAYLOAD': str(invalid)}]:
|
||||
with self.subTest(patch=patch):
|
||||
self.cache.unlink(missing_ok=True)
|
||||
self.requests.unlink(missing_ok=True)
|
||||
old = self.env.copy()
|
||||
self.env.update(patch)
|
||||
checked = self.call('check')
|
||||
self.assertEqual(checked['result'], 0)
|
||||
self.assertEqual(checked['notes'], self.release['notes'])
|
||||
requests = self.requests.read_text()
|
||||
self.assertEqual(requests.count(PRIMARY), 1)
|
||||
self.assertEqual(requests.count(FALLBACK), 1)
|
||||
self.env = old
|
||||
|
||||
def test_failed_checks_have_a_cooldown_and_keep_the_previous_success(self):
|
||||
cached = self.call('check')
|
||||
cached['checked_at'] -= 400
|
||||
self.cache.write_text(json.dumps(cached))
|
||||
self.env['FETCH_FAIL'] = '1'
|
||||
failed = self.call('check')
|
||||
requests = self.requests.read_text()
|
||||
self.assertEqual(failed['result'], 1)
|
||||
self.assertGreater(failed['retry_at'], time.time())
|
||||
self.assertEqual(self.call('check')['retry_at'], failed['retry_at'])
|
||||
self.assertEqual(self.requests.read_text(), requests)
|
||||
self.assertEqual(self.call('get')['notes'], cached['notes'])
|
||||
(self.directory / 'state/retry_at').write_text(str(int(time.time()) - 1))
|
||||
self.env['FETCH_FAIL'] = '0'
|
||||
self.assertEqual(self.call('check')['result'], 0)
|
||||
self.assertFalse((self.directory / 'state/retry_at').exists())
|
||||
|
||||
def test_concurrent_checks_share_one_network_request(self):
|
||||
self.env['MANIFEST_DELAY'] = '1'
|
||||
processes = [subprocess.Popen(['sh', str(self.script), 'call', 'check'], env=self.env,
|
||||
stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE, text=True) for _ in range(3)]
|
||||
outputs = [process.communicate(timeout=20) for process in processes]
|
||||
for process, (output, errors) in zip(processes, outputs):
|
||||
self.assertEqual(process.returncode, 0, errors)
|
||||
self.assertEqual(json.loads(output)['result'], 0)
|
||||
self.assertEqual(self.requests.read_text().count(PRIMARY), 1)
|
||||
|
||||
def test_remote_fields_cannot_override_local_state_or_add_a_download_url(self):
|
||||
self.payload.write_text(json.dumps(dict(self.release, checked_at=1, result=99,
|
||||
current_version='99.0.0', url='https://untrusted.invalid/')))
|
||||
result = self.call('check')
|
||||
self.assertEqual(result['result'], 0)
|
||||
self.assertEqual(result['current_version'], '3.0.0-r1')
|
||||
self.assertGreater(result['checked_at'], 1)
|
||||
self.assertNotIn('url', result)
|
||||
|
||||
def test_parallel_opkg_queries_do_not_lose_versions_to_the_native_database_lock(self):
|
||||
self.env.update(APK_VERSION='', OPKG_VERSION='3.0.0-1', OPKG_QUERY_GUARD='1')
|
||||
self.assertTrue(self.call('check')['can_upgrade'])
|
||||
processes = [subprocess.Popen(['sh', str(self.script), 'call', 'get'], env=self.env,
|
||||
stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE, text=True) for _ in range(4)]
|
||||
outputs = [process.communicate(timeout=20) for process in processes]
|
||||
for process, (output, errors) in zip(processes, outputs):
|
||||
self.assertEqual(process.returncode, 0, errors)
|
||||
result = json.loads(output)
|
||||
self.assertEqual(result['current_version'], '3.0.0-1')
|
||||
self.assertTrue(result['can_upgrade'])
|
||||
|
||||
def test_expired_or_future_cache_refreshes_and_failed_refresh_keeps_notes(self):
|
||||
first = self.call('check')
|
||||
for checked_at in [int(time.time()) - 400, int(time.time()) + 1000]:
|
||||
(self.directory / 'state/retry_at').unlink(missing_ok=True)
|
||||
old = dict(first, checked_at=checked_at)
|
||||
self.cache.write_text(json.dumps(old))
|
||||
self.env['FETCH_FAIL'] = '1'
|
||||
@@ -165,23 +250,23 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
self.assertEqual(self.call('get')['notes'], first['notes'])
|
||||
|
||||
def test_invalid_and_prerelease_responses_never_enter_cache(self):
|
||||
for value in ['not JSON', '{}', '[]', json.dumps(dict(self.release, draft=True)),
|
||||
json.dumps(dict(self.release, prerelease=True)),
|
||||
json.dumps(dict(self.release, tag_name='v3.1.0-beta.1'))]:
|
||||
for value in ['not JSON', '{}', '[]', json.dumps(dict(self.release, schema=2)),
|
||||
json.dumps(dict(self.release, repository='other/repo')),
|
||||
json.dumps(dict(self.release, tag='v3.1.0-beta.1'))]:
|
||||
with self.subTest(value=value[:60]):
|
||||
(self.directory / 'state/retry_at').unlink(missing_ok=True)
|
||||
self.payload.write_text(value)
|
||||
self.assertNotEqual(self.call('check')['result'], 0)
|
||||
self.assertFalse(self.cache.exists())
|
||||
|
||||
def test_mismatched_and_unsafe_asset_names_are_ignored(self):
|
||||
self.release['assets'] = [{'name': name} for name in [
|
||||
def test_mismatched_and_unsafe_asset_names_are_rejected(self):
|
||||
for name in [
|
||||
'luci-theme-argon-4.0.0-r2.apk', 'luci-theme-argon_4.0.0_all.ipk',
|
||||
'luci-theme-argon-3.0.0-r2.apk?evil', 'luci-theme-argon_3.0.0-../../tmp_all.ipk']]
|
||||
self.payload.write_text(json.dumps(self.release))
|
||||
result = self.call('check')
|
||||
self.assertEqual(result['result'], 0)
|
||||
self.assertEqual(result['apk'], '')
|
||||
self.assertEqual(result['ipk'], '')
|
||||
'luci-theme-argon-3.0.0-r2.apk?evil', 'luci-theme-argon_3.0.0-../../tmp_all.ipk']:
|
||||
(self.directory / 'state/retry_at').unlink(missing_ok=True)
|
||||
self.payload.write_text(json.dumps(dict(self.release, apk=name)))
|
||||
self.assertNotEqual(self.call('check')['result'], 0)
|
||||
self.assertFalse(self.cache.exists())
|
||||
|
||||
def test_linked_cache_is_not_read_or_overwritten_and_failed_download_is_retryable(self):
|
||||
outside = self.directory / 'outside'
|
||||
@@ -191,6 +276,7 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
self.env['FETCH_FAIL'] = '1'
|
||||
self.assertEqual(self.call('check')['result'], 1)
|
||||
self.env['FETCH_FAIL'] = '0'
|
||||
(self.directory / 'state/retry_at').unlink(missing_ok=True)
|
||||
self.assertEqual(self.call('check')['result'], 0)
|
||||
self.assertEqual(outside.read_text(), 'keep me')
|
||||
|
||||
@@ -245,13 +331,14 @@ json_dump() {{ printf '%s\\n' "$FIXTURE_JSON"; }}
|
||||
self.assertEqual(self.start()['result'], 3)
|
||||
self.assertFalse((self.directory / 'mutations').exists())
|
||||
|
||||
def test_unverified_assets_remain_manual_downloads(self):
|
||||
for patch in [{'digest': None}, {'digest': 'bad'}, {'size': 0}, {'size': 9000000}]:
|
||||
def test_unverified_manifests_cannot_enable_installation(self):
|
||||
for patch in [{'apk_sha256': None}, {'apk_sha256': 'bad'}, {'apk_size': 0}, {'apk_size': 9000000}, {'apk_size': '08'}]:
|
||||
self.cache.unlink(missing_ok=True)
|
||||
release = dict(self.release, assets=[dict(self.release['assets'][2], **patch)])
|
||||
(self.directory / 'state/retry_at').unlink(missing_ok=True)
|
||||
release = dict(self.release, **patch)
|
||||
self.payload.write_text(json.dumps(release))
|
||||
checked = self.call('check')
|
||||
self.assertEqual(checked['apk'], 'luci-theme-argon-3.0.0-r2.apk')
|
||||
self.assertNotEqual(checked['result'], 0)
|
||||
self.assertFalse(checked['can_upgrade'])
|
||||
self.assertEqual(self.start()['result'], 3)
|
||||
self.assertFalse((self.directory / 'mutations').exists())
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
"""Verify the published update feed against release metadata and package bytes."""
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SCRIPT = ROOT / '.github/scripts/generate_update_site.py'
|
||||
sys.path.insert(0, str(SCRIPT.parent))
|
||||
SPEC = importlib.util.spec_from_file_location('update_site', SCRIPT)
|
||||
SITE = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(SITE)
|
||||
|
||||
|
||||
class UpdateSiteTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.directory = Path(self.temp.name)
|
||||
self.packages = self.directory / 'packages'
|
||||
self.packages.mkdir()
|
||||
self.output = self.directory / 'site'
|
||||
self.release = self.release_for('v3.0.0')
|
||||
|
||||
def release_for(self, tag):
|
||||
metadata = SITE.resolve(tag)
|
||||
release = {'tag_name': tag, 'draft': False, 'prerelease': False,
|
||||
'html_url': f'https://github.com/jerrykuku/luci-theme-argon/releases/tag/{tag}',
|
||||
'published_at': '2026-10-21T01:00:00Z', 'body': '## 更新\n- 修复布局。', 'assets': []}
|
||||
for name in [f'luci-theme-argon_{metadata["ipk_version"]}_all.ipk',
|
||||
f'luci-theme-argon-{metadata["apk_version"]}-r{metadata["package_release"]}.apk']:
|
||||
content = ('package bytes for ' + name).encode()
|
||||
(self.packages / name).write_bytes(content)
|
||||
release['assets'].append({'name': name, 'size': len(content),
|
||||
'digest': 'sha256:' + hashlib.sha256(content).hexdigest()})
|
||||
return release
|
||||
|
||||
def generate(self, release=None):
|
||||
return SITE.generate(release or self.release, self.packages, 'jerrykuku/luci-theme-argon', self.output)
|
||||
|
||||
def test_manifest_contains_exact_revision_names_digests_sizes_and_notes(self):
|
||||
for tag in ['v3.0.0', 'v3.1.0']:
|
||||
release = self.release_for(tag)
|
||||
manifest = self.generate(release)
|
||||
self.assertEqual(json.loads((self.output / 'updates/stable.json').read_text()), manifest)
|
||||
self.assertEqual(manifest['schema'], 1)
|
||||
self.assertEqual(manifest['tag'], tag)
|
||||
self.assertEqual(manifest['notes'], release['body'])
|
||||
for kind in ['apk', 'ipk']:
|
||||
content = (self.packages / manifest[kind]).read_bytes()
|
||||
self.assertEqual(manifest[kind + '_size'], len(content))
|
||||
self.assertEqual(manifest[kind + '_sha256'], hashlib.sha256(content).hexdigest())
|
||||
self.assertNotIn('checked_at', manifest)
|
||||
self.assertNotIn('url', manifest)
|
||||
|
||||
def test_no_site_is_written_for_drafts_previews_or_foreign_releases(self):
|
||||
for patch in [{'draft': True}, {'prerelease': True}, {'tag_name': 'v3.1.0-beta.1'},
|
||||
{'tag_name': 'latest'}, {'published_at': ''},
|
||||
{'html_url': 'https://github.com/other/repo/releases/tag/v3.0.0'}]:
|
||||
with self.subTest(patch=patch), self.assertRaises(ValueError):
|
||||
self.generate(dict(self.release, **patch))
|
||||
self.assertFalse(self.output.exists())
|
||||
|
||||
def test_missing_duplicate_or_mismatched_assets_block_publication(self):
|
||||
for mutate in [lambda release: release['assets'].pop(),
|
||||
lambda release: release['assets'].append(release['assets'][0]),
|
||||
lambda release: release['assets'][0].update(size=1),
|
||||
lambda release: release['assets'][0].update(digest='sha256:' + '0' * 64)]:
|
||||
release = copy.deepcopy(self.release)
|
||||
mutate(release)
|
||||
with self.assertRaises(ValueError):
|
||||
self.generate(release)
|
||||
self.assertFalse(self.output.exists())
|
||||
|
||||
def test_modified_or_linked_local_package_cannot_be_published(self):
|
||||
path = self.packages / self.release['assets'][0]['name']
|
||||
content = path.read_bytes()
|
||||
path.write_bytes(b'corrupted')
|
||||
with self.assertRaises(ValueError):
|
||||
self.generate()
|
||||
target = self.directory / 'external-package'
|
||||
target.write_bytes(content)
|
||||
path.unlink()
|
||||
path.symlink_to(target)
|
||||
with self.assertRaises(ValueError):
|
||||
self.generate()
|
||||
self.assertFalse(self.output.exists())
|
||||
|
||||
def test_large_notes_are_bounded_and_unknown_paths_return_real_404(self):
|
||||
self.release['body'] = '更新' * 40000
|
||||
manifest = self.generate()
|
||||
self.assertEqual(len(manifest['notes']), 32768)
|
||||
self.assertTrue((self.output / '404.html').is_file())
|
||||
self.assertIn('max-age=300', (self.output / '_headers').read_text())
|
||||
self.assertTrue((self.output / '.nojekyll').is_file())
|
||||
|
||||
def test_sources_support_an_unconfigured_primary_and_distinct_https_hosts(self):
|
||||
output = self.directory / 'sources.json'
|
||||
fallback = 'https://jerrykuku.github.io/luci-theme-argon/updates/stable.json'
|
||||
for primary in ['', 'https://owned-project.pages.dev/updates/stable.json', fallback]:
|
||||
SITE.configure_sources(primary, fallback, output)
|
||||
sources = json.loads(output.read_text())
|
||||
self.assertEqual(sources['fallback'], fallback)
|
||||
self.assertEqual(sources['primary'], '' if primary == fallback else primary)
|
||||
|
||||
def test_unsafe_or_incomplete_source_urls_are_rejected(self):
|
||||
for source in ['http://example.com/updates/stable.json', 'https://user:token@example.com/feed',
|
||||
'https://example.com:443/feed', 'https://example.com/feed?token=secret',
|
||||
'https://example.com/feed#part', 'https://example.com', 'file:///tmp/feed',
|
||||
'https://example.com/feed\n--no-check-certificate']:
|
||||
with self.subTest(source=source), self.assertRaises(ValueError):
|
||||
SITE.configure_sources(source, 'https://example.com/feed', self.directory / 'sources.json')
|
||||
with self.assertRaises(ValueError):
|
||||
SITE.configure_sources('', '', self.directory / 'sources.json')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -57,6 +57,16 @@ test('loading the settings reads local state without a remote check; checks are
|
||||
assert.equal(f.nodes.find(n => n.tag === 'details').open, true);
|
||||
});
|
||||
|
||||
test('failed checks show a cooldown time and retain previous version information', async () => {
|
||||
const f = fixture({ initial: checked('3.0.0-r1'), check: { result: 1, retry_at: Math.floor(Date.now() / 1000) + 60 } });
|
||||
await f.render();
|
||||
await f.button().click();
|
||||
assert.match(f.status(), /network connection/);
|
||||
assert.match(f.status(), /Try again after/);
|
||||
assert.equal(f.installButton().hidden, true);
|
||||
assert.ok(f.nodes.some(n => n.textContent === '3.0.0-r1'));
|
||||
});
|
||||
|
||||
test('package revisions, numeric versions, prereleases and locally newer builds compare correctly', async () => {
|
||||
for (const [current, latest, manager, expected] of [
|
||||
['3.0.0-r1', '3.0.0-r2', 'apk', 'Update available.'],
|
||||
|
||||
Reference in new issue
Block a user