test(python): cover macro proxy, plugin loader, interactive fit, h5 browser

Adds 40 headless tests for the four src/runtime modules that had none,
exercising the JS-bridge proxy, plugin load/unload/discovery, the
interactive-fit lifecycle and the HDF5 browser (open/preview/import).

Assisted-by: Claude Opus 4.8

Author: PierreRaybaut

tests/python/test_h5browser.py

@@ -0,0 +1,144 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause License
+# See LICENSE file for details
+"""Tests for the HDF5 browser backend (``dlw_h5browser``).
+
+Builds a small real HDF5 file with h5py (a 1-D signal, a 2-D image and a
+nested group), feeds its raw bytes through ``open_file`` and exercises
+the public surface (tree walk, attrs, preview, array data, import,
+close). Malformed input and the encoding helper are covered too.
+"""
+
+from __future__ import annotations
+
+import dlw_h5browser as h5b
+import h5py
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def h5_bytes(tmp_path):
+    """Return the raw bytes of a small multi-node HDF5 file."""
+    path = tmp_path / "sample.h5"
+    with h5py.File(path, "w") as f:
+        sig = f.create_dataset("sig", data=np.linspace(0.0, 1.0, 32))
+        sig.attrs["units"] = "V"
+        f.create_dataset("img", data=np.arange(64, dtype=float).reshape(8, 8))
+        grp = f.create_group("grp")
+        grp.create_dataset("inner", data=np.ones(10))
+    return path.read_bytes()
+
+
+@pytest.fixture
+def opened(h5_bytes):
+    """Open the sample file and guarantee cleanup of all browser state."""
+    result = h5b.open_file("sample.h5", h5_bytes)
+    try:
+        yield result
+    finally:
+        h5b.close_all()
+
+
+# ---------------------------------------------------------------------------
+# Encoding helper
+# ---------------------------------------------------------------------------
+
+
+def test_safe_decode_bytes():
+    assert h5b._safe_decode_bytes(b"hello") == "hello"
+    assert h5b._safe_decode_bytes("already str") == "already str"
+    assert h5b._safe_decode_bytes(123) == "123"
+
+
+# ---------------------------------------------------------------------------
+# open / close
+# ---------------------------------------------------------------------------
+
+
+def test_open_file_returns_tree(opened):
+    assert opened["filename"] == "sample.h5"
+    root = opened["root"]
+    child_ids = {c["id"] for c in root["children"]}
+    assert {"/sig", "/img", "/grp"} <= child_ids
+
+
+def test_open_invalid_file_raises():
+    with pytest.raises(ValueError):
+        h5b.open_file("bogus.h5", b"definitely not an HDF5 file")
+
+
+def test_close_file_clears_state(opened):
+    file_id = opened["file_id"]
+    assert file_id in h5b.STATE
+    h5b.close_file(file_id)
+    assert file_id not in h5b.STATE
+
+
+def test_close_file_unknown_id_is_noop():
+    # Must not raise even for an id that was never opened.
+    h5b.close_file("never-opened")
+
+
+# ---------------------------------------------------------------------------
+# Node inspection
+# ---------------------------------------------------------------------------
+
+
+def test_node_attrs_exposes_attributes(opened):
+    file_id = opened["file_id"]
+    attrs = h5b.node_attrs(file_id, "/sig")
+    assert attrs["path"] == "/sig"
+    assert attrs["attributes"].get("units") == "V"
+
+
+def test_preview_signal(opened):
+    file_id = opened["file_id"]
+    prev = h5b.preview(file_id, "/sig")
+    assert prev["kind"] == "signal"
+    assert len(prev["x"]) == len(prev["y"]) == 32
+
+
+def test_preview_image(opened):
+    file_id = opened["file_id"]
+    prev = h5b.preview(file_id, "/img")
+    assert prev["kind"] == "image"
+    assert prev["width"] == 8
+    assert prev["height"] == 8
+
+
+def test_array_data_returns_shape_and_values(opened):
+    file_id = opened["file_id"]
+    data = h5b.array_data(file_id, "/img")
+    assert data["shape"] == [8, 8]
+    assert "float" in data["dtype"]
+    assert len(data["data"]) == 8
+
+
+def test_require_node_rejects_unknown(opened):
+    file_id = opened["file_id"]
+    with pytest.raises(KeyError):
+        h5b.node_attrs(file_id, "/does-not-exist")
+
+
+# ---------------------------------------------------------------------------
+# Import
+# ---------------------------------------------------------------------------
+
+
+def test_import_nodes_builds_objects(opened):
+    file_id = opened["file_id"]
+    result = h5b.import_nodes(file_id, ["/sig", "/img"])
+    kinds = sorted(kind for kind, _obj in result["objects"])
+    assert kinds == ["image", "signal"]
+    assert result["uint32_clipped"] is False
+
+
+def test_import_nodes_unknown_id_raises(opened):
+    file_id = opened["file_id"]
+    with pytest.raises(KeyError):
+        h5b.import_nodes(file_id, ["/nope"])
+
+
+def test_import_nodes_unknown_file_raises():
+    with pytest.raises(KeyError):
+        h5b.import_nodes("never-opened", ["/sig"])

tests/python/test_interactive_fit.py

@@ -0,0 +1,119 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause License
+# See LICENSE file for details
+"""Tests for the interactive-fit helpers (``dlw_interactive_fit``).
+
+The module exposes a JSON-friendly fitting API consumed by the React
+``InteractiveFitDialog``. These tests drive a Gaussian signal through
+the full session lifecycle (catalogue → init → evaluate → auto-fit →
+commit) under CPython, with the live ``_MODEL`` borrowed from a fresh
+bootstrap and published on ``__main__`` (where ``_get_model`` reads it).
+"""
+
+from __future__ import annotations
+
+import sys
+
+import dlw_interactive_fit as ifit
+import numpy as np
+import pytest
+
+
+def _gaussian_xy():
+    """Return a clean Gaussian (amp=3, mu=0.5, sigma=0.8, y0=0.1)."""
+    x = np.linspace(-5.0, 5.0, 200)
+    y = 3.0 * np.exp(-((x - 0.5) ** 2) / (2.0 * 0.8**2)) + 0.1
+    return x, y
+
+
+@pytest.fixture
+def fit_session(fresh_bootstrap, monkeypatch):
+    """Create a Gaussian signal and expose ``_MODEL`` on ``__main__``."""
+    bs = fresh_bootstrap
+    main_mod = sys.modules["__main__"]
+    monkeypatch.setattr(main_mod, "_MODEL", bs._MODEL, raising=False)
+    x, y = _gaussian_xy()
+    oid = bs.add_signal_from_arrays("Gaussian", x, y)
+    return bs, oid
+
+
+# ---------------------------------------------------------------------------
+# Catalogue
+# ---------------------------------------------------------------------------
+
+
+def test_list_interactive_fits_catalogue():
+    fits = ifit.list_interactive_fits()
+    ids = {f["id"] for f in fits}
+    assert {"linear_fit", "gaussian_fit", "polynomial_fit"} <= ids
+    # Each entry exposes the menu-rendering contract.
+    for entry in fits:
+        assert set(entry) == {"id", "label", "needs_degree"}
+    poly = next(f for f in fits if f["id"] == "polynomial_fit")
+    assert poly["needs_degree"] is True
+
+
+# ---------------------------------------------------------------------------
+# Session lifecycle
+# ---------------------------------------------------------------------------
+
+
+def test_init_interactive_fit_returns_session(fit_session):
+    _bs, oid = fit_session
+    session = ifit.init_interactive_fit(oid, "gaussian_fit")
+    assert session["fit_id"] == "gaussian_fit"
+    assert len(session["x"]) == len(session["y"]) == 200
+    assert len(session["y_fit"]) == 200
+    assert session["params"]  # at least one slider row
+    for row in session["params"]:
+        assert set(row) >= {"name", "label", "value", "min", "max"}
+        # The initial value always lies within the slider bounds.
+        assert row["min"] <= row["value"] <= row["max"]
+
+
+def test_evaluate_interactive_fit_matches_length(fit_session):
+    _bs, oid = fit_session
+    session = ifit.init_interactive_fit(oid, "gaussian_fit")
+    values = {p["name"]: p["value"] for p in session["params"]}
+    x = session["x"]
+    y_eval = ifit.evaluate_interactive_fit("gaussian_fit", x, values)
+    assert len(y_eval) == len(x)
+    assert all(np.isfinite(y_eval))
+
+
+def test_auto_fit_recovers_gaussian_params(fit_session):
+    _bs, oid = fit_session
+    result = ifit.auto_fit_interactive(oid, "gaussian_fit")
+    assert len(result["y_fit"]) == 200
+    # The optimiser should fit clean synthetic data almost exactly.
+    assert result["residual_rms"] < 1e-3
+    # The fitted curve reproduces the source Gaussian (peak ≈ 3.1, the
+    # 3.0 amplitude plus the 0.1 offset) — independent of how Sigima
+    # parametrises the model internally.
+    _x, y = _gaussian_xy()
+    assert abs(max(result["y_fit"]) - float(y.max())) < 0.05
+
+
+def test_commit_interactive_fit_adds_signal(fit_session):
+    bs, oid = fit_session
+    before = len(bs.get_object_uuids("signal"))
+    session = ifit.init_interactive_fit(oid, "gaussian_fit")
+    values = {p["name"]: p["value"] for p in session["params"]}
+    new_oid = ifit.commit_interactive_fit(oid, "gaussian_fit", values)
+    assert new_oid != oid
+    after = bs.get_object_uuids("signal")
+    assert len(after) == before + 1
+    assert new_oid in after
+    # The committed signal carries interactive-fit metadata.
+    obj = bs._MODEL.get(new_oid)
+    assert obj.metadata["fit_params"]["interactive"] is True
+
+
+def test_evaluate_polynomial_uses_degree(fit_session):
+    _bs, oid = fit_session
+    session = ifit.init_interactive_fit(oid, "polynomial_fit", {"degree": 2})
+    values = {p["name"]: p["value"] for p in session["params"]}
+    y_eval = ifit.evaluate_interactive_fit(
+        "polynomial_fit", session["x"], values, {"degree": 2}
+    )
+    assert len(y_eval) == len(session["x"])
+    assert all(np.isfinite(y_eval))