Vito
048d599386
* test(inspect): add synthetic inspection parity fixtures and legacy characterization * test(inspect): pin test-time parity vectors and keep fixtures fully synthetic * fix(inspect): bound resolver work instead of graph size * fix(inspect): bound shared-node and stripped-text work in the inspection profile Keep one memo per resolution whose entries carry their unfolded visit cost; a memo hit charges that cost to the current candidate's allowance only. Cache node validation and charge input keys, stripped characters and copied provenance entries to a whole-resolution work budget before doing the work. The default profile is unchanged. * fix(inspect): keep memoized depth honest across inspection candidates A memo entry now records its height below the reusing depth; a hit raises depth-limit exactly where a fresh walk would, so each candidate's outcome matches its anchored result and does not depend on trace or node order. The default profile is unchanged. * test(inspect): pin memo height propagation Three samplers share one chain, each later one hanging below a memo hit. The third candidate must report depth-limit in both trace orders and when anchored; removing the memo-hit height propagation fails this test. The provenance test now asserts a plain subset. * fix(inspect): tolerate ComfyUI node metadata quirks in projections Projections now take a kind. Each prompt node keeps exactly class_type and inputs; _meta, is_changed and other node keys are validated and dropped, so "is_changed": [NaN] no longer marks the whole prompt graph malformed. A nonfinite value inside inputs, anywhere in a workflow, or in a retained carrier member projects to null and is never reported as a number. The carrier applies the prompt/workflow kinds to its members. Exact numbers are unchanged (Decimal spelling, unsafe integers as strings) and duplicate keys are still malformed. The 500-node gate is replaced by a 20,000-node backstop (workflow count includes subgraph definitions). Raw records are untouched. The f14 inspection vector's facts become known; default vectors are unchanged. * fix(inspect): budget metadata per record so large workflows never hide prompts PNG inspection no longer counts every text chunk against one shared 2 MiB budget. Role records (prompt, parameters, the pair execution record) keep a 2 MiB budget together, encoded and decoded, and exceeding it still fails the whole read. A workflow has its own 4 MiB budget: a chunk over it is skipped by seek, and a compressed one stops inflating at budget + 1. Only the workflow is then reported as limited (record format "limited", no raw text, workflow_graph limited); prompts, facts and the prompt graph are unaffected. Each text chunk's keyword is read first (at most 80 bytes). Chunks that are not retained are skipped by length without being read or checksummed, so memory stays bounded. Byte-identical duplicates of a retained record are accepted and do not consume budget; differing duplicates still raise "Duplicate prompt metadata", and a duplicate of a limited workflow stays limited. The chunk-count limit is unchanged. InspectionRead gains limited_records (empty by default). The reader is only used by the inspection routes, so ingestion, scan and import are unchanged. Vectors: f04-inspection (2.5 MB workflow, within the new workflow budget) and f15-inspection (identical duplicate chunks) now read and resolve, with the same outcome and facts as f05-inspection. Default vectors are unchanged. * fix(inspect): keep prompt evidence longest under the response budget * fix(inspect): bound identical duplicate chunk reads * fix(inspect): fail closed when role duplicates exceed their budget * fix(inspect): use the bounded inspection profile end to end Inspection routes resolve with INSPECTION_PROFILE and expose reason_code and node on the resolution; scan, live monitor and admin import keep the default profile (pinned by spies over the real resolver on f03). JS facts drop the entries and workflow node-count gates; per-lookup visit sets and the server's node ceiling bound the work. The validator accepts the textless `limited` workflow format, follows the workflow-first response omission order, and checks the closed reason-code vocabulary. The file inspector labels limited records and disables their workflow download. vectors.json: 12 inspection vectors gain their reason codes; f03 facts become known and f01 facts ambiguous. Default vectors are unchanged. A new parity test asserts vectors.json facts through the workspace JS. * chore(tools): add read-only inspection corpus tool tools/inspection_corpus.py runs the inspection route pipeline and the workspace JS facts of a chosen code tree over a media folder, read-only, and reports the #240 invariants H1 to H8 with aggregate counts. Rows hold statuses and SHA-256 digests of resolved role texts, never file names or prompt text unless --with-paths is given. Outputs inside the root or a code tree are refused. The facts-over-vectors test now fails instead of skipping when CI is set and Node.js is missing. * docs(testing): document bounded inspection work * fix(tools): fail the corpus run when facts or inspection did not run Rows whose facts were never computed (no or exiting Node.js) now fail H3, and a new harness line fails on any tool exception or missing facts, so a run where nothing was measured can no longer exit 0. Unreadable files stay inspector outcomes. A missing --node binary is refused, an exited harness is reaped, H8 has a 50 ms floor for tiny baselines, and JSONL rows are sorted by id. * docs(inspect): correct ceiling wording and bandit annotations Describe the two 20,000-node ceilings (prompt entries, workflow UI plus subgraph nodes) in TESTING.md, and use bare nosec ids so Bandit stops warning about unparsed test names. * test(inspect): make parity observation tuples explicit
113 lines
3.9 KiB
Python
113 lines
3.9 KiB
Python
"""Shared parity vectors: the workspace's JS facts match ``vectors.json``.
|
|
|
|
Each ``inspection`` vector's file goes through the real current-file route
|
|
pipeline (``inspect_current_file`` then ``encode_inspection_response``). The
|
|
exact response text is handed to Node, where the workspace's own
|
|
``projectInspectionPayload`` validates it and ``extractGenerationFacts`` reads
|
|
it. Python and JS therefore assert the same files with the same expectations.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess # nosec B404
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from py.api.inspection_service import inspect_current_file
|
|
from utils.inspection_response import encode_inspection_response
|
|
|
|
try:
|
|
from tests import inspection_parity as parity
|
|
from tests.open_handles import assert_closed
|
|
except ImportError: # pragma: no cover - discover -s tests puts tests/ first
|
|
import inspection_parity as parity
|
|
from open_handles import assert_closed
|
|
|
|
HARNESS = (
|
|
Path(__file__).resolve().parent / "js" / "support" / "inspection-parity-facts.mjs"
|
|
)
|
|
LIBRARY = {
|
|
"status": "none",
|
|
"scope": "saved-library",
|
|
"positive_id": None,
|
|
"pair_id": None,
|
|
"title": None,
|
|
"category": None,
|
|
"tags": [],
|
|
"metadata_scope": None,
|
|
}
|
|
NODE_TIMEOUT_SECONDS = 120
|
|
|
|
|
|
def _encoded(name: str, path: Path) -> str:
|
|
observed = inspect_current_file(
|
|
path, source_label="parity", saved=None, library=LIBRARY
|
|
)
|
|
body = encode_inspection_response(
|
|
image={"root_index": 0, "path": f"{name}.png", "filename": f"{name}.png"},
|
|
root_scope="a" * 64,
|
|
file=observed["file"],
|
|
prompts=observed["prompts"],
|
|
resolution=observed["resolution"],
|
|
inspection=observed["inspection"],
|
|
library=observed["library"],
|
|
)
|
|
return body.decode("utf-8")
|
|
|
|
|
|
def _responses(vectors, directory: Path) -> list:
|
|
responses = []
|
|
for vector in vectors:
|
|
name = vector["fixture"]
|
|
if name in parity.TEST_TIME:
|
|
path = parity.fixture_path(name, directory)
|
|
parity.write_png(path, parity.build(name))
|
|
else:
|
|
path = parity.fixture_path(name)
|
|
responses.append({"name": vector["name"], "body": _encoded(name, path)})
|
|
return responses
|
|
|
|
|
|
class TestParityFacts(unittest.TestCase):
|
|
def setUp(self):
|
|
temporary = tempfile.TemporaryDirectory()
|
|
self.addCleanup(temporary.cleanup)
|
|
self.addCleanup(assert_closed, self, temporary.name)
|
|
self.directory = Path(temporary.name)
|
|
|
|
def test_vectors_json_facts_match_workspace_js(self):
|
|
node = shutil.which("node")
|
|
if node is None: # pragma: no cover - CI runners and dev hosts ship Node
|
|
if os.environ.get("CI"):
|
|
self.fail("Node.js is required in CI for the facts vectors")
|
|
self.skipTest("Node.js is not installed")
|
|
vectors = [v for v in parity.load_vectors() if v["profile"] == "inspection"]
|
|
self.assertTrue(vectors)
|
|
payload = json.dumps(_responses(vectors, self.directory))
|
|
# Fixed local Node harness, no shell.
|
|
completed = subprocess.run( # nosec B603
|
|
[node, str(HARNESS)],
|
|
input=payload.encode("utf-8"),
|
|
capture_output=True,
|
|
timeout=NODE_TIMEOUT_SECONDS,
|
|
check=False,
|
|
)
|
|
self.assertEqual(completed.returncode, 0, completed.stderr.decode("utf-8"))
|
|
observed = json.loads(completed.stdout)
|
|
for vector in vectors:
|
|
with self.subTest(vector=vector["name"]):
|
|
self.assertEqual(observed[vector["name"]], vector["expect"]["facts"])
|
|
|
|
def test_default_vectors_carry_no_facts(self):
|
|
# Facts are a workspace (inspection) concern; default vectors pin the
|
|
# ingestion resolver only.
|
|
for vector in parity.load_vectors():
|
|
if vector["profile"] == "default":
|
|
self.assertIsNone(vector["expect"]["facts"], vector["name"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|