Replaces scaffold tests with concrete test implementations

Author: AndrewSazonov

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

@@ -1,20 +1,53 @@
-# Auto-generated scaffold. Replace TODOs with concrete tests.
-import pytest
 import numpy as np
 
-# expected vs actual helpers
 
-def _assert_equal(expected, actual):
-    assert expected == actual
+def test_calculate_r_metrics_and_chi_square():
+    from easydiffraction.analysis.fit_helpers import metrics as M
 
+    y_obs = np.array([1.0, 2.0, 3.0])
+    y_calc = np.array([1.1, 1.9, 2.8])
+    weights = np.array([1.0, 2.0, 3.0])
+    residuals = y_obs - y_calc
 
-# Module under test: easydiffraction.analysis.fit_helpers.metrics
+    r = M.calculate_r_factor(y_obs, y_calc)
+    rb = M.calculate_rb_factor(y_obs, y_calc)
+    rw = M.calculate_weighted_r_factor(y_obs, y_calc, weights)
+    r2 = M.calculate_r_factor_squared(y_obs, y_calc)
+    chi2 = M.calculate_reduced_chi_square(residuals, num_parameters=1)
 
-# TODO: Replace with real, small tests per class/method.
-# Keep names explicit: expected_*, actual_*; compare in a single assert.
+    assert 0 <= r <= 1 and np.isfinite(r)
+    assert np.isclose(r, rb)
+    assert np.isfinite(rw)
+    assert np.isfinite(r2)
+    assert np.isfinite(chi2)
 
-def test_module_import():
-    import easydiffraction.analysis.fit_helpers.metrics as MUT
-    expected_module_name = "easydiffraction.analysis.fit_helpers.metrics"
-    actual_module_name = MUT.__name__
-    _assert_equal(expected_module_name, actual_module_name)
+
+def test_get_reliability_inputs_collects_arrays_with_default_su():
+    from easydiffraction.analysis.fit_helpers import metrics as M
+
+    # Minimal fakes for experiments
+    class DS:
+        def __init__(self):
+            self.meas = np.array([1.0, 2.0])
+            self.meas_su = None  # triggers default ones
+            self.calc = np.array([1.1, 1.9])
+
+    class Expt:
+        def __init__(self):
+            self.datastore = DS()
+
+    class Expts(dict):
+        def values(self):
+            return [Expt()]
+
+    class SampleModels(dict):
+        pass
+
+    class Calc:
+        def calculate_pattern(self, sample_models, experiment):
+            # no-op; calc already set in DS
+            return None
+
+    y_obs, y_calc, y_err = M.get_reliability_inputs(SampleModels(), Expts(), Calc())
+    assert y_obs.shape == (2,) and y_calc.shape == (2,) and y_err.shape == (2,)
+    assert np.allclose(y_err, 1.0)

tests/unit/easydiffraction/analysis/test_analysis_access_params.py

@@ -0,0 +1,45 @@
+def test_how_to_access_parameters_prints_paths_and_uids(capsys):
+    from easydiffraction.analysis.analysis import Analysis
+    from easydiffraction.core.parameters import Parameter
+    from easydiffraction.core.validation import AttributeSpec, DataTypes
+    from easydiffraction.io.cif.handler import CifHandler
+
+    # Build two parameters with identity metadata set directly
+    def make_param(db, cat, entry, name, val):
+        p = Parameter(
+            name=name,
+            value_spec=AttributeSpec(value=val, type_=DataTypes.NUMERIC, default=0.0),
+            cif_handler=CifHandler(names=[f'_{cat}.{name}']),
+        )
+        # Inject identity metadata (avoid parent chain)
+        p._identity.datablock_entry_name = lambda: db
+        p._identity.category_code = cat
+        if entry:
+            p._identity.category_entry_name = lambda: entry
+        else:
+            p._identity.category_entry_name = lambda: ''
+        return p
+
+    p1 = make_param('db1', 'catA', '', 'alpha', 1.0)
+    p2 = make_param('db2', 'catB', 'row1', 'beta', 2.0)
+
+    class Coll:
+        def __init__(self, params):
+            self.parameters = params
+
+    class Project:
+        _varname = 'proj'
+        def __init__(self):
+            self.sample_models = Coll([p1])
+            self.experiments = Coll([p2])
+
+    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

tests/unit/easydiffraction/core/test_category.py

@@ -1,28 +1,34 @@
 from easydiffraction.core.category import CategoryCollection, CategoryItem
-from easydiffraction.core.parameters import GenericDescriptorBase
+from easydiffraction.core.parameters import StringDescriptor
 from easydiffraction.core.validation import AttributeSpec, DataTypes
-from easydiffraction.io.cif.serialize import category_item_to_cif
-
-
-class SimpleDescriptor(GenericDescriptorBase):
-    _value_type = DataTypes.STRING
-    def __init__(self, name, value):
-        super().__init__(
-            name=name,
-            description='',
-            value_spec=AttributeSpec(value=value, type_=DataTypes.STRING, default=''),
-        )
+from easydiffraction.io.cif.handler import CifHandler
 
 
 class SimpleItem(CategoryItem):
     def __init__(self, entry_name):
         super().__init__()
         self._identity.category_code = 'simple'
         self._identity.category_entry_name = entry_name
-        # Assign as private attributes to bypass GuardedBase writable checks,
-        # and expose via properties below.
-        object.__setattr__(self, '_a', SimpleDescriptor('a', 'x'))
-        object.__setattr__(self, '_b', SimpleDescriptor('b', 'y'))
+        object.__setattr__(
+            self,
+            '_a',
+            StringDescriptor(
+                name='a',
+                description='',
+                value_spec=AttributeSpec(value='x', type_=DataTypes.STRING, default=''),
+                cif_handler=CifHandler(names=['_simple.a']),
+            ),
+        )
+        object.__setattr__(
+            self,
+            '_b',
+            StringDescriptor(
+                name='b',
+                description='',
+                value_spec=AttributeSpec(value='y', type_=DataTypes.STRING, default=''),
+                cif_handler=CifHandler(names=['_simple.b']),
+            ),
+        )
 
     @property
     def a(self):
@@ -52,24 +58,5 @@ def test_category_collection_str_and_cif_calls():
     c.add(SimpleItem('n2'))
     s = str(c)
     assert 'collection' in s and '2 items' in s
-    # as_cif delegates to serializer; calling it ensures code path executed
-    _ = c.as_cif# Auto-generated scaffold. Replace TODOs with concrete tests.
-import pytest
-import numpy as np
-
-# expected vs actual helpers
-
-def _assert_equal(expected, actual):
-    assert expected == actual
-
-
-# Module under test: easydiffraction.core.category
-
-# TODO: Replace with real, small tests per class/method.
-# Keep names explicit: expected_*, actual_*; compare in a single assert.
-
-def test_module_import():
-    import easydiffraction.core.category as MUT
-    expected_module_name = "easydiffraction.core.category"
-    actual_module_name = MUT.__name__
-    _assert_equal(expected_module_name, actual_module_name)
+    # as_cif delegates to serializer; should be a string (possibly empty)
+    assert isinstance(c.as_cif, str)

tests/unit/easydiffraction/core/test_collection.py

@@ -1,25 +1,3 @@
-# Auto-generated scaffold. Replace TODOs with concrete tests.
-import pytest
-import numpy as np
-
-# expected vs actual helpers
-
-def _assert_equal(expected, actual):
-    assert expected == actual
-
-
-# Module under test: easydiffraction.core.collection
-
-# TODO: Replace with real, small tests per class/method.
-# Keep names explicit: expected_*, actual_*; compare in a single assert.
-
-def test_module_import():
-    import easydiffraction.core.collection as MUT
-    expected_module_name = "easydiffraction.core.collection"
-    actual_module_name = MUT.__name__
-    _assert_equal(expected_module_name, actual_module_name)
-
-
 def test_collection_add_get_delete_and_names():
     from easydiffraction.core.collection import CollectionBase
     from easydiffraction.core.identity import Identity
@@ -38,17 +16,13 @@ def as_cif(self) -> str:
             return ""
 
     c = MyCollection(item_type=Item)
-    # add two items
     a = Item("a")
     b = Item("b")
     c["a"] = a
     c["b"] = b
-    # get
     assert c["a"] is a and c["b"] is b
-    # overwrite existing key
     a2 = Item("a")
     c["a"] = a2
     assert c["a"] is a2 and len(list(c.keys())) == 2
-    # delete
     del c["b"]
     assert list(c.names) == ["a"]

tests/unit/easydiffraction/core/test_datablock.py

@@ -1,58 +1,71 @@
-# Auto-generated scaffold. Replace TODOs with concrete tests.
 import pytest
-import numpy as np
 
-# expected vs actual helpers
 
-def _assert_equal(expected, actual):
-    assert expected == actual
-
-
-# Module under test: easydiffraction.core.datablock
-
-# TODO: Replace with real, small tests per class/method.
-# Keep names explicit: expected_*, actual_*; compare in a single assert.
-
-def test_module_import():
-    import easydiffraction.core.datablock as MUT
-    expected_module_name = "easydiffraction.core.datablock"
-    actual_module_name = MUT.__name__
-    _assert_equal(expected_module_name, actual_module_name)
-
-
-def test_datablock_collection_add_and_filters():
+def test_datablock_collection_add_and_filters_with_real_parameters():
     from easydiffraction.core.datablock import DatablockCollection, DatablockItem
+    from easydiffraction.core.category import CategoryItem
     from easydiffraction.core.parameters import Parameter
-    from easydiffraction.core.identity import Identity
+    from easydiffraction.core.validation import AttributeSpec, DataTypes
+    from easydiffraction.io.cif.handler import CifHandler
 
-    class DummyParam:
-        def __init__(self, name, free=True, constrained=False):
-            self.free = free
-            self.constrained = constrained
-            self._identity = Identity(owner=self, category_entry=lambda: name)
+    class Cat(CategoryItem):
+        def __init__(self):
+            super().__init__()
+            self._identity.category_code = 'cat'
+            self._identity.category_entry_name = 'e1'
+            # real Parameters
+            self._p1 = Parameter(
+                name='p1',
+                description='',
+                value_spec=AttributeSpec(value=1.0, type_=DataTypes.NUMERIC, default=0.0),
+                units='',
+                cif_handler=CifHandler(names=['_cat.p1']),
+            )
+            self._p2 = Parameter(
+                name='p2',
+                description='',
+                value_spec=AttributeSpec(value=2.0, type_=DataTypes.NUMERIC, default=0.0),
+                units='',
+                cif_handler=CifHandler(names=['_cat.p2']),
+            )
+            # Make p2 constrained and not free
+            self._p2._constrained = True
+            self._p2._free = False
+            # Mark p1 free to be included in free_parameters
+            self._p1.free = True
+
+        @property
+        def p1(self):
+            return self._p1
+
+        @property
+        def p2(self):
+            return self._p2
 
     class Block(DatablockItem):
-        def __init__(self, name, params):
+        def __init__(self, name):
             super().__init__()
+            # set datablock entry name
             self._identity.datablock_entry_name = lambda: name
-            self._params = params
-
-        @property
-        def parameters(self):
-            return self._params
+            # include the category as attribute so DatablockItem.parameters picks them up
+            self._cat = Cat()
 
         @property
-        def as_cif(self) -> str:
-            return ""
+        def cat(self):
+            return self._cat
 
     coll = DatablockCollection(item_type=Block)
-    a = Block("A", [DummyParam("p1", free=True, constrained=False)])
-    b = Block("B", [DummyParam("p2", free=False, constrained=False), DummyParam("p3", free=True, constrained=True)])
+    a = Block('A')
+    b = Block('B')
     coll.add(a)
     coll.add(b)
-    # aggregate
-    assert len(coll.parameters) == 3
-    # fittable: Parameter subclass and not constrained -> here 0 because DummyParam not Parameter
-    assert coll.fittable_parameters == []
-    # free: subset of fittable -> empty
-    assert coll.free_parameters == []
+    # parameters collection aggregates from both blocks (p1 & p2 each)
+    params = coll.parameters
+    assert len(params) == 4
+    # fittable excludes constrained parameters
+    fittable = coll.fittable_parameters
+    assert all(isinstance(p, Parameter) for p in fittable)
+    assert len(fittable) == 2  # only p1 from each block
+    # free is subset of fittable where free=True (true for p1)
+    free_params = coll.free_parameters
+    assert free_params == fittable