Refactors test environment detection logic

Author: AndrewSazonov

tests/unit/easydiffraction/analysis/fit_helpers/test_tracking.py

@@ -16,8 +16,8 @@ def test_tracker_terminal_flow_prints_and_updates_best(monkeypatch, capsys):
     import easydiffraction.analysis.fit_helpers.tracking as tracking_mod
     from easydiffraction.analysis.fit_helpers.tracking import FitProgressTracker
 
-    # Force terminal branch (not notebook)
-    monkeypatch.setattr(tracking_mod, 'is_notebook', lambda: False)
+    # Force terminal branch (not notebook): tracking imports in_jupyter directly
+    monkeypatch.setattr(tracking_mod, 'in_jupyter', lambda: False)
 
     tracker = FitProgressTracker()
     tracker.start_tracking('dummy')

tests/unit/easydiffraction/analysis/test_analysis_access_params.py

@@ -1,12 +1,13 @@
 # SPDX-FileCopyrightText: 2021-2025 EasyDiffraction contributors <https://github.com/easyscience/diffraction>
 # SPDX-License-Identifier: BSD-3-Clause
 
-def test_how_to_access_parameters_prints_paths_and_uids(capsys):
+def test_how_to_access_parameters_prints_paths_and_uids(capsys, monkeypatch):
     from easydiffraction.analysis.analysis import Analysis
     from easydiffraction.core.parameters import Parameter
     from easydiffraction.core.validation import AttributeSpec
     from easydiffraction.core.validation import DataTypes
     from easydiffraction.io.cif.handler import CifHandler
+    import easydiffraction.analysis.analysis as analysis_mod
 
     # Build two parameters with identity metadata set directly
     def make_param(db, cat, entry, name, val):
@@ -38,13 +39,45 @@ def __init__(self):
             self.sample_models = Coll([p1])
             self.experiments = Coll([p2])
 
+    # Capture the table payload by monkeypatching render_table to avoid
+    # terminal wrapping/ellipsis affecting string matching.
+    captured = {}
+
+    def fake_render_table(**kwargs):
+        captured.update(kwargs)
+
+    monkeypatch.setattr(analysis_mod, 'render_table', fake_render_table)
     a = Analysis(Project())
     a.how_to_access_parameters()
+
     out = capsys.readouterr().out
     assert 'How to access parameters' in out
-    # Expect code path strings
-    assert "proj.sample_models['db1'].catA.alpha" in out
-    assert "proj.experiments['db2'].catB['row1'].beta" in out
-    # Expect CIF uid (owner.unique_name) present for both
-    assert 'db1.catA.alpha' in out
-    assert 'db2.catB.row1.beta' in out
+
+    # Validate headers and row contents independent of terminal renderer
+    headers = captured.get('columns_headers') or []
+    data = captured.get('columns_data') or []
+
+    assert 'How to Access in Python Code' in headers
+
+    # Flatten rows to strings for simple membership checks
+    flat_rows = [' '.join(map(str, row)) for row in data]
+
+    # Python access paths
+    assert any("proj.sample_models['db1'].catA.alpha" in r for r in flat_rows)
+    assert any("proj.experiments['db2'].catB['row1'].beta" in r for r in flat_rows)
+
+    # Now check CIF unique identifiers via the new API
+    captured2 = {}
+
+    def fake_render_table2(**kwargs):
+        captured2.update(kwargs)
+
+    monkeypatch.setattr(analysis_mod, 'render_table', fake_render_table2)
+    a.show_parameter_cif_uids()
+    headers2 = captured2.get('columns_headers') or []
+    data2 = captured2.get('columns_data') or []
+    assert 'Unique Identifier for CIF Constraints' in headers2
+    flat_rows2 = [' '.join(map(str, row)) for row in data2]
+    # Unique names are datablock.category[.entry].parameter
+    assert any('db1 catA  alpha' in r.replace('.', ' ') for r in flat_rows2)
+    assert any('db2 catB row1 beta' in r.replace('.', ' ') for r in flat_rows2)

tests/unit/easydiffraction/display/plotters/test_plotly.py

@@ -13,7 +13,7 @@ def test_get_trace_and_plot(monkeypatch):
     import easydiffraction.display.plotters.plotly as pp
 
     # Arrange: force non-PyCharm branch and stub fig.show/HTML/display so nothing opens
-    monkeypatch.setattr(pp, 'is_pycharm', lambda: False)
+    monkeypatch.setattr(pp, 'in_pycharm', lambda: False)
 
     shown = {'count': 0}
 

tests/unit/easydiffraction/display/test_plotting.py

@@ -71,40 +71,32 @@ def __init__(self):
 
     p = Plotter()
 
-    # Error paths
+    # Error paths (now log errors via console; messages are printed)
     p.plot_meas(Ptn(x=None, meas=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # plot_meas uses formatting.error(...) without printing -> no stdout
-    assert out == ''
+    assert 'No data available for experiment E' in out
 
     p.plot_meas(Ptn(x=[1], meas=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # Same here: no print, so no stdout
-    assert out == ''
+    assert 'No measured data available for experiment E' in out
 
     p.plot_calc(Ptn(x=None, calc=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # error path should not print to stdout
-    assert out == ''
+    assert 'No data available for experiment E' in out
 
     p.plot_calc(Ptn(x=[1], calc=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # assert 'No calculated data available' in out or 'No calculated data' in out
-    # error path should not print to stdout in new API
-    assert out == ''
+    assert 'No calculated data available for experiment E' in out
 
     p.plot_meas_vs_calc(Ptn(x=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # assert 'No data available' in out
-    assert out == ''
+    assert 'No data available for experiment E' in out
     p.plot_meas_vs_calc(Ptn(x=[1], meas=None, calc=[1]), 'E', ExptType())
     out = capsys.readouterr().out
-    # assert 'No measured data available' in out
-    assert out == ''
+    assert 'No measured data available for experiment E' in out
     p.plot_meas_vs_calc(Ptn(x=[1], meas=[1], calc=None), 'E', ExptType())
     out = capsys.readouterr().out
-    # assert 'No calculated data available' in out
-    assert out == ''
+    assert 'No calculated data available for experiment E' in out
     # TODO: Update assertions with new logging-based error handling
     #  in the above line and elsewhere as needed.
 

tests/unit/easydiffraction/project/test_project_d_spacing.py

@@ -97,7 +97,6 @@ def _load_ascii_data_to_experiment(self, data_path: str) -> None:
     # Act
     p.update_pattern_d_spacing('e1')
 
-    # Assert error was logged via logger (no stdout expected in new API)
+    # Assert error is reported via console/logging in the new API
     out = capsys.readouterr().out
-    # assert 'Unsupported beam mode' in out
-    assert out == ''
+    assert 'Unsupported beam mode' in out

tests/unit/easydiffraction/utils/test_utils.py

@@ -93,11 +93,11 @@ def test_validate_url_rejects_non_http_https():
 
 
 def test_is_github_ci_env_true(monkeypatch):
-    import easydiffraction.utils.env as env
+    import easydiffraction.utils.environment as env
 
     monkeypatch.setenv('GITHUB_ACTIONS', 'true')
     expected = True
-    actual = env.is_github_ci()
+    actual = env.in_github_ci()
     assert expected == actual
 
 
@@ -110,29 +110,31 @@ def test_package_version_missing_package_returns_none():
 
 
 def test_is_notebook_false_in_plain_env(monkeypatch):
-    import easydiffraction.utils.env as env
+    import easydiffraction.utils.environment as env
 
     # Ensure no IPython and not PyCharm
     monkeypatch.setenv('PYCHARM_HOSTED', '', prepend=False)
-    assert env.is_notebook() is False
+    assert env.in_jupyter() is False
 
 
 def test_is_pycharm_and_is_colab(monkeypatch):
-    import easydiffraction.utils.env as env
+    import easydiffraction.utils.environment as env
 
     # PyCharm
     monkeypatch.setenv('PYCHARM_HOSTED', '1')
-    assert env.is_pycharm() is True
+    assert env.in_pycharm() is True
     # Colab detection when module is absent -> False
-    assert env.is_colab() is False
+    assert env.in_colab() is False
 
 
 def test_render_table_terminal_branch(capsys, monkeypatch):
     import easydiffraction.utils.utils as MUT
-
-    import easydiffraction.utils.env as env
-    monkeypatch.setattr(env, 'is_notebook', lambda: False)
-    MUT.render_table(columns_data=[[1, 2], [3, 4]], columns_alignment=['left', 'left'])
+    # Ensure non-notebook rendering; on CI/default env it's terminal anyway.
+    MUT.render_table(
+        columns_data=[[1, 2], [3, 4]],
+        columns_alignment=['left', 'left'],
+        columns_headers=['A', 'B'],
+    )
     out = capsys.readouterr().out
     # fancy_outline uses box-drawing characters; accept a couple of expected ones
     assert ('╒' in out and '╕' in out) or ('┌' in out and '┐' in out)