🌈 Sync 2026-09-24 15:19:50

2026-10-31 07:35:13 +08:00 · 2026-09-24 15:19:50 +08:00
1 parent 765ac2b267
commit 87101cc7f2
@@ -0,0 +1,249 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { mkdtempSync, writeFileSync, rmSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const test = require('node:test');
+
+const root = path.join(__dirname, '..');
+const menuSource = fs.readFileSync(path.join(root, 'htdocs/luci-static/resources/menu-argon.js'), 'utf8');
+
+function element(tag, attrs = {}, children = []) {
+	const node = {
+		tag,
+		attrs,
+		children: [],
+		style: {},
+		appendChild(child) {
+			if (child && child.parent)
+				child.parent.children.splice(child.parent.children.indexOf(child), 1);
+			this.children.push(child);
+			if (child && typeof child === 'object')
+				child.parent = this;
+		}
+	};
+	for (const child of children)
+		node.appendChild(child);
+	return node;
+}
+
+String.prototype.format = function(...values) {
+	let i = 0;
+	return this.replace(/%s/g, () => values[i++]);
+};
+
+function loadMenu(dispatchpath, container) {
+	return new Function('baseclass', 'ui', 'L', 'E', 'document', '_', menuSource)(
+		{ extend: value => value },
+		{ menu: { getChildren: node => node.children || [] } },
+		{ env: { dispatchpath }, url: (...parts) => parts.join('/') },
+		element,
+		{ querySelector: () => container },
+		value => value
+	);
+}
+
+test('nested LuCI tabs stay in parent-to-child order', () => {
+	const container = element('div');
+	const menu = loadMenu(['admin', 'system', 'demo', 'a', 'b', 'c', 'd'], container);
+	const tree = { children: [{ name: 'a', title: 'A', children: [
+		{ name: 'b', title: 'B', children: [
+			{ name: 'c', title: 'C', children: [
+				{ name: 'd', title: 'D', children: [] }
+			] }
+		] }
+	] }] };
+
+	menu.renderTabMenu(tree, 'admin/system/demo');
+	assert.deepEqual(container.children.map(ul => ul.children[0].children[0].children[0]), ['A', 'B', 'C', 'D']);
+	assert.equal(container.children[0].children[0].attrs.class, 'tabmenu-item-a  active');
+	assert.equal(container.children[3].children[0].children[0].attrs.href, 'admin/system/demo/a/b/c/d');
+});
+
+function runUcodeSnippet(file, start, end, setup, result, settings = {}, hasConfig = true) {
+	const source = fs.readFileSync(path.join(root, file), 'utf8');
+	const first = source.indexOf(start);
+	const last = source.indexOf(end, first);
+	assert.ok(first >= 0 && last > first, `Cannot find Ucode snippet in ${file}`);
+	const dir = mkdtempSync(path.join(tmpdir(), 'argon-ucode-test-'));
+	const script = path.join(dir, 'test.uc');
+	writeFileSync(script, `${setup}\n${source.slice(first, last)}\nprint(sprintf("%J", ${result}));\n`);
+	try {
+		const output = execFileSync(process.env.UCODE_BIN || 'ucode', [
+			`-Dsettings=${JSON.stringify(settings)}`,
+			`-DhasConfig=${JSON.stringify(hasConfig)}`,
+			script
+		], { encoding: 'utf8' });
+		return JSON.parse(output);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+const configSetup = `
+let cfg = { get_first: (packageName, section, key) => settings[key] };
+function access(path) { return hasConfig; }
+`;
+const configResult = '{mode, primary, dark_primary, blur_radius, blur_radius_dark, blur_opacity, blur_opacity_dark, bar_color}';
+
+for (const template of ['header.ut', 'header_login.ut']) {
+	const file = `ucode/template/themes/argon/${template}`;
+	test(`${template} uses safe defaults for missing and invalid settings`, () => {
+		const empty = runUcodeSnippet(file, 'function validColor', '\n-%}', configSetup, configResult);
+		assert.deepEqual(empty, {
+			mode: 'normal', primary: '#5e72e4', dark_primary: '#483d8b',
+			blur_radius: '10', blur_radius_dark: '10',
+			blur_opacity: '0.5', blur_opacity_dark: '0.5', bar_color: '#5e72e4'
+		});
+		assert.deepEqual(runUcodeSnippet(file, 'function validColor', '\n-%}', configSetup, configResult, {}, false), empty);
+		const invalid = runUcodeSnippet(file, 'function validColor', '\n-%}', configSetup, configResult, {
+			primary: 'red;}', blur: '-1', transparency: '2', mode: 'unknown'
+		});
+		assert.deepEqual(invalid, empty);
+		const dark = runUcodeSnippet(file, 'function validColor', '\n-%}', configSetup, configResult, {
+			primary: '#123456', dark_primary: '#abcdef', blur: '0', transparency: '0.7', mode: 'dark'
+		});
+		assert.equal(dark.mode, 'dark');
+		assert.equal(dark.bar_color, '#abcdef');
+		assert.equal(dark.blur_radius, '0');
+		assert.equal(dark.blur_opacity, '0.7');
+		const light = runUcodeSnippet(file, 'function validColor', '\n-%}', configSetup, configResult, {
+			primary: '#123456', mode: 'light'
+		});
+		assert.equal(light.mode, 'light');
+		assert.equal(light.bar_color, '#123456');
+	});
+}
+
+test('local backgrounds accept dotted names and encode spaces', () => {
+	const setup = `
+let fs = { lsdir: path => ['photo.jpg', 'my.photo.jpg', 'space name.webp', 'hash#name.jpg', 'what?.png', 'VIDEO.MP4', 'notes.txt'] };
+let http = { urlencode: value => replace(replace(replace(value, ' ', '%20'), '#', '%23'), '?', '%3F') };
+`;
+	const backgrounds = runUcodeSnippet(
+		'ucode/template/themes/argon/sysauth.ut',
+		'const imageTypes', '\n\tfunction selectBackground',
+		setup, 'fetchMedia("/www/luci-static/argon/background", "/luci-static/argon/background/")'
+	);
+	assert.deepEqual(backgrounds.map(bg => bg.url), [
+		'/luci-static/argon/background/photo.jpg',
+		'/luci-static/argon/background/my.photo.jpg',
+		'/luci-static/argon/background/space%20name.webp',
+		'/luci-static/argon/background/hash%23name.jpg',
+		'/luci-static/argon/background/what%3F.png',
+		'/luci-static/argon/background/VIDEO.MP4'
+	]);
+	assert.deepEqual(backgrounds.map(bg => bg.type), ['jpg', 'jpg', 'webp', 'jpg', 'png', 'mp4']);
+});
+
+test('online wallpaper URLs require HTTPS and fall back locally', () => {
+	const setup = `
+let media = "/luci-static/argon";
+let fs = { access: path => true };
+let cfg = { get_first: (packageName, section, key) => key == 'online_wallpaper' ? 'bing' : null };
+let ubus = { call: (object, method) => ({ url: settings.url }) };
+let videoTypes = " mp4 webm ";
+function fetchMedia() {
+  if (settings.empty) return [];
+  if (settings.video) return [{ type: 'mp4', url: '/luci-static/argon/background/local.mp4' }];
+  return [{ type: 'jpg', url: '/luci-static/argon/background/local.jpg' }];
+}
+function randomIndex() { return 0; }
+`;
+	const file = 'ucode/template/themes/argon/sysauth.ut';
+	const start = 'function selectBackground';
+	const end = '\n\tconst boardinfo';
+	const selected = settings => runUcodeSnippet(file, start, end, setup, 'selectBackground("/luci-static/argon/background/")', settings);
+	assert.equal(selected({ url: 'https://example.com/image.jpg' }).bgUrl, 'https://example.com/image.jpg');
+	for (const invalid of ['http://example.com/image.jpg', 'https://example.com/a b.jpg', 'javascript:alert(1)', 'https://example.com/"bad'])
+		assert.equal(selected({ url: invalid }).bgUrl, '/luci-static/argon/background/local.jpg');
+	assert.equal(selected({ url: 'http://example.com/image.jpg', empty: true }).bgUrl, '/luci-static/argon/img/bg1.jpg');
+	assert.deepEqual(selected({ url: '', video: true }), {
+		bgUrl: '/luci-static/argon/background/local.mp4',
+		backgroundType: 'Video',
+		mimeType: 'video/mp4'
+	});
+});
+
+test('authentication fields preserve numeric length limits and escape attributes', () => {
+	const source = fs.readFileSync(path.join(root, 'ucode/template/themes/argon/sysauth.ut'), 'utf8');
+	const first = source.indexOf('{%- if (auth_fields): %}');
+	const last = source.indexOf('{%- if (auth_html): %}', first);
+	assert.ok(first >= 0 && last > first);
+	const dir = mkdtempSync(path.join(tmpdir(), 'argon-auth-test-'));
+	const script = path.join(dir, 'auth.ut');
+	// LuCI's html module returns null for non-string values, including numbers.
+	const setup = `{%
+function _(value) { return value; }
+function entityencode(value, attribute) {
+  if (type(value) != 'string') return null;
+  return replace(replace(replace(replace(value, '&', '&amp;'), '<', '&lt;'), '>', '&gt;'), '"', '&quot;');
+}
+%}`;
+	try {
+		writeFileSync(script, setup + source.slice(first, last));
+		const output = execFileSync(process.env.UCODE_BIN || 'ucode', [
+			'-T,', `-Dauth_fields=${JSON.stringify([{
+				name: 'luci_otp', type: 'text', label: 'One-Time Password',
+				placeholder: 'Code "123456"', inputmode: 'numeric', pattern: '[0-9]*',
+				maxlength: 6, autocomplete: 'one-time-code', required: true
+			}])}`, script
+		], { encoding: 'utf8' });
+		assert.match(output, /maxlength="6"/);
+		assert.match(output, /for="luci_otp">One-Time Password<\/label>/);
+		assert.match(output, /title="Code &quot;123456&quot;"/);
+		assert.match(output, /autocomplete="one-time-code"/);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test('Unsplash falls back on missing key or failed fetch', () => {
+	const source = fs.readFileSync(path.join(root, 'root/usr/libexec/rpcd/luci.argon_wallpaper'), 'utf8');
+	const imports = '. /lib/functions.sh\n. /usr/share/libubox/jshn.sh';
+	assert.ok(source.includes(imports));
+	const stub = `
+uci() {
+  case "$*" in
+    *online_wallpaper) printf '%s\\n' "$TEST_WALLPAPER" ;;
+    *use_api_key) [ -n "$TEST_KEY" ] && printf '%s\\n' "$TEST_KEY" ;;
+    *use_exact_resolution) printf '1\\n' ;;
+  esac
+}
+json_init() { json_url=''; }
+json_add_string() { [ "$1" = url ] && json_url="$2"; }
+json_dump() { printf '{"url":"%s"}\\n' "$json_url"; }
+json_cleanup() { :; }
+flock() { return 0; }
+wget() { return 1; }
+jsonfilter() { return 1; }
+`;
+	const dir = mkdtempSync(path.join(tmpdir(), 'argon-wallpaper-test-'));
+	try {
+		const script = path.join(dir, 'wallpaper.sh');
+		const cache = path.join(dir, 'wallpaper.url');
+		writeFileSync(cache, 'https://example.com/old.jpg\n');
+		writeFileSync(script, source.replace(imports, stub)
+			.replace('CACHE="/var/run/argon_${WEB_PIC_SRC}.url"', 'CACHE="$TEST_CACHE"')
+			.replace('WRLOCK="/var/lock/argon_${WEB_PIC_SRC}.lock"', 'WRLOCK="$TEST_LOCK"'));
+		for (const wallpaper of ['unsplash', 'unsplash_123']) {
+			const output = execFileSync('sh', [script, 'call', 'get_url'], {
+				input: '{}\n', encoding: 'utf8',
+				env: { ...process.env, TEST_WALLPAPER: wallpaper, TEST_KEY: '', TEST_CACHE: cache, TEST_LOCK: path.join(dir, 'lock') }
+			});
+			assert.deepEqual(JSON.parse(output), { url: '' });
+		}
+		rmSync(cache);
+		const failedFetch = execFileSync('bash', [script, 'call', 'get_url'], {
+			input: '{}\n', encoding: 'utf8',
+			env: { ...process.env, TEST_WALLPAPER: 'unsplash', TEST_KEY: 'test-key', TEST_CACHE: cache, TEST_LOCK: path.join(dir, 'lock') }
+		});
+		assert.deepEqual(JSON.parse(failedFetch), { url: '' });
+		assert.equal(fs.readFileSync(cache, 'utf8'), '');
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});