From f03d6d2d0b703cc1d36a27947bda779bd9f381d4 Mon Sep 17 00:00:00 2001 From: codeasier <48463012+codeasier@users.noreply.github.com> Date: Mon, 12 Oct 2026 03:48:04 +0800 Subject: [PATCH 1/2] test: verify dataset report hashing completion and validation resource bounds Rebase reviewed PR263 after PR260 and PR259. Preserve the complete seven-gate union and the independent 200-seed step. Refs #253, #241 and #238. --- .github/scripts/run_dataset_acceptance.py | 2 + benchmarks/export_validation_memory.py | 156 ++++++++++++++++++ .../core/test_export_validation_resources.py | 136 +++++++++++++++ tests/dataset_cli_resource_probe.py | 129 +++++++++++++++ tests/test_dataset_acceptance_runner.py | 38 +++++ tests/test_dataset_cli_resources.py | 123 ++++++++++++++ tests/test_export_validation_probe.py | 80 +++++++++ 7 files changed, 664 insertions(+) create mode 100644 benchmarks/export_validation_memory.py create mode 100644 tests/core/test_export_validation_resources.py create mode 100644 tests/dataset_cli_resource_probe.py create mode 100644 tests/test_dataset_cli_resources.py create mode 100644 tests/test_export_validation_probe.py diff --git a/.github/scripts/run_dataset_acceptance.py b/.github/scripts/run_dataset_acceptance.py index 7bbdce6..1921b2b 100644 --- a/.github/scripts/run_dataset_acceptance.py +++ b/.github/scripts/run_dataset_acceptance.py @@ -31,6 +31,8 @@ "tests/core/test_dataset_route_scale_acceptance.py::test_million_lifecycles_real_attach_and_scratch_routes", "tests/core/test_dataset_route_scale_acceptance.py::test_million_lifecycles_over_limit_respects_disabled_scratch_budget", "tests/core/test_dataset_route_scale_acceptance.py::test_million_lifecycles_real_subprocess_deep_offset_and_budget_precedence", + "tests/core/test_export_validation_resources.py::test_million_event_export_validation_memory_is_bounded", + "tests/core/test_export_validation_resources.py::test_first_500k_dataset_cli_query_startup_trend", ) diff --git a/benchmarks/export_validation_memory.py b/benchmarks/export_validation_memory.py new file mode 100644 index 0000000..7bdc188 --- /dev/null +++ b/benchmarks/export_validation_memory.py @@ -0,0 +1,156 @@ +"""Measure only msinsight export preflight in fresh subprocesses (#241/#253). + +Build synthetic finalized SQLite shards first, then invoke ``measure`` in a NEW +process for each metric. No pickle load, replay, shard construction, conversion +or publication is included in the measurement. tracemalloc is Python allocator +peak only. Linux RSS uses /proc/self/status VmHWM for the current address space, +with VmRSS snapshots alongside it. ru_maxrss can retain pre-exec parent history, +so it is reported separately and never used for the bound. The VmHWM increment +is relative to the post-import baseline, not a sampled instantaneous phase peak. + +Example (from the repository root, with PYTHONPATH=src): + python benchmarks/export_validation_memory.py build /tmp/export-check --events 1000000 + python benchmarks/export_validation_memory.py measure /tmp/export-check --metric python + python benchmarks/export_validation_memory.py measure /tmp/export-check --metric rss +""" + +from __future__ import annotations + +import argparse +import gc +import json +import platform +import sqlite3 +import sys +import time +import tracemalloc +from contextlib import closing +from pathlib import Path + +from pt_snap_cli.core.msinsight_export import DEFAULT_CAPACITY, _validate_shards +from pt_snap_cli.core.sharded_replay_service import ShardedReplayResult +from pt_snap_cli.snapshot.tools.adaptors.sharded_replay import ReplaySlice + + +def build(root: Path, events: int) -> dict: + """Stream synthetic rows; do not retain an event-sized list during setup.""" + root.mkdir() + (root / "device_0").mkdir() + slices = [] + for index, low in enumerate(range(0, events, DEFAULT_CAPACITY)): + high = min(events, low + DEFAULT_CAPACITY) - 1 + path = root / f"device_0/slice_{index:05d}.db" + with closing(sqlite3.connect(path)) as conn, conn: + conn.execute( + "CREATE TABLE trace_entry_0 (id INTEGER PRIMARY KEY, action INTEGER, " + "address INTEGER, size INTEGER, stream INTEGER, allocated INTEGER, " + "active INTEGER, reserved INTEGER, callstackId INTEGER)" + ) + conn.executemany( + "INSERT INTO trace_entry_0 VALUES (?,7,0,0,0,0,0,0,0)", + ((event,) for event in range(low, high + 1)), + ) + conn.execute("INSERT INTO trace_entry_0 VALUES (-1,2,0,0,0,0,0,0,0)") + count = conn.execute("SELECT COUNT(*) FROM trace_entry_0 WHERE id>=0").fetchone()[0] + assert count == high - low + 1 + slices.append( + {"index": index, "low": low, "high": high, "file": str(path.relative_to(root))} + ) + result = {"events": events, "capacity": DEFAULT_CAPACITY, "slices": slices} + (root / "probe.json").write_text(json.dumps(result), encoding="utf-8") + return result + + +def _parse_linux_rss(status: str) -> dict[str, int]: + """Read Linux's current-address-space RSS/high-water values, in bytes.""" + values = {} + for line in status.splitlines(): + fields = line.split() + if fields and fields[0] in ("VmRSS:", "VmHWM:"): + if len(fields) != 3 or fields[2] != "kB" or not fields[1].isdigit(): + raise RuntimeError(f"Unsupported /proc RSS record: {line!r}") + key = fields[0].removesuffix(":") + if key in values: + raise RuntimeError(f"Duplicate /proc RSS record: {key}") + values[key] = int(fields[1]) * 1024 + if set(values) != {"VmRSS", "VmHWM"}: + raise RuntimeError("RSS probe requires Linux /proc/self/status VmRSS and VmHWM") + return values + + +def _linux_rss_snapshot() -> dict[str, int]: + if not sys.platform.startswith("linux"): + raise RuntimeError("RSS probe requires Linux /proc; scheduled acceptance uses Ubuntu") + return _parse_linux_rss(Path("/proc/self/status").read_text()) + + +def measure(root: Path, metric: str) -> dict: + specification = json.loads((root / "probe.json").read_text()) + items = tuple( + ReplaySlice( + 0, row["index"], row["low"], row["high"], row["low"], row["high"], root / row["file"] + ) + for row in specification["slices"] + ) + staged = ShardedReplayResult(root, items, ()) + # Import and setup high-water are separate from the measured validation. + gc.collect() + evidence = { + "phase": "msinsight_export._validate_shards", + "events": specification["events"], + "shards": len(items), + "events_per_slice": specification["capacity"], + "metric": metric, + "python": platform.python_version(), + "platform": platform.platform(), + "tracemalloc_enabled": metric == "python", + } + if metric == "python": + tracemalloc.start() + started = time.perf_counter() + _validate_shards(staged) + evidence["validation_seconds"] = time.perf_counter() - started + evidence["python_current_bytes"], evidence["python_peak_bytes"] = ( + tracemalloc.get_traced_memory() + ) + tracemalloc.stop() + else: + before = _linux_rss_snapshot() + import resource + + historical_before = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024 + started = time.perf_counter() + _validate_shards(staged) + evidence["validation_seconds"] = time.perf_counter() - started + after = _linux_rss_snapshot() + historical_after = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024 + evidence.update( + rss_source="Linux /proc/self/status: current-address-space VmHWM and VmRSS", + rss_current_before_bytes=before["VmRSS"], + rss_current_after_bytes=after["VmRSS"], + rss_high_water_before_bytes=before["VmHWM"], + rss_high_water_after_bytes=after["VmHWM"], + rss_high_water_increase_bytes=max(0, after["VmHWM"] - before["VmHWM"]), + ru_maxrss_before_bytes=historical_before, + ru_maxrss_after_bytes=historical_after, + ru_maxrss_scope="diagnostic only; may retain pre-exec parent high-water history", + ) + return evidence + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("operation", choices=("build", "measure")) + parser.add_argument("directory", type=Path) + parser.add_argument("--events", type=int, default=1_000_000) + parser.add_argument("--metric", choices=("python", "rss"), default="python") + args = parser.parse_args() + if args.events < 1: + parser.error("--events must be positive") + root = args.directory.resolve() + evidence = build(root, args.events) if args.operation == "build" else measure(root, args.metric) + print(json.dumps(evidence, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tests/core/test_export_validation_resources.py b/tests/core/test_export_validation_resources.py new file mode 100644 index 0000000..0039932 --- /dev/null +++ b/tests/core/test_export_validation_resources.py @@ -0,0 +1,136 @@ +"""Nightly million-event validation-only memory acceptance (#253).""" + +import json +import os +import platform +import sqlite3 +import subprocess +import sys +import time +from pathlib import Path + +import pytest + +import pt_snap_cli + +PROBE = Path(__file__).resolve().parents[2] / "benchmarks/export_validation_memory.py" +MIB = 1024 * 1024 + + +def run_probe(tmp_path, *arguments): + env = os.environ.copy() + env["PYTHONPATH"] = str(Path(pt_snap_cli.__file__).resolve().parents[1]) + env["HOME"] = env["USERPROFILE"] = str(tmp_path) + result = subprocess.run( + [sys.executable, str(PROBE), *map(str, arguments)], + cwd=tmp_path, + env=env, + capture_output=True, + text=True, + timeout=180, + check=False, + ) + assert result.returncode == 0, result.stderr + return json.loads(result.stdout) + + +@pytest.mark.nightly +@pytest.mark.slow +def test_million_event_export_validation_memory_is_bounded(tmp_path, record_property): + # fcntl/resource are supported on the Linux scheduled runner. Keep the + # expensive gate out of every-PR platform jobs; do not silently skip it. + import fcntl + + evidence = [] + with Path("/tmp/ptsnap-large-acceptance.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + for events in (10_000, 1_000_000): + root = tmp_path / f"native-{events}" + built = run_probe(tmp_path, "build", root, "--events", events) + assert built["events"] == events and built["capacity"] == 500_000 + assert len(built["slices"]) == (1 if events == 10_000 else 2) + # Setup and both instruments each get a fresh process. RSS never + # includes tracemalloc overhead or the synthetic fixture builder. + for metric in ("python", "rss"): + result = run_probe(tmp_path, "measure", root, "--metric", metric) + assert result["events"] == events + assert result["tracemalloc_enabled"] == (metric == "python") + evidence.append(result) + record_property("export_validation_memory", json.dumps(evidence, sort_keys=True)) + destination = os.environ.get("PT_SNAP_ACCEPTANCE_EVIDENCE_DIR") + if destination: + output = Path(destination) + output.mkdir(parents=True, exist_ok=True) + (output / "export-validation-memory.json").write_text(json.dumps(evidence, indent=2) + "\n") + python_results = [row for row in evidence if row["metric"] == "python"] + rss_results = [row for row in evidence if row["metric"] == "rss"] + # A Python list of one million integer IDs needs tens of MiB. Leave ample + # runtime headroom while rejecting the old O(events) validation regression. + assert all(row["python_peak_bytes"] < 8 * MIB for row in python_results), evidence + assert python_results[1]["python_peak_bytes"] - python_results[0]["python_peak_bytes"] < 2 * MIB + # Linux VmHWM belongs to the current address space. ru_maxrss can carry + # the previous producer/pytest parent's peak across exec; keep it diagnostic. + assert all("/proc/self/status" in row["rss_source"] for row in rss_results) + assert all(row["rss_high_water_increase_bytes"] < 32 * MIB for row in rss_results), evidence + assert all(row["rss_high_water_after_bytes"] < 128 * MIB for row in rss_results), evidence + + +@pytest.mark.nightly +@pytest.mark.slow +def test_first_500k_dataset_cli_query_startup_trend(tmp_path, record_property): + """Fresh CLI/process cache, with no latency threshold or OS-cold claim.""" + import fcntl + + from tests.core.test_dataset_scale_acceptance import scale_dataset + + with Path("/tmp/ptsnap-large-acceptance.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + root = scale_dataset(tmp_path / "dataset", 500_000, 500_000, "synthetic stack") + env = os.environ.copy() + env["PYTHONPATH"] = str(Path(pt_snap_cli.__file__).resolve().parents[1]) + env["HOME"] = env["USERPROFILE"] = str(tmp_path) + for key in ("PT_SNAP_DB_PATH", "PT_SNAP_QUERY_TIMEOUT", "PT_SNAP_DATASET_CACHE"): + env.pop(key, None) + command = [ + sys.executable, + "-m", + "pt_snap_cli.cli", + "query", + str(root), + "--template-use", + "memory_peak", + "--json", + ] + started = time.perf_counter() + result = subprocess.run( + command, + cwd=tmp_path, + env=env, + capture_output=True, + text=True, + timeout=180, + check=False, + ) + seconds = time.perf_counter() - started + assert result.returncode == 0, result.stderr + payload = json.loads(result.stdout) + assert payload["rows"][0]["peak_active"] == 16 + evidence = { + "events": 500_000, + "shards": 1, + "python": platform.python_version(), + "sqlite": sqlite3.sqlite_version, + "platform": platform.platform(), + "runtime_module": str(Path(pt_snap_cli.__file__).resolve()), + "command": command, + "seconds": seconds, + "cache_contract": "default strong; fresh CLI process and empty process-local cache", + "os_cache": "uncontrolled; fixture construction may warm the OS page cache", + "timing_gate": False, + } + record_property("dataset_cold_start_trend", json.dumps(evidence, sort_keys=True)) + destination = os.environ.get("PT_SNAP_ACCEPTANCE_EVIDENCE_DIR") + if destination: + output = Path(destination) + output.mkdir(parents=True, exist_ok=True) + (output / "dataset-cold-start-trend.json").write_text(json.dumps(evidence, indent=2) + "\n") diff --git a/tests/dataset_cli_resource_probe.py b/tests/dataset_cli_resource_probe.py new file mode 100644 index 0000000..9f6dd87 --- /dev/null +++ b/tests/dataset_cli_resource_probe.py @@ -0,0 +1,129 @@ +"""Subprocess instrumentation around the real console entry point, never CliRunner. + +Count bytes returned by hash reads (logical I/O, not physical disk traffic). +The unmodified resolver, report composition, hash implementation and Typer CLI +still run. Audit events observe shard opens even outside Path.open. +""" + +import json +import os +import sqlite3 +import sys +from contextlib import closing +from pathlib import Path + +from pt_snap_cli.cli import _safe_call +from pt_snap_cli.core import dataset_files, dataset_resolver, native_dataset_contract +from pt_snap_cli.core import query_service as queries + + +def main(): + evidence_path, dataset, mutate_stage, *arguments = sys.argv[1:] + root = Path(dataset) + phase = ["cli"] + active = [] + pinned = [] + evidence = {"hash_reads": [], "guards": 0, "sqlite_opens": 0, "member_opens": 0} + real_hash, real_open = dataset_files.hash_file, Path.open + inspect = dataset_resolver.DatasetResolver.inspect + guard = dataset_resolver.ResolvedDataset.require_unchanged + + def audit(event, args): + if event == "sqlite3.connect": + evidence["sqlite_opens"] += 1 + if event == "open" and isinstance(args[0], (str, bytes)): + path = Path(os.fsdecode(args[0])) + if path.suffix == ".db" and path.is_relative_to(root): + evidence["member_opens"] += 1 + + class Reader: + def __init__(self, source, record): + self.source, self.record = source, record + + def __enter__(self): + self.source.__enter__() + return self + + def __exit__(self, *args): + return self.source.__exit__(*args) + + def read(self, size): + data = self.source.read(size) + self.record["bytes_read"] += len(data) + return data + + def opened(path, *args, **kwargs): + source = real_open(path, *args, **kwargs) + if active and path == active[-1][0]: + return Reader(source, active[-1][1]) + return source + + def hashed(path, **kwargs): + record = { + "path": str(path.relative_to(root)), + "phase": phase[-1], + "bytes_read": 0, + "completed": False, + } + evidence["hash_reads"].append(record) + active.append((path, record)) + try: + value = real_hash(path, **kwargs) + record["completed"] = True + return value + finally: + active.pop() + + def inspected(self, *args, **kwargs): + phase.append("inspect") + try: + resolved = inspect(self, *args, **kwargs) + pinned.append(resolved) + return resolved + finally: + phase.pop() + + def guarded(self, *args, **kwargs): + evidence["guards"] += 1 + phase.append(f"guard{evidence['guards']}") + try: + return guard(self, *args, **kwargs) + finally: + phase.pop() + + if mutate_stage != "none": + name = "global_query" if mutate_stage == "peak" else "event_attribution" + original_query = getattr(queries, name) + + def changed(*args, **kwargs): + result = original_query(*args, **kwargs) + # Alter an unselected device after a real successful query. Hide all + # generation tokens so only the retained strong content guard helps. + target = root / "device_1/slice_00000.db" + before = target.stat() + with closing(sqlite3.connect(target)) as conn, conn: + conn.execute("UPDATE trace_entry_1 SET reserved=reserved+1 WHERE id>=0") + os.utime(target, ns=(before.st_atime_ns, before.st_mtime_ns)) + assert target.stat().st_size == before.st_size + dataset_resolver._generation = lambda *a: pinned[-1].generation + evidence["mutated"] = str(target.relative_to(root)) + return result + + setattr(queries, name, changed) + + Path.open = opened + dataset_files.hash_file = hashed + dataset_resolver._hash_file = hashed + native_dataset_contract._hash_file = hashed + dataset_resolver.DatasetResolver.inspect = inspected + dataset_resolver.ResolvedDataset.require_unchanged = guarded + sys.addaudithook(audit) + sys.argv = ["pt-snap", *arguments] + try: + return _safe_call() + finally: + Path(evidence_path).write_text(json.dumps(evidence), encoding="utf-8") + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_dataset_acceptance_runner.py b/tests/test_dataset_acceptance_runner.py index 15f1d3c..afa6de3 100644 --- a/tests/test_dataset_acceptance_runner.py +++ b/tests/test_dataset_acceptance_runner.py @@ -12,6 +12,11 @@ import pytest RUNNER = Path(".github/scripts/run_dataset_acceptance.py") +RESOURCE_FILE = "tests/core/test_export_validation_resources.py" +RESOURCE_NAMES = ( + "test_million_event_export_validation_memory_is_bounded", + "test_first_500k_dataset_cli_query_startup_trend", +) BOUNDARY_NAME = "test_installed_default_export_short_final_shard_boundary" SCALE_TEST_NODES = ( "tests/core/test_dataset_route_scale_acceptance.py::test_million_lifecycles_real_attach_and_scratch_routes", @@ -60,6 +65,14 @@ def write_report(path, name, evidence, outcome=None, *, include_boundary=True): file=file, classname=file.removesuffix(".py").replace("/", "."), ) + for resource_name in RESOURCE_NAMES: + ET.SubElement( + suite, + "testcase", + name=resource_name, + file=RESOURCE_FILE, + classname="tests.core.test_export_validation_resources", + ) ET.ElementTree(suite).write(path) @@ -135,6 +148,7 @@ def test_runner_accepts_additional_nightly_cases_and_records_complete_identities runner.TEST_NODE, runner.BOUNDARY_TEST_NODE, *SCALE_TEST_NODES, + *(f"{RESOURCE_FILE}::{name}" for name in RESOURCE_NAMES), "tests/test_extra.py::TestRoutes::test_extra[v2]", ] @@ -325,6 +339,7 @@ def test_required_nightly_registry_contains_actual_scale_gates(runner): runner.TEST_NODE, runner.BOUNDARY_TEST_NODE, *SCALE_TEST_NODES, + *(f"{RESOURCE_FILE}::{name}" for name in RESOURCE_NAMES), ) @@ -344,3 +359,26 @@ def test_every_scale_gate_is_required_by_full_identity(runner, tmp_path, node, o tree.write(report) with pytest.raises(runner.AcceptanceError, match=re.escape(node)): runner.read_evidence(report, "abc") + + +def test_runner_requires_both_real_resource_gates(runner): + assert {f"{RESOURCE_FILE}::{name}" for name in RESOURCE_NAMES} <= set( + runner.REQUIRED_TEST_NODES + ) + + +@pytest.mark.parametrize("name", RESOURCE_NAMES) +@pytest.mark.parametrize("outcome", ["missing", "skipped", "failure", "error"]) +def test_runner_rejects_missing_or_nonpassing_resource_gate(runner, tmp_path, name, outcome): + report = tmp_path / "junit.xml" + write_report(report, runner.TEST_NAME, {"wheel_sha256": "abc"}) + tree = ET.parse(report) + case = tree.find(f".//testcase[@name='{name}']") + assert case is not None + if outcome == "missing": + tree.getroot().remove(case) + else: + ET.SubElement(case, outcome) + tree.write(report) + with pytest.raises(runner.AcceptanceError, match=name): + runner.read_evidence(report, "abc") diff --git a/tests/test_dataset_cli_resources.py b/tests/test_dataset_cli_resources.py new file mode 100644 index 0000000..a2651d9 --- /dev/null +++ b/tests/test_dataset_cli_resources.py @@ -0,0 +1,123 @@ +"""Small deterministic CLI resource contracts, required on every PR (#253).""" + +import json +import os +import subprocess +import sys +from collections import Counter +from pathlib import Path + +import pytest + +import pt_snap_cli +from pt_snap_cli.core.native_dataset_contract import NATIVE_FORMAT +from tests.test_dataset_focus import make_dataset +from tests.test_native_dataset import dataset as native_dataset + +PROBE = Path(__file__).with_name("dataset_cli_resource_probe.py") + + +@pytest.fixture(params=["compatibility", "native"]) +def artifact(request, tmp_path, monkeypatch): + monkeypatch.chdir(tmp_path) + monkeypatch.setenv("HOME", str(tmp_path)) + monkeypatch.setattr(Path, "home", lambda: tmp_path) + for name in ("PT_SNAP_DB_PATH", "PT_SNAP_QUERY_TIMEOUT", "PT_SNAP_DATASET_CACHE"): + monkeypatch.delenv(name, raising=False) + return ( + make_dataset(tmp_path / "dataset", devices=(0, 1), slices=2) + if request.param == "compatibility" + else native_dataset(tmp_path) + ) + + +def run_probe(tmp_path, root, arguments, *, cache=None, stage="none", completion=False): + env = os.environ.copy() + # Use the same runtime as the parent test, from an isolated CWD/home. No + # editable installation is repointed and no source checkout is inferred. + env["PYTHONPATH"] = str(Path(pt_snap_cli.__file__).resolve().parents[1]) + env["HOME"] = env["USERPROFILE"] = str(tmp_path) + for key in ("PT_SNAP_DB_PATH", "PT_SNAP_QUERY_TIMEOUT", "PT_SNAP_DATASET_CACHE"): + env.pop(key, None) + if cache is not None: + env["PT_SNAP_DATASET_CACHE"] = cache + if completion: + env.update( + _PT_SNAP_COMPLETE="complete_bash", + COMP_WORDS="pt-snap report peak-memory --device ", + COMP_CWORD="4", + ) + evidence = tmp_path / "cli-resource-evidence.json" + result = subprocess.run( + [sys.executable, str(PROBE), str(evidence), str(root), stage, *arguments], + cwd=tmp_path, + env=env, + text=True, + capture_output=True, + timeout=60, + check=False, + ) + assert evidence.exists(), (result.stdout, result.stderr) + return result, json.loads(evidence.read_text()) + + +@pytest.mark.parametrize("cache", [None, "immutable"], ids=["default-strong", "explicit-immutable"]) +def test_cli_report_hash_passes_and_logical_bytes(artifact, tmp_path, cache): + root = artifact + result, evidence = run_probe( + tmp_path, root, ["report", "peak-memory", str(root), "--device", "0", "--json"], cache=cache + ) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout)["event_id"] is not None + files = { + str(path.relative_to(root)): path.stat().st_size + for path in root.rglob("*") + if path.is_file() + } + reads = evidence["hash_reads"] + assert evidence["guards"] == 2 + assert all(row["completed"] and row["bytes_read"] == files[row["path"]] for row in reads) + # Immutable is opt-in and only supported with POSIX change-time tokens. + strong = cache != "immutable" or os.name != "posix" + native = json.loads((root / "manifest.json").read_text()).get("format") == NATIVE_FORMAT + expected = { + ("inspect", name): 2 if name == "manifest.json" or native or cache is None else 1 + for name in files + } + if strong: + expected.update({(phase, name): 1 for phase in ("guard1", "guard2") for name in files}) + assert Counter((row["phase"], row["path"]) for row in reads) == expected + assert sum(row["bytes_read"] for row in reads) == sum( + count * files[name] for (_, name), count in expected.items() + ) + + +@pytest.mark.parametrize("stage", ["peak", "attribution"]) +def test_default_cli_report_retains_both_strong_guards(artifact, tmp_path, stage): + result, evidence = run_probe( + tmp_path, + artifact, + ["report", "peak-memory", str(artifact), "--device", "0", "--json"], + stage=stage, + ) + assert result.returncode != 0 + assert "content changed during operation" in result.stderr + assert not result.stdout.strip() # Never return a mixed-generation report. + assert evidence["guards"] == (1 if stage == "peak" else 2) + assert evidence["mutated"] == "device_1/slice_00000.db" + assert any(row["phase"] == f"guard{evidence['guards']}" for row in evidence["hash_reads"]) + + +@pytest.mark.parametrize("manifest_path", [False, True], ids=["directory", "manifest"]) +def test_cli_tab_completion_reads_only_focused_manifest(artifact, tmp_path, manifest_path): + focus = tmp_path / ".pt-snap/focus.json" + focus.parent.mkdir() + target = artifact / "manifest.json" if manifest_path else artifact + focus.write_text(json.dumps({"db_path": str(target)})) + result, evidence = run_probe(tmp_path, artifact, [], completion=True) + assert result.returncode == 0, result.stderr + assert result.stdout.splitlines() == ["0", "1"] + assert evidence["sqlite_opens"] == 0 + assert evidence["member_opens"] == 0 + assert evidence["hash_reads"] == [] + assert evidence["guards"] == 0 diff --git a/tests/test_export_validation_probe.py b/tests/test_export_validation_probe.py new file mode 100644 index 0000000..6c5e652 --- /dev/null +++ b/tests/test_export_validation_probe.py @@ -0,0 +1,80 @@ +"""RSS instrumentation must not count an earlier producer's pre-exec peak.""" + +import importlib.util +import json +import sys +from pathlib import Path +from types import SimpleNamespace + +import pytest + +PROBE = Path(__file__).resolve().parents[1] / "benchmarks/export_validation_memory.py" + + +@pytest.fixture +def probe(): + spec = importlib.util.spec_from_file_location("export_validation_probe", PROBE) + assert spec is not None and spec.loader is not None + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_parse_current_address_space_rss_normalizes_kib(probe): + assert probe._parse_linux_rss("Name:\tpython\nVmHWM:\t24000 kB\nVmRSS:\t20000 kB\n") == { + "VmHWM": 24_000 * 1024, + "VmRSS": 20_000 * 1024, + } + + +@pytest.mark.parametrize( + "status", + [ + "VmRSS: 1 kB", + "VmHWM: 1 kB", + "VmHWM: 1 MB\nVmRSS: 1 kB", + "VmHWM: -1 kB\nVmRSS: 1 kB", + "VmHWM: 1 kB\nVmHWM: 2 kB\nVmRSS: 1 kB", + ], +) +def test_missing_or_unsupported_rss_capability_fails_explicitly(probe, status): + with pytest.raises(RuntimeError, match="RSS|/proc"): + probe._parse_linux_rss(status) + + +def test_rss_probe_reports_unsupported_platform_without_silent_skip(probe, monkeypatch): + monkeypatch.setattr(probe.sys, "platform", "win32") + with pytest.raises(RuntimeError, match="requires Linux /proc"): + probe._linux_rss_snapshot() + + +def test_inherited_ru_maxrss_does_not_fail_current_process_memory_bound( + probe, tmp_path, monkeypatch +): + mib = 1024 * 1024 + (tmp_path / "probe.json").write_text( + json.dumps({"events": 1_000_000, "capacity": 500_000, "slices": []}) + ) + monkeypatch.setitem( + sys.modules, + "resource", + SimpleNamespace(RUSAGE_SELF=0, getrusage=lambda _: SimpleNamespace(ru_maxrss=1024 * 1024)), + ) + snapshots = iter( + [ + {"VmRSS": 20 * mib, "VmHWM": 22 * mib}, + {"VmRSS": 21 * mib, "VmHWM": 25 * mib}, + ] + ) + monkeypatch.setattr(probe, "_linux_rss_snapshot", lambda: next(snapshots)) + calls = [] + monkeypatch.setattr(probe, "_validate_shards", calls.append) + evidence = probe.measure(tmp_path, "rss") + assert len(calls) == 1 + assert evidence["rss_current_before_bytes"] == 20 * mib + assert evidence["rss_current_after_bytes"] == 21 * mib + assert evidence["rss_high_water_before_bytes"] == 22 * mib + assert evidence["rss_high_water_after_bytes"] == 25 * mib < 128 * mib + assert evidence["rss_high_water_increase_bytes"] == 3 * mib < 32 * mib + assert evidence["ru_maxrss_before_bytes"] == evidence["ru_maxrss_after_bytes"] == 1024 * mib + assert evidence["tracemalloc_enabled"] is False From 9247b98aa20334a68abc4cfb01dd0a962b2d81bf Mon Sep 17 00:00:00 2001 From: codeasier <48463012+codeasier@users.noreply.github.com> Date: Mon, 12 Oct 2026 04:06:56 +0800 Subject: [PATCH 2/2] test: serialize resource evidence paths portably Use stable slash-separated relative identities in test-owned hash/mutation evidence and test inventory. Add pure Windows/POSIX path regression without changing product behavior or guard assertions. --- tests/dataset_cli_resource_probe.py | 11 ++++++++--- tests/test_dataset_cli_resources.py | 12 ++++++++++-- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/tests/dataset_cli_resource_probe.py b/tests/dataset_cli_resource_probe.py index 9f6dd87..d359aa9 100644 --- a/tests/dataset_cli_resource_probe.py +++ b/tests/dataset_cli_resource_probe.py @@ -10,13 +10,18 @@ import sqlite3 import sys from contextlib import closing -from pathlib import Path +from pathlib import Path, PurePath from pt_snap_cli.cli import _safe_call from pt_snap_cli.core import dataset_files, dataset_resolver, native_dataset_contract from pt_snap_cli.core import query_service as queries +def relative_evidence_path(path: PurePath, root: PurePath) -> str: + """Serialize relative evidence identities with platform-independent separators.""" + return path.relative_to(root).as_posix() + + def main(): evidence_path, dataset, mutate_stage, *arguments = sys.argv[1:] root = Path(dataset) @@ -60,7 +65,7 @@ def opened(path, *args, **kwargs): def hashed(path, **kwargs): record = { - "path": str(path.relative_to(root)), + "path": relative_evidence_path(path, root), "phase": phase[-1], "bytes_read": 0, "completed": False, @@ -106,7 +111,7 @@ def changed(*args, **kwargs): os.utime(target, ns=(before.st_atime_ns, before.st_mtime_ns)) assert target.stat().st_size == before.st_size dataset_resolver._generation = lambda *a: pinned[-1].generation - evidence["mutated"] = str(target.relative_to(root)) + evidence["mutated"] = relative_evidence_path(target, root) return result setattr(queries, name, changed) diff --git a/tests/test_dataset_cli_resources.py b/tests/test_dataset_cli_resources.py index a2651d9..96121b9 100644 --- a/tests/test_dataset_cli_resources.py +++ b/tests/test_dataset_cli_resources.py @@ -5,18 +5,26 @@ import subprocess import sys from collections import Counter -from pathlib import Path +from pathlib import Path, PurePosixPath, PureWindowsPath import pytest import pt_snap_cli from pt_snap_cli.core.native_dataset_contract import NATIVE_FORMAT +from tests.dataset_cli_resource_probe import relative_evidence_path from tests.test_dataset_focus import make_dataset from tests.test_native_dataset import dataset as native_dataset PROBE = Path(__file__).with_name("dataset_cli_resource_probe.py") +@pytest.mark.parametrize("path_type", [PurePosixPath, PureWindowsPath]) +def test_relative_evidence_paths_use_portable_separators(path_type): + root = path_type("dataset") + member = root / "device_1" / "slice_00000.db" + assert relative_evidence_path(member, root) == "device_1/slice_00000.db" + + @pytest.fixture(params=["compatibility", "native"]) def artifact(request, tmp_path, monkeypatch): monkeypatch.chdir(tmp_path) @@ -70,7 +78,7 @@ def test_cli_report_hash_passes_and_logical_bytes(artifact, tmp_path, cache): assert result.returncode == 0, result.stderr assert json.loads(result.stdout)["event_id"] is not None files = { - str(path.relative_to(root)): path.stat().st_size + path.relative_to(root).as_posix(): path.stat().st_size for path in root.rglob("*") if path.is_file() }