finish unit test for NeuronModule

Tests/__init__.py

@@ -8,3 +8,4 @@ from test_settings_loader import TestSettingLoader
 from test_singleton import TestSingleton
 from test_tts_module import TestTTSModule
 from test_yaml_loader import TestYAMLLoader
+from test_neuron_module import TestNeuronModule

Tests/templates/template_test.j2

@@ -0,0 +1 @@
+hello, this is a {{ test }}

Tests/test_neuron_module.py

@@ -1,28 +1,39 @@
+import os
 import unittest
 import mock
 
-from kalliope.core.NeuronModule import NeuronModule
+from kalliope.core.NeuronModule import NeuronModule, TemplateFileNotFoundException
 
 
 class TestNeuronModule(unittest.TestCase):
 
     def setUp(self):
-        pass
+        self.expected_result = "hello, this is a replaced word"
+        # this allow us to run the test from an IDE and from the root with python -m unittest Tests.TestNeuronModule
+        if "/Tests" in os.getcwd():
+            self.file_template = "templates/template_test.j2"
+        else:
+            self.file_template = "Tests/templates/template_test.j2"
+        self.say_template = "hello, this is a {{ test }}"
+        self.message = {
+            "test": "replaced word"
+        }
+        self.neuron_module_test = NeuronModule()
 
     def tearDown(self):
-        pass
+        del self.neuron_module_test
 
     def test_get_audio_from_stt(self):
         """
         Test the OrderListener thread is started
         """
 
-        with mock.patch("kalliope.core.OrderListener.start") as mock_orderListerner_start:
+        with mock.patch("kalliope.core.OrderListener.start") as mock_orderListener_start:
             def callback():
                 pass
             NeuronModule.get_audio_from_stt(callback=callback())
-            mock_orderListerner_start.assert_called_once_with()
-            mock_orderListerner_start.reset_mock()
+            mock_orderListener_start.assert_called_once_with()
+            mock_orderListener_start.reset_mock()
 
     def test_update_cache_var(self):
         """
@@ -54,6 +65,45 @@ class TestNeuronModule(unittest.TestCase):
 
         self.assertTrue(args_dict["cache"])
 
+    def test_get_message_from_dict(self):
+
+        self.neuron_module_test.say_template = self.say_template
+
+        self.assertEqual(self.neuron_module_test._get_message_from_dict(self.message), self.expected_result)
+        del self.neuron_module_test
+        self.neuron_module_test = NeuronModule()
+
+        # test with file_template
+        self.neuron_module_test.file_template = self.file_template
+        self.assertEqual(self.neuron_module_test._get_message_from_dict(self.message), self.expected_result)
+        del self.neuron_module_test
+
+        # test with no say_template and no file_template
+        self.neuron_module_test = NeuronModule()
+        self.assertEqual(self.neuron_module_test._get_message_from_dict(self.message), None)
+
+    def test_get_say_template(self):
+        # test with a string
+        self.assertEqual(NeuronModule._get_say_template(self.say_template, self.message), self.expected_result)
+
+        # test with a list
+        say_template = list()
+        say_template.append("hello, this is a {{ test }} one")
+        say_template.append("hello, this is a {{ test }} two")
+        expected_result = list()
+        expected_result.append("hello, this is a replaced word one")
+        expected_result.append("hello, this is a replaced word two")
+        self.assertTrue(NeuronModule._get_say_template(say_template, self.message) in expected_result)
 
+    def test_get_file_template(self):
+        # test with a valid template
+        self.assertEqual(NeuronModule._get_file_template(self.file_template, self.message), self.expected_result)
 
+        # test raise with a non existing template
+        file_template = "does_not_exist.j2"
+        with self.assertRaises(TemplateFileNotFoundException):
+            NeuronModule._get_file_template(file_template, self.message)
 
+    def test_get_content_of_file(self):
+        expected_result = "hello, this is a {{ test }}"
+        self.assertEqual(NeuronModule._get_content_of_file(self.file_template), expected_result)

kalliope/core/NeuronModule.py

@@ -118,7 +118,7 @@ class NeuronModule(object):
         if tts_message is not None:
             logger.debug("tts_message to say: %s" % tts_message)
 
-            # create a tts object from the tts the user want to user
+            # create a tts object from the tts the user want to use
             tts_object = next((x for x in self.settings.ttss if x.name == self.tts), None)
             if tts_object is None:
                 raise TTSModuleNotFound("The tts module name %s does not exist in settings file" % self.tts)
@@ -158,10 +158,6 @@ class NeuronModule(object):
 
         return returned_message
 
-        # we don't force the usage of a template. The user can choose to do nothing with returned value
-        # if not returned_message:
-        #     raise NoTemplateException("You must specify a say_template or a file_template")
-
     @staticmethod
     def _get_say_template(list_say_template, message_dict):
         if isinstance(list_say_template, list):
@@ -173,13 +169,14 @@ class NeuronModule(object):
     @classmethod
     def _get_file_template(cls, file_template, message_dict):
         real_file_template_path = Utils.get_real_file_path(file_template)
-        if os.path.isfile(real_file_template_path):
-            # load the content of the file as template
-            t = Template(cls._get_content_of_file(real_file_template_path))
-            returned_message = t.render(**message_dict)
-        else:
+        if real_file_template_path is None:
             raise TemplateFileNotFoundException("Template file %s not found in templates folder"
                                                 % real_file_template_path)
+
+        # load the content of the file as template
+        t = Template(cls._get_content_of_file(real_file_template_path))
+        returned_message = t.render(**message_dict)
+
         return returned_message
 
     def run_synapse_by_name(self, name):