Pārlūkot izejas kodu

[Feature] #137 manage a resource path to load external resources like neurons + Tests
TODO : Doc h

monf 8 gadi atpakaļ
vecāks
revīzija
969c1859f1

+ 30 - 11
Tests/test_launchers.py

@@ -1,10 +1,10 @@
 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.ConfigurationManager import SettingLoader
 
 from kalliope.core.Models.Trigger import Trigger
 from kalliope.core.Models.Neuron import Neuron
@@ -32,9 +32,9 @@ class TestLaunchers(unittest.TestCase):
             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.assert_called_once_with(package_name="trigger",
+                                                                 module_name=trigger.name.capitalize(),
+                                                                 parameters=trigger.parameters)
             mock_get_class_instantiation.reset_mock()
 
     ####
@@ -63,12 +63,20 @@ class TestLaunchers(unittest.TestCase):
 
         br = Brain(synapses=all_synapse_list)
 
+        sl = SettingLoader()
+        sl.settings.resource_dir = '/var/tmp/test/resources'
         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)]
+            calls = [mock.call(package_name="neurons",
+                               module_name=neuron1.name.capitalize(),
+                               parameters=neuron1.parameters,
+                               resources_dir='/var/tmp/test/resources'),
+                     mock.call(package_name="neurons",
+                               module_name=neuron2.name.capitalize(),
+                               parameters=neuron2.parameters,
+                               resources_dir='/var/tmp/test/resources')]
             mock_get_class_instantiation.assert_has_calls(calls=calls)
             mock_get_class_instantiation.reset_mock()
 
@@ -85,11 +93,19 @@ class TestLaunchers(unittest.TestCase):
         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()
+        sl.settings.resource_dir = '/var/tmp/test/resources'
         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)]
+            calls = [mock.call(package_name="neurons",
+                               module_name=neuron1.name.capitalize(),
+                               parameters=neuron1.parameters,
+                               resources_dir='/var/tmp/test/resources'),
+                     mock.call(package_name="neurons",
+                               module_name=neuron2.name.capitalize(),
+                               parameters=neuron2.parameters,
+                               resources_dir='/var/tmp/test/resources')]
             mock_get_class_instantiation.assert_has_calls(calls=calls)
             mock_get_class_instantiation.reset_mock()
 
@@ -105,11 +121,14 @@ class TestLaunchers(unittest.TestCase):
         Test the Neuron Launcher trying to start a Neuron
         """
         neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
+        sl = SettingLoader()
+        sl.settings.resource_dir = '/var/tmp/test/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("neurons",
-                                                                 neuron.name.capitalize(),
-                                                                 neuron.parameters)
+            mock_get_class_instantiation.assert_called_once_with(package_name="neurons",
+                                                                 module_name=neuron.name.capitalize(),
+                                                                 parameters=neuron.parameters,
+                                                                 resources_dir='/var/tmp/test/resources')
             mock_get_class_instantiation.reset_mock()
 

+ 12 - 3
Tests/test_utils.py

@@ -1,10 +1,16 @@
 import unittest
 import os
+import mock
 
 from kalliope.core.Models.Neuron import Neuron
+from kalliope.core.Models.Order import Order
+from kalliope.core.Models.Synapse import Synapse
 from kalliope.neurons.say.say import Say
 from kalliope.core.Utils.Utils import Utils
 
+from kalliope.core.ConfigurationManager import SettingLoader
+from kalliope.core.ConfigurationManager import BrainLoader
+
 
 class TestUtils(unittest.TestCase):
     """
@@ -121,11 +127,14 @@ class TestUtils(unittest.TestCase):
         """
         Test that an instance as been instantiate properly.
         """
+        sl = SettingLoader()
+        sl.settings.resource_dir = '/var/tmp/test/resources'
 
         neuron = Neuron(name='Say', parameters={'message': 'test dynamic class instantiate'})
-        self.assertTrue(isinstance(Utils.get_dynamic_class_instantiation("neurons",
-                                                                         neuron.name.capitalize(),
-                                                                         neuron.parameters),
+        self.assertTrue(isinstance(Utils.get_dynamic_class_instantiation(package_name="neurons",
+                                                                         module_name=neuron.name.capitalize(),
+                                                                         parameters=neuron.parameters,
+                                                                         resources_dir='/var/tmp/test/resources'),
                                    Say),
                         "Fail instantiate a class")
 

+ 0 - 8
kalliope/brain.yml

@@ -16,11 +16,3 @@
       - say:
           message:
             - "Hello sir"
-
-  - name: "testest"
-    signals:
-      - order: "testest"
-    neurons:
-      - testest:
-          message:
-            - "testest"

+ 5 - 7
kalliope/core/ConfigurationManager/ConfigurationChecker.py

@@ -1,5 +1,4 @@
 import re
-import sys
 import os
 import imp
 
@@ -145,21 +144,20 @@ class ConfigurationChecker:
             sl = SettingLoader()
             settings = sl.settings
             neuron_resource_path = settings.resource_dir + '/' + "neurons" + '/' + neuron_module_name.lower()+"/" + neuron_module_name.lower()+".py"
-            print neuron_resource_path
-
             if os.path.exists(neuron_resource_path):
-                # sys.path.append(neuron_resource_path)
-                # print sys.path
                 imp.load_source(neuron_module_name.capitalize(), neuron_resource_path)
                 package_name = neuron_module_name.capitalize()
             else:
                 package_name = "kalliope.neurons"+ "." + neuron_module_name.lower() + "." + neuron_module_name.lower()
-            mod = __import__(package_name, fromlist=[neuron_module_name.capitalize()])
 
             try:
+                mod = __import__(package_name, fromlist=[neuron_module_name.capitalize()])
                 getattr(mod, neuron_module_name.capitalize())
             except AttributeError:
-                raise ModuleNotFoundError("The module %s does not exist in the package %s " % (neuron_module_name.capitalize(),
+                raise ModuleNotFoundError("[AttributeError] The module %s does not exist in the package %s " % (neuron_module_name.capitalize(),
+                                                                         package_name))
+            except ImportError:
+                raise ModuleNotFoundError("[ImportError] The module %s does not exist in the package %s " % (neuron_module_name.capitalize(),
                                                                                                package_name))
             return True