Browse Source

[Tests] Launchers (Trigger, Synapses, Neuron)

monf 8 years ago
parent
commit
1f39c26166

+ 115 - 0
Tests/test_launchers.py

@@ -0,0 +1,115 @@
+import unittest
+import mock
+import os
+
+from kalliope.core.NeuronLauncher import NeuronLauncher
+from kalliope.core.SynapseLauncher import SynapseLauncher, SynapseNameNotFound
+from kalliope.core.TriggerLauncher import TriggerLauncher
+
+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("trigger",
+                                                                 trigger.name.capitalize(),
+                                                                 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)
+
+        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
+            # Success
+            SynapseLauncher.start_synapse("Synapse1", brain=br)
+
+            calls = [mock.call("neurons", neuron1.name.capitalize(), neuron1.parameters),
+                     mock.call("neurons", neuron2.name.capitalize(), neuron2.parameters)]
+            mock_get_class_instantiation.assert_has_calls(calls=calls)
+            mock_get_class_instantiation.reset_mock()
+
+            # Fail
+            with self.assertRaises(SynapseNameNotFound):
+                SynapseLauncher.start_synapse("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])
+        with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
+            SynapseLauncher._run_synapse(synapse=synapse1)
+
+            calls = [mock.call("neurons",neuron1.name.capitalize(),neuron1.parameters),
+                     mock.call("neurons",neuron2.name.capitalize(),neuron2.parameters)]
+            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'})
+        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("neurons",
+                                                                 neuron.name.capitalize(),
+                                                                 neuron.parameters)
+            mock_get_class_instantiation.reset_mock()
+

+ 2 - 2
Tests/test_tts_module.py

@@ -59,7 +59,7 @@ class TestTTSModule(unittest.TestCase):
 
             # test missing callback
             with self.assertRaises(TtsGenerateAudioFunctionNotFound):
-                self.assertRaises(self.TTSMod.generate_and_play(words=words))
+                self.TTSMod.generate_and_play(words=words)
 
             # Assert Callback is called
             # no Cache
@@ -124,4 +124,4 @@ class TestTTSModule(unittest.TestCase):
                          "Fail asserting that the file does not exist.")
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

+ 1 - 1
Tests/test_utils.py

@@ -127,5 +127,5 @@ class TestUtils(unittest.TestCase):
                                                                          neuron.name.capitalize(),
                                                                          neuron.parameters),
                                    Say),
-                        "Fail instanciate a class")
+                        "Fail instantiate a class")
 

+ 3 - 1
kalliope/core/NeuronLauncher.py

@@ -20,4 +20,6 @@ class NeuronLauncher:
         :return:
         """
         logger.debug("Run plugin \"%s\" with parameters %s" % (neuron.name, neuron.parameters))
-        return Utils.get_dynamic_class_instantiation("neurons", neuron.name.capitalize(), neuron.parameters)
+        return Utils.get_dynamic_class_instantiation("neurons",
+                                                     neuron.name.capitalize(),
+                                                     neuron.parameters)

+ 2 - 1
kalliope/core/TriggerLauncher.py

@@ -23,5 +23,6 @@ class TriggerLauncher(object):
         # add the callback method to parameters
         trigger.parameters["callback"] = callback
         logger.debug("TriggerLauncher: Start trigger %s with parameters: %s" % (trigger.name, trigger.parameters))
-        return Utils.get_dynamic_class_instantiation("trigger", trigger.name.capitalize(),
+        return Utils.get_dynamic_class_instantiation("trigger",
+                                                     trigger.name.capitalize(),
                                                      trigger.parameters)