139 lines
6.0 KiB
Python
139 lines
6.0 KiB
Python
"""Unit tests for skills/exe-reverse/scripts/fold.py, the bounded summariser.
|
|
|
|
What these tests hold is the promise the tool makes about itself: the summary is bounded, it says
|
|
what it withheld, and the numbers it prints are true of the file's actual shape.
|
|
|
|
The shape tests exist because the first version read a pretty-printed 32 MB JSON document line by
|
|
line -- its shape decision was the first byte plus a size cutoff, and both a document and a record
|
|
file begin with `{` -- and summarised it as 16,278 records with 1.7 million unparseable lines. Every
|
|
count in that summary was honestly computed and the summary described a file that did not exist.
|
|
The depth scan that replaced it is what the first three tests hold, including the case that breaks
|
|
naive counters: braces and escaped quotes inside string values.
|
|
"""
|
|
import json
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
pytestmark = pytest.mark.unit
|
|
|
|
|
|
def run_fold(load_script, monkeypatch, capsys, tmp_path, name, content, extra=()):
|
|
"""Write the input, run main() as if from the command line, and return (code, stdout)."""
|
|
path = tmp_path / name
|
|
if isinstance(content, bytes):
|
|
path.write_bytes(content)
|
|
else:
|
|
path.write_text(content, encoding="utf-8")
|
|
fold = load_script("fold.py")
|
|
monkeypatch.setattr(sys, "argv", ["fold.py", str(path), *extra])
|
|
code = fold.main()
|
|
out = capsys.readouterr().out
|
|
return code, out
|
|
|
|
|
|
# --- the shape is decided by the bytes, not the name or the size ----------------
|
|
|
|
|
|
def test_two_records_on_two_lines_are_records(load_script, monkeypatch, capsys, tmp_path):
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "a.jsonl",
|
|
'{"a": 1}\n{"a": 2}\n')
|
|
assert code == 0
|
|
assert "records : 2" in out
|
|
assert "RESULT=fold_ok" in out
|
|
|
|
|
|
def test_a_pretty_printed_document_is_one_value_not_many(load_script, monkeypatch, capsys,
|
|
tmp_path):
|
|
# The string value carries braces, brackets and escaped quotes of its own: a naive depth count
|
|
# is fooled by exactly this, the scanner must not be.
|
|
doc = {"outer": {"s": 'a "{[quoted]}" body', "n": 3}, "arr": [1, 2, 3]}
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "graph.json",
|
|
json.dumps(doc, indent=2))
|
|
assert code == 0
|
|
assert "one JSON document" in out
|
|
assert "records" not in out
|
|
|
|
|
|
def test_content_after_the_first_value_closes_means_records(load_script, monkeypatch, capsys,
|
|
tmp_path):
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "b.jsonl",
|
|
'{"a": 1}\n{"a": 2}\n{"a": 3}\n')
|
|
assert code == 0
|
|
assert "records : 3" in out
|
|
|
|
|
|
def test_a_single_document_past_the_walk_limit_is_left_unwalked(load_script, monkeypatch, capsys,
|
|
tmp_path):
|
|
fold = load_script("fold.py")
|
|
path = tmp_path / "huge.json"
|
|
path.write_text('{"a": "%s"}' % ("x" * 40), encoding="utf-8")
|
|
monkeypatch.setattr(fold, "JSON_WALK_LIMIT", 8)
|
|
monkeypatch.setattr(sys, "argv", ["fold.py", str(path)])
|
|
assert fold.main() == 0
|
|
out = capsys.readouterr().out
|
|
assert "was not loaded" in out
|
|
assert "RESULT=fold_ok" in out
|
|
|
|
|
|
# --- the summary admits its bounds ----------------------------------------------
|
|
|
|
|
|
def test_a_key_with_few_values_counts_them_exactly(load_script, monkeypatch, capsys, tmp_path):
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "c.jsonl",
|
|
'{"kind": "call"}\n{"kind": "call"}\n{"kind": "ret"}\n',
|
|
("--key", "kind", "--limit", "4"))
|
|
assert code == 0
|
|
assert 'key "kind": 2 distinct value(s) seen (showing 2)' in out
|
|
assert "x2" in out
|
|
|
|
|
|
def test_a_key_at_the_tracking_cap_is_reported_as_a_floor(load_script, monkeypatch, capsys,
|
|
tmp_path):
|
|
fold = load_script("fold.py")
|
|
body = "".join(json.dumps({"v": i}) + "\n" for i in range(fold.VALUE_TRACK_CAP + 5))
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "wide.jsonl", body,
|
|
("--key", "v", "--limit", "3"))
|
|
assert code == 0
|
|
assert "at least" in out
|
|
assert "floor" in out
|
|
# The cap must not leak as an exact count: "at least" only ever prefixes the capped number.
|
|
assert "2005 distinct" not in out
|
|
|
|
|
|
def test_grep_reports_how_many_matches_were_withheld(load_script, monkeypatch, capsys, tmp_path):
|
|
text = "\n".join("hit %d premium" % i if i % 2 else "miss %d plain" % i
|
|
for i in range(10)) + "\n"
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "log.txt", text,
|
|
("--grep", "premium", "--limit", "1"))
|
|
assert code == 0
|
|
assert "matches: 5 (showing 1)" in out
|
|
assert "4 more match(es) withheld" in out
|
|
|
|
|
|
def test_text_input_never_touches_the_json_paths(load_script, monkeypatch, capsys, tmp_path):
|
|
code, out = run_fold(load_script, monkeypatch, capsys, tmp_path, "notes.txt",
|
|
"first\nsecond\nthird\n", ("--limit", "2"))
|
|
assert code == 0
|
|
assert "shape : text" in out
|
|
assert "lines : 3" in out
|
|
|
|
|
|
# --- the record itself is never the cost ----------------------------------------
|
|
|
|
|
|
def test_the_input_is_not_modified(load_script, monkeypatch, capsys, tmp_path):
|
|
body = '{"a": 1}\n{"a": 2}\n'
|
|
path = tmp_path / "keep.jsonl"
|
|
path.write_text(body, encoding="utf-8")
|
|
run_fold(load_script, monkeypatch, capsys, tmp_path, "keep.jsonl", body)
|
|
assert path.read_text(encoding="utf-8") == body
|
|
|
|
|
|
def test_a_missing_file_is_a_usage_error_not_a_summary(load_script, monkeypatch, capsys,
|
|
tmp_path):
|
|
fold = load_script("fold.py")
|
|
monkeypatch.setattr(sys, "argv", ["fold.py", str(tmp_path / "absent.jsonl")])
|
|
assert fold.main() == 2
|
|
assert "RESULT=usage_error" in capsys.readouterr().out
|