mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 14:05:49 +00:00
test(managed): consolidate identity and finalization checks (#12845)
test(managed): consolidate snapshot cancellation coverage
This commit is contained in:
1 parent
baf80358cb
commit
52cf28b28e
2 files changed
+80
-130
No files matched your search
@@ -12,8 +12,6 @@ import { OwnedFileHandle } from "../../../../src/filesystem/OwnedFileHandle.js";
|
||||
import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js";
|
||||
|
||||
it.each([
|
||||
{ denyClose: false, reasonKind: "plain" },
|
||||
{ denyClose: true, reasonKind: "plain" },
|
||||
{ denyClose: false, reasonKind: "filesystem" },
|
||||
{ denyClose: true, reasonKind: "filesystem" },
|
||||
{ denyClose: false, reasonKind: "cleanup" },
|
||||
@@ -25,7 +23,7 @@ it.each([
|
||||
const path = join(directory, "fixture.exe");
|
||||
await writeFile(
|
||||
path,
|
||||
Buffer.concat([buildManagedPeFixture(), Buffer.alloc(512 * 1024)]),
|
||||
Buffer.concat([buildManagedPeFixture(), Buffer.alloc(64 * 1024 + 1)]),
|
||||
);
|
||||
const parsed = await parseBinaryTarget(path);
|
||||
if (!parsed.ok) throw parsed.error;
|
||||
@@ -50,7 +48,7 @@ it.each([
|
||||
})
|
||||
: Object.assign(
|
||||
new Error("cancel after actual managed source bytes arrive"),
|
||||
reasonKind === "filesystem" ? { code: "EACCES" } : {},
|
||||
{ code: "EACCES" },
|
||||
);
|
||||
let cancelledHandle: FileHandle | undefined;
|
||||
let readCount = 0;
|
||||
@@ -88,6 +86,7 @@ it.each([
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
expect(cancelledHandle).toBeDefined();
|
||||
expect(readCount).toBe(1);
|
||||
if (cancelled.ok) throw new Error("Cancelled managed hashing succeeded");
|
||||
if (denyClose) {
|
||||
expect(projectAnalysisError(cancelled.error)).toMatchObject({
|
||||
|
||||
@@ -113,17 +113,14 @@ it.each([
|
||||
},
|
||||
);
|
||||
|
||||
it.each(
|
||||
[false, true]
|
||||
.flatMap((warm) =>
|
||||
[false, true].flatMap((changed) =>
|
||||
[false, true].map((failedClose) => ({ warm, changed, failedClose })),
|
||||
),
|
||||
)
|
||||
.filter(({ changed, failedClose }) => changed || failedClose),
|
||||
)(
|
||||
"preserves selected managed identity through finalization (cached=$warm, changed=$changed, failedClose=$failedClose)",
|
||||
async ({ warm, changed, failedClose }) => {
|
||||
it.each([
|
||||
{ warm: false, failedClose: false },
|
||||
{ warm: false, failedClose: true },
|
||||
{ warm: true, failedClose: false },
|
||||
{ warm: true, failedClose: true },
|
||||
])(
|
||||
"keeps a changed digest primary over finalization cancellation (cached=$warm, failedClose=$failedClose)",
|
||||
async ({ warm, failedClose }) => {
|
||||
const root = await createTestTempDirectory(
|
||||
"rea-managed-selected-identity-",
|
||||
);
|
||||
@@ -138,11 +135,8 @@ it.each(
|
||||
true,
|
||||
);
|
||||
const observed = Buffer.from(bytes);
|
||||
if (changed) {
|
||||
observed[observed.length - 1] =
|
||||
observed.readUInt8(observed.length - 1) ^ 1;
|
||||
await writeFile(path, observed);
|
||||
}
|
||||
observed[observed.length - 1] = observed.readUInt8(observed.length - 1) ^ 1;
|
||||
await writeFile(path, observed);
|
||||
const controller = new AbortController();
|
||||
const reason = { source: "selected managed finalization" };
|
||||
let blocked = failedClose;
|
||||
@@ -163,20 +157,21 @@ it.each(
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
if (result.ok) throw new Error("Expected source finalization failure");
|
||||
const primary = primaryAnalysisError(result.error);
|
||||
expect(primary._tag).toBe(
|
||||
changed ? "AnalysisArtifactChangedError" : "AnalysisCancelledError",
|
||||
);
|
||||
if (changed)
|
||||
expect(primary.diagnostics).toMatchObject({
|
||||
const observedSha256 = createHash("sha256")
|
||||
.update(observed)
|
||||
.digest("hex");
|
||||
expect(primaryAnalysisError(result.error)).toMatchObject({
|
||||
_tag: "AnalysisArtifactChangedError",
|
||||
diagnostics: {
|
||||
expected_sha256: target.value.sha256,
|
||||
observed_sha256: createHash("sha256").update(observed).digest("hex"),
|
||||
});
|
||||
else expect(primary.cause).toBe(reason);
|
||||
observed_sha256: observedSha256,
|
||||
observed_bytes: observed.length,
|
||||
},
|
||||
});
|
||||
const receipt = {
|
||||
kind: "file-snapshot-hash",
|
||||
path,
|
||||
sha256: createHash("sha256").update(observed).digest("hex"),
|
||||
sha256: observedSha256,
|
||||
bytes: observed.length,
|
||||
};
|
||||
expect(result.error.partialObservation).toEqual(receipt);
|
||||
@@ -185,7 +180,8 @@ it.each(
|
||||
blocked = false;
|
||||
expect((await client.close()).ok).toBe(true);
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
expect([...owners].every((owner) => owner.handle.fd === -1)).toBe(true);
|
||||
expect(owners.size).toBe(1);
|
||||
expect([...owners][0]?.handle.fd).toBe(-1);
|
||||
expect(result.error.partialObservation).toEqual(receipt);
|
||||
} finally {
|
||||
blocked = false;
|
||||
@@ -265,10 +261,8 @@ it("classifies a source changed during managed snapshot acquisition as artifact_
|
||||
.spyOn(boundedFileBytes, "readBoundedFileBytes")
|
||||
.mockImplementation(async (...args) => {
|
||||
const observed = await original(...args);
|
||||
await writeFile(
|
||||
path,
|
||||
buildManagedPeFixture({ methodName: "ChangedAfterRead" }),
|
||||
);
|
||||
// A size change is observable even when both writes share a filesystem timestamp.
|
||||
await truncate(path, bytes.length + 1);
|
||||
return observed;
|
||||
});
|
||||
try {
|
||||
@@ -332,100 +326,43 @@ describe("managed static snapshot capacity failure", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("managed static completed snapshot cancellation", () => {
|
||||
for (const warm of [false, true]) {
|
||||
for (const retryClose of [false, true]) {
|
||||
it.each([null, "stop after read", { caller: "stop after read" }])(
|
||||
`retains completed facts after confirmed close (cached=${String(warm)}, retry=${String(retryClose)}): %s`,
|
||||
async (reason) => {
|
||||
const directory = await createTestTempDirectory(
|
||||
"rea-managed-completed-close-",
|
||||
);
|
||||
const path = join(directory, "fixture.dll");
|
||||
const bytes = buildManagedPeFixture();
|
||||
await writeFile(path, bytes);
|
||||
const parsed = await parseBinaryTarget(path);
|
||||
if (!parsed.ok) throw parsed.error;
|
||||
const client = new ManagedStaticProvider().createClient(parsed.value);
|
||||
if (warm) {
|
||||
const initial = await client.execute(
|
||||
"inspect_managed_artifact",
|
||||
{},
|
||||
);
|
||||
if (!initial.ok) throw initial.error;
|
||||
}
|
||||
const controller = new AbortController();
|
||||
const nativeClose = OwnedFileHandle.prototype.close;
|
||||
const owners: OwnedFileHandle[] = [];
|
||||
const close = vi
|
||||
.spyOn(OwnedFileHandle.prototype, "close")
|
||||
.mockImplementation(async function (this: OwnedFileHandle) {
|
||||
owners.push(this);
|
||||
controller.abort(reason);
|
||||
if (retryClose && owners.length === 1)
|
||||
throw new Error("controlled transient close denial");
|
||||
await nativeClose.call(this);
|
||||
});
|
||||
try {
|
||||
const result = await client.execute(
|
||||
"inspect_managed_artifact",
|
||||
{},
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
if (result.ok) throw new Error("Expected cancellation after read");
|
||||
expect(result.error._tag).toBe("AnalysisCancelledError");
|
||||
expect(result.error.cause).toBe(reason);
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
const observation = {
|
||||
kind: "file-snapshot-hash",
|
||||
path,
|
||||
bytes: bytes.length,
|
||||
sha256: createHash("sha256").update(bytes).digest("hex"),
|
||||
};
|
||||
expect(parsed.value.sha256).toBe(observation.sha256);
|
||||
expect(result.error.partialObservation).toEqual(observation);
|
||||
expect(projectAnalysisError(result.error)).toMatchObject({
|
||||
code: "cancelled",
|
||||
details: { partial_observation: observation },
|
||||
});
|
||||
expect(owners).toHaveLength(retryClose ? 2 : 1);
|
||||
expect(owners.every((owner) => owner.handle.fd === -1)).toBe(true);
|
||||
if (retryClose) expect(owners[0]).toBe(owners[1]);
|
||||
expect(await client.close()).toEqual({ ok: true, value: null });
|
||||
expect(result.error.partialObservation).toEqual(observation);
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
expect(owners.every((owner) => owner.handle.fd === -1)).toBe(true);
|
||||
} finally {
|
||||
close.mockRestore();
|
||||
await client.close();
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
describe("managed static snapshot cancellation", () => {
|
||||
it.each([null, "stop after read", { caller: "stop after read" }])(
|
||||
"retains completed snapshot facts and exact cancellation during failed close: %s",
|
||||
async (reason) => {
|
||||
const directory = await createTestTempDirectory(
|
||||
"rea-managed-final-close-",
|
||||
);
|
||||
const path = join(directory, "fixture.exe");
|
||||
it.each([
|
||||
{ warm: false, closeMode: "clean", reason: null },
|
||||
{ warm: false, closeMode: "retry", reason: "stop after read" },
|
||||
{ warm: false, closeMode: "retained", reason: null },
|
||||
{ warm: true, closeMode: "clean", reason: "stop after rehash" },
|
||||
{ warm: true, closeMode: "retry", reason: null },
|
||||
{
|
||||
warm: true,
|
||||
closeMode: "retained",
|
||||
reason: { caller: "stop after rehash" },
|
||||
},
|
||||
] as const)(
|
||||
"retains completed facts after finalization cancellation (cached=$warm, close=$closeMode)",
|
||||
async ({ warm, closeMode, reason }) => {
|
||||
const directory = await createTestTempDirectory("rea-managed-close-");
|
||||
const path = join(directory, "fixture.dll");
|
||||
const bytes = buildManagedPeFixture();
|
||||
await writeFile(path, bytes);
|
||||
const parsed = await parseBinaryTarget(path);
|
||||
if (!parsed.ok) throw parsed.error;
|
||||
const client = new ManagedStaticProvider().createClient(parsed.value);
|
||||
if (warm) {
|
||||
const initial = await client.execute("inspect_managed_artifact", {});
|
||||
if (!initial.ok) throw initial.error;
|
||||
}
|
||||
const controller = new AbortController();
|
||||
const nativeClose = OwnedFileHandle.prototype.close;
|
||||
let denied = true;
|
||||
const owners: OwnedFileHandle[] = [];
|
||||
let denyClose = closeMode === "retained";
|
||||
const close = vi
|
||||
.spyOn(OwnedFileHandle.prototype, "close")
|
||||
.mockImplementation(async function (this: OwnedFileHandle) {
|
||||
owners.push(this);
|
||||
controller.abort(reason);
|
||||
if (denied) throw new Error("controlled final close denial");
|
||||
if (denyClose || (closeMode === "retry" && owners.length === 1))
|
||||
throw new Error("controlled descriptor close denial");
|
||||
await nativeClose.call(this);
|
||||
});
|
||||
try {
|
||||
@@ -434,28 +371,42 @@ describe("managed static snapshot cancellation", () => {
|
||||
{},
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
if (result.ok)
|
||||
throw new Error("Expected cancellation and incomplete cleanup");
|
||||
expect(result.error.cleanupIncomplete).toBe(true);
|
||||
expect(result.error.cleanupPrimary).toMatchObject({
|
||||
_tag: "AnalysisCancelledError",
|
||||
});
|
||||
expect(result.error.cleanupPrimary?.cause).toBe(reason);
|
||||
expect(result.error.partialObservation).toEqual({
|
||||
if (result.ok) throw new Error("Expected cancellation after read");
|
||||
const primary = primaryAnalysisError(result.error);
|
||||
expect(primary._tag).toBe("AnalysisCancelledError");
|
||||
expect(primary.cause).toBe(reason);
|
||||
const observation = {
|
||||
kind: "file-snapshot-hash",
|
||||
path,
|
||||
bytes: bytes.length,
|
||||
sha256: parsed.value.sha256,
|
||||
});
|
||||
denied = false;
|
||||
sha256: createHash("sha256").update(bytes).digest("hex"),
|
||||
};
|
||||
expect(result.error.partialObservation).toEqual(observation);
|
||||
expect(owners).toHaveLength(closeMode === "clean" ? 1 : 2);
|
||||
expect(result.error.cleanupIncomplete).toBe(denyClose);
|
||||
if (denyClose) {
|
||||
expect(result.error.cleanupResources).toEqual([path]);
|
||||
expect(owners[0]?.handle.fd).toBeGreaterThanOrEqual(0);
|
||||
expect((await client.close()).ok).toBe(false);
|
||||
} else {
|
||||
expect(result.error._tag).toBe("AnalysisCancelledError");
|
||||
expect(owners[0]?.handle.fd).toBe(-1);
|
||||
}
|
||||
|
||||
denyClose = false;
|
||||
expect(await client.close()).toEqual({ ok: true, value: null });
|
||||
expect(owners.every((owner) => owner === owners[0])).toBe(true);
|
||||
expect(owners[0]?.handle.fd).toBe(-1);
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
expect(projectAnalysisError(result.error)).toMatchObject({
|
||||
code: "cancelled",
|
||||
details: { cleanup: "complete" },
|
||||
details: {
|
||||
partial_observation: observation,
|
||||
...(closeMode === "retained" ? { cleanup: "complete" } : {}),
|
||||
},
|
||||
});
|
||||
} finally {
|
||||
denied = false;
|
||||
denyClose = false;
|
||||
await client.close();
|
||||
close.mockRestore();
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user