Merged branch dev into tests_nico

Tests/settings/settings_test.yml

@@ -71,3 +71,10 @@ rest_api:
   password_protected: True
   login: admin
   password: secret
+
+
+# ---------------------------
+# Default Synapse
+# ---------------------------
+# Specify an optional default synapse response in case your order is not found.
+default_synapse: "Default-synapse"

Tests/test_brain_loader.py

@@ -36,7 +36,6 @@ class TestBrainLoader(unittest.TestCase):
         """
         brain_loader = BrainLoader(file_path=self.brain_to_test)
         self.assertEqual(brain_loader.yaml_config, self.expected_result)
-        del brain_loader
 
     def test_get_brain(self):
         """
@@ -61,7 +60,6 @@ class TestBrainLoader(unittest.TestCase):
 
         brain_loader = BrainLoader(file_path=self.brain_to_test)
         self.assertEqual(brain, brain_loader.brain)
-        del brain_loader
 
     def test_get_neurons(self):
         neuron_list = [{'say': {'message': ['test message']}}]
@@ -72,7 +70,6 @@ class TestBrainLoader(unittest.TestCase):
         neurons_from_brain_loader = bl._get_neurons(neuron_list)
 
         self.assertEqual([neuron], neurons_from_brain_loader)
-        del bl
 
     def test_get_signals(self):
         signals = [{'order': 'test_order'}]
@@ -83,7 +80,6 @@ class TestBrainLoader(unittest.TestCase):
         signals_from_brain_loader = bl._get_signals(signals)
 
         self.assertEqual([signal], signals_from_brain_loader)
-        del bl
 
     def test_get_event_or_order_from_dict(self):
 
@@ -99,15 +95,12 @@ class TestBrainLoader(unittest.TestCase):
 
         self.assertEqual(order_from_bl, order_object)
         self.assertEqual(event_from_bl, event_object)
-        del bl
 
     def test_singleton(self):
         bl1 = BrainLoader(file_path=self.brain_to_test)
         bl2 = BrainLoader(file_path=self.brain_to_test)
 
         self.assertTrue(bl1.brain is bl2.brain)
-        del bl1
-        del bl2
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_order_analyser.py

@@ -1,9 +1,10 @@
 import unittest
-
+import mock
 
 from kalliope.core.OrderAnalyser import OrderAnalyser
 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
 
 
@@ -14,6 +15,123 @@ class TestOrderAnalyser(unittest.TestCase):
     def setUp(self):
         pass
 
+    def test_start(self):
+        """
+        Testing if the matches from the incoming messages and the signals/order sentences.
+        Scenarii :
+            - Order matchs a synapse and the synapse has been launched.
+            - Order does not match but have a default synapse.
+            - Order does not match and does not ahve default 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)
+
+        def _start_neuron_mock(cls, neuron, params):
+            pass
+
+        with mock.patch("kalliope.core.OrderAnalyser._start_neuron") as mock_start_neuron_method:
+            # assert synapses have been launched
+            order_to_match = "this is the sentence"
+            oa = OrderAnalyser(order=order_to_match,
+                               brain=br)
+            expected_result = [synapse1]
+
+            self.assertEquals(oa.start(),
+                              expected_result,
+                              "Fail to run the expected Synapse matching the order")
+
+            calls = [mock.call(neuron1, {}), mock.call(neuron2, {})]
+            mock_start_neuron_method.assert_has_calls(calls=calls)
+            mock_start_neuron_method.reset_mock()
+
+            # No order matching Default Synapse to run
+            order_to_match = "random sentence"
+            oa = OrderAnalyser(order=order_to_match,
+                               brain=br)
+            oa.settings = mock.MagicMock(default_synapse="Synapse3")
+            expected_result = [synapse3]
+            self.assertEquals(oa.start(),
+                              expected_result,
+                              "Fail to run the default Synapse because no other synapses match the order")
+
+            # No order matching no Default Synapse
+            order_to_match = "random sentence"
+            oa = OrderAnalyser(order=order_to_match,
+                               brain=br)
+            oa.settings = mock.MagicMock()
+            expected_result = []
+            self.assertEquals(oa.start(),
+                              expected_result,
+                              "Fail to no synapse because no synapse matchs and no default defined")
+
+    def test_start_neuron(self):
+        """
+        Testing params association and starting a Neuron
+        """
+
+        neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
+
+        with mock.patch("kalliope.core.NeuronLauncher.NeuronLauncher.start_neuron") as mock_start_neuron_method:
+            # Assert to the neuron is launched
+            neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
+            params = {
+                'param1':'parval1'
+            }
+            OrderAnalyser._start_neuron(neuron=neuron1,params=params)
+            mock_start_neuron_method.assert_called_with(neuron1)
+            mock_start_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'
+            }
+            OrderAnalyser._start_neuron(neuron=neuron2, params=params)
+            neuron2_params = Neuron(name='neurone2',
+                                    parameters={'var2': 'val2',
+                                                'args': ['arg1', 'arg2'],
+                                                'arg1':'argval1',
+                                                'arg2':'argval2'}
+                                    )
+            mock_start_neuron_method.assert_called_with(neuron2_params)
+            mock_start_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'
+            }
+            OrderAnalyser._start_neuron(neuron=neuron3, params=params)
+            mock_start_neuron_method.assert_not_called()
+            mock_start_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 = {}
+            OrderAnalyser._start_neuron(neuron=neuron4, params=params)
+            mock_start_neuron_method.assert_not_called()
+            mock_start_neuron_method.reset_mock()
+
+
     def test_is_containing_bracket(self):
         #  Success
         order_to_test = "This test contains {{ bracket }}"
@@ -349,5 +467,33 @@ class TestOrderAnalyser(unittest.TestCase):
                          expected_result,
                          "Fail to retrieve the 'all of the sentence is a variable' of the synapse from the order")
 
+    def test_get_default_synapse_from_sysnapses_list(self):
+        # 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])
+
+        default_synapse_name = "Synapse2"
+        all_synapse_list = [synapse1,
+                            synapse2,
+                            synapse3]
+        expected_result = synapse2
+
+        # Assert equals
+        self.assertEquals(OrderAnalyser._get_default_synapse_from_sysnapses_list(all_synapses_list=all_synapse_list,
+                                                                                 default_synapse_name=default_synapse_name),
+                          expected_result,
+                          "Fail to match the expected default Synapse")
+
+
 if __name__ == '__main__':
     unittest.main()

Tests/test_settings_loader.py

@@ -34,7 +34,8 @@ class TestSettingLoader(unittest.TestCase):
             'text_to_speech': [
                 {'pico2wave': {'cache': True, 'language': 'fr-FR'}},
                 {'voxygen': {'voice': 'Agnes', 'cache': True}}
-            ]
+            ],
+            'default_synapse': 'Default-synapse'
         }
 
     def tearDown(self):
@@ -46,14 +47,10 @@ class TestSettingLoader(unittest.TestCase):
 
         self.assertTrue(s1.settings is s2.settings)
 
-        del s1
-        del s2
-
     def test_get_yaml_config(self):
 
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(sl.yaml_config, self.settings_dict)
-        del sl
 
     def test_get_settings(self):
         settings_object = Settings()
@@ -73,57 +70,50 @@ class TestSettingLoader(unittest.TestCase):
         settings_object.rest_api = RestAPI(password_protected=True, active=True,
                                            login="admin", password="secret", port=5000)
         settings_object.cache_path = '/tmp/kalliope_tts_cache'
+        settings_object.default_synapse = 'Default-synapse'
         settings_object.machine = platform.machine()
 
         sl = SettingLoader(file_path=self.settings_file_to_test)
 
         self.assertEqual(settings_object, sl.settings)
-        del sl
 
     def test_get_default_speech_to_text(self):
         expected_default_speech_to_text = "google"
         sl = SettingLoader(file_path=self.settings_file_to_test)
 
         self.assertEqual(expected_default_speech_to_text, sl._get_default_speech_to_text(self.settings_dict))
-        del sl
 
     def test_get_default_text_to_speech(self):
         expected_default_text_to_speech = "pico2wave"
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_default_text_to_speech, sl._get_default_text_to_speech(self.settings_dict))
-        del sl
 
     def test_get_default_trigger(self):
         expected_default_trigger = "snowboy"
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_default_trigger, sl._get_default_trigger(self.settings_dict))
-        del sl
 
     def test_get_stts(self):
         stt = Stt(name="google", parameters={'language': 'fr-FR'})
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([stt], sl._get_stts(self.settings_dict))
-        del sl
 
     def test_get_ttss(self):
         tts1 = Tts(name="pico2wave", parameters={'cache': True, 'language': 'fr-FR'})
         tts2 = Tts(name="voxygen", parameters={'voice': 'Agnes', 'cache': True})
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([tts1, tts2], sl._get_ttss(self.settings_dict))
-        del sl
 
     def test_get_triggers(self):
         trigger1 = Trigger(name="snowboy",
                            parameters={'pmdl_file': 'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'})
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([trigger1], sl._get_triggers(self.settings_dict))
-        del sl
 
     def test_get_random_wake_up_answers(self):
         expected_random_wake_up_answers = ['Oui monsieur?']
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_random_wake_up_answers, sl._get_random_wake_up_answers(self.settings_dict))
-        del sl
 
     def test_get_rest_api(self):
         expected_rest_api = RestAPI(password_protected=True, active=True,
@@ -131,13 +121,16 @@ class TestSettingLoader(unittest.TestCase):
 
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_rest_api, sl._get_rest_api(self.settings_dict))
-        del sl
 
     def test_get_cache_path(self):
         expected_cache_path = '/tmp/kalliope_tts_cache'
         sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_cache_path, sl._get_cache_path(self.settings_dict))
-        del sl
+
+    def test_get_default_synapse(self):
+        expected_default_synapse = 'Default-synapse'
+        sl = SettingLoader(file_path=self.settings_file_to_test)
+        self.assertEqual(expected_default_synapse, sl._get_default_synapse(self.settings_dict))
 
 if __name__ == '__main__':
     unittest.main()

kalliope/core/MainController.py

@@ -65,7 +65,7 @@ class MainController:
         :type order: str
         """
         if order is not None:   # maybe we have received a null audio from STT engine
-            order_analyser = OrderAnalyser(order, main_controller=self, brain=self.brain)
+            order_analyser = OrderAnalyser(order, brain=self.brain)
             order_analyser.start()
 
         # restart the trigger when the order analyser has finish his job

kalliope/core/NeuroneLauncher.py → kalliope/core/NeuronLauncher.py

@@ -6,13 +6,13 @@ logging.basicConfig()
 logger = logging.getLogger("kalliope")
 
 
-class NeuroneLauncher:
+class NeuronLauncher:
 
     def __init__(self):
         pass
 
     @classmethod
-    def start_neurone(cls, neuron):
+    def start_neuron(cls, neuron):
         """
         Start a neuron plugin
         :param neuron: neuron object

kalliope/core/OrderAnalyser.py

@@ -3,8 +3,9 @@ import re
 from collections import Counter
 
 from kalliope.core.Utils.Utils import Utils
+from kalliope.core.ConfigurationManager import SettingLoader
 from kalliope.core.Models import Order
-from kalliope.core.NeuroneLauncher import NeuroneLauncher
+from kalliope.core.NeuronLauncher import NeuronLauncher
 
 import logging
 
@@ -16,14 +17,15 @@ class OrderAnalyser:
     """
     This Class is used to compare the incoming message to the Signal/Order sentences.
     """
-    def __init__(self, order, main_controller=None, brain=None):
+    def __init__(self, order, brain=None):
         """
         Class used to load brain and run neuron attached to the received order
         :param order: spelt order
         :param main_controller
         :param brain: loaded brain
         """
-        self.main_controller = main_controller
+        sl = SettingLoader()
+        self.settings = sl.settings
         self.order = order
         if isinstance(self.order, str):
             self.order = order.decode('utf-8')
@@ -41,9 +43,9 @@ class OrderAnalyser:
         if not launched_synapses:
             Utils.print_info("No synapse match the captured order: %s" % self.order)
 
-            if self.main_controller.settings.default_synapse is not None:
+            if self.settings.default_synapse is not None:
                 default_synapse = self._get_default_synapse_from_sysnapses_list(self.brain.synapses,
-                                                                        self.main_controller.settings.default_synapse)
+                                                                                self.settings.default_synapse)
 
                 if default_synapse is not None:
                     logger.debug("Default synapse found %s" % default_synapse)
@@ -131,7 +133,7 @@ class OrderAnalyser:
 
         # if no error detected, we run the neuron
         if not problem_in_neuron_found:
-            NeuroneLauncher.start_neurone(neuron)
+            NeuronLauncher.start_neuron(neuron)
         else:
             Utils.print_danger("A problem has been found in the Synapse.")
 
@@ -251,7 +253,7 @@ class OrderAnalyser:
 
         :param all_synapses_list: the complete list of all synapses
         :param default_synapse_name: the synapse to find
-        :return: the dict key/value
+        :return: the Synapse
         """
         default_synapse = None
         for synapse in all_synapses_list:

kalliope/core/SynapseLauncher.py

@@ -1,4 +1,4 @@
-from kalliope.core.NeuroneLauncher import NeuroneLauncher
+from kalliope.core.NeuronLauncher import NeuronLauncher
 
 
 class SynapseNameNotFound(Exception):
@@ -46,5 +46,5 @@ class SynapseLauncher(object):
         :return:
         """
         for neuron in synapse.neurons:
-            NeuroneLauncher.start_neurone(neuron)
+            NeuronLauncher.start_neuron(neuron)
         return True