add number tests

Author: TorecLuik

biomero/schema_parsers.py

@@ -99,14 +99,15 @@ def adapt_to_biomero_schema(
             value_key = input_param.get("value-key", f"@{param_id.upper()}")
 
             # Build the parameter data with alias names for Pydantic validation
+            raw_default = input_param.get("default-value")
             param_data = {
                 "id": param_id,
                 "type": param_type,
                 "name": input_param.get("name") or param_id,
                 "description": input_param.get("description", ""),
                 "value-key": value_key,  # Use alias name
                 "command-line-flag": cmd_flag,  # Use alias name
-                "default-value": input_param.get("default-value"),  # Alias
+                "default-value": raw_default,  # Alias
                 "optional": input_param.get("optional", False),
                 "set-by-server": input_param.get("set-by-server", False),
                 "value-choices": input_param.get("value-choices"),
@@ -297,6 +298,26 @@ def _map_bilayers(self, param, is_output=False):
             if any(str(lbl) != str(val) for lbl, val in zip(labels, param_data["value-choices"])):
                 param_data["value-choices-labels"] = [str(lbl) if lbl is not None else None for lbl in labels]
 
+        # Ensure the default value type is consistent with value-choices.
+        # When all choices are integers the default MUST also be an int so
+        # OMERO's scripts framework can match str(default) against the
+        # stringified choices list.  We coerce unconditionally here (not just
+        # when already a float) because Pydantic on older schema versions
+        # re-coerces any int→float if int is absent from the Union — and
+        # there is no way to prevent that without fixing the schema.
+        # Fixing the schema (adding int to Union) is the real fix; this is
+        # defence-in-depth that also pre-aligns the raw value before Pydantic.
+        choices = param_data.get("value-choices", [])
+        default = param_data.get("default-value")
+        if choices and all(isinstance(c, int) for c in choices) and default is not None:
+            try:
+                coerced = int(default)
+                # only coerce if it's a lossless conversion (e.g. 0.0→0 ok, 0.5 not)
+                if coerced == default:
+                    param_data["default-value"] = coerced
+            except (ValueError, TypeError):
+                pass
+
         param_format = param.get("format")
         if param_format:
             param_data["format"] = param_format

tests/unit/test_schema_parsers.py

@@ -66,6 +66,24 @@ def test_biaflows_parsing(self, biaflows_descriptor):
         assert "Radius" in param_names
         assert "Threshold" in param_names
 
+    def test_biaflows_number_int_default_stays_integer(self, biaflows_descriptor):
+        """Number param with int default parses as type 'integer' with int default_value."""
+        parsed = DescriptorParserFactory.parse_descriptor(biaflows_descriptor)
+        radius = next(p for p in parsed.inputs if p.id == 'ij_radius')
+        assert radius.type == 'integer'
+        assert isinstance(radius.default_value, int), (
+            f"default_value must be int, got {type(radius.default_value)}: {radius.default_value!r}"
+        )
+        assert radius.default_value == 5
+
+    def test_biaflows_number_float_default_stays_float(self, biaflows_descriptor):
+        """Number param with float default parses as type 'float' with float default_value."""
+        parsed = DescriptorParserFactory.parse_descriptor(biaflows_descriptor)
+        threshold = next(p for p in parsed.inputs if p.id == 'ij_threshold')
+        assert threshold.type == 'float'
+        assert isinstance(threshold.default_value, float)
+        assert threshold.default_value == -0.5
+
 
 class TestBiomeroSchemaParser:
     """Test cases for biomero-schema format parsing."""
@@ -232,14 +250,37 @@ def test_bilayers_value_choices_labels_none_when_labels_equal_values(self, bilay
         assert channel_axis.value_choices == [0, 2]
         assert channel_axis.value_choices_labels is None
 
+    def test_bilayers_integer_radio_default_is_int_not_float(self, bilayers_descriptor):
+        """channel_axis default value is int, not float."""
+        parsed = DescriptorParserFactory.parse_descriptor(bilayers_descriptor)
+        channel_axis = next(p for p in parsed.inputs if p.id == 'channel_axis')
+        assert isinstance(channel_axis.default_value, int), (
+            f"default_value must be int, got {type(channel_axis.default_value)}: "
+            f"{channel_axis.default_value!r}"
+        )
+        assert channel_axis.default_value == 0
+
+    def test_bilayers_integer_radio_default_str_matches_string_choices(self, bilayers_descriptor):
+        """str(default_value) is in [str(c) for c in value_choices]."""
+        parsed = DescriptorParserFactory.parse_descriptor(bilayers_descriptor)
+        channel_axis = next(p for p in parsed.inputs if p.id == 'channel_axis')
+        str_choices = [str(c) for c in channel_axis.value_choices]
+        assert str(channel_axis.default_value) in str_choices, (
+            f"str({channel_axis.default_value!r}) not in {str_choices}"
+        )
+
     def test_bilayers_value_choices_labels_survive_model_dump(self, bilayers_descriptor):
-        """value-choices-labels must survive model_dump(by_alias=True) for downstream use."""
+        """value-choices-labels survives model_dump(by_alias=True)."""
         parsed = DescriptorParserFactory.parse_descriptor(bilayers_descriptor)
         dumped = parsed.model_dump(by_alias=True)
         pretrained = next(p for p in dumped['inputs'] if p['id'] == 'pretrained_model')
         assert pretrained['value-choices-labels'] == ["Cyto", "Nuclei", "Cyto2", "Ignore"]
+
+
+
+class TestDescriptorParserFactory:
     """Test cases for the descriptor parser factory."""
-    
+
     def test_factory_parse_descriptor(self, biaflows_descriptor,
                                       biomero_descriptor):
         """Test end-to-end parsing through factory."""