Merged branch draft_FIFO_tests into draft_FIFO

Tests/test_launchers.py

@@ -1,140 +0,0 @@
-import unittest
-import mock
-
-from kalliope.core.Models.Resources import Resources
-from kalliope.core.NeuronLauncher import NeuronLauncher
-from kalliope.core.SynapseLauncher import SynapseLauncher, SynapseNameNotFound
-from kalliope.core.TriggerLauncher import TriggerLauncher
-from kalliope.core.ConfigurationManager import SettingLoader
-from kalliope.core.Models.Settings import Settings
-
-from kalliope.core.Models.Trigger import Trigger
-from kalliope.core.Models.Neuron import Neuron
-from kalliope.core.Models.Order import Order
-from kalliope.core.Models.Brain import Brain
-from kalliope.core.Models.Synapse import Synapse
-
-
-class TestLaunchers(unittest.TestCase):
-    """
-    Class to test Launchers Classes (TriggerLauncher, SynapseLauncher, NeuronLauncher) and methods
-    """
-
-    def setUp(self):
-        pass
-
-    ####
-    # Trigger Launcher
-    def test_get_trigger(self):
-        """
-        Test the Trigger Launcher trying to run the trigger
-        """
-        trigger = Trigger("Trigger", {})
-        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
-            TriggerLauncher.get_trigger(trigger=trigger,
-                                        callback=None)
-
-            mock_get_class_instantiation.assert_called_once_with(package_name="trigger",
-                                                                 module_name=trigger.name,
-                                                                 parameters=trigger.parameters)
-            mock_get_class_instantiation.reset_mock()
-
-    ####
-    # Synapse Launcher
-    def test_start_synapse(self):
-        """
-        Test the Synapse launcher trying to start synapse
-        """
-        # Init
-        neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
-        neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
-        neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
-        neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
-
-        signal1 = Order(sentence="this is the sentence")
-        signal2 = Order(sentence="this is the second sentence")
-        signal3 = Order(sentence="that is part of the third sentence")
-
-        synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
-        synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
-        synapse3 = Synapse(name="Synapse3", neurons=[neuron2, neuron4], signals=[signal3])
-
-        all_synapse_list = [synapse1,
-                            synapse2,
-                            synapse3]
-
-        br = Brain(synapses=all_synapse_list)
-
-        sl = SettingLoader()
-        r = Resources(neuron_folder="/var/tmp/test/resources")
-        sl.settings.resources = r
-        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
-            # Success
-            SynapseLauncher.start_synapse_by_name("Synapse1", brain=br)
-
-            calls = [mock.call(package_name="neurons",
-                               module_name=neuron1.name,
-                               parameters=neuron1.parameters,
-                               resources_dir='/var/tmp/test/resources'),
-                     mock.call(package_name="neurons",
-                               module_name=neuron2.name,
-                               parameters=neuron2.parameters,
-                               resources_dir='/var/tmp/test/resources')]
-            mock_get_class_instantiation.assert_has_calls(calls=calls)
-            mock_get_class_instantiation.reset_mock()
-
-            # Fail
-            with self.assertRaises(SynapseNameNotFound):
-                SynapseLauncher.start_synapse_by_name("Synapse4", brain=br)
-
-    def test_run_synapse(self):
-        """
-        Test to run a Synapse
-        """
-        neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
-        neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
-        signal1 = Order(sentence="this is the sentence")
-        synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
-        synapse_empty = Synapse(name="Synapse_empty", neurons=[], signals=[signal1])
-        sl = SettingLoader()
-        resources = Resources(neuron_folder='/var/tmp/test/resources')
-        sl.settings.resources = resources
-        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
-            SynapseLauncher._run_synapse(synapse=synapse1)
-
-            calls = [mock.call(package_name="neurons",
-                               module_name=neuron1.name,
-                               parameters=neuron1.parameters,
-                               resources_dir="/var/tmp/test/resources"),
-                     mock.call(package_name="neurons",
-                               module_name=neuron2.name,
-                               parameters=neuron2.parameters,
-                               resources_dir="/var/tmp/test/resources")]
-            mock_get_class_instantiation.assert_has_calls(calls=calls)
-            mock_get_class_instantiation.reset_mock()
-
-            # Do not any Neurons
-            SynapseLauncher._run_synapse(synapse=synapse_empty)
-            mock_get_class_instantiation.assert_not_called()
-            mock_get_class_instantiation.reset_mock()
-
-    ####
-    # Neurons Launcher
-    def test_start_neuron(self):
-        """
-        Test the Neuron Launcher trying to start a Neuron
-        """
-        neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
-        sl = SettingLoader()
-        resources = Resources(neuron_folder='/var/tmp/test/resources')
-        sl.settings.resources = resources
-        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
-            NeuronLauncher.start_neuron(neuron=neuron)
-
-            mock_get_class_instantiation.assert_called_once_with(package_name="neurons",
-                                                                 module_name=neuron.name,
-                                                                 parameters=neuron.parameters,
-                                                                 resources_dir=sl.settings.resources.neuron_folder)
-            mock_get_class_instantiation.reset_mock()
-
-

Tests/test_neuron_launcher.py

@@ -0,0 +1,90 @@
+import unittest
+import mock
+
+from kalliope.core.Models.Resources import Resources
+from kalliope.core.NeuronLauncher import NeuronLauncher
+from kalliope.core.ConfigurationManager import SettingLoader
+
+from kalliope.core.Models.Neuron import Neuron
+
+
+class TestNeuronLauncher(unittest.TestCase):
+    """
+    Class to test Launchers Classes (TriggerLauncher, SynapseLauncher, NeuronLauncher) and methods
+    """
+
+    def setUp(self):
+        pass
+
+    ####
+    # Neurons Launcher
+    def test_launch_neuron(self):
+        """
+        Test the Neuron Launcher trying to start a Neuron
+        """
+        neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
+        sl = SettingLoader()
+        resources = Resources(neuron_folder='/var/tmp/test/resources')
+        sl.settings.resources = resources
+        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
+            NeuronLauncher.start_neuron(neuron=neuron)
+
+            mock_get_class_instantiation.assert_called_once_with(package_name="neurons",
+                                                                 module_name=neuron.name,
+                                                                 parameters=neuron.parameters,
+                                                                 resources_dir=sl.settings.resources.neuron_folder)
+            mock_get_class_instantiation.reset_mock()
+
+    def test_start_neuron(self):
+        """
+        Testing params association and starting a Neuron
+        """
+
+        with mock.patch("kalliope.core.NeuronLauncher.launch_neuron") as mock_launch_neuron_method:
+            # Assert to the neuron is launched
+            neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
+            params = {
+                'param1':'parval1'
+            }
+            NeuronLauncher.start_neuron(neuron=neuron1,
+                                        parameters_dict=params)
+            mock_launch_neuron_method.assert_called_with(neuron1)
+            mock_launch_neuron_method.reset_mock()
+
+            # Assert the params are well passed to the neuron
+            neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2', 'args': ['arg1', 'arg2']})
+            params = {
+                'arg1':'argval1',
+                'arg2':'argval2'
+            }
+            NeuronLauncher.start_neuron(neuron=neuron2,
+                                        parameters_dict=params)
+            neuron2_params = Neuron(name='neurone2',
+                                    parameters={'var2': 'val2',
+                                                'args': ['arg1', 'arg2'],
+                                                'arg1':'argval1',
+                                                'arg2':'argval2'}
+                                    )
+            mock_launch_neuron_method.assert_called_with(neuron2_params)
+            mock_launch_neuron_method.reset_mock()
+
+            # Assert the Neuron is not started when missing args
+            neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3', 'args': ['arg3', 'arg4']})
+            params = {
+                'arg1': 'argval1',
+                'arg2': 'argval2'
+            }
+            NeuronLauncher.start_neuron(neuron=neuron3,
+                                        parameters_dict=params)
+            mock_launch_neuron_method.assert_not_called()
+            mock_launch_neuron_method.reset_mock()
+
+            # Assert no neuron is launched when waiting for args and none are given
+            neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4', 'args': ['arg5', 'arg6']})
+            params = {}
+            NeuronLauncher.start_neuron(neuron=neuron4,
+                                        parameters_dict=params)
+            mock_launch_neuron_method.assert_not_called()
+            mock_launch_neuron_method.reset_mock()
+
+

Tests/test_neuron_module.py

@@ -3,10 +3,6 @@ import unittest
 import mock
 
 from kalliope.core.NeuronModule import NeuronModule, TemplateFileNotFoundException
-from kalliope.core.Models.Neuron import Neuron
-from kalliope.core.Models.Synapse import Synapse
-from kalliope.core.Models.Brain import Brain
-from kalliope.core.Models.Order import Order
 
 
 class TestNeuronModule(unittest.TestCase):
@@ -114,61 +110,20 @@ class TestNeuronModule(unittest.TestCase):
         expected_result = "hello, this is a {{ test }}"
         self.assertEqual(NeuronModule._get_content_of_file(self.file_template), expected_result)
 
-    def test_run_synapse_by_name_with_order(self):
+    def test_serialize(self):
         """
-        Test to start a synapse with a specific given order
-        Scenarii :
-            - Neuron has been found and launched
-            - Neuron has not been found
+        Test the serialisation of the neuron module
         """
+        neuron_module = NeuronModule()
+        neuron_module.neuron_name = "kalliope"
+        neuron_module.tts_message = "I am french"
 
-        # Init
-        neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
-        neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
-        neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
-        neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
-
-        signal1 = Order(sentence="the sentence")
-        signal2 = Order(sentence="the second sentence")
-        signal3 = Order(sentence="part of the third sentence")
-
-        synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
-        synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
-        synapse3 = Synapse(name="Synapse3", neurons=[neuron2, neuron4], signals=[signal3])
-
-        all_synapse_list = [synapse1,
-                            synapse2,
-                            synapse3]
-
-        br = Brain(synapses=all_synapse_list)
-
-        order = "This is the order"
-        synapse_name = "Synapse2"
-        answer = "This is the {{ answer }}"
-        expected_parameter = {"answer": "order"}
-
-        with mock.patch("kalliope.core.NeuronLauncher.start_neuron_list") as mock_NeuronLauncher_start:
-            neuron_mod = NeuronModule()
-            neuron_mod.brain = br
-
-            # Success, run synapse 2
-            launched_synapse = neuron_mod.run_synapse_by_name_with_order(order=order,
-                                                                         synapse_name=synapse_name,
-                                                                         order_template=answer)
-            self.assertEqual(synapse2, launched_synapse)
-
-            mock_NeuronLauncher_start.assert_called_once_with(neuron_list=[neuron3, neuron4],
-                                                              parameters_dict=expected_parameter)
-            mock_NeuronLauncher_start.reset_mock()
-
-            # Fail
-            synapse_name = "Synapse5"
-            self.assertIsNone(neuron_mod.run_synapse_by_name_with_order(order=order,
-                                                                        synapse_name=synapse_name,
-                                                                        order_template=answer))
-
-            mock_NeuronLauncher_start.assert_not_called()
-            mock_NeuronLauncher_start.reset_mock()
+        expected_result = {
+            'neuron_name': "kalliope",
+            'generated_message': "I am french"
+        }
+
+        self.assertEqual(expected_result, neuron_module.serialize())
 
 
 

Tests/test_order_analyser.py

@@ -5,6 +5,7 @@ from kalliope.core.Models import Brain
 from kalliope.core.Models import Neuron
 from kalliope.core.Models import Order
 from kalliope.core.Models import Synapse
+from kalliope.core.Models.MatchedSynapse import MatchedSynapse
 from kalliope.core.OrderAnalyser import OrderAnalyser
 
 
@@ -38,9 +39,15 @@ class TestOrderAnalyser(unittest.TestCase):
 
         # TEST1: should return synapse1
         spoken_order = "this is the sentence"
+
+        # Create the matched synapse
+        matched_synapse_1 = MatchedSynapse(matched_synapse=synapse1,
+                                           matched_order=spoken_order,
+                                           user_order=spoken_order)
+
         matched_synapses = OrderAnalyser.get_matching_synapse(order=spoken_order, brain=br)
         self.assertEqual(len(matched_synapses), 1)
-        self.assertTrue(any(synapse1 in matched_synapse for matched_synapse in matched_synapses))
+        self.assertTrue(matched_synapse_1 in matched_synapses)
 
         # TEST2: should return synapse1 and 2
         spoken_order = "this is the second sentence"

Tests/test_trigger_launcher.py

@@ -0,0 +1,31 @@
+import unittest
+import mock
+
+from kalliope.core.TriggerLauncher import TriggerLauncher
+
+from kalliope.core.Models.Trigger import Trigger
+
+
+class TestTriggerLauncher(unittest.TestCase):
+    """
+    Class to test Launchers Classes (TriggerLauncher, SynapseLauncher, NeuronLauncher) and methods
+    """
+
+    def setUp(self):
+        pass
+
+    ####
+    # Trigger Launcher
+    def test_get_trigger(self):
+        """
+        Test the Trigger Launcher trying to run the trigger
+        """
+        trigger = Trigger("Trigger", {})
+        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
+            TriggerLauncher.get_trigger(trigger=trigger,
+                                        callback=None)
+
+            mock_get_class_instantiation.assert_called_once_with(package_name="trigger",
+                                                                 module_name=trigger.name,
+                                                                 parameters=trigger.parameters)
+            mock_get_class_instantiation.reset_mock()

kalliope/core/Models/MatchedSynapse.py

@@ -11,8 +11,9 @@ class MatchedSynapse(object):
     def __init__(self, matched_synapse=None, matched_order=None, user_order=None):
         """
         
-        :param matched_synapse: The synapse that has matched in the brain
-        :param matched_order: The order from the synapse that have matched
+        :param matched_synapse: The synapse that has matched in the brain.
+        :param matched_order: The order from the synapse that have matched.
+        :param user_order: The order said by the user.
         """
         # create a copy of the synapse. the received synapse come from the brain.
         self.synapse = matched_synapse