Browse Source

add unit tests, use dict and not a list for kalliope_memory object

nico 7 năm trước cách đây
mục cha
commit
aa57d6a406
3 tập tin đã thay đổi với 181 bổ sung34 xóa
  1. 151 0
      Tests/test_cortex.py
  2. 28 32
      kalliope/core/Cortex.py
  3. 2 2
      kalliope/neurons/neurotimer/README.md

+ 151 - 0
Tests/test_cortex.py

@@ -0,0 +1,151 @@
+import unittest
+
+from kalliope.core.Cortex import Cortex
+
+
+class TestCortex(unittest.TestCase):
+
+    def setUp(self):
+        # cleanup the cortex memory
+        Cortex.memory = dict()
+        Cortex.temp = dict()
+
+    def test_get_memory(self):
+        test_memory = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        Cortex.memory = test_memory
+        self.assertDictEqual(test_memory, Cortex.get_memory())
+
+    def test_save(self):
+        key_to_save = "key1"
+        value_to_save = "value1"
+
+        expected_memory = {
+            "key1": "value1"
+        }
+
+        Cortex.save(key=key_to_save, value=value_to_save)
+        self.assertDictEqual(expected_memory, Cortex.memory)
+
+    def test_get_from_key(self):
+        test_memory = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        Cortex.memory = test_memory
+        expected_value = "value2"
+        self.assertEqual(expected_value, Cortex.get_from_key("key2"))
+
+    def test_add_parameters_from_order(self):
+
+        order_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        expected_temp_dict = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        Cortex.add_parameters_from_order(order_parameters)
+        self.assertDictEqual(Cortex.temp, expected_temp_dict)
+
+    def test_clean_parameter_from_order(self):
+        Cortex.temp = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        Cortex.clean_parameter_from_order()
+        expected_temp_dict = dict()
+        self.assertDictEqual(expected_temp_dict, Cortex.memory)
+
+    def test_save_neuron_parameter_in_memory(self):
+
+        # test with a list of parameter with bracket
+
+        neuron1_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        dict_val_to_save = {"my_key_in_memory": "{{key1}}"}
+
+        expected_dict = {"my_key_in_memory": "value1"}
+
+        Cortex.save_neuron_parameter_in_memory(kalliope_memory_dict=dict_val_to_save,
+                                               neuron_parameters=neuron1_parameters)
+
+        self.assertDictEqual(expected_dict, Cortex.memory)
+
+        # test with a list of parameter with brackets and string
+        self.setUp()  # clean
+        neuron1_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        dict_val_to_save = {"my_key_in_memory": "string {{key1}}"}
+
+        expected_dict = {"my_key_in_memory": "string value1"}
+
+        Cortex.save_neuron_parameter_in_memory(kalliope_memory_dict=dict_val_to_save,
+                                               neuron_parameters=neuron1_parameters)
+
+        self.assertDictEqual(expected_dict, Cortex.memory)
+
+        # test with a list of parameter with only a string. Neuron parameters are not used
+        self.setUp()  # clean
+        neuron1_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        dict_val_to_save = {"my_key_in_memory": "string"}
+
+        expected_dict = {"my_key_in_memory": "string"}
+
+        Cortex.save_neuron_parameter_in_memory(kalliope_memory_dict=dict_val_to_save,
+                                               neuron_parameters=neuron1_parameters)
+
+        self.assertDictEqual(expected_dict, Cortex.memory)
+
+        # test with an empty list of parameter to save (no kalliope_memory set)
+        self.setUp()  # clean
+
+        neuron1_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        dict_val_to_save = None
+
+        Cortex.save_neuron_parameter_in_memory(kalliope_memory_dict=dict_val_to_save,
+                                               neuron_parameters=neuron1_parameters)
+
+        self.assertDictEqual(dict(), Cortex.memory)
+
+    def test_save_parameter_from_order_in_memory(self):
+        # define temp saved order parameter
+        order_parameters = {
+            "key1": "value1",
+            "key2": "value2"
+        }
+
+        Cortex.temp = order_parameters
+
+        dict_val_to_save = {"my_key_in_memory": "{{key1}}"}
+
+        expected_dict = {"my_key_in_memory": "value1"}
+
+        Cortex.save_parameter_from_order_in_memory(dict_val_to_save)
+
+        self.assertDictEqual(expected_dict, Cortex.memory)
+
+if __name__ == '__main__':
+    unittest.main()

+ 28 - 32
kalliope/core/Cortex.py

@@ -58,14 +58,6 @@ class Cortex(with_metaclass(Singleton, object)):
         logger.debug("[Cortex] place parameters in temp list: %s" % dict_parameter)
         cls.temp.update(dict_parameter)
 
-    @classmethod
-    def get_parameters_from_order(cls):
-        """
-        return the current list of
-        :return:
-        """
-        return cls.temp
-
     @classmethod
     def clean_parameter_from_order(cls):
         """
@@ -75,7 +67,7 @@ class Cortex(with_metaclass(Singleton, object)):
         cls.temp = dict()
 
     @classmethod
-    def save_neuron_parameter_in_memory(cls, dict_parameter_to_save, neuron_parameters):
+    def save_neuron_parameter_in_memory(cls, kalliope_memory_dict, neuron_parameters):
         """
         receive a dict of value send by the child neuron
         save in kalliope memory all value
@@ -88,31 +80,35 @@ class Cortex(with_metaclass(Singleton, object)):
 
         :param neuron_parameters: dict of parameter the neuron has processed and send to the neurone module to
                 be processed by the TTS engine
-        :param dict_parameter_to_save: a dict of key value the user want to save from the dict_neuron_parameter
+        :param kalliope_memory_dict: a dict of key value the user want to save from the dict_neuron_parameter
         """
 
-        if dict_parameter_to_save is not None:
-            logger.debug("[NeuronModule] save_memory - User want to save: %s" % dict_parameter_to_save)
-            logger.debug("[NeuronModule] save_memory - Available parameters in the neuron: %s" % neuron_parameters)
+        if kalliope_memory_dict is not None:
+            logger.debug("[Cortex] save_memory - User want to save: %s" % kalliope_memory_dict)
+            logger.debug("[Cortex] save_memory - Available parameters in the neuron: %s" % neuron_parameters)
 
-            for dict_key_val in dict_parameter_to_save:
-                for key, value in dict_key_val.items():
-                    # ask the cortex to save in memory the target "key" if it was in parameters of the neuron
-                    if isinstance(neuron_parameters, dict):
-                        if Utils.is_containing_bracket(value):
-                            value = jinja2.Template(value).render(neuron_parameters)
-                        Cortex.save(key, value)
+            for key, value in kalliope_memory_dict.items():
+                # ask the cortex to save in memory the target "key" if it was in parameters of the neuron
+                if isinstance(neuron_parameters, dict):
+                    if Utils.is_containing_bracket(value):
+                        value = jinja2.Template(value).render(neuron_parameters)
+                    Cortex.save(key, value)
 
     @classmethod
-    def save_parameter_from_order_in_memory(cls, dict_parameter_to_save):
-
-        if dict_parameter_to_save is not None:
-            logger.debug("[NeuronModule] save_memory - User want to save: %s" % dict_parameter_to_save)
-            logger.debug("[NeuronModule] save_memory - Available parameters in orders: %s"
-                         % Cortex.get_parameters_from_order())
-            for dict_key_val in dict_parameter_to_save:
-                for key, value in dict_key_val.items():
-                    # ask the cortex to save in memory the target "key" if it was in the order
-                    if Utils.is_containing_bracket(value):
-                        value = jinja2.Template(value).render(Cortex.get_parameters_from_order())
-                        Cortex.save(key, value)
+    def save_parameter_from_order_in_memory(cls, order_parameters):
+        """
+        Save key from the temp dict (where parameters loaded from the voice order where placed temporary)
+        into the memory dict
+        :param order_parameters: dict of key to save.  {'key_name_in_memory': 'key_name_in_temp_dict'}
+        """
+
+        if order_parameters is not None:
+            logger.debug("[Cortex] save_memory - User want to save: %s" % order_parameters)
+            logger.debug("[Cortex] save_memory - Available parameters in orders: %s"
+                         % cls.temp)
+
+            for key, value in order_parameters.items():
+                # ask the cortex to save in memory the target "key" if it was in the order
+                if Utils.is_containing_bracket(value):
+                    value = jinja2.Template(value).render(Cortex.temp)
+                    Cortex.save(key, value)

+ 2 - 2
kalliope/neurons/neurotimer/README.md

@@ -94,8 +94,8 @@ Passing argument to the called synapse with the `kalliope_memory`.
         seconds: "{{ time }}"
         synapse: "remember-todo"
         kalliope_memory:
-          - remember: "{{ remember }}"
-          - seconds: "{{ time }}"
+          remember: "{{ remember }}"
+          seconds: "{{ time }}"
     - say:
         message:
           - "I'll remind you in {{ time }} minutes"