Files
reverse-engineering-anything/tests/process-global/cliLogging.test.ts
T
morluto 26d6cf39e6 test(cli): consolidate JSON admission and status checks (#11898)
* test(cli): consolidate JSON admission and status checks

* test(cli): retain delimiter-led paths in browser validation
2026-11-18 07:45:34 +08:00

229 lines
7.1 KiB
TypeScript

import pino from "pino";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { ArtifactOperationError } from "../../src/domain/artifactOperationError.js";
import { ConfigurationError } from "../../src/domain/configurationErrors.js";
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
import { isCliOperationFailure, logCliCommand } from "../../src/cliLogging.js";
import { silentLogger } from "../../src/logger.js";
import { runSetup } from "../../src/application/Setup.js";
import {
isSetupFailure,
type SetupResult,
} from "../../src/application/SetupTypes.js";
import {
FakeSetupHost,
options as setupOptions,
} from "../../src/application/Setup.fixture.js";
import { err } from "../../src/domain/result.js";
import { runUpdate, type UpdateHost } from "../../src/application/Update.js";
import { isUpdateFailure } from "../../src/application/UpdateFailure.js";
import {
runUninstall,
type UninstallHost,
} from "../../src/application/Uninstall.js";
import { isUninstallFailure } from "../../src/application/UninstallFailure.js";
import { CLI_COMMANDS } from "../../src/contracts/cliCommandNames.js";
const originalExitCode = process.exitCode;
beforeEach(() => {
process.exitCode = undefined;
});
afterEach(() => {
process.exitCode = originalExitCode;
});
it("logs error-looking source data as a successful command result", async () => {
const value = { error: "source data", code: "invalid_request" };
const records: unknown[] = [];
const logger = pino(
{ level: "info" },
{
write: (line) => records.push(JSON.parse(line) as unknown),
},
);
expect(await logCliCommand(logger, "fixture", async () => value)).toEqual(
value,
);
expect(process.exitCode).toBeUndefined();
expect(records).toEqual([
expect.objectContaining({
command: "fixture",
level: 30,
status: "ok",
msg: "CLI command completed",
}),
]);
});
it("does not classify nested Evidence as command failure", () => {
expect(
isCliOperationFailure({
result: projectAnalysisError(new ConfigurationError("source setting")),
}),
).toBe(false);
});
describe("CLI command outcome classification", () => {
it("returns nonzero for the UpdateResult failure variant", async () => {
const installation = {
manager: "npm",
prefix: "/fixture",
packageRoot: "/fixture/lib/node_modules/rea-agents",
} as const;
const updateHost: UpdateHost = {
installation: () => Promise.resolve(installation),
latestVersion: () =>
Promise.resolve(
err({ kind: "unavailable", detail: "registry unavailable" }),
),
installVersion: () => Promise.resolve(err("not called")),
installedVersion: () => Promise.resolve(err("not called")),
planMaintenance: () =>
Promise.resolve({ status: "current", plannedActions: [] }),
};
const result = await runUpdate("3.2.1", updateHost);
expect(result.status).toBe("failed");
const output = await logCliCommand(
silentLogger,
CLI_COMMANDS.update,
async () => result,
isUpdateFailure,
);
expect(output).toBe(result);
expect(process.exitCode).toBe(1);
});
it.each(["needs_confirmation", "needs_human"] as const)(
"returns nonzero for a real setup result with status %s",
async (expectedStatus) => {
const host = new FakeSetupHost();
const setup: SetupResult =
expectedStatus === "needs_human"
? await runSetup(
{ ...setupOptions(false), structured: false },
host,
() => Promise.resolve(true),
)
: await runSetup(
{ ...setupOptions(false), clientIds: ["cursor"] },
Object.assign(host, {
clients: [{ name: "cursor", configPath: "/cursor.json" }],
}),
);
expect(setup.status).toBe(expectedStatus);
const output = await logCliCommand(
silentLogger,
CLI_COMMANDS.setup,
async () => setup,
isSetupFailure,
);
expect(output).toBe(setup);
expect(process.exitCode).toBe(1);
},
);
it("returns nonzero when the real uninstall outcome contains a failed action", async () => {
const host: UninstallHost = {
clients: () => Promise.resolve([]),
inspectClient: () => Promise.resolve(undefined),
removeClient: () =>
Promise.resolve({ name: "client", status: "failed", detail: "write" }),
removeSkill: () =>
Promise.resolve({ name: "skill", status: "failed", detail: "write" }),
purgeData: () => Promise.resolve([]),
};
const result = await runUninstall(false, host);
expect(result.status).toBe("failed");
await logCliCommand(
silentLogger,
CLI_COMMANDS.uninstall,
async () => result,
isUninstallFailure,
);
expect(process.exitCode).toBe(1);
});
});
describe("CLI thrown analysis failures", () => {
it("returns the shared projection with actionable failure coordinates", async () => {
const projected = await logCliCommand(silentLogger, "fixture", async () => {
throw new ArtifactOperationError(
"analyze_javascript_application",
"integrity",
{
logicalPath: "src/main.js",
declaredSha256: "a".repeat(64),
calculatedSha256: "b".repeat(64),
unpacked: true,
},
);
});
expect(projected).toMatchObject({
code: "artifact_integrity_mismatch",
category: "integrity_mismatch",
details: {
logical_path: "src/main.js",
declared_sha256: "a".repeat(64),
calculated_sha256: "b".repeat(64),
},
});
});
});
describe("CLI successful setup outcomes", () => {
it.each(["planned", "cancelled"] as const)(
"keeps a real %s setup result successful",
async (status) => {
const host = new FakeSetupHost();
const result = await runSetup(
{
...setupOptions(false),
dryRun: status === "planned",
structured: status === "planned",
},
host,
() => Promise.resolve(false),
);
expect(result.status).toBe(status);
const output = await logCliCommand(
silentLogger,
CLI_COMMANDS.setup,
async () => result,
isSetupFailure,
);
expect(output).toBe(result);
expect(process.exitCode).toBeUndefined();
expect(host.hopperInstalls).toBe(0);
expect(host.configurations).toBe(0);
expect(host.skillInstalls).toBe(0);
},
);
});
describe("CLI structured failure output", () => {
it("sets a nonzero process status without replacing structured output", async () => {
const output = {
error: "Analysis failed",
...projectAnalysisError(
new ArtifactOperationError("inspect_artifact", "integrity", {
logicalPath: "main.js",
declaredSha256: "a".repeat(64),
calculatedSha256: "b".repeat(64),
unpacked: false,
}),
),
};
await expect(
logCliCommand(silentLogger, "inspect-artifact", () =>
Promise.resolve(output),
),
).resolves.toBe(output);
expect(process.exitCode).toBe(1);
});
});