doppler-cli 0.2.6__py3-none-any.whl

doppler_cli/tests/test_blocks.py

@@ -0,0 +1,172 @@
+"""
+Tests for the block registry and individual block configs/commands.
+
+Covers:
+  - Registry: register, get, unknown block error
+  - ToneBlock: defaults, config override, command argv
+  - FirBlock: defaults, taps in command, no-taps omission
+  - SpecanBlock: terminal and web mode commands
+"""
+
+import pytest
+
+import doppler_cli.blocks.fir  # noqa: F401 — populate registry
+import doppler_cli.blocks.specan  # noqa: F401
+import doppler_cli.blocks.tone  # noqa: F401
+from doppler_cli.blocks import get, all_blocks
+from doppler_cli.blocks.tone import ToneBlock, ToneConfig
+from doppler_cli.blocks.fir import FirBlock, FirConfig
+from doppler_cli.blocks.specan import SpecanBlock, SpecanConfig
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+
+class TestRegistry:
+    def test_known_blocks_present(self):
+        names = set(all_blocks())
+        assert {"tone", "fir", "specan"} <= names
+
+    def test_get_returns_correct_class(self):
+        assert get("tone") is ToneBlock
+        assert get("fir") is FirBlock
+        assert get("specan") is SpecanBlock
+
+    def test_get_unknown_raises(self):
+        with pytest.raises(KeyError, match="Unknown block"):
+            get("nonexistent_block")
+
+    def test_roles(self):
+        assert ToneBlock.role == "source"
+        assert FirBlock.role == "chain"
+        assert SpecanBlock.role == "sink"
+
+
+# ---------------------------------------------------------------------------
+# ToneBlock
+# ---------------------------------------------------------------------------
+
+
+class TestToneBlock:
+    def test_default_config(self):
+        cfg = ToneConfig()
+        assert cfg.sample_rate == 2.048e6
+        assert cfg.tone_freq == 100e3
+        assert cfg.tone_power == -20.0
+        assert cfg.noise_floor == -90.0
+
+    def test_config_override(self):
+        cfg = ToneConfig(tone_freq=50e3, tone_power=-30.0)
+        assert cfg.tone_freq == 50e3
+        assert cfg.tone_power == -30.0
+
+    def test_command_contains_bind(self):
+        cfg = ToneConfig()
+        cmd = ToneBlock().command(cfg, None, "tcp://127.0.0.1:5600")
+        assert "--bind" in cmd
+        assert "tcp://127.0.0.1:5600" in cmd
+
+    def test_command_contains_params(self):
+        cfg = ToneConfig(sample_rate=1e6, tone_freq=200e3)
+        cmd = ToneBlock().command(cfg, None, "tcp://127.0.0.1:5600")
+        assert "--fs" in cmd
+        assert "1000000.0" in cmd
+        assert "--tone-freq" in cmd
+        assert "200000.0" in cmd
+
+    def test_command_no_input_addr(self):
+        cfg = ToneConfig()
+        cmd = ToneBlock().command(cfg, None, "tcp://127.0.0.1:5600")
+        assert "--connect" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# FirBlock
+# ---------------------------------------------------------------------------
+
+
+class TestFirBlock:
+    def test_default_config_empty_taps(self):
+        cfg = FirConfig()
+        assert cfg.taps == []
+
+    def test_command_contains_connect_and_bind(self):
+        cfg = FirConfig()
+        cmd = FirBlock().command(
+            cfg,
+            "tcp://127.0.0.1:5600",
+            "tcp://127.0.0.1:5601",
+        )
+        assert "--connect" in cmd
+        assert "tcp://127.0.0.1:5600" in cmd
+        assert "--bind" in cmd
+        assert "tcp://127.0.0.1:5601" in cmd
+
+    def test_command_with_taps(self):
+        cfg = FirConfig(taps=[0.25, 0.5, 0.25])
+        cmd = FirBlock().command(
+            cfg,
+            "tcp://127.0.0.1:5600",
+            "tcp://127.0.0.1:5601",
+        )
+        assert "--taps" in cmd
+        assert "0.25" in cmd
+        assert "0.5" in cmd
+
+    def test_command_no_taps_flag_when_empty(self):
+        cfg = FirConfig(taps=[])
+        cmd = FirBlock().command(
+            cfg,
+            "tcp://127.0.0.1:5600",
+            "tcp://127.0.0.1:5601",
+        )
+        assert "--taps" not in cmd
+
+    def test_requires_both_addrs(self):
+        cfg = FirConfig()
+        with pytest.raises(AssertionError):
+            FirBlock().command(cfg, None, "tcp://127.0.0.1:5601")
+        with pytest.raises(AssertionError):
+            FirBlock().command(cfg, "tcp://127.0.0.1:5600", None)
+
+
+# ---------------------------------------------------------------------------
+# SpecanBlock
+# ---------------------------------------------------------------------------
+
+
+class TestSpecanBlock:
+    def test_default_config(self):
+        cfg = SpecanConfig()
+        assert cfg.mode == "web"
+        assert cfg.web_port == 8080
+
+    def test_terminal_command(self):
+        cfg = SpecanConfig(mode="terminal")
+        cmd = SpecanBlock().command(cfg, "tcp://127.0.0.1:5601", None)
+        assert "--source" in cmd
+        assert "pull" in cmd
+        assert "--address" in cmd
+        assert "tcp://127.0.0.1:5601" in cmd
+        assert "--web" not in cmd
+
+    def test_web_command_includes_web_flag(self):
+        cfg = SpecanConfig(mode="web", web_port=9090)
+        cmd = SpecanBlock().command(cfg, "tcp://127.0.0.1:5601", None)
+        assert "--web" in cmd
+        assert "--port" in cmd
+        assert "9090" in cmd
+
+    def test_optional_display_params(self):
+        cfg = SpecanConfig(span=200e3, rbw=500.0, level=-40.0)
+        cmd = SpecanBlock().command(cfg, "tcp://127.0.0.1:5601", None)
+        assert "--span" in cmd
+        assert "--rbw" in cmd
+        assert "--level" in cmd
+
+    def test_requires_input_addr(self):
+        cfg = SpecanConfig()
+        with pytest.raises(AssertionError):
+            SpecanBlock().command(cfg, None, None)

doppler_cli/tests/test_compose.py

@@ -0,0 +1,148 @@
+"""
+Tests for doppler compose init.
+
+Covers:
+  - init() writes a valid YAML file
+  - Generated file has correct id, source, chain, sink structure
+  - Ports are assigned and present in the file
+  - Custom output path is respected
+  - Single-port chain (source → sink, no middle blocks)
+  - Unknown block name raises KeyError
+  - Wrong roles raise ValueError
+  - Too-few blocks (< 2) raises ValueError
+"""
+
+import yaml
+import pytest
+
+import doppler_cli.blocks.fir  # noqa: F401 — populate registry
+import doppler_cli.blocks.specan  # noqa: F401
+import doppler_cli.blocks.tone  # noqa: F401
+from doppler_cli import compose as compose_mod
+from doppler_cli import ports as ports_mod
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _init(tmp_path, monkeypatch, blocks):
+    """Run compose.init with a temp chains dir and return parsed YAML."""
+    monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+    monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+    path = compose_mod.init(blocks)
+    return path, yaml.safe_load(path.read_text())
+
+
+# ---------------------------------------------------------------------------
+# Structure
+# ---------------------------------------------------------------------------
+
+
+class TestComposeInit:
+    def test_file_is_written(self, tmp_path, monkeypatch):
+        path, _ = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert path.exists()
+
+    def test_has_id(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert "id" in doc
+        assert len(doc["id"]) == 6  # 3 hex bytes → 6 chars
+
+    def test_named_chain_id(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        path = compose_mod.init(["tone", "specan"], name="filter-test")
+        doc = yaml.safe_load(path.read_text())
+        assert doc["id"] == "filter-test"
+        assert path.name == "filter-test.yml"
+
+    def test_named_chain_filename(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        path = compose_mod.init(["tone", "specan"], name="my-chain")
+        assert path == tmp_path / "my-chain.yml"
+
+    def test_source_type(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert doc["source"]["type"] == "tone"
+
+    def test_sink_type(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert doc["sink"]["type"] == "specan"
+
+    def test_source_has_port(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert "port" in doc["source"]
+        assert doc["source"]["port"] == ports_mod._BASE_PORT
+
+    def test_no_chain_key_for_two_blocks(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert "chain" not in doc or doc.get("chain") == []
+
+    def test_chain_block_present(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "fir", "specan"])
+        assert "chain" in doc
+        assert len(doc["chain"]) == 1
+        assert "fir" in doc["chain"][0]
+
+    def test_chain_block_has_port(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "fir", "specan"])
+        fir_entry = doc["chain"][0]["fir"]
+        assert "port" in fir_entry
+
+    def test_source_defaults_present(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        src = doc["source"]
+        assert "sample_rate" in src
+        assert "tone_freq" in src
+
+    def test_sink_defaults_present(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "specan"])
+        assert "mode" in doc["sink"]
+
+    def test_custom_out_path(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        out = tmp_path / "my_chain.yml"
+        path = compose_mod.init(["tone", "specan"], out=out)
+        assert path == out
+        assert out.exists()
+
+    def test_ports_are_unique(self, tmp_path, monkeypatch):
+        _, doc = _init(tmp_path, monkeypatch, ["tone", "fir", "specan"])
+        src_port = doc["source"]["port"]
+        fir_port = doc["chain"][0]["fir"]["port"]
+        assert src_port != fir_port
+
+
+# ---------------------------------------------------------------------------
+# Error cases
+# ---------------------------------------------------------------------------
+
+
+class TestComposeInitErrors:
+    def test_too_few_blocks(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        with pytest.raises(ValueError, match="at least"):
+            compose_mod.init(["tone"])
+
+    def test_unknown_block(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        with pytest.raises(KeyError, match="Unknown block"):
+            compose_mod.init(["tone", "mystery_block"])
+
+    def test_wrong_first_role(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        with pytest.raises(ValueError, match="source"):
+            compose_mod.init(["specan", "tone"])
+
+    def test_wrong_last_role(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(compose_mod, "_CHAINS_DIR", tmp_path)
+        monkeypatch.setattr(ports_mod, "_CHAINS_DIR", tmp_path)
+        with pytest.raises(ValueError, match="sink"):
+            compose_mod.init(["tone", "fir"])

doppler_cli/tests/test_dopplerfile.py

@@ -0,0 +1,290 @@
+"""
+Tests for doppler dopplerfile — YAML-defined block loading.
+
+Covers:
+  - load() parses name / role / executable / config / args
+  - auto-map: --bind for source, --connect for sink
+  - auto-map: config fields become --flag-name value
+  - auto-map: lists JSON-encoded, bool flags are bare
+  - explicit args template overrides auto-map
+  - discover() finds ~/.doppler/blocks/<name>.yml
+  - discover() finds ./<name>.yml (CWD)
+  - discover() returns None when not found
+  - blocks.get() falls back to dopplerfile discovery
+  - missing required field raises KeyError
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+import doppler_cli.blocks.fir  # noqa: F401
+import doppler_cli.blocks.specan  # noqa: F401
+import doppler_cli.blocks.tone  # noqa: F401
+from doppler_cli import blocks as block_registry
+from doppler_cli import dopplerfile as df
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _write_dopplerfile(tmp_path: Path, doc: dict) -> Path:
+    p = tmp_path / f"{doc['name']}.yml"
+    p.write_text(yaml.dump(doc))
+    return p
+
+
+SIMPLE_DOC = {
+    "name": "chirp",
+    "role": "source",
+    "executable": "./chirp.py",
+    "config": {
+        "sample_rate": 2048000.0,
+        "sweep_rate": 50000.0,
+        "tone_power": -20.0,
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# load()
+# ---------------------------------------------------------------------------
+
+
+class TestLoad:
+    def test_name(self, tmp_path):
+        path = _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        cls = df.load(path)
+        assert cls.name == "chirp"
+
+    def test_role(self, tmp_path):
+        path = _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        cls = df.load(path)
+        assert cls.role == "source"
+
+    def test_config_defaults(self, tmp_path):
+        path = _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        cls = df.load(path)
+        cfg = cls.Config()
+        assert cfg.sample_rate == 2048000.0
+        assert cfg.sweep_rate == 50000.0
+
+    def test_missing_name_raises(self, tmp_path):
+        bad = {"role": "source", "executable": "./x.py"}
+        p = tmp_path / "bad.yml"
+        p.write_text(yaml.dump(bad))
+        with pytest.raises(KeyError):
+            df.load(p)
+
+
+# ---------------------------------------------------------------------------
+# Auto-map command building
+# ---------------------------------------------------------------------------
+
+
+class TestAutoMap:
+    def _block(self, tmp_path, doc=None):
+        path = _write_dopplerfile(tmp_path, doc or SIMPLE_DOC)
+        return df.load(path)()
+
+    def test_executable_first(self, tmp_path):
+        blk = self._block(tmp_path)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert cmd[0] == "./chirp.py"
+
+    def test_source_gets_bind(self, tmp_path):
+        blk = self._block(tmp_path)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--bind" in cmd
+        assert "tcp://127.0.0.1:5600" in cmd
+
+    def test_source_no_connect(self, tmp_path):
+        blk = self._block(tmp_path)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--connect" not in cmd
+
+    def test_sink_gets_connect(self, tmp_path):
+        doc = {**SIMPLE_DOC, "role": "sink"}
+        blk = self._block(tmp_path, doc)
+        cmd = blk.command(blk.__class__.Config(), "tcp://127.0.0.1:5600", None)
+        assert "--connect" in cmd
+        assert "--bind" not in cmd
+
+    def test_chain_gets_both(self, tmp_path):
+        doc = {**SIMPLE_DOC, "role": "chain"}
+        blk = self._block(tmp_path, doc)
+        cmd = blk.command(
+            blk.__class__.Config(),
+            "tcp://127.0.0.1:5600",
+            "tcp://127.0.0.1:5601",
+        )
+        assert "--connect" in cmd
+        assert "--bind" in cmd
+
+    def test_config_field_mapping(self, tmp_path):
+        blk = self._block(tmp_path)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--sample-rate" in cmd
+        assert "--sweep-rate" in cmd
+        assert "--tone-power" in cmd
+
+    def test_list_field_json_encoded(self, tmp_path):
+        doc = {**SIMPLE_DOC, "config": {"taps": []}}
+        blk = self._block(tmp_path, doc)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        idx = cmd.index("--taps")
+        assert cmd[idx + 1] == "[]"
+
+    def test_bool_true_is_bare_flag(self, tmp_path):
+        doc = {**SIMPLE_DOC, "config": {"verbose": True}}
+        blk = self._block(tmp_path, doc)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--verbose" in cmd
+        # bare flag — no separate value token follows it
+        idx = cmd.index("--verbose")
+        assert idx == len(cmd) - 1 or not cmd[idx + 1].startswith("True")
+
+    def test_bool_false_omitted(self, tmp_path):
+        doc = {**SIMPLE_DOC, "config": {"verbose": False}}
+        blk = self._block(tmp_path, doc)
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--verbose" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# Explicit args template
+# ---------------------------------------------------------------------------
+
+
+class TestArgsTemplate:
+    def test_explicit_args_used(self, tmp_path):
+        doc = {
+            **SIMPLE_DOC,
+            "args": {
+                "output": "{output_addr}",
+                "rate": "{sample_rate}",
+            },
+        }
+        path = _write_dopplerfile(tmp_path, doc)
+        blk = df.load(path)()
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--output" in cmd
+        assert "tcp://127.0.0.1:5600" in cmd
+        assert "--rate" in cmd
+
+    def test_auto_map_not_applied_with_template(self, tmp_path):
+        doc = {
+            **SIMPLE_DOC,
+            "args": {"output": "{output_addr}"},
+        }
+        path = _write_dopplerfile(tmp_path, doc)
+        blk = df.load(path)()
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        # --bind is the auto-map flag; should NOT appear when using template
+        assert "--bind" not in cmd
+
+
+# ---------------------------------------------------------------------------
+# discover()
+# ---------------------------------------------------------------------------
+
+
+class TestDiscover:
+    def test_finds_global_blocks_dir(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(df, "_BLOCKS_DIR", tmp_path)
+        _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        cls = df.discover("chirp")
+        assert cls is not None
+        assert cls.name == "chirp"
+
+    def test_finds_cwd(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        monkeypatch.setattr(df, "_BLOCKS_DIR", tmp_path / "nonexistent")
+        cls = df.discover("chirp")
+        assert cls is not None
+
+    def test_returns_none_when_not_found(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(df, "_BLOCKS_DIR", tmp_path)
+        monkeypatch.chdir(tmp_path)
+        assert df.discover("no-such-block") is None
+
+    def test_global_takes_priority_over_cwd(self, tmp_path, monkeypatch):
+        global_dir = tmp_path / "global"
+        cwd_dir = tmp_path / "cwd"
+        global_dir.mkdir()
+        cwd_dir.mkdir()
+
+        # Global has sweep_rate=1.0, CWD has sweep_rate=2.0
+        _write_dopplerfile(global_dir, {**SIMPLE_DOC, "config": {"sweep_rate": 1.0}})
+        _write_dopplerfile(cwd_dir, {**SIMPLE_DOC, "config": {"sweep_rate": 2.0}})
+
+        monkeypatch.setattr(df, "_BLOCKS_DIR", global_dir)
+        monkeypatch.chdir(cwd_dir)
+
+        cls = df.discover("chirp")
+        assert cls.Config().sweep_rate == 1.0
+
+
+# ---------------------------------------------------------------------------
+# Dependency isolation
+# ---------------------------------------------------------------------------
+
+
+class TestDependencies:
+    def _block_with_deps(self, tmp_path, deps):
+        doc = {**SIMPLE_DOC, "dependencies": deps}
+        path = _write_dopplerfile(tmp_path, doc)
+        return df.load(path)()
+
+    def test_no_deps_no_uv_wrap(self, tmp_path):
+        path = _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        blk = df.load(path)()
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert cmd[0] != "uv"
+
+    def test_deps_wrap_with_uv_run(self, tmp_path):
+        blk = self._block_with_deps(tmp_path, ["numpy", "scipy"])
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert cmd[:2] == ["uv", "run"]
+
+    def test_deps_each_get_with_flag(self, tmp_path):
+        blk = self._block_with_deps(tmp_path, ["numpy", "scipy"])
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "--with" in cmd
+        assert cmd[cmd.index("--with") + 1] == "numpy"
+        assert cmd[cmd.index("--with", cmd.index("--with") + 2) + 1] == "scipy"
+
+    def test_deps_executable_still_present(self, tmp_path):
+        blk = self._block_with_deps(tmp_path, ["numpy"])
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "./chirp.py" in cmd
+
+    def test_deps_bind_addr_still_present(self, tmp_path):
+        blk = self._block_with_deps(tmp_path, ["numpy"])
+        cmd = blk.command(blk.__class__.Config(), None, "tcp://127.0.0.1:5600")
+        assert "tcp://127.0.0.1:5600" in cmd
+
+
+# ---------------------------------------------------------------------------
+# blocks.get() fallback
+# ---------------------------------------------------------------------------
+
+
+class TestRegistryFallback:
+    def test_get_falls_back_to_dopplerfile(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(df, "_BLOCKS_DIR", tmp_path)
+        _write_dopplerfile(tmp_path, SIMPLE_DOC)
+        cls = block_registry.get("chirp")
+        assert cls.name == "chirp"
+
+    def test_get_raises_for_unknown(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(df, "_BLOCKS_DIR", tmp_path)
+        monkeypatch.chdir(tmp_path)
+        with pytest.raises(KeyError, match="no-such-block"):
+            block_registry.get("no-such-block")