Small refactoring of metadata tests

Author: tobiasploetz

tests/hypothesis_strategies/parameters.py

@@ -175,7 +175,6 @@ def substance_parameters(draw: st.DrawFn):
     encodings.remove(SubstanceEncoding.RDKIT)
     encoding = draw(st.sampled_from(encodings))
 
-    # Optionally generate metadata
     param_metadata = draw(measurable_metadata())
 
     return SubstanceParameter(

tests/hypothesis_strategies/targets.py

@@ -38,7 +38,6 @@ def numerical_targets(
         )
     bounds = draw(bounds_strategy)
 
-    # Optionally generate metadata
     target_metadata = draw(measurable_metadata())
 
     return NumericalTarget(
@@ -62,7 +61,6 @@ def binary_targets(draw: st.DrawFn):
     name = draw(target_name)
     choices = draw(st.lists(choice_values, min_size=2, max_size=2, unique=True))
 
-    # Optionally generate metadata
     target_metadata = draw(measurable_metadata())
 
     return BinaryTarget(

tests/integration/test_metadata_integration.py

@@ -4,7 +4,7 @@
 
 from baybe.objectives.single import SingleTargetObjective
 from baybe.parameters.numerical import NumericalDiscreteParameter
-from baybe.targets.enum import TargetMode, TargetTransformation
+from baybe.targets.enum import TargetMode
 from baybe.targets.numerical import NumericalTarget
 from baybe.utils.metadata import MeasurableMetadata, Metadata
 
@@ -65,32 +65,30 @@ def test_parameter_metadata_always_non_none(self):
 class TestTargetMetadataIntegration:
     """Tests for metadata integration with Target class."""
 
+    def _create_target(self, **kwargs) -> NumericalTarget:
+        """Create a standard NumericalTarget for testing."""
+        return NumericalTarget(
+            name="yield",
+            mode=TargetMode.MAX,
+            transformation=None,
+            **kwargs,
+        )
+
     @pytest.mark.parametrize("as_dict", [True, False])
     def test_target_with_metadata(self, as_dict: bool):
         """Targets accept, ingest, and surface metadata."""
         meta = MeasurableMetadata(
             description="test target", unit="kg", misc={"priority": "high"}
         )
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata=meta.to_dict() if as_dict else meta,
-        )
+        target = self._create_target(metadata=meta.to_dict() if as_dict else meta)
         assert target.description == "test target"
         assert target.unit == "kg"
         assert target.metadata is not None
         assert target.metadata.misc == {"priority": "high"}
 
     def test_target_without_metadata(self):
         """Targets without metadata have ``None`` properties."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
         assert target.metadata is not None
         assert target.metadata.is_empty
         assert target.description is None
@@ -99,37 +97,22 @@ def test_target_without_metadata(self):
     def test_target_metadata_always_non_none(self):
         """Test that target metadata is always non-None."""
         # Test target without explicit metadata
-        target1 = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target1 = self._create_target()
         assert target1.metadata is not None
         assert target1.metadata.is_empty
         assert target1.description is None
         assert target1.unit is None
 
         # Test target with empty dict metadata
-        target2 = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata={},
-        )
+        target2 = self._create_target(metadata={})
         assert target2.metadata is not None
         assert target2.metadata.is_empty
         assert target2.description is None
         assert target2.unit is None
 
         # Test target with actual metadata
-        target3 = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata={"description": "Chemical yield", "unit": "%"},
+        target3 = self._create_target(
+            metadata={"description": "Chemical yield", "unit": "%"}
         )
         assert target3.metadata is not None
         assert not target3.metadata.is_empty
@@ -138,12 +121,8 @@ def test_target_metadata_always_non_none(self):
 
     def test_target_metadata_serialization(self):
         """Target metadata survives serialization roundtrip."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata={"description": "Chemical yield", "unit": "%", "method": "HPLC"},
+        target = self._create_target(
+            metadata={"description": "Chemical yield", "unit": "%", "method": "HPLC"}
         )
 
         # Serialize and deserialize
@@ -160,6 +139,15 @@ def test_target_metadata_serialization(self):
 class TestObjectiveMetadataIntegration:
     """Tests for metadata integration with Objective class."""
 
+    def _create_target(self, **kwargs) -> NumericalTarget:
+        """Create a standard NumericalTarget for testing."""
+        return NumericalTarget(
+            name="yield",
+            mode=TargetMode.MAX,
+            transformation=None,
+            **kwargs,
+        )
+
     @pytest.mark.parametrize("as_dict", [True, False])
     def test_objective_with_metadata(self, as_dict: bool):
         """Objectives accept, ingest, and surface metadata."""
@@ -168,12 +156,7 @@ def test_objective_with_metadata(self, as_dict: bool):
         )
 
         # Create a target first
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
 
         objective = SingleTargetObjective(
             target=target,
@@ -185,12 +168,7 @@ def test_objective_with_metadata(self, as_dict: bool):
 
     def test_objective_without_metadata(self):
         """Objectives without metadata have ``None`` properties."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
 
         objective = SingleTargetObjective(target=target)
         assert objective.metadata is not None
@@ -199,12 +177,7 @@ def test_objective_without_metadata(self):
 
     def test_objective_metadata_serialization(self):
         """Objective metadata survives serialization roundtrip."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
 
         objective = SingleTargetObjective(
             target=target,
@@ -222,12 +195,8 @@ def test_objective_metadata_serialization(self):
 
     def test_combined_target_objective_metadata(self):
         """Both target and objective can have independent metadata."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata={"description": "Chemical yield", "unit": "%"},
+        target = self._create_target(
+            metadata={"description": "Chemical yield", "unit": "%"}
         )
 
         objective = SingleTargetObjective(
@@ -250,12 +219,7 @@ def test_combined_target_objective_metadata(self):
 
     def test_objective_metadata_always_non_none(self):
         """Test that objective metadata is always non-None."""
-        target = NumericalTarget(
-            name="yield",
-            bounds=(0, 100),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
 
         # Test objective without explicit metadata
         objective1 = SingleTargetObjective(target=target)

tests/validation/test_metadata_validation.py

@@ -4,7 +4,7 @@
 from pytest import param
 
 from baybe.objectives.single import SingleTargetObjective
-from baybe.targets.enum import TargetMode, TargetTransformation
+from baybe.targets.enum import TargetMode
 from baybe.targets.numerical import NumericalTarget
 from baybe.utils.metadata import MeasurableMetadata, Metadata, to_metadata
 
@@ -39,25 +39,7 @@ def test_invalid_arguments_for_metadata(description, misc, error, match):
 @pytest.mark.parametrize(
     ("description", "unit", "misc", "error", "match"),
     [
-        param(0, None, {}, TypeError, "must be <class 'str'>", id="desc-non-str"),
         param(None, 0, {}, TypeError, "must be <class 'str'>", id="unit-non-str"),
-        param(None, None, 0, TypeError, "must be <class 'dict'>", id="misc-non-dict"),
-        param(
-            None,
-            None,
-            {0: 0},
-            TypeError,
-            "must be <class 'str'>",
-            id="misc-non-str-keys",
-        ),
-        param(
-            None,
-            None,
-            {"description": 0},
-            ValueError,
-            "fields: {'description'}",
-            id="desc_in_misc",
-        ),
         param(
             None, None, {"unit": 0}, ValueError, "fields: {'unit'}", id="unit_in_misc"
         ),
@@ -91,39 +73,32 @@ def test_invalid_input_conversion(invalid_input):
 class TestTargetMetadataValidation:
     """Validation tests for target metadata."""
 
+    def _create_target(self, **kwargs) -> NumericalTarget:
+        """Create a standard NumericalTarget for testing."""
+        return NumericalTarget(
+            name="test",
+            mode=TargetMode.MAX,
+            transformation=None,
+            **kwargs,
+        )
+
     def test_target_invalid_metadata_type(self):
         """Creating target with invalid metadata type raises error."""
         with pytest.raises(
             TypeError, match="must be a dictionary or a 'MeasurableMetadata' instance"
         ):
-            NumericalTarget(
-                name="test",
-                bounds=(0, 1),
-                mode=TargetMode.MAX,
-                transformation=TargetTransformation.LINEAR,
-                metadata="invalid_string",
-            )
+            self._create_target(metadata="invalid_string")
 
     def test_target_metadata_with_invalid_unit(self):
         """Target metadata with invalid unit type raises error."""
         with pytest.raises(TypeError, match="must be <class 'str'>"):
-            NumericalTarget(
-                name="test",
-                bounds=(0, 1),
-                mode=TargetMode.MAX,
-                transformation=TargetTransformation.LINEAR,
-                metadata={"unit": 123},  # Invalid unit type
-            )
+            self._create_target(metadata={"unit": 123})  # Invalid unit type
 
     def test_target_metadata_with_unit_field_separation(self):
         """Target metadata should automatically separate unit from misc."""
         # This test shows that unit is automatically separated from misc
-        target = NumericalTarget(
-            name="test",
-            bounds=(0, 1),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-            metadata={"description": "test", "unit": "kg", "extra": "value"},
+        target = self._create_target(
+            metadata={"description": "test", "unit": "kg", "extra": "value"}
         )
         # The unit should be extracted to the unit field
         assert target.unit == "kg"
@@ -141,28 +116,27 @@ def test_target_direct_metadata_with_unit_in_misc(self):
 class TestObjectiveMetadataValidation:
     """Validation tests for objective metadata."""
 
-    def test_objective_invalid_metadata_type(self):
-        """Creating objective with invalid metadata type raises error."""
-        target = NumericalTarget(
+    def _create_target(self, **kwargs) -> NumericalTarget:
+        """Create a standard NumericalTarget for testing."""
+        return NumericalTarget(
             name="test",
-            bounds=(0, 1),
             mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
+            transformation=None,
+            **kwargs,
         )
 
+    def test_objective_invalid_metadata_type(self):
+        """Creating objective with invalid metadata type raises error."""
+        target = self._create_target()
+
         with pytest.raises(
             TypeError, match="must be a dictionary or a 'Metadata' instance"
         ):
             SingleTargetObjective(target=target, metadata=["invalid_list"])
 
     def test_objective_metadata_field_separation(self):
         """Objective metadata should automatically separate description from misc."""
-        target = NumericalTarget(
-            name="test",
-            bounds=(0, 1),
-            mode=TargetMode.MAX,
-            transformation=TargetTransformation.LINEAR,
-        )
+        target = self._create_target()
 
         # Test that description is automatically separated from other fields
         objective = SingleTargetObjective(