Files
reverse-engineering-anything/tests/boundary/android/jadxDoctor.test.ts
T
morluto 5d4e9b8532 refactor(android): take the host in JADX configuration, doctor and workspace roots (#11086)
* refactor(android): take the host in JADX configuration, doctor and workspace roots

* fix(android): pass the host in verifiers, follow it for JAVA_HOME, and test the native cache split

* test(platform): count tests that redefine process.platform or process.arch (#11102)

Tests select a host by injection. A redefined process.platform stops exercising its branch once the module under test reads HOST_PLATFORM, and still passes. A counted baseline (105 sites in 20 files) may only shrink; each module migration switches its tests to injection.
2026-11-15 20:52:58 +08:00

445 lines
15 KiB
TypeScript

import {
HOST_PLATFORM,
type HostPlatform,
} from "../../../src/platform/HostPlatform.js";
import { createInspectionResources } from "../../fixtures/inspectionResources.js";
import { chmod, mkdir, realpath, symlink, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { expect, it as test, onTestFinished } from "vitest";
import { inspectJadxProvider as inspectProvider } from "../../../src/android/JadxDoctor.js";
import { JADX_RELEASE } from "../../../src/android/JadxRelease.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import { writeJadxJarInventory } from "../../fixtures/android/jadxJar.js";
import { writeOrderedZip } from "../../fixtures/artifactEntryOrder.js";
const inspectionOwner = () => {
const resources = createInspectionResources();
onTestFinished(() => resources.close());
return resources.owner;
};
const inspectJadxProvider = (
environment: Parameters<typeof inspectProvider>[0],
host: HostPlatform = HOST_PLATFORM,
) => inspectProvider(environment, inspectionOwner(), host);
const it = test.skipIf(process.platform === "win32");
it("publishes REA_JADX_MCP_JAR as registration environment when the configured JAR validates", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection).toMatchObject({
id: "jadx",
configured: true,
available: true,
providerVersion: null,
registrationEnvironment: { REA_JADX_MCP_JAR: await realpath(jar) },
checks: [
{
name: "configuration",
ok: true,
code: null,
classification: "config_drift",
details: { operation_timeout_ms: 120_000 },
},
],
});
});
it("publishes JAVA_HOME alongside the JAR when the configured JAR validates", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-javahome-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection.registrationEnvironment).toEqual({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
});
it("preserves the caller-selected JAR path when it is a symlink", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-symlink-");
const jar = join(root, "jadx-headless-mcp.jar");
const link = join(root, "current.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
await symlink(jar, link);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: link,
JAVA_HOME: javaHome,
});
expect(inspection.available).toBe(true);
expect(inspection.registrationEnvironment["REA_JADX_MCP_JAR"]).toBe(link);
});
it("guides Java selection when the Java runtime is missing", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-remediation-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: join(root, "missing-jdk"),
});
expect(inspection.checks[0]?.code).toBe("runtime_missing");
expect(inspection.checks[0]?.remediation).toContain("JAVA_HOME");
expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");
});
it("guides Java selection when JAVA_HOME is not an absolute path", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-options-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: "relative/path",
});
expect(inspection.checks[0]?.code).toBe("open_options_invalid");
expect(inspection.checks[0]?.remediation).toContain("JAVA_HOME");
expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");
});
it("publishes no registration environment when REA_JADX_MCP_JAR is unset", async () => {
const inspection = await inspectJadxProvider({});
expect(inspection).toMatchObject({
id: "jadx",
configured: false,
available: false,
providerVersion: null,
registrationEnvironment: {},
checks: [
{
name: "configuration",
ok: false,
code: "not_configured",
classification: "missing_analysis_engine",
},
],
});
// The recovery names where to obtain the exact audited JAR.
expect(inspection.checks[0]?.remediation).toContain(JADX_RELEASE.url);
expect(inspection.checks[0]?.remediation).toContain(JADX_RELEASE.sha256);
});
it("reports a relative REA_JADX_MCP_JAR as a rejected selection, not an unset one", async () => {
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: "tools/jadx-headless-mcp.jar",
});
expect(inspection).toMatchObject({
id: "jadx",
configured: true,
available: false,
registrationEnvironment: {},
checks: [
{
name: "configuration",
ok: false,
code: "open_options_invalid",
classification: "config_drift",
},
],
});
expect(inspection.checks[0]?.detail).toContain(
'REA_JADX_MCP_JAR must be an absolute path; received "tools/jadx-headless-mcp.jar".',
);
expect(inspection.checks[0]?.remediation).toContain("REA_JADX_MCP_JAR");
});
it("publishes no registration environment when the configured JAR fails validation", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-invalid-");
const jar = join(root, "engine.jar");
const javaHome = await createFakeJdk(root);
await writeFile(jar, "not a Java archive");
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection).toMatchObject({
id: "jadx",
configured: true,
available: false,
registrationEnvironment: {},
checks: [
{
name: "configuration",
ok: false,
code: "version_unresolved",
classification: "config_drift",
},
],
});
expect(inspection.checks[0]?.detail).toContain("REA_JADX_MCP_JAR");
});
it("classifies a missing Java runtime as a missing dependency", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-runtime-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: join(root, "missing-jdk"),
});
expect(inspection).toMatchObject({
configured: true,
available: false,
registrationEnvironment: {},
checks: [
{
name: "configuration",
ok: false,
code: "runtime_missing",
classification: "missing_dependency",
},
],
});
});
it("guides JVM option correction when REA_JADX_HEAP_MIB is invalid", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-heap-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_HEAP_MIB: "not-a-number",
});
expect(inspection.checks[0]?.code).toBe("open_options_invalid");
expect(inspection.checks[0]?.remediation).toContain("REA_JADX_HEAP_MIB");
expect(inspection.checks[0]?.remediation).not.toContain("JAVA_HOME");
});
it("publishes validated JVM resource overrides in the registration environment", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-overrides-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_HEAP_MIB: "4096",
REA_JADX_ACTIVE_PROCESSOR_COUNT: "8",
});
expect(inspection.available).toBe(true);
expect(inspection.registrationEnvironment).toEqual({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_HEAP_MIB: "4096",
REA_JADX_ACTIVE_PROCESSOR_COUNT: "8",
});
});
it("publishes and reports a validated operation deadline", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-deadline-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_OPERATION_TIMEOUT_MS: "900000",
});
expect(inspection.registrationEnvironment).toEqual({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_OPERATION_TIMEOUT_MS: "900000",
});
expect(inspection.checks[0]).toMatchObject({
ok: true,
details: { operation_timeout_ms: 900_000 },
});
});
it("guides deadline correction when REA_JADX_OPERATION_TIMEOUT_MS is invalid", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-bad-deadline-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
REA_JADX_OPERATION_TIMEOUT_MS: "2147483648",
});
expect(inspection.available).toBe(false);
expect(inspection.registrationEnvironment).toEqual({});
expect(inspection.checks[0]).toMatchObject({
ok: false,
code: "open_options_invalid",
classification: "config_drift",
});
expect(inspection.checks[0]?.remediation).toContain(
"REA_JADX_OPERATION_TIMEOUT_MS",
);
expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");
});
it("guides JDK selection when the Java runtime is older than 17", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-oldjdk-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root, "11");
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection.checks[0]?.code).toBe("unsupported_version");
expect(inspection.checks[0]?.remediation).toContain("JDK");
expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");
});
it("guides JAR replacement when the JAR misses bridge classes", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-classes-");
const jar = join(root, "jadx-headless-mcp.jar");
const javaHome = await createFakeJdk(root);
await writeOrderedZip(jar, ["com/atxx/jhmcp/JadxSession.class"]);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection.checks[0]?.code).toBe("unsupported_version");
expect(inspection.checks[0]?.remediation).toContain("REA_JADX_MCP_JAR");
});
it("remediates an unsupported host with platform guidance", async () => {
const inspection = await inspectJadxProvider(
{ REA_JADX_MCP_JAR: "/opt/jadx-headless-mcp.jar" },
{ platform: "sunos", architecture: "x64" },
);
expect(inspection.checks[0]?.code).toBe("unsupported_host");
expect(inspection.checks[0]?.remediation).toContain("Linux");
});
it("guides Windows native package correction when process ownership is unavailable", async () => {
const inspection = await inspectJadxProvider(
{ REA_JADX_MCP_JAR: "/opt/jadx-headless-mcp.jar" },
{ platform: "win32", architecture: "x64" },
);
expect(inspection.checks[0]?.code).toBe("runtime_missing");
expect(inspection.checks[0]?.remediation).toContain(
"Windows x64 REA package",
);
expect(inspection.checks[0]?.remediation).not.toContain("JAVA_HOME");
});
it("guides Java probe correction when the module listing is unparseable", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-unparseable-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
// Fake JDK whose module listing lacks a parseable java.base version.
const javaHome = join(root, "fake-jdk");
const bin = join(javaHome, "bin");
const java = join(bin, "java");
await mkdir(bin, { recursive: true });
await writeFile(java, "#!/bin/sh\nprintf 'jdk.compiler@21\\n'\n");
await chmod(java, 0o700);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection.checks[0]?.code).toBe("version_unresolved");
expect(inspection.checks[0]?.remediation).toContain("java --list-modules");
expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");
});
const createFakeJdk = async (root: string, major = "21"): Promise<string> => {
const javaHome = join(root, "fake-jdk");
const bin = join(javaHome, "bin");
const java = join(bin, "java");
await mkdir(bin, { recursive: true });
await writeFile(
java,
`#!/bin/sh\nprintf 'java.base@${major}\\njdk.compiler@${major}\\n'\n`,
);
await chmod(java, 0o700);
return javaHome;
};
it("classifies missing Windows native artifacts as missing dependencies", async () => {
const inspection = await inspectJadxProvider(
{ REA_JADX_MCP_JAR: "/opt/jadx-headless-mcp.jar" },
{ platform: "win32", architecture: "x64" },
);
expect(inspection.checks[0]?.code).toBe("runtime_missing");
expect(inspection.checks[0]?.classification).toBe("missing_dependency");
});
it("classifies malformed JAVA_HOME as configuration drift", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-javahome-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: "relative/path",
});
expect(inspection.checks[0]?.code).toBe("open_options_invalid");
expect(inspection.checks[0]?.classification).toBe("config_drift");
});
it("preserves Java probe diagnostics in doctor output", async () => {
const root = await createTestTempDirectory("rea-jadx-doctor-probe-");
const jar = join(root, "jadx-headless-mcp.jar");
await writeJadxJarInventory(jar);
const javaHome = join(root, "fake-jdk-unparseable");
const bin = join(javaHome, "bin");
const java = join(bin, "java");
await mkdir(bin, { recursive: true });
// Emits jdk.compiler but no parseable java.base version.
await writeFile(java, `#!/bin/sh\nprintf 'jdk.compiler@21\\n'\n`);
await chmod(java, 0o700);
const inspection = await inspectJadxProvider({
REA_JADX_MCP_JAR: jar,
JAVA_HOME: javaHome,
});
expect(inspection.checks[0]?.code).toBe("version_unresolved");
expect(inspection.checks[0]?.details).toMatchObject({
java_executable: expect.any(String),
});
});