| """Coverage rules of the D1 scripts. Fixtures are unit tests only and never enter data/. |
| |
| Standalone, with no project install: |
| uv run --isolated --no-project --with pytest --with httpx --with pycryptodome pytest --noconftest -p no:cacheprovider src/tests/test_d1_coverage.py |
| D1_SCRIPTS_DIR points the tests at another copy of the scripts. |
| """ |
| from __future__ import annotations |
|
|
| import importlib, json, os, sys |
| from pathlib import Path |
|
|
| import pytest |
|
|
| SCRIPTS = Path(os.environ.get("D1_SCRIPTS_DIR", Path(__file__).resolve().parents[2] / "scripts")) |
| sys.path.insert(0, str(SCRIPTS)) |
| census = importlib.import_module("d1_census_6551") |
| candidates = importlib.import_module("d1_candidates") |
|
|
| URL = "https://endpoint.test" |
| HB_ADDR = census.CHAINS["ethereum"]["heartbeat"]["addresses"][0] |
| HB_TOPIC = census.CHAINS["ethereum"]["heartbeat"]["topics"][0] |
| UNREQUESTED = "0x" + "ab" * 32 |
|
|
|
|
| def log(block: int, topic: str = HB_TOPIC, address: str = HB_ADDR, removed: bool = False, index: int = 0) -> dict: |
| return {"address": address, "topics": [topic], "data": "0x", "blockNumber": hex(block), "logIndex": hex(index), "transactionHash": "0x" + "11" * 32, "removed": removed} |
|
|
|
|
| def endpoint(cap: int = 1000): |
| return census.Endpoint(census.E(URL, 1000, 0, cap=cap)) |
|
|
|
|
| @pytest.fixture(autouse=True) |
| def no_waiting(monkeypatch): |
| monkeypatch.setattr(census.time, "sleep", lambda _: None) |
|
|
|
|
| def answer_with(monkeypatch, logs: list) -> None: |
| fake = lambda *a, **k: ("OK", logs) |
| monkeypatch.setattr(census, "rpc", fake) |
| monkeypatch.setattr(candidates, "rpc", fake) |
|
|
|
|
| def window_answer(start: int, end: int, cap: int = 1000): |
| return candidates.get_sub_range([endpoint(cap)], end, start, {HB_TOPIC}) |
|
|
|
|
| def census_answer(start: int, end: int, cap: int = 1000): |
| c = census.Census.__new__(census.Census) |
| c.cfg, c.client = census.CHAINS["ethereum"], None |
| return c.ep_get_logs(endpoint(cap), start, end) |
|
|
|
|
| SINGLE_BLOCK_AT_CAP = [log(100, index=i) for i in range(3)] |
| BAD_ANSWERS = { |
| "out_of_range_heartbeat": [log(5000)], |
| "removed_heartbeat": [log(100, removed=True)], |
| "unrequested_topic": [log(100, topic=UNREQUESTED)], |
| } |
|
|
|
|
| def test_capped_singleton_rejected_in_windows(monkeypatch): |
| answer_with(monkeypatch, SINGLE_BLOCK_AT_CAP) |
| with pytest.raises(LookupError): |
| window_answer(100, 100, cap=3) |
|
|
|
|
| def test_capped_singleton_rejected_in_census(monkeypatch): |
| answer_with(monkeypatch, SINGLE_BLOCK_AT_CAP) |
| with pytest.raises(RuntimeError): |
| census_answer(100, 100, cap=3) |
|
|
|
|
| @pytest.mark.parametrize("case", BAD_ANSWERS) |
| def test_invalid_heartbeat_rejected_in_windows(monkeypatch, case): |
| answer_with(monkeypatch, BAD_ANSWERS[case]) |
| with pytest.raises(LookupError): |
| window_answer(100, 200) |
|
|
|
|
| @pytest.mark.parametrize("case", BAD_ANSWERS) |
| def test_invalid_heartbeat_rejected_in_census(monkeypatch, case): |
| answer_with(monkeypatch, BAD_ANSWERS[case]) |
| with pytest.raises(RuntimeError): |
| census_answer(100, 200) |
|
|
|
|
| def finalized(monkeypatch, tmp_path, answered: list, checks_log_block: int | None = None, cap_blocks: list | None = None) -> dict: |
| """A real finalize over a fixture checkpoint: nothing mocked between the controls and the complete flag.""" |
| data = tmp_path / "data" |
| (data / "census_6551").mkdir(parents=True, exist_ok=True) |
| monkeypatch.setattr(census, "ROOT", tmp_path) |
| monkeypatch.setattr(census, "DATA", data) |
| monkeypatch.setattr(census, "write_summary", lambda: None) |
| c = census.Census.__new__(census.Census) |
| c.chain, c.cfg, c.smoke, c.client = "ethereum", census.CHAINS["ethereum"], None, None |
| c.raw, c.out_path = data / "raw", data / "census_6551" / "ethereum.json" |
| c.endpoints = [endpoint()] |
| lo, hi = min(x[0] for x in answered), max(x[1] for x in answered) |
| c.ckpt = {"chain_id": 1, "covered": [x[:2] for x in answered], "answered": answered, "pinned": {"number": hi, "hash": "0x0", "queried_at_utc": "t"}, "runs": [], "wall_seconds": 0, "ep_stats": {}, |
| "single_block_at_cap": cap_blocks or [], "first_code_block": lo, "method": "fixture", "sourcify_deployment_block": None} |
| monkeypatch.setattr(c, "bounds", lambda: (lo, hi)) |
| monkeypatch.setattr(c, "month_boundaries", lambda a, b: {"2026-10": a}) |
| monkeypatch.setattr(c, "save_checkpoint", lambda: None) |
| monkeypatch.setattr(c, "cross_check", lambda logs: []) |
| saved = {} |
| if checks_log_block is not None: |
| entry = log(checks_log_block, topic=census.EXPECTED_TOPIC0, address=census.REGISTRY) |
| entry["topics"] = [census.EXPECTED_TOPIC0, "0x" + "00" * 32, "0x" + "00" * 32, "0x" + "00" * 32] |
| entry["data"] = "0x" + "00" * 96 |
| monkeypatch.setattr(c, "ep_get_logs", lambda ep, a, b: [entry]) |
| saved = {(entry["transactionHash"], 0): entry} |
| monkeypatch.setattr(c, "load_logs", lambda: (saved, len(saved), 0)) |
| return c.finalize() |
|
|
|
|
| def write_audit(tmp_path, ranges: list, below: int, **overrides) -> None: |
| path = tmp_path / "data" / "census_6551" / "ethereum_reread_audit.json" |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps({"endpoint": URL, "below": below, "via": "https://via.test", "validator": "judge_answer", "finished": True, "matched_ranges": len(ranges), |
| "mismatched_ranges": 0, "unanswered_ranges": 0, "ranges": [{"range": r, "match": True} for r in ranges], **overrides})) |
|
|
|
|
| def test_endpoint_with_zero_checks_blocks_complete(monkeypatch, tmp_path): |
| out = finalized(monkeypatch, tmp_path, [[100, 200, URL, 0, 5]]) |
| assert out["positive_controls"][0]["registry_log_checks"] == [] |
| assert out["complete"] is False |
| assert out["positive_controls"][0]["control_status"] == "inconclusive" |
|
|
|
|
| def test_clean_audit_stands_in_below_its_height_and_is_named(monkeypatch, tmp_path): |
| write_audit(tmp_path, [[100, 200]], below=1000) |
| out = finalized(monkeypatch, tmp_path, [[100, 200, URL, 0, 5]]) |
| assert out["complete"] is True |
| assert out["positive_controls"][0]["substitute"]["reread_audit"] == "data/census_6551/ethereum_reread_audit.json" |
| assert out["positive_controls"][0]["substitute"]["stands_in_only_below_block"] == 1000 |
|
|
|
|
| def test_audit_does_not_reach_above_its_height(monkeypatch, tmp_path): |
| write_audit(tmp_path, [[100, 999]], below=1000) |
| out = finalized(monkeypatch, tmp_path, [[100, 999, URL, 0, 5], [1000, 1100, URL, 0, 5]]) |
| assert out["complete"] is False |
| assert out["positive_controls"][0]["control_status"] == "inconclusive" |
|
|
|
|
| def test_endpoint_above_audit_height_passes_only_with_its_own_check(monkeypatch, tmp_path): |
| write_audit(tmp_path, [[100, 999]], below=1000) |
| out = finalized(monkeypatch, tmp_path, [[100, 999, URL, 0, 5], [1000, 1100, URL, 1, 5]], checks_log_block=1050) |
| assert out["complete"] is True |
| assert out["positive_controls"][0]["control_status"] == "own_checks_above_audit_height_and_audit_substitute_below" |
|
|
|
|
| @pytest.mark.parametrize("field", [{"finished": False}, {"mismatched_ranges": 1}, {"unanswered_ranges": 1}]) |
| def test_unclean_audit_is_no_substitute(monkeypatch, tmp_path, field): |
| write_audit(tmp_path, [[100, 200]], below=1000, **field) |
| assert finalized(monkeypatch, tmp_path, [[100, 200, URL, 0, 5]])["complete"] is False |
|
|
|
|
| def test_capped_block_needs_two_endpoint_evidence_and_output_names_it(monkeypatch, tmp_path): |
| answered = [[100, 200, URL, 1, 5]] |
| out = finalized(monkeypatch, tmp_path, answered, checks_log_block=150, cap_blocks=[[150, 3, URL]]) |
| assert out["complete"] is False and out["single_block_at_cap"][0]["covered_only_through"] is None |
| evidence = tmp_path / "data" / "census_6551" / "ethereum_block_150.json" |
| evidence.write_text(json.dumps({"sources": [{"endpoint": "https://a.test", "status": "OK", "registry_logs": 1}, {"endpoint": "https://b.test", "status": "OK", "registry_logs": 1}]})) |
| out = finalized(monkeypatch, tmp_path, answered, checks_log_block=150, cap_blocks=[[150, 3, URL]]) |
| assert out["complete"] is True and out["single_block_at_cap"][0]["covered_only_through"] == "data/census_6551/ethereum_block_150.json" |
|
|
|
|
| def test_valid_heartbeat_is_accepted(monkeypatch): |
| answer_with(monkeypatch, [log(150)]) |
| assert window_answer(100, 200)[0] == 200 |
| assert census_answer(100, 200) == [] |
|
|
|
|
| def test_capped_larger_range_is_split_not_rejected(monkeypatch): |
| def rpc(client, url, method, params): |
| span = int(params[0]["toBlock"], 16) - int(params[0]["fromBlock"], 16) + 1 |
| return "OK", ([log(int(params[0]["fromBlock"], 16), index=i) for i in range(3)] if span > 50 else [log(int(params[0]["fromBlock"], 16))]) |
| monkeypatch.setattr(candidates, "rpc", rpc) |
| monkeypatch.setattr(census, "rpc", rpc) |
| assert window_answer(100, 200, cap=3)[0] < 200 |
| assert census_answer(100, 200, cap=3) == [] |
|
|
