mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 03:33:25 +00:00
* refactor(errors): read cleanup completion from dependencies instead of pushing it to dependents AnalysisError.cleanupIncomplete becomes a getter over the error's own unresolved state and its bound dependencies. The WeakRef dependents graph and resolveCleanup's push propagation are removed, and subclasses mark their initial state through markCleanupIncomplete instead of overriding a public mutable field. * fix(errors): settle bound dependencies before binding more A composite whose dependencies had released but whose status was never read stayed incomplete when a later dependency was bound. * refactor(errors): let errors read a lease group's release instead of resolving them (#10759) AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink (#10763) * refactor(errors): let errors read a lease group's release instead of resolving them AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink
527 lines
18 KiB
TypeScript
527 lines
18 KiB
TypeScript
import { expect, it } from "vitest";
|
|
import {
|
|
AnalysisCancelledError,
|
|
AnalysisCapabilityUnavailableError,
|
|
AnalysisInputError,
|
|
AnalysisOutputError,
|
|
AnalysisResourceConstraintError,
|
|
AnalysisTimeoutError,
|
|
} from "./analysisErrorCore.js";
|
|
import { analysisErrorWithCleanupFailure } from "./analysisErrorCleanup.js";
|
|
import {
|
|
projectAnalysisError,
|
|
projectAnalysisErrorWithoutCapturedOutput,
|
|
} from "./analysisErrorProjection.js";
|
|
import {
|
|
analysisErrorCategory,
|
|
analysisErrorRemediationAction,
|
|
analysisErrorUserMessage,
|
|
} from "./analysisErrorPresentation.js";
|
|
import { ProviderCleanupError } from "./providerCleanupError.js";
|
|
import { createEvidence } from "./evidence.js";
|
|
import { ArtifactOperationError } from "./artifactOperationError.js";
|
|
|
|
it.each([false, true])(
|
|
"keeps each owner's capture without text-based deduplication (matching: %s)",
|
|
(matching) => {
|
|
const primary = new AnalysisTimeoutError("inspect", 1234, {
|
|
capturedOutput: {
|
|
stdout: "primary-capture-sentinel",
|
|
stderr: "",
|
|
truncated: false,
|
|
},
|
|
});
|
|
const cleanup = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-worker"],
|
|
{},
|
|
{
|
|
capturedOutput: {
|
|
stdout: matching
|
|
? "primary-capture-sentinel"
|
|
: "cleanup-capture-sentinel",
|
|
stderr: "",
|
|
truncated: true,
|
|
},
|
|
},
|
|
);
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
"inspect",
|
|
);
|
|
const projected = projectAnalysisError(composed);
|
|
expect(projected.details?.captured_output).toEqual(primary.capturedOutput);
|
|
expect(projected.details?.diagnostics).toMatchObject({
|
|
primary_error: {
|
|
code: "provider_timeout",
|
|
details: { timeout_ms: 1234 },
|
|
},
|
|
cleanup_error: { details: { captured_output: cleanup.capturedOutput } },
|
|
});
|
|
expect(
|
|
JSON.stringify(projected).split("primary-capture-sentinel"),
|
|
).toHaveLength(matching ? 3 : 2);
|
|
if (!matching)
|
|
expect(
|
|
JSON.stringify(projected).split("cleanup-capture-sentinel"),
|
|
).toHaveLength(2);
|
|
expect(
|
|
projectAnalysisErrorWithoutCapturedOutput(primary).details,
|
|
).not.toHaveProperty("captured_output");
|
|
expect(projectAnalysisError(primary).details?.captured_output).toEqual(
|
|
primary.capturedOutput,
|
|
);
|
|
},
|
|
);
|
|
|
|
it("keeps dependency-owned resources empty after the final owner releases", () => {
|
|
const file = new ProviderCleanupError("fixture", ["file-owner"], {});
|
|
const trace = new ProviderCleanupError("fixture", ["trace-owner"], {});
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
file,
|
|
trace,
|
|
).bindCleanupDependencies([file, trace]);
|
|
expect(new Set(composed.cleanupResources)).toEqual(
|
|
new Set(["file-owner", "trace-owner"]),
|
|
);
|
|
file.resolveCleanup();
|
|
expect(composed.cleanupResources).toEqual(["trace-owner"]);
|
|
trace.resolveCleanup();
|
|
expect(composed.cleanupIncomplete).toBe(false);
|
|
expect(composed.cleanupResources).toEqual([]);
|
|
expect(new Set(composed.cleanup?.resources)).toEqual(
|
|
new Set(["file-owner", "trace-owner"]),
|
|
);
|
|
});
|
|
|
|
it("reads completion through nested compositions from the releasing owner only", () => {
|
|
const owner = new ProviderCleanupError("fixture", ["owned-worker"], {});
|
|
const inner = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-worker"],
|
|
{},
|
|
).bindCleanupDependencies([owner]);
|
|
const outer = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-worker"],
|
|
{},
|
|
).bindCleanupDependencies([inner]);
|
|
// Cleanup state is not writable state of an error value.
|
|
expect(Reflect.set(outer, "cleanupIncomplete", false)).toBe(false);
|
|
expect(outer.cleanupIncomplete).toBe(true);
|
|
owner.resolveCleanup();
|
|
expect(outer.cleanupIncomplete).toBe(false);
|
|
expect(inner.cleanupIncomplete).toBe(false);
|
|
// Completion is monotonic: a later binding cannot reopen it.
|
|
outer.bindCleanupDependencies([
|
|
new ProviderCleanupError("fixture", ["later"], {}),
|
|
]);
|
|
expect(outer.cleanupIncomplete).toBe(false);
|
|
});
|
|
|
|
it("keeps completion when a dependency is bound after release without an intermediate read", () => {
|
|
const owner = new ProviderCleanupError("fixture", ["owned-worker"], {});
|
|
const outer = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-worker"],
|
|
{},
|
|
).bindCleanupDependencies([owner]);
|
|
owner.resolveCleanup();
|
|
outer.bindCleanupDependencies([
|
|
new ProviderCleanupError("fixture", ["later"], {}),
|
|
]);
|
|
expect(outer.cleanupIncomplete).toBe(false);
|
|
});
|
|
|
|
it("keeps primary diagnostics separate from historical cleanup diagnostics with the same keys", () => {
|
|
const primary = new AnalysisInputError("inspect", {
|
|
diagnostics: {
|
|
primary_error: "source observation",
|
|
cleanup_error: "another source observation",
|
|
},
|
|
});
|
|
const cleanup = new ProviderCleanupError("fixture", ["owned-input"], {});
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
).bindCleanupDependencies([primary, cleanup]);
|
|
cleanup.resolveCleanup();
|
|
const projected = projectAnalysisError(composed);
|
|
expect(projected.details?.diagnostics).toEqual(primary.diagnostics);
|
|
expect(projected.details?.cleanup_history).toMatchObject({
|
|
primary_error: projectAnalysisError(primary),
|
|
cleanup_error: { code: "cleanup_incomplete" },
|
|
});
|
|
expect(composed.cleanupPrimary).toBe(primary);
|
|
expect(Object.hasOwn(composed, "cleanupPrimary")).toBe(false);
|
|
});
|
|
|
|
it.each([
|
|
new ArtifactOperationError(
|
|
"inspect_asset_catalog",
|
|
"integrity",
|
|
undefined,
|
|
"Asset catalog changed during inspection: Contents/Resources/Assets.car",
|
|
),
|
|
new AnalysisInputError("inspect", { diagnostics: { input: "original" } }, [
|
|
{
|
|
path: ["path"],
|
|
reason: "out_of_range",
|
|
message: "fixed input allowance",
|
|
},
|
|
]),
|
|
new AnalysisCancelledError("inspect", { cause: "caller reason" }),
|
|
new AnalysisTimeoutError("inspect", 1234),
|
|
new AnalysisResourceConstraintError(
|
|
"inspect",
|
|
"file-size",
|
|
"fixed input allowance",
|
|
{ maximum_input_bytes: 123 },
|
|
{ retryable: false, remediationAction: "Select a smaller suitable input." },
|
|
),
|
|
new AnalysisOutputError("inspect", "invalid output", {
|
|
capturedOutput: {
|
|
stdout: "original output",
|
|
stderr: "original warning",
|
|
truncated: true,
|
|
},
|
|
partialObservation: createEvidence(
|
|
undefined,
|
|
{ id: "fixture", name: "Fixture", version: null },
|
|
{
|
|
operation: "inspect",
|
|
parameters: {},
|
|
result: { original_fact: true },
|
|
confidence: "observed",
|
|
locations: [],
|
|
limitations: [],
|
|
},
|
|
),
|
|
}),
|
|
])("restores the typed $_tag primary after confirmed cleanup", (primary) => {
|
|
const original = projectAnalysisError(primary);
|
|
const cleanup = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-input"],
|
|
{ reason: "close denied" },
|
|
{
|
|
operation: "inspect",
|
|
cleanup: { reason: "close denied", resources: ["owned-input"] },
|
|
},
|
|
);
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
"inspect",
|
|
).bindCleanupDependencies([primary, cleanup]);
|
|
expect(composed.cleanup?.reason).toBe("close denied");
|
|
expect(composed.cleanup?.reason).not.toBe(
|
|
projectAnalysisError(cleanup).message,
|
|
);
|
|
const pending = projectAnalysisError(composed);
|
|
expect(pending.code).toBe("cleanup_incomplete");
|
|
expect(pending.category).toBe(original.category);
|
|
expect(analysisErrorCategory(composed)).toBe(original.category);
|
|
const { diagnostics: _diagnostics, ...semanticDetails } =
|
|
original.details ?? {};
|
|
expect(pending.details).toMatchObject({
|
|
...semanticDetails,
|
|
cleanup: "incomplete",
|
|
execution_failure: original.code,
|
|
resources: ["owned-input"],
|
|
});
|
|
cleanup.resolveCleanup();
|
|
const projected = projectAnalysisError(composed);
|
|
expect(projected).toMatchObject(original);
|
|
expect(projected.details?.cleanup_history).toMatchObject({
|
|
primary_error: { code: original.code, message: original.message },
|
|
cleanup_error: { code: "cleanup_incomplete" },
|
|
});
|
|
expect(projected.details?.cleanup_history).not.toHaveProperty(
|
|
"primary_error.details.partial_observation",
|
|
);
|
|
expect(projected.details?.cleanup_history).not.toHaveProperty(
|
|
"primary_error.details.captured_output",
|
|
);
|
|
expect(projected.details).not.toHaveProperty("cleanup", "incomplete");
|
|
expect(projected.details).not.toHaveProperty("resources");
|
|
expect(analysisErrorCategory(composed)).toBe(original.category);
|
|
expect(analysisErrorUserMessage(composed)).toBe(original.message);
|
|
expect(analysisErrorRemediationAction(composed)).toBe(
|
|
original.remediation.action,
|
|
);
|
|
expect(composed.cause).toBeInstanceOf(AggregateError);
|
|
expect((composed.cause as AggregateError).errors[0]).toBe(primary);
|
|
});
|
|
|
|
it.each(["inner", "outer"] as const)(
|
|
"waits for both nested cleanup owners when %s resolves first",
|
|
(first) => {
|
|
const primary = new AnalysisInputError("inspect", undefined, [
|
|
{ path: ["path"], reason: "missing_argument" },
|
|
]);
|
|
const innerCleanup = new ProviderCleanupError("fixture", ["input"], {});
|
|
const outerCleanup = new ProviderCleanupError("fixture", ["workspace"], {});
|
|
const inner = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
innerCleanup,
|
|
).bindCleanupDependencies([primary, innerCleanup]);
|
|
const outer = analysisErrorWithCleanupFailure(
|
|
inner,
|
|
outerCleanup,
|
|
).bindCleanupDependencies([inner, outerCleanup]);
|
|
const released = first === "inner" ? innerCleanup : outerCleanup;
|
|
const pending = first === "inner" ? outerCleanup : innerCleanup;
|
|
expect(projectAnalysisError(outer)).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "invalid_input",
|
|
details: {
|
|
operation: "inspect",
|
|
issues: primary.issues,
|
|
execution_failure: "invalid_request",
|
|
},
|
|
});
|
|
released.resolveCleanup();
|
|
expect(outer.cleanupIncomplete).toBe(true);
|
|
expect(projectAnalysisError(outer).code).toBe("cleanup_incomplete");
|
|
expect(projectAnalysisError(outer).category).toBe("invalid_input");
|
|
pending.resolveCleanup();
|
|
expect(outer.cleanupIncomplete).toBe(false);
|
|
expect(projectAnalysisError(outer)).toMatchObject(
|
|
projectAnalysisError(primary),
|
|
);
|
|
},
|
|
);
|
|
|
|
it("preserves recovery and secondary failures owned by an intermediate cleanup", () => {
|
|
const primary = new AnalysisInputError("inspect");
|
|
const inner = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
new ProviderCleanupError("fixture", ["input"], {}),
|
|
);
|
|
inner.retainSourcePublication({
|
|
kind: "omitted",
|
|
reason: "primary-authentication-failed",
|
|
source_closure: "not-established",
|
|
});
|
|
inner.retainSecondaryFailure(new AnalysisInputError("source"));
|
|
const outer = analysisErrorWithCleanupFailure(
|
|
inner,
|
|
new ProviderCleanupError("fixture", ["workspace"], {}),
|
|
);
|
|
expect(projectAnalysisError(outer)).toMatchObject({
|
|
details: {
|
|
completed_observation_omitted: {
|
|
reason: "primary-authentication-failed",
|
|
source_closure: "not-established",
|
|
},
|
|
secondary_failures: [{ code: "invalid_request" }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it("prefers the outer publication source over the nested primary observation", () => {
|
|
const provider = { id: "fixture", name: "Fixture", version: null };
|
|
const source = createEvidence(undefined, provider, {
|
|
operation: "source",
|
|
parameters: {},
|
|
result: "source",
|
|
});
|
|
const nested = createEvidence(undefined, provider, {
|
|
operation: "nested",
|
|
parameters: {},
|
|
result: "nested",
|
|
});
|
|
const primary = new AnalysisCancelledError("inspect", {
|
|
partialObservation: nested,
|
|
});
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
new ProviderCleanupError("fixture", ["input"], {}),
|
|
);
|
|
composed.partialObservation = source;
|
|
composed.retainSourcePublication({
|
|
kind: "omitted",
|
|
reason: "primary-authentication-failed",
|
|
source_closure: "not-established",
|
|
});
|
|
expect(projectAnalysisError(composed).details?.partial_observation).toEqual(
|
|
source,
|
|
);
|
|
});
|
|
|
|
it("does not infer cleanup success when a composition has no live owner binding", () => {
|
|
const primary = new AnalysisInputError("inspect");
|
|
const cleanup = new ProviderCleanupError("fixture", ["input"], {});
|
|
const composed = analysisErrorWithCleanupFailure(primary, cleanup);
|
|
cleanup.resolveCleanup();
|
|
expect(projectAnalysisError(composed).code).toBe("cleanup_incomplete");
|
|
expect(projectAnalysisError(composed).category).toBe("invalid_input");
|
|
expect(composed.cleanupIncomplete).toBe(true);
|
|
});
|
|
|
|
it("keeps the physical failure primary when later cleanup observes cancellation", () => {
|
|
const physical = Object.assign(new Error("selected file read EIO"), {
|
|
code: "EIO",
|
|
});
|
|
const primary = new ArtifactOperationError(
|
|
"inspect_asset_catalog",
|
|
"io",
|
|
undefined,
|
|
physical.message,
|
|
{ cause: physical },
|
|
);
|
|
const reason = { request: "cancel after read failure" };
|
|
const cleanup = new ProviderCleanupError(
|
|
"fixture",
|
|
["owned-input"],
|
|
{},
|
|
{
|
|
cause: new AnalysisCancelledError("inspect", { cause: reason }),
|
|
},
|
|
);
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
"inspect",
|
|
).bindCleanupDependencies([primary, cleanup]);
|
|
expect(projectAnalysisError(composed)).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "execution_failure",
|
|
details: {
|
|
operation: "inspect_asset_catalog",
|
|
reason: "io",
|
|
detail: physical.message,
|
|
execution_failure: "artifact_operation_failed",
|
|
},
|
|
});
|
|
expect(composed.cleanupPrimary?.cause).toBe(physical);
|
|
cleanup.resolveCleanup();
|
|
expect(projectAnalysisError(composed)).toMatchObject(
|
|
projectAnalysisError(primary),
|
|
);
|
|
});
|
|
|
|
it("retains an observation attached to the composite after the primary failed", () => {
|
|
const primary = new AnalysisInputError("inspect");
|
|
const cleanup = new ProviderCleanupError("fixture", ["input"], {});
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
).bindCleanupDependencies([primary, cleanup]);
|
|
const observation = createEvidence(
|
|
undefined,
|
|
{ id: "fixture", name: "Fixture", version: null },
|
|
{
|
|
operation: "inspect",
|
|
parameters: {},
|
|
result: { late_fact: true },
|
|
confidence: "observed",
|
|
locations: [],
|
|
limitations: [],
|
|
},
|
|
);
|
|
composed.retainPartialObservation(observation);
|
|
composed.resolveCleanup();
|
|
expect(projectAnalysisError(composed).code).toBe("cleanup_incomplete");
|
|
cleanup.resolveCleanup();
|
|
expect(projectAnalysisError(composed)).toMatchObject({
|
|
code: "invalid_request",
|
|
details: { partial_observation: observation },
|
|
});
|
|
});
|
|
|
|
it("retains an owner's finalization report independently of pending primary semantics", () => {
|
|
const report = {
|
|
owned_process_group: { state: "not_required" as const, reason: null },
|
|
terminal_renderer: { state: "not_required" as const, reason: null },
|
|
temporary_root: { state: "cleaned" as const, reason: null },
|
|
};
|
|
class ReportedCleanup extends ProviderCleanupError {
|
|
override readonly cleanupReport = report;
|
|
}
|
|
const primary = new AnalysisInputError("inspect", undefined, [
|
|
{ path: ["path"], reason: "missing_argument" },
|
|
]);
|
|
const finalized = new ReportedCleanup(
|
|
"fixture",
|
|
["input"],
|
|
{},
|
|
{
|
|
cleanupPrimary: primary,
|
|
},
|
|
);
|
|
const later = new ProviderCleanupError("fixture", ["workspace"], {});
|
|
const outer = analysisErrorWithCleanupFailure(
|
|
finalized,
|
|
later,
|
|
).bindCleanupDependencies([finalized, later]);
|
|
const assertReport = (error: typeof outer) => {
|
|
expect(projectAnalysisError(error)).toMatchObject({
|
|
category: "invalid_input",
|
|
details: {
|
|
operation: "inspect",
|
|
issues: primary.issues,
|
|
cleanup_report: report,
|
|
},
|
|
});
|
|
};
|
|
assertReport(finalized);
|
|
assertReport(outer);
|
|
expect(outer.cleanupIncomplete).toBe(true);
|
|
later.resolveCleanup();
|
|
assertReport(outer);
|
|
expect(outer.cleanupIncomplete).toBe(true);
|
|
finalized.resolveCleanup();
|
|
assertReport(outer);
|
|
expect(outer.cleanupIncomplete).toBe(false);
|
|
});
|
|
|
|
it.each(["primary", "cleanup", "default", "cleanup-continuing"] as const)(
|
|
"preserves the explicit %s remediation owner through cleanup projection",
|
|
(owner) => {
|
|
const primaryAction =
|
|
"Inspect the selected compiler before retrying this request.";
|
|
const cleanupAction =
|
|
"Release the recorded cleanup resource before retrying.";
|
|
const primary = new AnalysisTimeoutError(
|
|
"inspect",
|
|
123,
|
|
owner === "default" ? {} : { remediationAction: primaryAction },
|
|
);
|
|
const cleanup = new AnalysisCapabilityUnavailableError(
|
|
"process-ownership",
|
|
"close",
|
|
"retained cleanup",
|
|
{
|
|
cleanup: { reason: "close failed", resources: ["owned resource"] },
|
|
...(owner === "cleanup" ? { remediationAction: cleanupAction } : {}),
|
|
...(owner === "cleanup-continuing"
|
|
? { continuingCallerGuidance: { remediationAction: cleanupAction } }
|
|
: {}),
|
|
},
|
|
);
|
|
const composed = analysisErrorWithCleanupFailure(
|
|
primary,
|
|
cleanup,
|
|
"inspect",
|
|
);
|
|
const expected =
|
|
owner === "cleanup"
|
|
? cleanupAction
|
|
: owner === "default"
|
|
? "This analysis is unavailable for the current target. Choose another analysis or target."
|
|
: primaryAction;
|
|
expect(projectAnalysisError(composed).remediation.action).toBe(
|
|
owner === "cleanup-continuing" ? cleanupAction : expected,
|
|
);
|
|
expect(
|
|
projectAnalysisError(composed, "invocation").remediation.action,
|
|
).toBe(expected);
|
|
expect(composed.cleanupPrimary).toBe(primary);
|
|
expect(composed.cleanupResources).toEqual(["owned resource"]);
|
|
expect(projectAnalysisError(composed).code).toBe("cleanup_incomplete");
|
|
},
|
|
);
|