test(tui): pin the runner locale and the update host so the suite is machine-independent (#137)

* test(vitest): pin the runner locale to the one CI uses

The TUI resolves its language from the environment: sessionMutationLocale()
falls back to Intl's resolved locale, which Node derives from LANG, and
packages/tui/src/update/messages.ts reads LC_ALL/LC_MESSAGES/LANG directly.
A developer shell running LANG=zh_CN.utf8 therefore renders Chinese copy
while the suites assert the English strings they ship, and 29 capability
tests fail on a host CI never exercises.

Spawn the suite with LC_ALL and LANG set to en_US.UTF-8 so every group runs
under one locale. Pinning the two variables together covers the Intl and the
environment lookup paths, which stubbing each test would miss. Fixing it in
the runner keeps the suites aligned with CI instead of teaching every
translation-sensitive assertion about the developer's shell.

Purely test infrastructure; no product behaviour changes.

* test(tui): pin the update-service host to a published release target

McodeUpdateService.check() calls resolveMcodeReleaseTarget() with no override,
so it reads process.platform and process.arch. release.ts publishes only
darwin-arm64, darwin-x64, linux-x64, windows-x64 and windows-arm64, and a
host outside that set — linux-arm64, for example — fails every check with
"Unsupported MCode update host" regardless of what the test asserts.

Pin both properties with Object.defineProperty in beforeEach and restore the
captured host descriptors in afterEach, so the rest of the process is
untouched. The fallback is linux-x64, a real REQUIRED_V1_TARGETS entry, so the
tests keep exercising a shipped target instead of an invented one.

Hosts that already publish keep their own platform and arch, which leaves the
win32-only install test on Windows driving the real win32 branch of
resolveMcodeInstallRoot and detectMcodeInstallSource.

Purely test infrastructure; release.ts TARGETS is unchanged, so whether
linux-arm64 should become a published target stays a product decision.

---------

Co-authored-by: s39-dev <s39-dev@local>

Author: fengzhi09

packages/tui/test/unit/update-service.test.ts

@@ -4,10 +4,10 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { McodeUpdateService, type McodeUpdateDependencies } from '../../src/update/service.js';
 import { resolveMcodeNpmDistribution } from '../../src/update/install-source.js';
-import type { McodeReleaseManifestV1 } from '../../src/update/release.js';
+import { resolveMcodeReleaseTarget, type McodeReleaseManifestV1 } from '../../src/update/release.js';
 
 const temporaryRoots: string[] = [];
 
@@ -56,6 +56,43 @@ afterEach(() => {
   }
 });
 
+// McodeUpdateService.check() resolves the release target from the running
+// process, so this file only runs on a host release.ts actually publishes for.
+// A host outside that set (linux-arm64, for example) fails every check with
+// "Unsupported MCode update host" no matter what the test asserts. Pin the
+// reported platform and arch to a real required target for the duration of
+// each test, and restore the host descriptors afterwards so the rest of the
+// process is unaffected. Hosts that already publish keep their own values,
+// which leaves the win32-only install test exercising the real win32 branch.
+const hostIsRequiredTarget = (() => {
+  try {
+    resolveMcodeReleaseTarget();
+    return true;
+  } catch {
+    return false;
+  }
+})();
+const pinnedTarget = hostIsRequiredTarget
+  ? { platform: process.platform, arch: process.arch }
+  : { platform: 'linux', arch: 'x64' };
+const hostDescriptors = {
+  platform: Object.getOwnPropertyDescriptor(process, 'platform'),
+  arch: Object.getOwnPropertyDescriptor(process, 'arch'),
+};
+
+beforeEach(() => {
+  for (const [key, value] of Object.entries(pinnedTarget)) {
+    Object.defineProperty(process, key, { value, configurable: true });
+  }
+});
+
+afterEach(() => {
+  for (const [key, descriptor] of Object.entries(hostDescriptors)) {
+    if (!descriptor) continue;
+    Object.defineProperty(process, key, descriptor);
+  }
+});
+
 describe('McodeUpdateService', () => {
   it
     .skipIf(process.platform !== 'win32')

scripts/run-vitest-suite.mjs

@@ -16,6 +16,16 @@ const cli = path.resolve(path.dirname(manifestPath), require(manifestPath).bin.v
 // https://github.com/libuv/libuv/issues/5010. Keep real filesystem watching in
 // the tests, but create their temporary fixtures beneath the canonical path.
 const environment = { ...process.env };
+// Assertions compare against the English copy the suites ship, but the TUI
+// picks its language from the environment: sessionMutationLocale() falls back to
+// Intl's resolved locale, which Node derives from LANG, and
+// packages/tui/src/update/messages.ts reads LC_ALL/LC_MESSAGES/LANG directly.
+// A developer shell with LANG=zh_CN.utf8 therefore renders Chinese TUI output
+// and fails English-only assertions that CI never sees. Pin both variables so
+// the suites run under the locale CI uses, and cover the Intl and environment
+// lookup paths together rather than stubbing each test.
+environment.LC_ALL = "en_US.UTF-8";
+environment.LANG = "en_US.UTF-8";
 if (process.platform === "win32") {
   environment.TEMP = environment.TMP = realpathSync.native(tmpdir());
 }