"""DGR-034: strict consumption of owned-range reports from loaded engine state. The ``meshnet-range-report`` native tool loads one dense-Llama GGUF through the Meshnet owned-range loader and prints a JSON document derived from the loaded model state. ``meshnet_node.range_report`` is the strict consumer: it must accept exactly the documents that encode the dense-Llama ownership contract and fail closed on everything else — invalid, empty, or out-of-model ranges, endpoint registrations that disagree with the loaded state, gapped or unexpected tensor registrations, and inconsistent byte counts. """ from __future__ import annotations from typing import Any import pytest from meshnet_node.range_report import ( OwnedRangeReport, RangeReportError, parse_owned_range_report, ) N_LAYER = 40 LAYER_BYTES = 300 * 2**20 EMBD_BYTES = 360 * 2**20 OUT_BYTES = 525 * 2**20 FILE_BYTES = 13669 * 2**20 def _doc(**overrides: Any) -> dict[str, Any]: """A valid middle-range [10, 20) mmap report the consumer must accept.""" doc: dict[str, Any] = { "ok": True, "model": "/models/dense.gguf", "architecture": "llama", "n_layer": N_LAYER, "file_bytes": FILE_BYTES, "requested_range": [10, 20], "reported_range": [10, 20], "mmap": True, "touched": False, "use_extra_bufts": True, "has_token_embeddings": False, "has_output_head": False, "tied_output_head": False, "mapped_bytes": 10 * LAYER_BYTES, "resident_bytes": 10 * LAYER_BYTES, "registered_tensors": 90, "registered_bytes": 10 * LAYER_BYTES, "unexpected_registered_tensors": [], "missing_owned_layers": [], "vm_size_bytes": FILE_BYTES + 2**28, "vm_rss_bytes": 2**28, "vm_hwm_bytes": 2**28, } doc.update(overrides) return doc def _head_doc(**overrides: Any) -> dict[str, Any]: base = _doc( requested_range=[0, 10], reported_range=[0, 10], has_token_embeddings=True, mapped_bytes=10 * LAYER_BYTES + EMBD_BYTES, resident_bytes=10 * LAYER_BYTES + EMBD_BYTES, registered_tensors=91, registered_bytes=10 * LAYER_BYTES + EMBD_BYTES, ) base.update(overrides) return base def _tail_doc(**overrides: Any) -> dict[str, Any]: base = _doc( requested_range=[30, 40], reported_range=[30, 40], has_output_head=True, mapped_bytes=10 * LAYER_BYTES + OUT_BYTES, resident_bytes=10 * LAYER_BYTES + OUT_BYTES, registered_tensors=92, registered_bytes=10 * LAYER_BYTES + OUT_BYTES, ) base.update(overrides) return base class TestAcceptance: def test_middle_range_registers_only_per_layer_tensors(self) -> None: report = parse_owned_range_report(_doc()) assert (report.start_layer, report.end_layer) == (10, 20) assert not report.is_head and not report.is_tail assert not report.has_token_embeddings and not report.has_output_head def test_head_range_owns_embeddings_only_at_the_head(self) -> None: report = parse_owned_range_report(_head_doc()) assert report.is_head and not report.is_tail assert report.has_token_embeddings and not report.has_output_head def test_tail_range_owns_norm_and_output_only_at_the_tail(self) -> None: report = parse_owned_range_report(_tail_doc()) assert report.is_tail and not report.is_head assert report.has_output_head and not report.has_token_embeddings def test_whole_model_range_owns_both_endpoints(self) -> None: report = parse_owned_range_report( _head_doc( requested_range=[0, 40], reported_range=[0, 40], has_output_head=True, mapped_bytes=FILE_BYTES, resident_bytes=FILE_BYTES, registered_tensors=363, registered_bytes=N_LAYER * LAYER_BYTES + EMBD_BYTES + OUT_BYTES, ) ) assert report.is_head and report.is_tail assert report.has_token_embeddings and report.has_output_head def test_tied_output_tail_registers_the_embedding_as_its_output_head(self) -> None: report = parse_owned_range_report( _tail_doc( has_token_embeddings=True, tied_output_head=True, registered_tensors=91, registered_bytes=10 * LAYER_BYTES + EMBD_BYTES, mapped_bytes=10 * LAYER_BYTES + EMBD_BYTES, resident_bytes=10 * LAYER_BYTES + EMBD_BYTES, ) ) assert report.tied_output_head and report.has_output_head def test_non_mmap_load_reports_resident_allocation_only(self) -> None: report = parse_owned_range_report( _doc(mmap=False, mapped_bytes=0, resident_bytes=10 * LAYER_BYTES) ) assert report.mapped_bytes == 0 assert report.resident_bytes == 10 * LAYER_BYTES def test_process_counters_may_be_absent_off_linux(self) -> None: report = parse_owned_range_report( _doc(vm_size_bytes=None, vm_rss_bytes=None, vm_hwm_bytes=None) ) assert report.vm_hwm_bytes is None class TestRangeRejection: def test_rejected_load_fails_closed_with_the_tool_error(self) -> None: with pytest.raises(RangeReportError, match="dense Llama only"): parse_owned_range_report( {"ok": False, "error": "owned-range load rejected the artifact or range: dense Llama only"} ) def test_reported_range_must_match_the_requested_range(self) -> None: with pytest.raises(RangeReportError, match="loaded engine state"): parse_owned_range_report(_doc(reported_range=[10, 21])) def test_out_of_model_range_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="outside the model"): parse_owned_range_report( _doc(requested_range=[30, 41], reported_range=[30, 41], has_output_head=True) ) def test_empty_range_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="empty or"): parse_owned_range_report(_doc(requested_range=[10, 10], reported_range=[10, 10])) def test_inverted_range_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="empty or"): parse_owned_range_report(_doc(requested_range=[20, 10], reported_range=[20, 10])) def test_boolean_range_bounds_are_rejected(self) -> None: with pytest.raises(RangeReportError, match="integer pair"): parse_owned_range_report(_doc(reported_range=[True, 20])) class TestEndpointRejection: def test_embeddings_registered_below_the_head_are_rejected(self) -> None: with pytest.raises(RangeReportError, match="embeddings belong to the head"): parse_owned_range_report(_doc(has_token_embeddings=True)) def test_output_head_registered_above_the_tail_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="output head belong to the tail"): parse_owned_range_report(_tail_doc(requested_range=[20, 30], reported_range=[20, 30])) def test_tail_without_an_output_head_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="output head belong to the tail"): parse_owned_range_report(_tail_doc(has_output_head=False)) def test_tied_output_below_the_tail_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="only belong to the tail"): parse_owned_range_report(_doc(tied_output_head=True)) def test_unexpected_registered_tensors_are_rejected(self) -> None: with pytest.raises(RangeReportError, match="unexpected_registered_tensors"): parse_owned_range_report( _doc(unexpected_registered_tensors=["blk.10.attn_q.weight.extra"]) ) def test_missing_owned_layers_are_rejected_as_gaps(self) -> None: with pytest.raises(RangeReportError, match="missing_owned_layers"): parse_owned_range_report(_doc(missing_owned_layers=[12])) class TestByteCountRejection: def test_mapped_span_must_cover_the_registered_tensors(self) -> None: with pytest.raises(RangeReportError, match="undercounts"): parse_owned_range_report(_doc(mapped_bytes=LAYER_BYTES)) def test_mapped_span_must_not_exceed_the_artifact(self) -> None: with pytest.raises(RangeReportError, match="exceeds the artifact"): parse_owned_range_report( _tail_doc(mapped_bytes=FILE_BYTES + 1, resident_bytes=FILE_BYTES + 1) ) def test_non_mmap_load_must_not_claim_a_mapped_span(self) -> None: with pytest.raises(RangeReportError, match="must not claim"): parse_owned_range_report(_doc(mmap=False, mapped_bytes=LAYER_BYTES)) def test_resident_allocation_must_cover_the_registered_tensors(self) -> None: with pytest.raises(RangeReportError, match="undercounts"): parse_owned_range_report( _doc(mmap=False, mapped_bytes=0, resident_bytes=LAYER_BYTES) ) def test_an_empty_registration_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="no tensors"): parse_owned_range_report(_doc(registered_tensors=0, registered_bytes=0)) class TestSchemaRejection: def test_wrong_architecture_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="dense Llama only"): parse_owned_range_report(_doc(architecture="qwen2")) def test_missing_field_is_rejected(self) -> None: doc = _doc() del doc["mapped_bytes"] with pytest.raises(RangeReportError, match="missing field"): parse_owned_range_report(doc) def test_boolean_bytes_are_rejected(self) -> None: with pytest.raises(RangeReportError, match="non-negative integer"): parse_owned_range_report(_doc(mapped_bytes=True)) def test_non_mapping_document_is_rejected(self) -> None: with pytest.raises(RangeReportError, match="JSON object"): parse_owned_range_report(["not", "a", "report"]) # type: ignore[arg-type] def test_owned_range_report_rejects_direct_construction_outside_the_contract() -> None: with pytest.raises(RangeReportError, match="dense Llama only"): OwnedRangeReport( architecture="qwen2", n_layer=N_LAYER, start_layer=10, end_layer=20, has_token_embeddings=False, has_output_head=False, tied_output_head=False, mapped_bytes=10 * LAYER_BYTES, resident_bytes=10 * LAYER_BYTES, registered_tensors=90, registered_bytes=10 * LAYER_BYTES, file_bytes=FILE_BYTES, mmap=True, touched=False, vm_size_bytes=None, vm_rss_bytes=None, vm_hwm_bytes=None, )