mirror of
https://github.com/MacRimi/ProxMenux.git
synced 2026-11-01 10:22:08 +00:00
MacRimi
89fdfd0952
- Notification settings show the last 20 notifications with the result of each send, the error when one failed and every daily digest run, also on days with nothing to send; the history is read without the flag the API never returned, and the page does not offer to erase it, as Audit & Report reads it. - The Ctrl menu of the three web terminals sends Ctrl+D, which ends a text pasted in the terminal, also from a phone or a tablet. - The repository check lists every Proxmox VE or Enterprise Ceph repository whose suite does not match the installed version, with its channel and file, and says where to disable it; repository addresses are never shown. - Adding an NVIDIA GPU to a VM writes its VFIO udev rule again when it is missing or was edited, and the pre-check counts a missing rule as a pending host change. - New texts in English and Spanish, modelled in the translation steady-state test, and the notifications docs page describes the history section. - Corrected the automatic translations of the new LXC update and power control texts, and the start, shutdown, reboot and stop buttons of VMs and LXCs in German, French, Portuguese and Swedish. - Tests for the history panel, the terminal Ctrl+D, the repository message and the VFIO rule.
298 lines
17 KiB
Python
298 lines
17 KiB
Python
"""Frozen conservative recovery: update the fixture only after explicit review.
|
|
|
|
Run offline with Python unittest and Node >=22.14 on PATH (or NODE_BINARY).
|
|
The consumer test executes only extracted pure lookup functions, not the UI.
|
|
"""
|
|
import io
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from contextlib import redirect_stdout, redirect_stderr
|
|
from unittest import mock
|
|
|
|
from test_build_i18n_messages import MODULE, SCRIPT
|
|
|
|
ROOT = SCRIPT.parents[2]
|
|
FIXTURE = json.loads((Path(__file__).parent / "fixtures/command_descriptions.json").read_text())
|
|
|
|
|
|
def require_node():
|
|
diagnostic = "Node >=22.14 is required; install Node 22 LTS or set NODE_BINARY to its executable"
|
|
node = os.environ.get("NODE_BINARY") or shutil.which("node")
|
|
if not node:
|
|
raise AssertionError(diagnostic)
|
|
try:
|
|
result = subprocess.run([node, "--version"], capture_output=True, text=True)
|
|
except OSError as exc:
|
|
raise AssertionError(f"{diagnostic}; cannot execute {node}: {exc}") from exc
|
|
version = re.fullmatch(r"v(\d+)\.(\d+)\.(\d+)", result.stdout.strip())
|
|
if result.returncode or not version or tuple(map(int, version.groups())) < (22, 14, 0):
|
|
raise AssertionError(f"{diagnostic}; found {result.stdout.strip() or result.stderr.strip()!r}")
|
|
return node
|
|
|
|
|
|
def catalog(lang):
|
|
return json.loads((ROOT / f"AppImage/messages/{lang}/common.json").read_text())
|
|
|
|
|
|
class NodeRuntimeTests(unittest.TestCase):
|
|
def test_missing_node_reports_setup_instructions(self):
|
|
with mock.patch.dict(os.environ, {"PATH": "", "NODE_BINARY": ""}):
|
|
with self.assertRaisesRegex(AssertionError, r"Node >=22\.14.*NODE_BINARY"):
|
|
require_node()
|
|
|
|
def test_invalid_override_reports_setup_instructions(self):
|
|
with mock.patch.dict(os.environ, {"NODE_BINARY": "/nonexistent/f05-node"}):
|
|
with self.assertRaisesRegex(AssertionError, r"Node >=22\.14.*NODE_BINARY"):
|
|
require_node()
|
|
|
|
def test_older_node_reports_detected_version(self):
|
|
with mock.patch.dict(os.environ, {"NODE_BINARY": "node"}), \
|
|
mock.patch.object(subprocess, "run", return_value=subprocess.CompletedProcess(
|
|
["node", "--version"], 0, "v20.19.0\n", "")):
|
|
with self.assertRaisesRegex(AssertionError, r"Node >=22\.14.*v20\.19\.0"):
|
|
require_node()
|
|
|
|
|
|
class CommandDescriptionsTests(unittest.TestCase):
|
|
def test_real_catalogs_exact_indexed_recovery_and_source_order(self):
|
|
self.assertEqual(catalog("en")["terminal"]["commandDescriptions"], FIXTURE["english"])
|
|
consumer = (ROOT / "AppImage/components/terminal-panel.tsx").read_text()
|
|
commands = re.search(r"const proxmoxCommands = (\[.*?\])", consumer, re.S).group(1)
|
|
commands = json.loads(re.sub(r",\s*\]$", "]", commands))
|
|
self.assertEqual(commands, FIXTURE["commands"])
|
|
self.assertIn('desc: t(`terminal.commandDescriptions.${index}`)', consumer)
|
|
for lang, expected in FIXTURE["locales"].items():
|
|
with self.subTest(locale=lang):
|
|
actual = catalog(lang)["terminal"]["commandDescriptions"]
|
|
self.assertIsInstance(actual, list)
|
|
self.assertEqual(len(actual), len(commands))
|
|
self.assertEqual(actual, expected)
|
|
self.assertTrue(all(isinstance(x, str) and x for x in actual))
|
|
# Explicit English recovery values are frozen locale text, not live fallback.
|
|
for index in FIXTURE["fallback_indices"]:
|
|
self.assertEqual(catalog("sv")["terminal"]["commandDescriptions"][index],
|
|
FIXTURE["locales"]["sv"][index])
|
|
|
|
def test_workflow_default_catalogs_rerun_without_provider_or_writes(self):
|
|
workflow = (ROOT / ".github/workflows/build-i18n-messages.yml").read_text()
|
|
languages = re.search(r'LANGS="\$\{LANGS:-(.*?)\}"', workflow).group(1)
|
|
self.assertEqual(languages.split(","), list(MODULE.DEFAULT_LANGUAGES))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = Path(directory)
|
|
for lang in ["en", *languages.split(",")]:
|
|
path = root / lang / "common.json"
|
|
path.parent.mkdir()
|
|
shutil.copyfile(ROOT / f"AppImage/messages/{lang}/common.json", path)
|
|
# This steady-state fixture assumes generation already finished.
|
|
# Seed only intentional message additions; keep the
|
|
# recovered command arrays and the repo catalogs exact. Runtime
|
|
# missing-key fallback is covered by the JSX seam tests and by
|
|
# test_storage_messages.cjs and test_health_text.cjs.
|
|
if lang != "en":
|
|
temporary = json.loads(path.read_text())
|
|
for section, key in (
|
|
("archives", "emptyMessage"),
|
|
("archives", "formerJob"),
|
|
("archives", "formerJobTitle"),
|
|
("archives", "hiddenOtherNodes"),
|
|
("archives", "scopeAllNodes"),
|
|
("archives", "scopeAriaLabel"),
|
|
("archives", "scopeShowAll"),
|
|
("archives", "scopeThisNode"),
|
|
("destinations", "backupsKeptMessage"),
|
|
("destinations", "localAttachHelpMessage"),
|
|
):
|
|
temporary["backup"][section].setdefault(
|
|
key, catalog("en")["backup"][section][key])
|
|
temporary["storage"].setdefault(
|
|
"savedSmartData", catalog("en")["storage"]["savedSmartData"])
|
|
report = temporary["storage"]["smartReport"]
|
|
source_report = catalog("en")["storage"]["smartReport"]
|
|
for key in ("passedAssessment", "noReallocatedSectorsReported",
|
|
"passedMeaningTitle", "passedMeaning"):
|
|
report.setdefault(key, source_report[key])
|
|
for key in ("passedTitle", "passedText"):
|
|
report["recommendations"].setdefault(
|
|
key, source_report["recommendations"][key])
|
|
# New health-popup messages deliberately use runtime English
|
|
# fallback until each locale is translated. Model generator
|
|
# steady state only in this disposable copy, as for thermal keys.
|
|
for key in (
|
|
'certificateExpired',
|
|
'certificateExpiresDays',
|
|
'certificateInconclusive',
|
|
'cpuCheckFailed',
|
|
'cpuHighSustained',
|
|
'cpuSustained',
|
|
'fail2banCheckUnavailable',
|
|
'fail2banInactive',
|
|
'failedLoginsWithinThreshold',
|
|
'kernelPackagesMore',
|
|
'kernelPveUpdates',
|
|
'loginCheckUnavailable',
|
|
'memoryCheckFailed',
|
|
'memoryPressure',
|
|
'noFailedLogins',
|
|
'noSwapConfigured',
|
|
'noTemperatureSensor',
|
|
'nonRunningKernelUpdates',
|
|
'pendingPackageUpdates',
|
|
'pendingSecurityUpdates',
|
|
'pendingSecurityUpdatesDays',
|
|
'pendingSecurityUpdatesUnpatched',
|
|
'pveVersionAvailable',
|
|
'ramHighSustained',
|
|
'ramSustained',
|
|
'runningKernelUpdate',
|
|
'securityCheckUnavailable',
|
|
'sensorHighSamplesSpan',
|
|
'swapRamPressure',
|
|
'systemNotUpdatedMonths',
|
|
'systemNotUpdatedYear',
|
|
'temperatureElevated',
|
|
'unknownDetail',
|
|
'updatesAptError',
|
|
'updatesAptTimeout',
|
|
'updatesCheckUnavailable',
|
|
'uptimeKernelAdvice',
|
|
'uptimeUnavailable',
|
|
):
|
|
temporary["healthStatus"]["details"].setdefault(
|
|
key, catalog("en")["healthStatus"]["details"][key])
|
|
# New thermal messages also await automatic translation.
|
|
# Seed only these intentional additions in the temporary copy.
|
|
for key in (
|
|
"temperatureNoDisks", "temperatureNormal", "temperatureHighCount",
|
|
"temperatureCriticalCount", "temperatureUnavailable",
|
|
"temperatureIncomplete", "temperatureUnavailableCount",
|
|
):
|
|
temporary["storage"].setdefault(key, catalog("en")["storage"][key])
|
|
# Every shipped locale carries the temperature alert fallback
|
|
# keys; the seed only guards a catalog that lacks them. The
|
|
# runtime fallback is tested separately.
|
|
source_fallback = catalog("en")["runtime"]["notifications"]["fallback"]
|
|
fallback = temporary["runtime"]["notifications"]["fallback"]
|
|
for key in ("temperatureAlertTitle", "temperatureAlertBody",
|
|
"recordedReason", "recordedDetails"):
|
|
fallback.setdefault(key, source_fallback[key])
|
|
# Slovak remains the exact upstream catalog; model the
|
|
# pending outcome-key generator additions in disposable
|
|
# copies rather than modifying its curated values.
|
|
if lang == 'sk':
|
|
local = temporary['runtime']['notifications']
|
|
source = catalog('en')['runtime']['notifications']
|
|
for key, value in source['backup'].items():
|
|
local.setdefault('backup', {}).setdefault(key, value)
|
|
local['channels']['email']['status'].setdefault(
|
|
'unconfirmed', source['channels']['email']['status']['unconfirmed'])
|
|
local['channels']['email']['status'].setdefault(
|
|
'completed_with_warnings', source['channels']['email']['status']['completed_with_warnings'])
|
|
path.write_text(json.dumps(temporary, ensure_ascii=False))
|
|
# Model steady state after the bot fills these intentional new
|
|
# messages; keep repository locales and all other leaves intact.
|
|
if lang != "en":
|
|
messages = json.loads(path.read_text())
|
|
english = catalog("en")
|
|
for section, key in (("encryption", "pbsHelp"),
|
|
("keyfileActions", "pveKeyDescription")):
|
|
messages["backup"][section].setdefault(key, english["backup"][section][key])
|
|
for key in ("sshUserHelpMessage", "sshKeyHelpMessage", "sshKeySetupTitle",
|
|
"sshKeySetupHelp", "sshAuthorizedKeyHelp"):
|
|
messages["backup"]["destinations"].setdefault(
|
|
key, english["backup"]["destinations"][key])
|
|
messages["backup"]["actions"].setdefault(
|
|
"prepareSshKey", english["backup"]["actions"]["prepareSshKey"])
|
|
# New LXC observation labels intentionally ship only EN/SK.
|
|
# Model the bot's future output in temporary catalogs, just
|
|
# like the other pending keys above; never rewrite locales.
|
|
messages["scriptTerminal"].setdefault("endOfInput", english["scriptTerminal"]["endOfInput"])
|
|
# The notification history panel texts await the bot as well.
|
|
for key, value in english["settings"]["notifications"]["history"].items():
|
|
messages["settings"]["notifications"].setdefault("history", {}).setdefault(key, value)
|
|
for key in ("checkNow", "checkReadOnlyHelp", "checkCooldown",
|
|
"checkStale", "checkStaleHelp", "checkBeforeUpdate",
|
|
"startBeforeCheck", "notCheckedYet",
|
|
"checkStillRunning", "refreshCheckHelp",
|
|
"checkInProgress", "checkSystemPackages", "runCustomCommand",
|
|
"installedVersionUnverified", "versionStatusUnknown"):
|
|
messages["vmLxc"]["updates"].setdefault(
|
|
key, english["vmLxc"]["updates"][key])
|
|
for key in ("startPending", "shutdownPending", "rebootPending", "stopPending"):
|
|
messages["vmLxc"]["actions"].setdefault(
|
|
key, english["vmLxc"]["actions"][key])
|
|
for key in ("osDockerScope", "dockerImageMethod", "unverifiedTargetsHelp"):
|
|
messages["vmLxc"]["bulkUpdate"].setdefault(
|
|
key, english["vmLxc"]["bulkUpdate"][key])
|
|
messages["vmLxc"]["errors"].setdefault(
|
|
"controlNotConfirmed", english["vmLxc"]["errors"]["controlNotConfirmed"])
|
|
path.write_text(json.dumps(messages, ensure_ascii=False))
|
|
before = {p: p.read_bytes() for p in root.glob("*/common.json")}
|
|
argv = [str(SCRIPT), "--source", str(root / "en/common.json"),
|
|
"--messages-dir", str(root), "--languages", languages, "--sleep", "0"]
|
|
output = io.StringIO()
|
|
with mock.patch.object(sys, "argv", argv), \
|
|
mock.patch.object(MODULE, "translate_one", side_effect=AssertionError("provider forbidden")) as provider, \
|
|
mock.patch.object(MODULE, "write_json", side_effect=AssertionError("writes forbidden")) as writer, \
|
|
redirect_stdout(output), redirect_stderr(output):
|
|
result = MODULE.main()
|
|
self.assertEqual(result, 0, output.getvalue())
|
|
provider.assert_not_called()
|
|
writer.assert_not_called()
|
|
self.assertEqual(before, {p: p.read_bytes() for p in before})
|
|
for lang in languages.split(","):
|
|
self.assertIn(f"{lang}: nothing to translate", output.getvalue())
|
|
|
|
def test_actual_consumer_lookup_null_fallback_and_explicit_english(self):
|
|
node = require_node()
|
|
source = (ROOT / "AppImage/lib/i18n/provider.tsx").read_text()
|
|
functions = source[source.index("function getMessage("):source.index("export function I18nProvider(")]
|
|
lookup = re.search(r" const localized =.*?return interpolate\(.*?\)\n", source, re.S).group(0)
|
|
catalogs = {lang: catalog(lang) for lang in ["en", *FIXTURE["locales"]]}
|
|
script = ('import assert from "node:assert/strict";\n'
|
|
'type MessageTree = Record<string, unknown>;\n'
|
|
'type TranslationParams = Record<string, string | number>;\n' + functions +
|
|
'\nconst MESSAGE_CATALOG = ' + json.dumps(catalogs) + ';\n' +
|
|
'function t(language: string, key: string, params?: TranslationParams) {\n' + lookup + '}\n' +
|
|
'const fixture = ' + json.dumps(FIXTURE) + ';\n' + '''
|
|
fixture.english.forEach((text, i) => {
|
|
assert.equal(t("en", `terminal.commandDescriptions.${i}`), text);
|
|
});
|
|
for (const [lang, texts] of Object.entries(fixture.locales)) {
|
|
texts.forEach((text, i) => {
|
|
const key = `terminal.commandDescriptions.${i}`;
|
|
assert.equal(getMessage(MESSAGE_CATALOG[lang], key), text);
|
|
assert.equal(t(lang, key), text);
|
|
});
|
|
}
|
|
for (const i of fixture.fallback_indices) {
|
|
const key = `terminal.commandDescriptions.${i}`;
|
|
const selected = MESSAGE_CATALOG.sv.terminal.commandDescriptions[i];
|
|
MESSAGE_CATALOG.en.terminal.commandDescriptions[i] = "CHANGED EN";
|
|
assert.equal(t("sv", key), selected); // Explicit English is a locale value.
|
|
MESSAGE_CATALOG.sv.terminal.commandDescriptions[i] = null;
|
|
assert.equal(t("sv", key), "CHANGED EN"); // Null would dynamically fall back.
|
|
MESSAGE_CATALOG.sv.terminal.commandDescriptions[i] = "";
|
|
assert.equal(t("sv", key), ""); // Empty strings do NOT fall back.
|
|
}
|
|
assert.equal(t("sv", "missing.key"), "missing.key");
|
|
console.log("390 indexed consumer lookups; 15 explicit-English/null/empty cases passed");
|
|
''')
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = Path(directory) / "consumer.ts"
|
|
path.write_text(script)
|
|
result = subprocess.run([node, "--experimental-strip-types", str(path)],
|
|
capture_output=True, text=True)
|
|
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
|
self.assertIn("390 indexed consumer lookups", result.stdout)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|