Files
reverse-engineering-anything/src/domain/analysisView/rustBinaryView.test.ts
T
gensokyo-dev 5241597594 perf(rust): query selected dependency facts from retained Evidence (#5815)
Add optional package/edge selection and summaries through shared retained Evidence, preserving complete delivery and parent identity.

Fixes #5802
2026-10-21 16:12:04 +08:00

174 lines
4.7 KiB
TypeScript

import { expect, it } from "vitest";
import { createEvidence } from "../evidence.js";
import type { RustBinary } from "../rust/rustBinary.js";
import {
projectAnalysisView,
type AnalysisViewParent,
} from "./analysisView.js";
const report: RustBinary = {
artifact: { path: "/artifacts/rust", sha256: "a".repeat(64), bytes: 512 },
format: "elf",
architecture: "amd64",
bits: 64,
byte_order: "little",
auditable_metadata: {
section_name: ".dep-v0",
file_offset: 32,
section_bytes: 64,
compressed_bytes: 64,
uncompressed_bytes: 128,
format_version: null,
packages: [
{
name: "root",
version: "1",
source: "local",
kind: null,
root: true,
dependencies: [0],
},
],
root_package_index: 0,
dependency_edges: [{ from_index: 0, to_index: 0 }],
cyclic_dependency_indices: [0],
},
rustc_commit: null,
limitations: [],
};
const parent = (value = structuredClone(report)): AnalysisViewParent => {
const evidence = createEvidence(
{
path: value.artifact.path,
sha256: value.artifact.sha256,
format: "elf",
architecture: "x86_64",
},
{ id: "rust-auditable", name: "Rust reader", version: "1" },
{
operation: "inspect_rust_binary",
parameters: { path: value.artifact.path },
result: value,
},
);
return {
evidenceId: evidence.evidence_id,
operation: evidence.operation,
subject: evidence.subject,
normalizedResult: value,
limitations: [],
};
};
it("revalidates mutable and merely frozen Rust imports despite a claimed seal", () => {
const mutable = structuredClone(report);
const input = { ...parent(mutable), sealedResult: true };
expect(projectAnalysisView(input, { kind: "summary" }).ok).toBe(true);
Object.freeze(mutable);
mutable.auditable_metadata!.dependency_edges[0]!.to_index = 99;
expect(
projectAnalysisView(input, {
kind: "rust",
collection: "edges",
offset: 0,
limit: 1,
}).ok,
).toBe(false);
});
it("checks exact artifact identity and subject architecture for every Rust view", () => {
for (const changed of [
{ local_path: "/different" },
{ format: "pe" as const },
{ architecture: "arm64" as const },
{ digest: { sha256: "b".repeat(64) } },
]) {
const source = parent();
if (source.subject == null || source.subject.format !== "elf")
throw new Error("Missing ELF source");
const input = { ...source, subject: { ...source.subject, ...changed } };
expect(projectAnalysisView(input, { kind: "summary" }).ok).toBe(false);
expect(
projectAnalysisView(input, {
kind: "rust",
collection: "packages",
offset: 0,
limit: 1,
}).ok,
).toBe(false);
}
});
it("bounds inherited warnings and retains cycle counts without walking a cyclic graph", () => {
const input = { ...parent(), limitations: ["x".repeat(300_000)] };
const result = projectAnalysisView(input, { kind: "summary" });
if (!result.ok) throw result.error;
expect(result.value).toMatchObject({
summary: {
auditable_metadata: {
format_version: null,
counts: { packages: 1, edges: 1, cyclic_packages: 1 },
},
},
source_coverage: {
embedded_records: "complete",
runtime_dependencies: "unknown",
},
});
expect(JSON.stringify(result.value).length).toBeLessThan(5000);
expect(result.value.limitations.join(" ")).toContain(input.evidenceId);
});
it("pages matching original indices and omits dependency vectors unless selected", () => {
const value = structuredClone(report);
value.auditable_metadata!.packages.push({
name: "other",
version: "1",
source: "local",
kind: null,
root: false,
dependencies: [],
});
const source = parent(value);
const first = projectAnalysisView(source, {
kind: "rust",
collection: "packages",
offset: 0,
limit: 1,
});
if (!first.ok || first.value.kind !== "rust")
throw new Error("Rust page failed");
expect(first.value.page.rows).toEqual([
{
index: 0,
name: "root",
version: "1",
source: "local",
kind: null,
root: true,
},
]);
expect(first.value.coverage).toMatchObject({
total: 2,
examined: 1,
exhausted: false,
next_offset: 1,
});
const next = projectAnalysisView(source, {
kind: "rust",
collection: "packages",
offset: 1,
limit: 1,
fields: [],
});
if (!next.ok || next.value.kind !== "rust")
throw new Error("Rust continuation failed");
expect(next.value.page.rows).toEqual([{ index: 1 }]);
expect(next.value.coverage).toMatchObject({
total: 2,
examined: 1,
exhausted: true,
next_offset: null,
});
});