+ tests

Author: SteSeg

test/test_benchmark.py

@@ -156,7 +156,9 @@ def test_generate_report_uses_default_config(mock_validate, valid_yaml, tmp_path
         bench = DummyBenchmark("dummy")
 
     results_path = tmp_path / "benchmark_results.h5"
-    results_path.write_text("data")
+    import h5py
+    with h5py.File(results_path, "w"):
+        pass
     monkeypatch.chdir(tmp_path)
 
     captured = {}
@@ -212,6 +214,101 @@ def test_generate_report_missing_results_warns(mock_validate, valid_yaml, tmp_pa
         bench._generate_report(report_config=None)
 
 
+@patch("openmc_fusion_benchmarks.benchmark.validate_benchmark")
+def test_write_spec_snapshot_writes_group(mock_validate, valid_yaml, tmp_path):
+    with patch.object(Path, "open", mock_open(read_data=valid_yaml)):
+        bench = DummyBenchmark("dummy")
+
+    results_path = tmp_path / "benchmark_results.h5"
+    import h5py
+    with h5py.File(results_path, "w"):
+        pass
+
+    bench._write_spec_snapshot(str(results_path))
+
+    import h5py
+
+    with h5py.File(results_path, "r") as handle:
+        assert "specifications" in handle
+        assert "yaml" in handle["specifications"]
+
+
+@patch("openmc_fusion_benchmarks.benchmark.validate_benchmark")
+def test_write_run_metadata_writes_attrs(mock_validate, valid_yaml, tmp_path):
+    with patch.object(Path, "open", mock_open(read_data=valid_yaml)):
+        bench = DummyBenchmark("dummy")
+
+    results_path = tmp_path / "benchmark_results.h5"
+    results_path.write_text("data")
+
+    bench._write_run_metadata(
+        code_name="openmc",
+        code_version="0.15.2",
+        nuclear_data_name="endfb",
+        nuclear_data_version="8.0",
+        geometry="cad",
+        filename=str(results_path),
+    )
+
+    import h5py
+
+    with h5py.File(results_path, "r") as handle:
+        attrs = handle["run_metadata"].attrs
+        assert attrs["code_name"] == "openmc"
+        assert attrs["code_version"] == "0.15.2"
+        assert attrs["nuclear_data_name"] == "endfb"
+        assert attrs["nuclear_data_version"] == "8.0"
+        assert attrs["geometry"] == "cad"
+
+
+@patch("openmc_fusion_benchmarks.benchmark.validate_benchmark")
+def test_generate_report_without_reference(mock_validate, valid_yaml, tmp_path, monkeypatch):
+    with patch.object(Path, "open", mock_open(read_data=valid_yaml)):
+        bench = DummyBenchmark("dummy")
+
+    results_path = tmp_path / "benchmark_results.h5"
+    results_path.write_text("data")
+    monkeypatch.chdir(tmp_path)
+
+    def _fake_from_file(path):
+        return Mock(filepath=Path(path))
+
+    def _fake_from_database(_name, filename="reference_results.h5"):
+        raise FileNotFoundError("missing")
+
+    captured = {}
+
+    def _fake_build_report(sources, config):
+        captured["sources"] = sources
+        return Mock()
+
+    monkeypatch.setattr(
+        "openmc_fusion_benchmarks.benchmark.BenchmarkResults.from_file",
+        _fake_from_file,
+    )
+    monkeypatch.setattr(
+        "openmc_fusion_benchmarks.benchmark.BenchmarkResults.from_database",
+        _fake_from_database,
+    )
+    monkeypatch.setattr(
+        "openmc_fusion_benchmarks.benchmark.build_report",
+        _fake_build_report,
+    )
+    monkeypatch.setattr(
+        "openmc_fusion_benchmarks.benchmark.render_yaml",
+        lambda report, path: path,
+    )
+    monkeypatch.setattr(
+        "openmc_fusion_benchmarks.benchmark.render_pdf",
+        lambda report, path, plots_dir: path,
+    )
+
+    bench._generate_report(report_config=None)
+
+    assert captured["sources"][0].kind == "calculation"
+    assert len(captured["sources"]) == 1
+
+
 @pytest.mark.skipif(not OPENMC_AVAILABLE, reason="OpenMC not installed")
 def test_openmc_benchmark_build_materials():
     """Test OpenmcBenchmark._build_materials with atomic fractions."""

test/test_database.py

@@ -65,3 +65,21 @@ def test_resolve_database_path_provides_helpful_error():
     except FileNotFoundError as e:
         # Error message should contain available benchmarks
         assert "Available benchmarks:" in str(e)
+
+
+def test_list_database_benchmarks_fallback(monkeypatch):
+    def _raise_files(_pkg):
+        raise ModuleNotFoundError("no resources")
+
+    monkeypatch.setattr("openmc_fusion_benchmarks.database.files", _raise_files)
+    benchmarks = list_database_benchmarks()
+    assert "oktavian_al" in benchmarks
+
+
+def test_resolve_database_path_fallback(monkeypatch):
+    def _raise_files(_pkg):
+        raise ModuleNotFoundError("no resources")
+
+    monkeypatch.setattr("openmc_fusion_benchmarks.database.files", _raise_files)
+    path = _resolve_database_path("oktavian_al", "experiment.h5")
+    assert path.exists()

test/test_report.py

@@ -74,9 +74,15 @@ def _module_available(name: str) -> bool:
 )
 from openmc_fusion_benchmarks.report.renderers import (
     _collect_observable_metrics,
+    _observable_metrics_for_verbosity,
+    _quality_metric_description,
+    _quality_metric_equation,
+    _quality_metrics_for_verbosity,
     render_plots_for_report,
     render_yaml,
 )
+from openmc_fusion_benchmarks.report import plots as report_plots
+from openmc_fusion_benchmarks.tallies import BaseTally
 
 
 def _write_structured_group(filepath: Path, group: str, tally_name: str) -> None:
@@ -337,3 +343,48 @@ def test_collect_observable_metrics(results_pair, tmp_path):
     assert entries
     assert entries[0]["tally"] == "tally_1"
     assert "rms_relative_deviation" in entries[0]
+
+
+def test_quality_metrics_for_verbosity():
+    assert _quality_metrics_for_verbosity(0) == ["ce"]
+    assert _quality_metrics_for_verbosity(1) == ["ce", "chi2_contribution"]
+    assert "relative_deviation" in _quality_metrics_for_verbosity(2)
+    assert "normalized_residual" in _quality_metrics_for_verbosity(3)
+
+
+def test_observable_metrics_for_verbosity():
+    assert _observable_metrics_for_verbosity(0) == ["rms_relative_deviation"]
+    assert "reduced_chi2" in _observable_metrics_for_verbosity(1)
+    assert "mean_abs_normalized_residual" in _observable_metrics_for_verbosity(3)
+
+
+def test_quality_metric_equations_and_descriptions():
+    assert _quality_metric_equation("ce")
+    assert _quality_metric_description("ce")
+    assert _quality_metric_equation("unknown") == ""
+    assert _quality_metric_description("unknown") == ""
+
+
+def test_plot_utilities_auto_scale_and_default_x():
+    values = np.array([1.0, 1000.0])
+    assert report_plots._auto_scale(values, threshold=100.0) == "log"
+    assert report_plots._auto_scale(np.array([-1.0, 2.0]), threshold=100.0) == "linear"
+
+    da = xr.DataArray(
+        np.array([1.0, 2.0, 3.0]),
+        dims=("energy",),
+        coords={"energy": np.array([0.1, 1.0, 10.0])},
+    )
+    tally = BaseTally(da)
+    x_vals = report_plots._default_x(tally)
+    assert np.allclose(x_vals, np.array([0.1, 1.0, 10.0]))
+
+
+def test_plot_utilities_flatten_tally():
+    da = xr.DataArray(
+        np.arange(6.0).reshape(2, 3),
+        dims=("cell", "energy"),
+    )
+    tally = BaseTally(da)
+    flat = report_plots._flatten_tally(tally)
+    assert flat.shape == (6,)

test/test_uq_utils.py

@@ -1,12 +1,20 @@
 import pytest
 import types
+from pathlib import Path
 from unittest.mock import patch
 from openmc_fusion_benchmarks.uq import (
     get_nuclide_zaid, 
     zaid_to_zam, 
     get_nuclide_gnds,
     get_reaction_mt
 )
+from openmc_fusion_benchmarks.uq.uq_utils import (
+    ace_to_hdf5,
+    get_ace_files,
+    perturb_to_hdf5,
+    perturb_xs_xml,
+    remove_ace_files,
+)
 
 
 def test_zaid_to_zam_len4():
@@ -151,3 +159,158 @@ def test_get_reaction_mt_unknown_reaction():
 def test_unsupported_type():
     with pytest.raises(TypeError, match="Unsupported nuclide type"):
         get_nuclide_gnds((1, 1))
+
+
+def test_remove_ace_files_removes_matching(tmp_path):
+    lib_name = "mylib"
+    extensions = ["03c", "03c.xsd", lib_name]
+    for ext in extensions:
+        (tmp_path / f"test.{ext}").write_text("data")
+
+    remove_ace_files(str(tmp_path), lib_name)
+    for ext in extensions:
+        assert not (tmp_path / f"test.{ext}").exists()
+
+
+def test_get_ace_files_calls_sandy(monkeypatch):
+    class FakeTape:
+        def get_perturbations(self, *args, **kwargs):
+            return ["p1", "p2"]
+
+        def apply_perturbations(self, *args, **kwargs):
+            return ["ace1", "ace2"]
+
+    def _fake_get_endf6_file(*args, **kwargs):
+        return FakeTape()
+
+    fake_sandy = types.SimpleNamespace(get_endf6_file=_fake_get_endf6_file)
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.sandy", fake_sandy, raising=False)
+
+    fake_openmc = _fake_openmc_with_data(REACTION_MT={"(n,gamma)": 102})
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.openmc", fake_openmc, raising=False)
+
+    ace_files = get_ace_files(2, "endfb_80", "H1", "(n,gamma)", 1, 0.001)
+    assert ace_files == ["ace1", "ace2"]
+
+
+def test_ace_to_hdf5_exports_and_cleans(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    class FakeIncident:
+        def export_to_hdf5(self, path):
+            Path(path).write_text("h5")
+
+    class FakeOpenmcData:
+        class IncidentNeutron:
+            @staticmethod
+            def from_ace(_path):
+                return FakeIncident()
+
+        @staticmethod
+        def gnds_name(z, a, m):
+            return f"H{a}" if z == 1 else f"U{a}"
+
+        @staticmethod
+        def zam(nuclide):
+            return fake_zam(nuclide)
+
+    fake_openmc = types.SimpleNamespace(data=FakeOpenmcData())
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.openmc", fake_openmc, raising=False)
+
+    removed = {"called": False}
+
+    def _fake_remove(_directory, _lib):
+        removed["called"] = True
+
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.remove_ace_files", _fake_remove)
+
+    ace_to_hdf5(2, "endfb_80", "H1", remove_ace=True)
+    assert removed["called"] is True
+    assert (tmp_path / "H1_endfb_80" / "H1_0_endfb_80.h5").exists()
+
+
+def test_perturb_to_hdf5_calls_helpers(monkeypatch):
+    calls = {"ace": False, "h5": False}
+
+    def _fake_get_ace(*args, **kwargs):
+        calls["ace"] = True
+
+    def _fake_ace_to_hdf5(*args, **kwargs):
+        calls["h5"] = True
+
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.get_ace_files", _fake_get_ace)
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.ace_to_hdf5", _fake_ace_to_hdf5)
+
+    perturb_to_hdf5(1, "endfb_80", "H1", "(n,gamma)")
+    assert calls["ace"] is True
+    assert calls["h5"] is True
+
+
+def test_perturb_xs_xml_updates_library(monkeypatch, tmp_path):
+    xs_file = tmp_path / "cross_sections.xml"
+    xs_h5 = tmp_path / "new_xs.h5"
+    xs_h5.write_text("data")
+
+    class FakeLibraries:
+        def __init__(self):
+            self.data = {"U235": {"path": "old"}}
+
+        def get_by_material(self, nuclide):
+            return self.data[nuclide]
+
+    class FakeDataLibrary:
+        def __init__(self):
+            self.libraries = FakeLibraries()
+
+        def export_to_xml(self, path):
+            Path(path).write_text("xml")
+
+        def append(self, entry):
+            self.libraries.data[entry["materials"][0]] = {"path": entry["path"]}
+
+        @classmethod
+        def from_xml(cls, _path):
+            return cls()
+
+    fake_openmc = types.SimpleNamespace(
+        config={"cross_sections": str(xs_file)},
+        data=types.SimpleNamespace(DataLibrary=FakeDataLibrary),
+    )
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.openmc", fake_openmc, raising=False)
+
+    perturb_xs_xml(str(xs_file), str(xs_h5), "U235")
+    assert xs_file.exists()
+
+
+def test_perturb_xs_xml_append_on_typeerror(monkeypatch, tmp_path):
+    xs_file = tmp_path / "cross_sections.xml"
+    xs_h5 = tmp_path / "new_xs.h5"
+    xs_h5.write_text("data")
+
+    class FakeLibraries:
+        def get_by_material(self, _nuclide):
+            raise TypeError("missing")
+
+    class FakeDataLibrary:
+        def __init__(self):
+            self.libraries = FakeLibraries()
+            self.appended = False
+
+        def export_to_xml(self, path):
+            Path(path).write_text("xml")
+
+        def append(self, _entry):
+            self.appended = True
+
+        @classmethod
+        def from_xml(cls, _path):
+            return cls()
+
+    fake_openmc = types.SimpleNamespace(
+        config={"cross_sections": str(xs_file)},
+        data=types.SimpleNamespace(DataLibrary=FakeDataLibrary),
+    )
+    monkeypatch.setattr("openmc_fusion_benchmarks.uq.uq_utils.openmc", fake_openmc, raising=False)
+
+    perturb_xs_xml(str(xs_file), str(xs_h5), "U235")
+    assert xs_file.exists()