Additional test. Small bug fixes and debug code cleanup

Author: nkleiner

PyAres/Analyzing/analysis_service.py

@@ -137,24 +137,19 @@ def GetConnectionStatus(self, request, context):
             print(f"Exception while trying to respond to ARES with connection status! {e}")
 
     def ValidateInputs(self, request: analyzer_service.ParameterValidationRequest, context): 
-        print("Validating Inputs")
         response = analyzer_service.ParameterValidationResult(success=True)
         provided_params: Mapping[str, ares_data_schema_pb2.SchemaEntry] = request.input_schema.fields
 
         for stored_key, stored_schema in self._analysis_parameters.items():
-            print(f"LOOKING AT {stored_key}")
             if stored_key in provided_params:
                 matching_schema = provided_params[stored_key]
                 if stored_schema.type != matching_schema.type:
-                    print(f" THIS IS THE TYPE RIGHT HERE LOOK AT IT: {type(matching_schema)}")
                     message = f"Schema Mismatch! {stored_key} was provided with the value type {stored_schema.type}, but the value type {matching_schema} was expected!"
                     response.messages.append(message)
-                    print(message)
             else:
                 if not stored_schema.optional:
                     message = f"Schema Missing! {stored_key} is marked as a required piece of data for analysis, but no assignment was found in the provided schema!"
                     response.messages.append(message)
-                    print(message)
 
         if len(response.messages) != 0:
             response.success = False

PyAres/Utils/ares_data_schema_utils.py

@@ -15,10 +15,13 @@ def create_settings_schema_entry(
     choices: Union[list[str], list[int], list[float]],
     struct_schema: Optional[Dict[str, AresSchemaEntry]] = None) -> ares_data_schema_pb2.SchemaEntry:
     """
-    Takes in an AresSetting object and converts it into the protobuf SchemaEntry message.
+    Creates a protobuf SchemaEntry message from the provided setting details.
 
     Args:
-        new_setting: The AresSetting object that provides all the details around the setting implementation.
+        setting_type (AresDataType): The data type of the setting.
+        optional (bool): Whether the setting is optional.
+        choices (Union[list[str], list[int], list[float]]): A list of valid choices for the setting.
+        struct_schema (Optional[Dict[str, AresSchemaEntry]]): Nested schema definition for STRUCT types.
 
     Returns:
         (SchemaEntry): A new SchemaEntry message.

tests/test_ares_data_schema_utils.py

@@ -0,0 +1,77 @@
+import unittest
+from PyAres.Utils import ares_data_schema_utils
+from PyAres.Models import AresDataType, AresSchemaEntry
+from ares_datamodel import ares_data_type_pb2
+
+class TestAresDataSchemaUtils(unittest.TestCase):
+    def test_create_simple_entry(self):
+        entry = ares_data_schema_utils.create_settings_schema_entry(
+            AresDataType.STRING, 
+            optional=True, 
+            choices=[]
+        )
+        self.assertEqual(entry.type, ares_data_type_pb2.AresDataType.STRING)
+        self.assertTrue(entry.optional)
+
+    def test_create_entry_with_string_choices(self):
+        choices = ["A", "B"]
+        entry = ares_data_schema_utils.create_settings_schema_entry(
+            AresDataType.STRING,
+            optional=False,
+            choices=choices
+        )
+        self.assertEqual(entry.string_choices.strings, choices)
+
+    def test_create_entry_with_number_choices(self):
+        choices = [1, 2.0]
+        entry = ares_data_schema_utils.create_settings_schema_entry(
+            AresDataType.NUMBER,
+            optional=False,
+            choices=choices
+        )
+        self.assertEqual(entry.number_choices.numbers, choices)
+
+    def test_create_entry_with_mixed_choices(self):
+        # Should result in no choices being set if types are mixed
+        choices = ["A", 1]
+        entry = ares_data_schema_utils.create_settings_schema_entry(
+            AresDataType.STRING,
+            optional=False,
+            choices=choices
+        )
+
+        self.assertEqual(len(entry.string_choices.strings), 0)
+        self.assertEqual(len(entry.number_choices.numbers), 0)
+
+    def test_convert_ares_schema_entry_to_proto(self):
+        py_entry = AresSchemaEntry(
+            type=AresDataType.NUMBER,
+            optional=True,
+            description="Test Desc",
+            unit="m/s",
+            choices=[1.0, 2.0]
+        )
+        proto = ares_data_schema_utils.convert_ares_schema_entry_to_proto(py_entry)
+        self.assertEqual(proto.type, ares_data_type_pb2.AresDataType.NUMBER)
+        self.assertTrue(proto.optional)
+        self.assertEqual(proto.description, "Test Desc")
+        self.assertEqual(proto.unit, "m/s")
+        self.assertEqual(proto.number_choices.numbers, [1.0, 2.0])
+
+    def test_nested_struct_schema(self):
+        nested_field = AresSchemaEntry(type=AresDataType.STRING, description="Inner")
+        struct_entry = AresSchemaEntry(
+            type=AresDataType.STRUCT,
+            struct_schema={"inner_key": nested_field}
+        )
+        
+        proto = ares_data_schema_utils.convert_ares_schema_entry_to_proto(struct_entry)
+        self.assertEqual(proto.type, ares_data_type_pb2.AresDataType.STRUCT)
+        self.assertIn("inner_key", proto.struct_schema.fields)
+        
+        inner_proto = proto.struct_schema.fields["inner_key"]
+        self.assertEqual(inner_proto.type, ares_data_type_pb2.AresDataType.STRING)
+        self.assertEqual(inner_proto.description, "Inner")
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/test_ares_struct_utils.py

@@ -52,8 +52,6 @@ def test_create_ares_struct_inference(self):
         self.assertEqual(s_list_num.fields["k"].number_array_value.numbers, [1, 2])
 
         s_list_bool = ares_struct_utils.create_ares_struct("k", [True, False])
-        blah = s_list_bool.fields["k"]
-        bleh = blah.list_value.values
         self.assertEqual(s_list_bool.fields["k"].list_value.values[0].bool_value, True)
 
         s_empty = ares_struct_utils.create_ares_struct("k", [])

tests/test_ares_value_type_conversions.py

@@ -41,7 +41,6 @@ def test_string_array_ares_value(self):
     original_list = ["one", "two", "three"]
     list_value = ares_value_utils.create_ares_value(original_list)
     self.assertEqual(list_value.string_array_value.strings, original_list)
-    print("String Array Test Passed!")
 
   def test_bool_array_ares_value(self):
     original_list = [True, False, True]