"""Run the real update RPC with isolated package managers, HTTP and cache files.""" import hashlib import json import os from pathlib import Path import subprocess import tempfile import time import unittest ROOT = Path(__file__).resolve().parents[1] PRIMARY = 'https://primary.argon.test/updates/stable.json' FALLBACK = 'https://fallback.argon.test/updates/stable.json' class UpdateRpcTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory() self.addCleanup(self.temp.cleanup) self.directory = Path(self.temp.name) self.cache = self.directory / 'cache.json' self.payload = self.directory / 'release.json' self.requests = self.directory / 'requests' fakebin = self.directory / 'bin' fakebin.mkdir() scripts = { 'apk': '''case "$1" in list) test -n "$APK_VERSION" || exit 1; v=$APK_VERSION; [ ! -f "$INSTALLED" ] || v=$(cat "$INSTALLED"); test -n "$v" || exit 1; printf 'luci-theme-argon-%s noarch [installed]\\n' "$v" ;; version) test "$COMPARE_FAIL" != 1 || exit 1; [ "$3" = "$4" ] && printf '=\\n' || { [ "$3" = 3.0.0-r20261015 ] && printf '>\\n' || 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': '''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' ;; esac ''', 'df': 'printf "Filesystem 1024-blocks Used Available Capacity Mounted on\\nroot 100000 1000 %s 1%% /\\n" "${FREE_KB:-99000}"\n', 'wget': '''printf '%s\\n' "$@" >> "$REQUESTS" 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 *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 ''' } for name, content in scripts.items(): path = fakebin / name path.write_text('#!/bin/sh\n' + content) path.chmod(0o755) helper = self.directory / 'json_fixture.py' helper.write_text('''import json,sys root=json.load(sys.stdin); path=json.loads(sys.argv[1]); op=sys.argv[2]; args=sys.argv[3:] obj=root for key in path: obj=obj[int(key)] if isinstance(obj,list) else obj[key] if op=='select': if args[0]=='..': path=path[:-1] else: child=obj[int(args[0])] if isinstance(obj,list) else obj[args[0]] if not isinstance(child,(dict,list)): raise ValueError('not a container') path.append(args[0]) print(json.dumps(path)) elif op=='keys': print(' '.join(map(str,range(len(obj)) if isinstance(obj,list) else obj.keys()))) elif op=='get': value=obj.get(args[0],'') print(int(value) if isinstance(value,bool) else '' if value is None else value) elif op=='add': obj[args[1]]=int(args[2]) if args[0]=='int' else bool(int(args[2])) if args[0]=='boolean' else {} if args[0]=='object' else args[2] print(json.dumps(root)) elif op=='validate': if not isinstance(root,(dict,list)): raise ValueError('invalid root') ''') shim = self.directory / 'jshn.sh' shim.write_text(f'''fixture_json() {{ printf '%s' "$FIXTURE_JSON" | python3 '{helper}' "$FIXTURE_PATH" "$@"; }} json_load() {{ FIXTURE_JSON=$1; FIXTURE_PATH='[]'; fixture_json validate >/dev/null 2>&1; }} json_load_file() {{ json_load "$(cat "$1")"; }} json_init() {{ FIXTURE_JSON='{{}}'; FIXTURE_PATH='[]'; }} json_get_var() {{ fixture_value=$(fixture_json get "$2"); export "$1=$fixture_value"; }} json_get_keys() {{ fixture_value=$(fixture_json keys); export "$1=$fixture_value"; }} json_select() {{ fixture_value=$(fixture_json select "$1" 2>/dev/null) || return 1; FIXTURE_PATH=$fixture_value; }} json_add_string() {{ FIXTURE_JSON=$(fixture_json add string "$1" "$2"); }} json_add_int() {{ FIXTURE_JSON=$(fixture_json add int "$1" "$2"); }} json_add_boolean() {{ FIXTURE_JSON=$(fixture_json add boolean "$1" "$2"); }} json_add_object() {{ FIXTURE_JSON=$(fixture_json add object "$1" ''); json_select "$1"; }} json_close_object() {{ json_select ..; }} json_set_namespace() {{ if [ "$1" = upgrade_status ]; then FIXTURE_SAVED_JSON=$FIXTURE_JSON; FIXTURE_SAVED_PATH=$FIXTURE_PATH; export "$2=base"; else FIXTURE_JSON=$FIXTURE_SAVED_JSON; FIXTURE_PATH=$FIXTURE_SAVED_PATH; fi }} 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'], APK_VERSION='3.0.0-r1', OPKG_VERSION='', PAYLOAD=str(self.payload), 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 = {'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): result = subprocess.run(['sh', str(self.script), 'call', method], input=json.dumps(arguments) + '\n', env=self.env, capture_output=True, text=True, check=True) return json.loads(result.stdout) def test_local_get_and_protocol_have_no_network_or_package_mutation(self): result = self.call('get') self.assertEqual(result['result'], 0) self.assertEqual(result['current_version'], '3.0.0-r1') self.assertFalse(result['can_upgrade']) self.assertEqual(result['upgrade']['phase'], 'idle') self.assertFalse(self.requests.exists()) protocol = subprocess.check_output(['sh', str(self.script), 'list'], text=True) self.assertEqual(json.loads(protocol), {'get': {}, 'check': {}, 'status': {}, 'start': {'tag': 'String', 'package': 'String'}}) self.env.update(APK_VERSION='', OPKG_VERSION='3.0.0-2') self.assertEqual(self.call('get')['package_manager'], 'opkg') self.assertEqual(self.call('get')['current_version'], '3.0.0-2') self.env['OPKG_VERSION'] = '' self.assertEqual(self.call('get')['current_version'], '') 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['notes']) self.assertEqual(result['current_version'], '3.0.0-r1') requests = self.requests.read_text() 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) def test_success_cache_avoids_network_but_reloads_the_installed_version(self): self.call('check') before = self.requests.read_text() self.env['APK_VERSION'] = '3.0.0-r2' self.assertEqual(self.call('check')['current_version'], '3.0.0-r2') 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' self.assertEqual(self.call('check')['result'], 1) self.assertEqual(json.loads(self.cache.read_text()), old) 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, 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_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.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' outside.write_text('keep me') self.cache.symlink_to(outside) self.assertNotIn('tag', self.call('get')) 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') def test_acl_separates_read_only_status_and_write_install(self): acl = json.loads((ROOT / 'root/usr/share/rpcd/acl.d/luci-app-argon-config.json').read_text())['luci-app-argon-config'] self.assertEqual(set(acl['read']['ubus']['luci.argon_update']), {'get', 'check', 'status'}) self.assertEqual(acl['write']['ubus']['luci.argon_update'], ['start']) def start(self, **patch): return self.call('start', **dict({'tag': 'v3.0.0', 'package': 'luci-theme-argon-3.0.0-r2.apk' if self.env['APK_VERSION'] else 'luci-theme-argon_3.0.0-2_all.ipk'}, **patch)) def finished(self): for _ in range(100): result = self.call('status') if not result['upgrade']['active']: return result time.sleep(.05) self.fail('worker did not finish') def test_background_install_for_both_managers_and_status_survives_reloads(self): for manager in ['apk', 'opkg']: with self.subTest(manager=manager): installed = self.directory / 'installed' installed.unlink(missing_ok=True) self.env.update(APK_VERSION='3.0.0-r1' if manager == 'apk' else '', OPKG_VERSION='3.0.0-1' if manager == 'opkg' else '') checked = self.call('check') self.assertTrue(checked['can_upgrade']) self.assertEqual(self.start()['result'], 0) done = self.finished() self.assertEqual(done['upgrade']['phase'], 'complete', done) self.assertEqual(done['current_version'], '3.0.0-r2' if manager == 'apk' else '3.0.0-2') self.assertFalse(self.call('get')['can_upgrade']) self.assertEqual(self.call('get')['upgrade']['phase'], 'complete') command = (self.directory / 'mutations').read_text() self.assertNotIn('force-', command) self.assertIn('Theme installed', done['upgrade']['log']) self.assertEqual((self.directory / 'state/status.json').stat().st_mode & 0o777, 0o600) self.assertEqual(list((self.directory / 'state').glob('job.*')), []) def test_start_rejects_changed_or_expired_metadata_unknown_versions_and_downgrades(self): self.assertEqual(self.start()['result'], 3) initial = self.call('check') for patch in [{'tag': 'v4.0.0'}, {'package': '../../unsafe.apk'}, {'package': 'luci-theme-argon-3.0.0-r1.apk'}]: self.assertEqual(self.start(**patch)['result'], 3) for value in ['unknown', '3.0.0-r2', '3.0.0-r20261015']: self.env['APK_VERSION'] = value self.assertEqual(self.start()['result'], 5) self.env['APK_VERSION'] = '3.0.0-r1' self.cache.write_text(json.dumps(dict(initial, checked_at=int(time.time()) - 301))) self.assertEqual(self.start()['result'], 3) self.assertFalse((self.directory / 'mutations').exists()) 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) (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.assertNotEqual(checked['result'], 0) self.assertFalse(checked['can_upgrade']) self.assertEqual(self.start()['result'], 3) self.assertFalse((self.directory / 'mutations').exists()) def test_download_checksum_storage_and_package_manager_failures_are_retryable(self): self.call('check') for patch, error in [({'DOWNLOAD_FAIL': '1'}, 'network'), ({'FREE_KB': '10'}, 'space'), ({'INSTALL_FAIL': '1'}, 'install'), ({'WRONG_VERSION': '1'}, 'install')]: with self.subTest(error=error): old = self.env.copy() self.env.update(patch) self.assertEqual(self.start()['result'], 0) result = self.finished() self.assertEqual(result['upgrade']['phase'], 'failed') self.assertEqual(result['upgrade']['error'], error, result) self.env = old (self.directory / 'package').write_bytes(b'wrong-package') self.assertEqual(self.start()['result'], 0) self.assertEqual(self.finished()['upgrade']['error'], 'checksum') (self.directory / 'package').write_bytes(b'argon-package') self.assertEqual(self.start()['result'], 0) self.assertEqual(self.finished()['upgrade']['phase'], 'complete') def test_one_worker_at_a_time_and_private_metadata_snapshot(self): self.call('check') self.env['DOWNLOAD_DELAY'] = '4' start = time.monotonic() self.assertEqual(self.start()['result'], 0) self.assertLess(time.monotonic() - start, 3) self.assertEqual(self.start()['result'], 4) self.assertTrue(self.call('get')['upgrade']['active']) cached = json.loads(self.cache.read_text()) cached['apk_sha256'] = '0' * 64 self.cache.write_text(json.dumps(cached)) self.assertEqual(self.finished()['upgrade']['phase'], 'complete') mutations = (self.directory / 'mutations').read_text() self.assertEqual(mutations.count('add'), 1) def test_version_is_rechecked_after_download_before_mutation(self): self.call('check') self.env['DOWNLOAD_DELAY'] = '2' self.assertEqual(self.start()['result'], 0) (self.directory / 'installed').write_text('3.0.0-r2') self.assertEqual(self.finished()['upgrade']['error'], 'version') self.assertFalse((self.directory / 'mutations').exists()) def test_internal_worker_refuses_to_run_or_clean_up_outside_its_private_job(self): result = subprocess.run(['sh', str(self.script), 'run', 'apk'], env=self.env, capture_output=True, text=True) self.assertNotEqual(result.returncode, 0) self.assertTrue(self.script.exists()) self.assertTrue(self.payload.exists()) self.assertFalse((self.directory / 'mutations').exists()) def test_interrupted_job_is_reported_without_a_stale_lock(self): state = self.directory / 'state' state.mkdir() (state / 'status.json').write_text(json.dumps({'phase': 'installing', 'version': '3.0.0-r2', 'error': ''})) self.assertEqual(self.call('status')['upgrade']['error'], 'interrupted') self.call('check') self.assertEqual(self.start()['result'], 0) self.assertEqual(self.finished()['upgrade']['phase'], 'complete') if __name__ == '__main__': unittest.main()