Merge pull request #32 from aai-research-lab/dktesting

Adding Coverage

Author: Paradoxicaly

tests/test_cli.py

@@ -342,6 +342,41 @@ def test_cli_phase_dashboard_uses_cli_output_path(tmp_path: Path) -> None:
     assert session.stopped is True
 
 
+@pytest.mark.parametrize("command", ["simulate", "analyze", "report"])
+def test_cli_dashboard_uses_cli_output_path_for_other_phases(
+    tmp_path: Path,
+    command: str,
+) -> None:
+    pdb = _make_pdb_stub(tmp_path)
+    out = tmp_path / f"{command}_run"
+    session = _FakeDashboardSession()
+
+    method_name = {"simulate": "simulate", "analyze": "analyze", "report": "report"}[command]
+    with patch(
+        "fastmdxplora.live.server.start_dashboard_session",
+        return_value=session,
+    ) as start, patch.object(
+        FastMDXplora,
+        method_name,
+        return_value=SimpleNamespace(status="ok"),
+    ):
+        rc = main(
+            [
+                command,
+                "--system",
+                str(pdb),
+                "--output",
+                str(out),
+                "--dashboard",
+                "--dashboard-stop-on-complete",
+            ]
+        )
+
+    assert rc == 0
+    assert start.call_args.kwargs["output"] == out.resolve()
+    assert session.stopped is True
+
+
 def test_cli_dashboard_prints_port_conflict_and_host_warning(
     tmp_path: Path,
     capsys,

tests/test_dashboard.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from fastmdxplora.report.dashboard import build_dashboard
+from fastmdxplora.report.region_highlights import (
+    RegionHighlight,
+    build_pymol_script,
+    build_region_highlight_artifacts,
+    validate_region_highlights,
+)
+
+
+PNG_BYTES = (
+    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01"
+    b"\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde"
+    b"\x00\x00\x00\x0cIDATx\x9cc```\x00\x00\x00\x04\x00\x01"
+    b"\xf6\x178U\x00\x00\x00\x00IEND\xaeB`\x82"
+)
+
+
+def test_static_dashboard_discovers_sections_links_and_dark_assets(tmp_path: Path) -> None:
+    root = tmp_path / "run"
+    _write_json(
+        root / "manifest.json",
+        {
+            "system": "demo-system",
+            "phases": [
+                {"name": "analysis", "status": "ok"},
+                {"name": "report", "status": "ok"},
+            ],
+        },
+    )
+    _write_json(
+        root / "analysis" / "analysis_manifest.json",
+        {"n_frames": 2, "n_atoms": 12, "results": {"rmsd": {"status": "ok"}}},
+    )
+    (root / "report").mkdir(parents=True)
+    (root / "report" / "report.md").write_text("# Report\n", encoding="utf-8")
+    (root / "report" / "slides.pptx").write_bytes(b"pptx")
+    (root / "report" / "project_bundle.zip").write_bytes(b"zip")
+
+    _write_plot(root, "analysis/rmsd/rmsd.png", "analysis/rmsd/rmsd.dat", "0 0.10\n1 0.20\n")
+    _write_plot(root, "analysis/rg/rg.png", "analysis/rg/rg.dat", "0 1.0\n1 1.2\n")
+    _write_plot(root, "analysis/sasa/sasa.png", "analysis/sasa/sasa.dat", "0 20.0\n1 22.0\n")
+    _write_plot(root, "analysis/dimred/dimred_pca.png", "analysis/dimred/dimred_pca.dat", "0 0.1 0.2\n1 0.3 0.4\n")
+    _write_plot(root, "analysis/cluster/cluster_kmeans.png", "analysis/cluster/cluster_kmeans.dat", "frame,cluster\n0,1\n1,2\n2,1\n")
+    _write_plot(root, "analysis/cluster/cluster_kmeans_counts.png", None, None)
+    _write_plot(root, "analysis/ss/ss.png", "analysis/ss/ss.dat", "frame,1,2\n0,H,C\n1,E,T\n")
+    _write_plot(root, "analysis/qvalue/qvalue.png", "analysis/qvalue/qvalue.dat", "0.9\n0.8\n")
+    (root / "report" / "region_highlight_summary.png").write_bytes(PNG_BYTES)
+
+    artifacts = build_dashboard(
+        orchestrator=SimpleNamespace(output_dir=root, system="demo-system"),
+        output_dir=root / "report",
+        title="Demo Dashboard",
+        include_bundle_link=True,
+    )
+
+    html = (root / "report" / "dashboard.html").read_text(encoding="utf-8")
+    assert artifacts == ["dashboard.html"]
+    for section in (
+        "Core Metrics",
+        "SASA",
+        "Secondary Structure",
+        "Dimensionality Reduction",
+        "Clustering",
+        "Region Highlights",
+        "Other",
+    ):
+        assert section in html
+    for link in (
+        "report.md",
+        "slides.pptx",
+        "project_bundle.zip",
+        "../analysis/analysis_manifest.json",
+        "../analysis/rmsd/rmsd.png",
+        "../analysis/cluster/cluster_kmeans_counts.png",
+    ):
+        assert link in html
+    for asset in (
+        "rmsd_dashboard.png",
+        "rg_dashboard.png",
+        "sasa_dashboard.png",
+        "pca_dashboard.png",
+        "kmeans_trajectory_dashboard.png",
+        "kmeans_population_dashboard.png",
+        "ss_dashboard.png",
+        "qvalue_dashboard.png",
+    ):
+        assert (root / "report" / "dashboard_assets" / asset).is_file()
+        assert f"dashboard_assets/{asset}" in html
+    assert "dashboard view" in html
+    assert "artifact fallback" in html
+    assert "Analysis/report workflow from existing trajectory." in html
+
+
+def test_region_highlights_validate_ranges_and_defaults() -> None:
+    regions = validate_region_highlights(
+        [{"start": 2, "end": 4}, {"label": "Loop", "start": 5, "end": 5, "color": "red"}],
+        np.array([1, 2, 3, 4, 5]),
+    )
+
+    assert regions[0] == RegionHighlight("Region 1", 2, 4, "#4E79A7")
+    assert regions[1].label == "Loop"
+    assert regions[1].color == "red"
+
+    with pytest.raises(ValueError, match="end must be >= start"):
+        validate_region_highlights([{"start": 4, "end": 3}], np.array([1, 2, 3, 4]))
+    with pytest.raises(ValueError, match="outside the RMSF residue range"):
+        validate_region_highlights([{"start": 1, "end": 10}], np.array([2, 3, 4]))
+    with pytest.raises(ValueError, match="missing required key"):
+        validate_region_highlights([{"end": 3}], np.array([1, 2, 3]))
+
+
+def test_region_highlight_artifacts_and_dashboard_metadata(tmp_path: Path) -> None:
+    root = tmp_path / "run"
+    report = root / "report"
+    rmsf = root / "analysis" / "rmsf" / "rmsf.dat"
+    rmsf.parent.mkdir(parents=True)
+    rmsf.write_text("1 0.1\n2 0.3\n3 0.2\n4 0.5\n", encoding="utf-8")
+    _write_json(
+        root / "manifest.json",
+        {"system": "demo", "phases": [{"name": "analysis", "status": "ok"}]},
+    )
+    _write_json(root / "analysis" / "analysis_manifest.json", {"n_frames": 4})
+
+    artifacts = build_region_highlight_artifacts(
+        project_root=root,
+        output_dir=report,
+        region_highlights=[{"label": "active loop", "start": 2, "end": 3, "color": "#E15759"}],
+    )
+
+    manifest = json.loads((report / "region_highlight_manifest.json").read_text(encoding="utf-8"))
+    assert "region_highlight_manifest.json" in artifacts
+    assert "region_highlight_summary.png" in artifacts
+    assert (root / "analysis" / "rmsf" / "rmsf_region_highlights.png").is_file()
+    assert (report / "region_highlight_summary.png").is_file()
+    assert manifest["status"] == "ok"
+    assert manifest["skipped"][0]["artifact"] == "structure_region_highlights.png"
+
+    build_dashboard(
+        orchestrator=SimpleNamespace(output_dir=root, system="demo"),
+        output_dir=report,
+        title="Region Dashboard",
+    )
+    html = (report / "dashboard.html").read_text(encoding="utf-8")
+    assert "Region Highlights" in html
+    assert "region_highlight_summary.png" in html
+    assert "rmsf_region_highlights.png" in html
+
+
+def test_region_highlight_pymol_script_contains_region_commands(tmp_path: Path) -> None:
+    script = build_pymol_script(
+        topology_path=tmp_path / "topology with spaces.pdb",
+        output_path=tmp_path / "out.png",
+        regions=[
+            RegionHighlight("Alpha", 2, 5, "#E15759"),
+            RegionHighlight("Beta", 8, 9, "not-a-color"),
+        ],
+    )
+
+    assert "load " in script
+    assert "set_color fastmdx_region_1, [0.8824, 0.3412, 0.3490]" in script
+    assert "select fastmdx_sel_1, prot and polymer.protein and resi 2-5" in script
+    assert "show sticks, fastmdx_sel_2 and sidechain" in script
+    assert "png " in script
+    assert "ray 1800, 1200" in script
+
+
+def _write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data), encoding="utf-8")
+
+
+def _write_plot(root: Path, image_rel: str, data_rel: str | None, data: str | None) -> None:
+    image = root / image_rel
+    image.parent.mkdir(parents=True, exist_ok=True)
+    image.write_bytes(PNG_BYTES)
+    if data_rel is not None and data is not None:
+        path = root / data_rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(data, encoding="utf-8")

tests/test_live_dashboard.py

@@ -3,6 +3,7 @@
 import json
 import socket
 from pathlib import Path
+from urllib.error import HTTPError
 from urllib.request import urlopen
 
 from fastmdxplora.cli.main import _build_parser
@@ -240,6 +241,66 @@ def test_live_json_endpoints_are_no_store(tmp_path: Path) -> None:
         server.server_close()
 
 
+def test_live_json_endpoints_are_sane_for_empty_run(tmp_path: Path) -> None:
+    run = tmp_path / "empty_run"
+
+    server, base_url = start_test_server(run)
+    try:
+        status_payload = json.loads(urlopen(f"{base_url}/api/status", timeout=5).read())
+        metrics_payload = json.loads(urlopen(f"{base_url}/api/metrics", timeout=5).read())
+        events_payload = json.loads(urlopen(f"{base_url}/api/events", timeout=5).read())
+        artifacts_payload = json.loads(urlopen(f"{base_url}/api/artifacts", timeout=5).read())
+        results_payload = json.loads(urlopen(f"{base_url}/api/results", timeout=5).read())
+    finally:
+        server.shutdown()
+        server.server_close()
+
+    assert status_payload["status"] == {}
+    assert status_payload["health"]["state"] == "unknown"
+    assert metrics_payload["metrics"] == []
+    assert events_payload["events"] == []
+    assert artifacts_payload["artifacts"] == []
+    assert results_payload["has_analysis"] is False
+    assert results_payload["has_report"] is False
+    assert results_payload["plots"] == []
+
+
+def test_live_server_rejects_artifact_path_traversal(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    run.mkdir()
+    outside = tmp_path / "outside.txt"
+    outside.write_text("secret", encoding="utf-8")
+
+    server, base_url = start_test_server(run)
+    try:
+        try:
+            urlopen(f"{base_url}/artifacts/../outside.txt", timeout=5)
+        except HTTPError as exc:
+            assert exc.code in {403, 404}
+        else:
+            raise AssertionError("path traversal unexpectedly succeeded")
+    finally:
+        server.shutdown()
+        server.server_close()
+
+
+def test_live_server_does_not_serve_static_path_traversal(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    run.mkdir()
+
+    server, base_url = start_test_server(run)
+    try:
+        try:
+            urlopen(f"{base_url}/static/../server.py", timeout=5)
+        except HTTPError as exc:
+            assert exc.code == 404
+        else:
+            raise AssertionError("static traversal unexpectedly succeeded")
+    finally:
+        server.shutdown()
+        server.server_close()
+
+
 def test_static_3dmol_asset_is_served_locally(tmp_path: Path) -> None:
     run = tmp_path / "run"
     run.mkdir()
@@ -294,6 +355,43 @@ def test_dashboard_session_stop_is_safe(tmp_path: Path) -> None:
     assert not session.thread.is_alive()
 
 
+def test_telemetry_readers_handle_missing_and_malformed_files(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    sim = run / "simulation"
+    sim.mkdir(parents=True)
+
+    assert read_status(run) == {}
+    assert read_metrics(run) == []
+    assert read_events(run) == []
+
+    (sim / "live_status.json").write_text("{not-json", encoding="utf-8")
+    (sim / "live_metrics.csv").write_text('timestamp,stage,total_energy\n"unterminated', encoding="utf-8")
+    (sim / "live_events.log").write_text("free-form event without tabs\n", encoding="utf-8")
+
+    assert read_status(run) == {}
+    assert isinstance(read_metrics(run), list)
+    assert read_events(run) == [
+        {"timestamp": "", "level": "info", "message": "free-form event without tabs"}
+    ]
+
+
+def test_analyze_health_temperature_and_stale_warning() -> None:
+    stale = analyze_health(
+        {"status": "running", "last_update_timestamp": "2000-01-01T00:00:00+00:00"},
+        [],
+        stale_after_seconds=1,
+    )
+    assert stale["state"] == "warning"
+    assert "stale" in stale["message"].lower()
+
+    hot = analyze_health(
+        {"status": "running", "target_temperature_K": 300.0},
+        [{"temperature": "420.0"}],
+    )
+    assert hot["state"] == "warning"
+    assert "Temperature" in hot["message"]
+
+
 def test_protein_preview_unavailable_without_structure(tmp_path: Path) -> None:
     payload = protein_preview_payload(tmp_path / "run")
 
@@ -322,6 +420,47 @@ def test_protein_preview_requires_pymol_when_missing(tmp_path: Path, monkeypatch
     assert "PyMOL preview unavailable" in payload["message"]
 
 
+def test_protein_preview_uses_existing_image_without_structure(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    preview = run / "report" / "dashboard_assets" / "protein_preview.png"
+    preview.parent.mkdir(parents=True)
+    preview.write_bytes(b"\x89PNG\r\n\x1a\n")
+
+    payload = protein_preview_payload(run)
+
+    assert payload["available"] is True
+    assert payload["static_available"] is True
+    assert payload["static_mode"] == "existing"
+    assert payload["path"] == "report/dashboard_assets/protein_preview.png"
+    assert payload["structure_available"] is False
+    assert payload["viewer_available"] is False
+
+
+def test_protein_preview_finds_manifest_system_path_and_handles_missing_viewer(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    system_pdb = tmp_path / "source.pdb"
+    system_pdb.write_text(_tiny_pdb(), encoding="utf-8")
+    run = tmp_path / "run"
+    run.mkdir()
+    (run / "manifest.json").write_text(json.dumps({"system": str(system_pdb)}), encoding="utf-8")
+
+    monkeypatch.setattr("fastmdxplora.live.protein_preview._find_pymol_executable", lambda _root: None)
+    monkeypatch.setattr("fastmdxplora.live.protein_preview.viewer_asset_available", lambda: False)
+
+    payload = protein_preview_payload(run)
+
+    assert payload["available"] is True
+    assert payload["static_available"] is False
+    assert payload["structure_path"] == str(system_pdb)
+    assert payload["structure_url"] is None
+    assert payload["structure_available"] is False
+    assert payload["viewer_available"] is False
+    assert payload["fallback_available"] is False
+    assert payload["fallback_mode"] is None
+
+
 def test_protein_preview_api_finds_topology(tmp_path: Path, monkeypatch) -> None:
     def _fake_render(_pymol, _structure, output_path):
         output_path.parent.mkdir(parents=True, exist_ok=True)