feat: add minValue and maxValue fields to AlgorithmSpecificationDTO and DataModelDTO; implement corresponding test cases

Author: KFilippopolitis

pom.xml

@@ -52,6 +52,11 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-jdbc</artifactId>

src/main/java/hbp/mip/algorithm/AlgorithmSpecificationDTO.java

@@ -30,12 +30,13 @@ public record AlgorithmParameterSpecificationDTO(
             List<String> types,
             String required,
             String multiple,
-            String min,
-            String max,
+            String minValue,
+            String maxValue,
             @SerializedName("default") String default_value,
             AlgorithmEnumDTO enums,
             AlgorithmEnumDTO dict_keys_enums,
-            AlgorithmEnumDTO dict_values_enums
+            AlgorithmEnumDTO dict_values_enums,
+            String dict_values_type
 
     ) {
         public record AlgorithmEnumDTO(
@@ -68,6 +69,7 @@ public record TransformerSpecificationDTO(
             String name,
             String label,
             String desc,
+            Integer order,
             Map<String, AlgorithmParameterSpecificationDTO> parameters) {
         @Override
         public Map<String, AlgorithmParameterSpecificationDTO> parameters() {

src/main/java/hbp/mip/datamodel/DataModelDTO.java

@@ -172,8 +172,8 @@ public static class CommonDataElementDTO {
         private String is_categorical;
         @Setter
         private List<DataModelDTO.EnumerationDTO> enumerations;
-        private String min;
-        private String max;
+        private String minValue;
+        private String maxValue;
         private String type;
         private String methodology;
         private String units;

src/test/java/hbp/mip/algorithm/AlgorithmSpecificationDTOTest.java

@@ -0,0 +1,111 @@
+package hbp.mip.algorithm;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import hbp.mip.experiment.ExperimentExecutionDTO;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Type;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class AlgorithmSpecificationDTOTest {
+    private final Gson gson = new Gson();
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Test
+    void deserializesOutlierDictionaryMetadataAndPreprocessingOrder() throws Exception {
+        String payload = """
+                [
+                  {
+                    "name": "outlier_report",
+                    "label": "Outlier Report",
+                    "desc": "Detect outliers.",
+                    "inputdata": {
+                      "data_model": { "label": "Data model", "desc": "", "types": ["text"] },
+                      "datasets": { "label": "Datasets", "desc": "", "types": ["text"] },
+                      "y": { "label": "Y", "desc": "", "types": ["real"], "required": true, "multiple": true }
+                    },
+                    "parameters": {
+                      "folds": {
+                        "label": "Folds",
+                        "types": ["dict"],
+                        "required": false,
+                        "multiple": false,
+                        "dict_keys_enums": {
+                          "type": "input_var_names",
+                          "source": ["x", "y"]
+                        },
+                        "dict_values_type": "real"
+                      }
+                    },
+                    "preprocessing": [
+                      {
+                        "name": "outlier_winsorizer",
+                        "label": "Outlier Winsorizer",
+                        "order": 2,
+                        "parameters": {}
+                      }
+                    ]
+                  }
+                ]
+                """;
+
+        Type algorithmListType = new TypeToken<List<AlgorithmSpecificationDTO>>() {
+        }.getType();
+        List<AlgorithmSpecificationDTO> algorithms = gson.fromJson(payload, algorithmListType);
+
+        AlgorithmSpecificationDTO algorithm = algorithms.getFirst();
+        AlgorithmSpecificationDTO.AlgorithmParameterSpecificationDTO folds = algorithm.parameters().get("folds");
+
+        assertThat(folds.dict_values_type()).isEqualTo("real");
+        assertThat(folds.dict_keys_enums().type()).isEqualTo("input_var_names");
+        assertThat(folds.dict_keys_enums().source()).containsExactly("x", "y");
+        assertThat(algorithm.preprocessing().getFirst().order()).isEqualTo(2);
+
+        JsonNode serialized = objectMapper.readTree(objectMapper.writeValueAsString(algorithm));
+        assertThat(serialized.at("/parameters/folds/dict_values_type").asText()).isEqualTo("real");
+        assertThat(serialized.at("/preprocessing/0/order").asInt()).isEqualTo(2);
+    }
+
+    @Test
+    void serializesNestedOutlierPreprocessingUnchangedForExaflowRequest() throws Exception {
+        Map<String, Object> outlierWinsorizer = new LinkedHashMap<>();
+        outlierWinsorizer.put("strategies", Map.of("age", "iqr"));
+        outlierWinsorizer.put("tails", Map.of("age", "both"));
+        outlierWinsorizer.put("folds", Map.of("age", 1.5));
+
+        Map<String, Object> preprocessing = Map.of("outlier_winsorizer", outlierWinsorizer);
+        ExperimentExecutionDTO.AlgorithmExecutionDTO algorithmExecutionDTO =
+                new ExperimentExecutionDTO.AlgorithmExecutionDTO(
+                        "linear_regression",
+                        new AlgorithmRequestDTO.InputDataRequestDTO(
+                                "dm:1",
+                                List.of("ds1"),
+                                List.of("outcome"),
+                                List.of("age"),
+                                null
+                        ),
+                        Map.of(),
+                        preprocessing
+                );
+
+        AlgorithmRequestDTO request = AlgorithmRequestDTO.create(
+                UUID.fromString("00000000-0000-0000-0000-000000000001"),
+                algorithmExecutionDTO
+        );
+
+        JsonNode outlierNode = objectMapper.readTree(objectMapper.writeValueAsString(request))
+                .at("/preprocessing/outlier_winsorizer");
+
+        assertThat(outlierNode.at("/strategies/age").asText()).isEqualTo("iqr");
+        assertThat(outlierNode.at("/tails/age").asText()).isEqualTo("both");
+        assertThat(outlierNode.at("/folds/age").asDouble()).isEqualTo(1.5);
+    }
+}