浏览代码

Merge branch 'dev' into tests_monf

monf 8 年之前
父节点
当前提交
b04a98b25d

+ 42 - 37
Tests/test_brain_loader.py

@@ -1,5 +1,7 @@
 import unittest
 import unittest
 
 
+from kalliope.core.Models import Singleton
+
 from kalliope.core.ConfigurationManager import BrainLoader
 from kalliope.core.ConfigurationManager import BrainLoader
 from kalliope.core.Models import Event
 from kalliope.core.Models import Event
 from kalliope.core.Models import Neuron
 from kalliope.core.Models import Neuron
@@ -25,45 +27,48 @@ class TestBrainLoader(unittest.TestCase):
              'name': 'test3'}
              'name': 'test3'}
         ]
         ]
 
 
-    # def test_get_yaml_config(self):
-    #     """
-    #     Test we can get a yaml config from the path
-    #     """
-    #     brain_loader = BrainLoader.Instance(file_path=self.brain_to_test)
-    #     self.assertEqual(brain_loader.yaml_config, self.expected_result)
-    #     del brain_loader
-    #
-    # def test_get_brain(self):
-    #     """
-    #     Test the class return a valid brain object
-    #     """
-    #
-    #     neuron = Neuron(name='say', parameters={'message': ['test message']})
-    #
-    #     signal1 = Order(sentence="test_order")
-    #     signal2 = Order(sentence="test_order_2")
-    #     signal3 = Order(sentence="test_order_3")
-    #
-    #     synapse1 = Synapse(name="test", neurons=[neuron], signals=[signal1])
-    #     synapse2 = Synapse(name="test2", neurons=[neuron], signals=[signal2])
-    #     synapse3 = Synapse(name="test3", neurons=[neuron], signals=[signal3])
-    #     synapses = [synapse1, synapse2, synapse3]
-    #
-    #     brain = Brain()
-    #     brain.synapses = synapses
-    #     brain.brain_file = self.brain_to_test
-    #     brain.brain_yaml = self.expected_result
-    #
-    #     brain_loader = BrainLoader.Instance(file_path=self.brain_to_test)
-    #     self.assertEqual(brain, brain_loader.brain)
-    #     del brain_loader
+    def tearDown(self):
+        Singleton._instances = {}
+
+    def test_get_yaml_config(self):
+        """
+        Test we can get a yaml config from the path
+        """
+        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):
+        """
+        Test the class return a valid brain object
+        """
+
+        neuron = Neuron(name='say', parameters={'message': ['test message']})
+
+        signal1 = Order(sentence="test_order")
+        signal2 = Order(sentence="test_order_2")
+        signal3 = Order(sentence="test_order_3")
+
+        synapse1 = Synapse(name="test", neurons=[neuron], signals=[signal1])
+        synapse2 = Synapse(name="test2", neurons=[neuron], signals=[signal2])
+        synapse3 = Synapse(name="test3", neurons=[neuron], signals=[signal3])
+        synapses = [synapse1, synapse2, synapse3]
+
+        brain = Brain()
+        brain.synapses = synapses
+        brain.brain_file = self.brain_to_test
+        brain.brain_yaml = self.expected_result
+
+        brain_loader = BrainLoader(file_path=self.brain_to_test)
+        self.assertEqual(brain, brain_loader.brain)
+        del brain_loader
 
 
     def test_get_neurons(self):
     def test_get_neurons(self):
         neuron_list = [{'say': {'message': ['test message']}}]
         neuron_list = [{'say': {'message': ['test message']}}]
 
 
         neuron = Neuron(name='say', parameters={'message': ['test message']})
         neuron = Neuron(name='say', parameters={'message': ['test message']})
 
 
-        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        bl = BrainLoader(file_path=self.brain_to_test)
         neurons_from_brain_loader = bl._get_neurons(neuron_list)
         neurons_from_brain_loader = bl._get_neurons(neuron_list)
 
 
         self.assertEqual([neuron], neurons_from_brain_loader)
         self.assertEqual([neuron], neurons_from_brain_loader)
@@ -74,7 +79,7 @@ class TestBrainLoader(unittest.TestCase):
 
 
         signal = Order(sentence='test_order')
         signal = Order(sentence='test_order')
 
 
-        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        bl = BrainLoader(file_path=self.brain_to_test)
         signals_from_brain_loader = bl._get_signals(signals)
         signals_from_brain_loader = bl._get_signals(signals)
 
 
         self.assertEqual([signal], signals_from_brain_loader)
         self.assertEqual([signal], signals_from_brain_loader)
@@ -88,7 +93,7 @@ class TestBrainLoader(unittest.TestCase):
         dict_order = {'order': 'test_order'}
         dict_order = {'order': 'test_order'}
         dict_event = {'event': '0 7 * * *'}
         dict_event = {'event': '0 7 * * *'}
 
 
-        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        bl = BrainLoader(file_path=self.brain_to_test)
         order_from_bl = bl._get_event_or_order_from_dict(dict_order)
         order_from_bl = bl._get_event_or_order_from_dict(dict_order)
         event_from_bl = bl._get_event_or_order_from_dict(dict_event)
         event_from_bl = bl._get_event_or_order_from_dict(dict_event)
 
 
@@ -97,8 +102,8 @@ class TestBrainLoader(unittest.TestCase):
         del bl
         del bl
 
 
     def test_singleton(self):
     def test_singleton(self):
-        bl1 = BrainLoader.Instance(file_path=self.brain_to_test)
-        bl2 = BrainLoader.Instance(file_path=self.brain_to_test)
+        bl1 = BrainLoader(file_path=self.brain_to_test)
+        bl2 = BrainLoader(file_path=self.brain_to_test)
 
 
         self.assertTrue(bl1.brain is bl2.brain)
         self.assertTrue(bl1.brain is bl2.brain)
         del bl1
         del bl1

+ 209 - 194
Tests/test_rest_api.py

@@ -1,9 +1,11 @@
 import json
 import json
+import os
 import unittest
 import unittest
 
 
 import requests
 import requests
 import time
 import time
 from flask import Flask
 from flask import Flask
+from kalliope.core.Models import Singleton
 
 
 from kalliope.core.ConfigurationManager import BrainLoader
 from kalliope.core.ConfigurationManager import BrainLoader
 from kalliope.core.ConfigurationManager import SettingLoader
 from kalliope.core.ConfigurationManager import SettingLoader
@@ -17,216 +19,229 @@ class TestRestAPI(unittest.TestCase):
         """
         """
         executed once at the beginning of the test
         executed once at the beginning of the test
         """
         """
+        super(TestRestAPI, cls).setUpClass()
+        current_path = os.getcwd()
+        full_path_brain_to_test = current_path + os.sep + "Tests/brains/brain_test.yml"
+        print full_path_brain_to_test
         # rest api config
         # rest api config
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         sl.settings.rest_api.password_protected = False
         sl.settings.rest_api.password_protected = False
         sl.settings.active = True
         sl.settings.active = True
         sl.settings.port = 5000
         sl.settings.port = 5000
+
+        print sl.settings.rest_api.password_protected
+
+        # be sure that the singleton haven't been loaded before
+        Singleton._instances = {}
         # prepare a test brain
         # prepare a test brain
-        brain_to_test = "../Tests/brains/brain_test.yml"
-        brain_loader = BrainLoader.Instance(file_path=brain_to_test)
+        brain_to_test = full_path_brain_to_test
+        brain_loader = BrainLoader(file_path=brain_to_test)
         brain = brain_loader.brain
         brain = brain_loader.brain
 
 
+        print brain_loader.yaml_config
+
         app = Flask(__name__)
         app = Flask(__name__)
         cls.flask_api = FlaskAPI(app, port=5000, brain=brain)
         cls.flask_api = FlaskAPI(app, port=5000, brain=brain)
         cls.flask_api.start()
         cls.flask_api.start()
         time.sleep(1)
         time.sleep(1)
 
 
-    @classmethod
-    def tearDownClass(cls):
-        """
-        executed once at the end of the test
-        """
-        url = "http://127.0.0.1:5000/shutdown/"
-        requests.post(url=url)
+    # @classmethod
+    # def tearDownClass(cls):
+    #     """
+    #     executed once at the end of the test
+    #     """
+    #     url = "http://127.0.0.1:5000/shutdown/"
+    #     requests.post(url=url)
 
 
     def setUp(self):
     def setUp(self):
         self.base_url = "http://127.0.0.1:5000"
         self.base_url = "http://127.0.0.1:5000"
 
 
-    def test_get_synapses(self):
-        url = self.base_url+"/synapses/"
-        result = requests.get(url=url)
-
-        expected_content = {
-            "synapses": [
-                {
-                    "name": "test",
-                    "neurons": [
-                        {
-                            "say": {
-                                "message": [
-                                    "test message"
-                                ]
-                            }
-                        }
-                    ],
-                    "signals": [
-                        {
-                            "order": "test_order"
-                        }
-                    ]
-                },
-                {
-                    "name": "test2",
-                    "neurons": [
-                        {
-                            "say": {
-                                "message": [
-                                    "test message"
-                                ]
-                            }
-                        }
-                    ],
-                    "signals": [
-                        {
-                            "order": "test_order_2"
-                        }
-                    ]
-                },
-                {
-                    "includes": [
-                        "included_brain_test.yml"
-                    ]
-                },
-                {
-                    "name": "test3",
-                    "neurons": [
-                        {
-                            "say": {
-                                "message": [
-                                    "test message"
-                                ]
-                            }
-                        }
-                    ],
-                    "signals": [
-                        {
-                            "order": "test_order_3"
-                        }
-                    ]
-                }
-            ]
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-
-    def test_get_one_synapse(self):
-        url = self.base_url+"/synapses/test"
-        result = requests.get(url=url)
-
-        expected_content = {
-            "synapses": {
-                "name": "test",
-                "neurons": [
-                    {
-                        "say": {
-                            "message": [
-                                "test message"
-                            ]
-                        }
-                    }
-                ],
-                "signals": [
-                    {
-                        "order": "test_order"
-                    }
-                ]
-            }
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-
-    def test_get_synapse_not_found(self):
-        url = self.base_url + "/synapses/test-none"
-        result = requests.get(url=url)
-
-        expected_content = {
-            "error": {
-                "synapse name not found": "test-none"
-            }
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-        self.assertEqual(result.status_code, 404)
-
-    def test_run_synapse_by_name(self):
-        url = self.base_url + "/synapses/test"
-        result = requests.post(url=url)
-
-        expected_content = {
-            "synapses": {
-                "name": "test",
-                "neurons": [
-                    {
-                        "say": {
-                            "message": [
-                                "test message"
-                            ]
-                        }
-                    }
-                ],
-                "signals": [
-                    {
-                        "order": "test_order"
-                    }
-                ]
-            }
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-        self.assertEqual(result.status_code, 201)
-
-    def test_post_synapse_not_found(self):
-        url = self.base_url + "/synapses/test-none"
-        result = requests.post(url=url)
-
-        expected_content = {
-            "error": {
-                "synapse name not found": "test-none"
-            }
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-        self.assertEqual(result.status_code, 404)
-
-    def test_run_synapse_with_order(self):
-        url = self.base_url + "/order/"
-        headers = {"Content-Type": "application/json"}
-        data = {"order": "test_order"}
-        result = requests.post(url=url, headers=headers, json=data)
-
-        expected_content = {
-            "synapses": [
-                {
-                    "name": "test",
-                    "neurons": [
-                        {
-                            "name": "say",
-                            "parameters": "{'message': ['test message']}"
-                        }
-                    ],
-                    "signals": [
-                        {
-                            "order": "test_order"
-                        }
-                    ]
-                }
-            ]
-        }
-
-        self.assertEqual(expected_content, json.loads(result.content))
-        self.assertEqual(result.status_code, 201)
-
-    def test_post_synapse_by_order_not_found(self):
-        url = self.base_url + "/order/"
-        data = {"order": "non existing order"}
-        headers = {"Content-Type": "application/json"}
-        result = requests.post(url=url, headers=headers, json=data)
-
-        expected_content = {'error': {'error': "The given order doesn't match any synapses"}}
-
-        self.assertEqual(expected_content, json.loads(result.content))
-        self.assertEqual(result.status_code, 400)
+    # def test_get_synapses(self):
+    #     url = self.base_url+"/synapses/"
+    #     result = requests.get(url=url)
+    #
+    #     print result.content
+    #
+    #     expected_content = {
+    #         "synapses": [
+    #             {
+    #                 "name": "test",
+    #                 "neurons": [
+    #                     {
+    #                         "say": {
+    #                             "message": [
+    #                                 "test message"
+    #                             ]
+    #                         }
+    #                     }
+    #                 ],
+    #                 "signals": [
+    #                     {
+    #                         "order": "test_order"
+    #                     }
+    #                 ]
+    #             },
+    #             {
+    #                 "name": "test2",
+    #                 "neurons": [
+    #                     {
+    #                         "say": {
+    #                             "message": [
+    #                                 "test message"
+    #                             ]
+    #                         }
+    #                     }
+    #                 ],
+    #                 "signals": [
+    #                     {
+    #                         "order": "test_order_2"
+    #                     }
+    #                 ]
+    #             },
+    #             {
+    #                 "includes": [
+    #                     "included_brain_test.yml"
+    #                 ]
+    #             },
+    #             {
+    #                 "name": "test3",
+    #                 "neurons": [
+    #                     {
+    #                         "say": {
+    #                             "message": [
+    #                                 "test message"
+    #                             ]
+    #                         }
+    #                     }
+    #                 ],
+    #                 "signals": [
+    #                     {
+    #                         "order": "test_order_3"
+    #                     }
+    #                 ]
+    #             }
+    #         ]
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+
+    # def test_get_one_synapse(self):
+    #     url = self.base_url+"/synapses/test"
+    #     result = requests.get(url=url)
+    #
+    #     expected_content = {
+    #         "synapses": {
+    #             "name": "test",
+    #             "neurons": [
+    #                 {
+    #                     "say": {
+    #                         "message": [
+    #                             "test message"
+    #                         ]
+    #                     }
+    #                 }
+    #             ],
+    #             "signals": [
+    #                 {
+    #                     "order": "test_order"
+    #                 }
+    #             ]
+    #         }
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #
+    # def test_get_synapse_not_found(self):
+    #     url = self.base_url + "/synapses/test-none"
+    #     result = requests.get(url=url)
+    #
+    #     expected_content = {
+    #         "error": {
+    #             "synapse name not found": "test-none"
+    #         }
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #     self.assertEqual(result.status_code, 404)
+    #
+    # def test_run_synapse_by_name(self):
+    #     url = self.base_url + "/synapses/test"
+    #     result = requests.post(url=url)
+    #
+    #     expected_content = {
+    #         "synapses": {
+    #             "name": "test",
+    #             "neurons": [
+    #                 {
+    #                     "say": {
+    #                         "message": [
+    #                             "test message"
+    #                         ]
+    #                     }
+    #                 }
+    #             ],
+    #             "signals": [
+    #                 {
+    #                     "order": "test_order"
+    #                 }
+    #             ]
+    #         }
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #     self.assertEqual(result.status_code, 201)
+    #
+    # def test_post_synapse_not_found(self):
+    #     url = self.base_url + "/synapses/test-none"
+    #     result = requests.post(url=url)
+    #
+    #     expected_content = {
+    #         "error": {
+    #             "synapse name not found": "test-none"
+    #         }
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #     self.assertEqual(result.status_code, 404)
+    #
+    # def test_run_synapse_with_order(self):
+    #     url = self.base_url + "/order/"
+    #     headers = {"Content-Type": "application/json"}
+    #     data = {"order": "test_order"}
+    #     result = requests.post(url=url, headers=headers, json=data)
+    #
+    #     expected_content = {
+    #         "synapses": [
+    #             {
+    #                 "name": "test",
+    #                 "neurons": [
+    #                     {
+    #                         "name": "say",
+    #                         "parameters": "{'message': ['test message']}"
+    #                     }
+    #                 ],
+    #                 "signals": [
+    #                     {
+    #                         "order": "test_order"
+    #                     }
+    #                 ]
+    #             }
+    #         ]
+    #     }
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #     self.assertEqual(result.status_code, 201)
+    #
+    # def test_post_synapse_by_order_not_found(self):
+    #     url = self.base_url + "/order/"
+    #     data = {"order": "non existing order"}
+    #     headers = {"Content-Type": "application/json"}
+    #     result = requests.post(url=url, headers=headers, json=data)
+    #
+    #     expected_content = {'error': {'error': "The given order doesn't match any synapses"}}
+    #
+    #     self.assertEqual(expected_content, json.loads(result.content))
+    #     self.assertEqual(result.status_code, 400)
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':
     unittest.main()
     unittest.main()

+ 47 - 41
Tests/test_settings_loader.py

@@ -1,7 +1,10 @@
+import platform
 import unittest
 import unittest
 
 
 from kalliope.core.ConfigurationManager import SettingLoader
 from kalliope.core.ConfigurationManager import SettingLoader
+from kalliope.core.Models import Singleton
 from kalliope.core.Models.RestAPI import RestAPI
 from kalliope.core.Models.RestAPI import RestAPI
+from kalliope.core.Models.Settings import Settings
 from kalliope.core.Models.Stt import Stt
 from kalliope.core.Models.Stt import Stt
 from kalliope.core.Models.Trigger import Trigger
 from kalliope.core.Models.Trigger import Trigger
 from kalliope.core.Models.Tts import Tts
 from kalliope.core.Models.Tts import Tts
@@ -34,88 +37,91 @@ class TestSettingLoader(unittest.TestCase):
             ]
             ]
         }
         }
 
 
+    def tearDown(self):
+        Singleton._instances = {}
+
     def test_singleton(self):
     def test_singleton(self):
-        s1 = SettingLoader.Instance(file_path=self.settings_file_to_test)
-        s2 = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        s1 = SettingLoader(file_path=self.settings_file_to_test)
+        s2 = SettingLoader(file_path=self.settings_file_to_test)
 
 
         self.assertTrue(s1.settings is s2.settings)
         self.assertTrue(s1.settings is s2.settings)
 
 
         del s1
         del s1
         del s2
         del s2
 
 
-    # def test_get_yaml_config(self):
-    #
-    #     sl = SettingLoader.Instance(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()
-    #     settings_object.default_tts_name = "pico2wave"
-    #     settings_object.default_stt_name = "google"
-    #     settings_object.default_trigger_name = "snowboy"
-    #     tts1 = Tts(name="pico2wave", parameters={'cache': True, 'language': 'fr-FR'})
-    #     tts2 = Tts(name="voxygen", parameters={'voice': 'Agnes', 'cache': True})
-    #     settings_object.ttss = [tts1, tts2]
-    #     stt = Stt(name="google", parameters={'language': 'fr-FR'})
-    #     settings_object.stts = [stt]
-    #     settings_object.random_wake_up_answers = ['Oui monsieur?']
-    #     settings_object.random_wake_up_sounds = ['ding.wav', 'dong.wav']
-    #     trigger1 = Trigger(name="snowboy",
-    #                        parameters={'pmdl_file': 'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'})
-    #     settings_object.triggers = [trigger1]
-    #     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.machine = platform.machine()
-    #
-    #     sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
-    #
-    #     self.assertEqual(settings_object, sl.settings)
-    #     del sl
+    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()
+        settings_object.default_tts_name = "pico2wave"
+        settings_object.default_stt_name = "google"
+        settings_object.default_trigger_name = "snowboy"
+        tts1 = Tts(name="pico2wave", parameters={'cache': True, 'language': 'fr-FR'})
+        tts2 = Tts(name="voxygen", parameters={'voice': 'Agnes', 'cache': True})
+        settings_object.ttss = [tts1, tts2]
+        stt = Stt(name="google", parameters={'language': 'fr-FR'})
+        settings_object.stts = [stt]
+        settings_object.random_wake_up_answers = ['Oui monsieur?']
+        settings_object.random_wake_up_sounds = ['ding.wav', 'dong.wav']
+        trigger1 = Trigger(name="snowboy",
+                           parameters={'pmdl_file': 'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'})
+        settings_object.triggers = [trigger1]
+        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.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):
     def test_get_default_speech_to_text(self):
         expected_default_speech_to_text = "google"
         expected_default_speech_to_text = "google"
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        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))
         self.assertEqual(expected_default_speech_to_text, sl._get_default_speech_to_text(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_default_text_to_speech(self):
     def test_get_default_text_to_speech(self):
         expected_default_text_to_speech = "pico2wave"
         expected_default_text_to_speech = "pico2wave"
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        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))
         self.assertEqual(expected_default_text_to_speech, sl._get_default_text_to_speech(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_default_trigger(self):
     def test_get_default_trigger(self):
         expected_default_trigger = "snowboy"
         expected_default_trigger = "snowboy"
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_default_trigger, sl._get_default_trigger(self.settings_dict))
         self.assertEqual(expected_default_trigger, sl._get_default_trigger(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_stts(self):
     def test_get_stts(self):
         stt = Stt(name="google", parameters={'language': 'fr-FR'})
         stt = Stt(name="google", parameters={'language': 'fr-FR'})
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([stt], sl._get_stts(self.settings_dict))
         self.assertEqual([stt], sl._get_stts(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_ttss(self):
     def test_get_ttss(self):
         tts1 = Tts(name="pico2wave", parameters={'cache': True, 'language': 'fr-FR'})
         tts1 = Tts(name="pico2wave", parameters={'cache': True, 'language': 'fr-FR'})
         tts2 = Tts(name="voxygen", parameters={'voice': 'Agnes', 'cache': True})
         tts2 = Tts(name="voxygen", parameters={'voice': 'Agnes', 'cache': True})
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([tts1, tts2], sl._get_ttss(self.settings_dict))
         self.assertEqual([tts1, tts2], sl._get_ttss(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_triggers(self):
     def test_get_triggers(self):
         trigger1 = Trigger(name="snowboy",
         trigger1 = Trigger(name="snowboy",
                            parameters={'pmdl_file': 'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'})
                            parameters={'pmdl_file': 'trigger/snowboy/resources/kalliope-FR-6samples.pmdl'})
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual([trigger1], sl._get_triggers(self.settings_dict))
         self.assertEqual([trigger1], sl._get_triggers(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_random_wake_up_answers(self):
     def test_get_random_wake_up_answers(self):
         expected_random_wake_up_answers = ['Oui monsieur?']
         expected_random_wake_up_answers = ['Oui monsieur?']
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        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))
         self.assertEqual(expected_random_wake_up_answers, sl._get_random_wake_up_answers(self.settings_dict))
         del sl
         del sl
 
 
@@ -123,13 +129,13 @@ class TestSettingLoader(unittest.TestCase):
         expected_rest_api = RestAPI(password_protected=True, active=True,
         expected_rest_api = RestAPI(password_protected=True, active=True,
                                     login="admin", password="secret", port=5000)
                                     login="admin", password="secret", port=5000)
 
 
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_rest_api, sl._get_rest_api(self.settings_dict))
         self.assertEqual(expected_rest_api, sl._get_rest_api(self.settings_dict))
         del sl
         del sl
 
 
     def test_get_cache_path(self):
     def test_get_cache_path(self):
         expected_cache_path = '/tmp/kalliope_tts_cache'
         expected_cache_path = '/tmp/kalliope_tts_cache'
-        sl = SettingLoader.Instance(file_path=self.settings_file_to_test)
+        sl = SettingLoader(file_path=self.settings_file_to_test)
         self.assertEqual(expected_cache_path, sl._get_cache_path(self.settings_dict))
         self.assertEqual(expected_cache_path, sl._get_cache_path(self.settings_dict))
         del sl
         del sl
 
 

+ 34 - 0
Tests/test_singleton.py

@@ -0,0 +1,34 @@
+import unittest
+
+from kalliope.core.Models import Singleton
+
+
+class MyClass(object):
+    __metaclass__ = Singleton
+
+    def __init__(self):
+        self.value = "test"
+
+
+class TestSingleton(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def test_singleton(self):
+
+        obj1 = MyClass()
+        obj2 = MyClass()
+
+        self.assertEqual(id(obj1), id(obj2))
+
+    def test_drop_singleton(self):
+
+        obj1 = MyClass()
+        obj2 = MyClass()
+        # drop the singleton instance
+        Singleton._instances = {}
+        obj3 = MyClass()
+
+        self.assertEqual(id(obj1), id(obj2))
+        self.assertNotEqual(id(obj1), id(obj3))

+ 1 - 1
kalliope/__init__.py

@@ -61,7 +61,7 @@ def main():
     if args.brain_file:
     if args.brain_file:
         brain_file = args.brain_file
         brain_file = args.brain_file
     # load the brain once
     # load the brain once
-    brain_loader = BrainLoader.Instance(file_path=brain_file)
+    brain_loader = BrainLoader(file_path=brain_file)
     brain = brain_loader.brain
     brain = brain_loader.brain
 
 
     # check the user provide a valid action
     # check the user provide a valid action

+ 1 - 2
kalliope/_version.py

@@ -1,3 +1,2 @@
 # https://www.python.org/dev/peps/pep-0440/
 # https://www.python.org/dev/peps/pep-0440/
-# version based on epoch
-version_str = "2016.11.20"
+version_str = "0.3"

+ 1 - 1
kalliope/core/ConfigurationManager/BrainLoader.py

@@ -15,11 +15,11 @@ logging.basicConfig()
 logger = logging.getLogger("kalliope")
 logger = logging.getLogger("kalliope")
 
 
 
 
-@Singleton
 class BrainLoader(object):
 class BrainLoader(object):
     """
     """
     This Class is used to get the brain YAML and the Brain as an object
     This Class is used to get the brain YAML and the Brain as an object
     """
     """
+    __metaclass__ = Singleton
 
 
     def __init__(self, file_path=None):
     def __init__(self, file_path=None):
         logger.debug("Loading brain with file path: %s" % file_path)
         logger.debug("Loading brain with file path: %s" % file_path)

+ 1 - 1
kalliope/core/ConfigurationManager/SettingLoader.py

@@ -42,11 +42,11 @@ class SettingNotFound(Exception):
     pass
     pass
 
 
 
 
-@Singleton
 class SettingLoader(object):
 class SettingLoader(object):
     """
     """
     This Class is used to get the Settings YAML and the Settings as an object
     This Class is used to get the Settings YAML and the Settings as an object
     """
     """
+    __metaclass__ = Singleton
 
 
     def __init__(self, file_path=None):
     def __init__(self, file_path=None):
         logger.debug("Loading settings with file path: %s" % file_path)
         logger.debug("Loading settings with file path: %s" % file_path)

+ 1 - 1
kalliope/core/MainController.py

@@ -24,7 +24,7 @@ class MainController:
     def __init__(self, brain=None):
     def __init__(self, brain=None):
         self.brain = brain
         self.brain = brain
         # get global configuration
         # get global configuration
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         self.settings = sl.settings
         self.settings = sl.settings
 
 
         # run the api if the user want it
         # run the api if the user want it

+ 6 - 39
kalliope/core/Models/Singleton.py

@@ -1,40 +1,7 @@
-class Singleton:
-    """
-    (From Stackoverflow : http://stackoverflow.com/questions/31875/is-there-a-simple-elegant-way-to-define-singletons-in-python)
+class Singleton(type):
+    _instances = {}
 
 
-    A non-thread-safe helper class to ease implementing singletons.
-    This should be used as a decorator -- not a metaclass -- to the
-    class that should be a singleton.
-
-    The decorated class can define one `__init__` function that
-    takes only the `self` argument. Other than that, there are
-    no restrictions that apply to the decorated class.
-
-    To get the singleton instance, use the `Instance` method. Trying
-    to use `__call__` will result in a `TypeError` being raised.
-
-    Limitations: The decorated class cannot be inherited from.
-
-    """
-
-    def __init__(self, decorated):
-        self._decorated = decorated
-
-    def Instance(self, **kwargs):
-        """
-        Returns the singleton instance. Upon its first call, it creates a
-        new instance of the decorated class and calls its `__init__` method.
-        On all subsequent calls, the already created instance is returned.
-
-        """
-        try:
-            return self._instance
-        except AttributeError:
-            self._instance = self._decorated(**kwargs)
-            return self._instance
-
-    def __call__(self):
-        raise TypeError('Singletons must be accessed through `Instance()`.')
-
-    def __instancecheck__(self, inst):
-        return isinstance(inst, self._decorated)
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

+ 2 - 2
kalliope/core/NeuronModule.py

@@ -66,9 +66,9 @@ class NeuronModule(object):
         self.neuron_name = child_name
         self.neuron_name = child_name
         logger.debug("NeuronModule called from class %s with parameters: %s" % (child_name, str(kwargs)))
         logger.debug("NeuronModule called from class %s with parameters: %s" % (child_name, str(kwargs)))
 
 
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         self.settings = sl.settings
         self.settings = sl.settings
-        brain_loader = BrainLoader.Instance()
+        brain_loader = BrainLoader()
         self.brain = brain_loader.brain
         self.brain = brain_loader.brain
 
 
         # check if the user has overrider the TTS
         # check if the user has overrider the TTS

+ 1 - 1
kalliope/core/OrderListener.py

@@ -39,7 +39,7 @@ class OrderListener(Thread):
         self._ignore_stderr()
         self._ignore_stderr()
         self.stt_module_name = stt
         self.stt_module_name = stt
         self.callback = callback
         self.callback = callback
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         self.settings = sl.settings
         self.settings = sl.settings
 
 
     def run(self):
     def run(self):

+ 2 - 2
kalliope/core/RestAPI/utils.py

@@ -8,7 +8,7 @@ def check_auth(username, password):
     """This function is called to check if a username /
     """This function is called to check if a username /
     password combination is valid.
     password combination is valid.
     """
     """
-    sl = SettingLoader.Instance()
+    sl = SettingLoader()
     settings = sl.settings
     settings = sl.settings
     return username == settings.rest_api.login and password == settings.rest_api.password
     return username == settings.rest_api.login and password == settings.rest_api.password
 
 
@@ -24,7 +24,7 @@ def authenticate():
 def requires_auth(f):
 def requires_auth(f):
     @wraps(f)
     @wraps(f)
     def decorated(*args, **kwargs):
     def decorated(*args, **kwargs):
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         settings = sl.settings
         settings = sl.settings
         if settings.rest_api.password_protected:
         if settings.rest_api.password_protected:
             auth = request.authorization
             auth = request.authorization

+ 1 - 1
kalliope/core/ShellGui.py

@@ -43,7 +43,7 @@ class ShellGui:
         self.brain = brain
         self.brain = brain
 
 
         # get settings
         # get settings
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         self.settings = sl.settings
         self.settings = sl.settings
         locale.setlocale(locale.LC_ALL, '')
         locale.setlocale(locale.LC_ALL, '')
 
 

+ 1 - 1
kalliope/core/TTS/TTSModule.py

@@ -56,7 +56,7 @@ class TTSModule(object):
         self.base_cache_path = None
         self.base_cache_path = None
 
 
         # load settings
         # load settings
-        sl = SettingLoader.Instance()
+        sl = SettingLoader()
         self.settings = sl.settings
         self.settings = sl.settings
 
 
         # create the path in the tmp folder
         # create the path in the tmp folder

+ 1 - 1
kalliope/core/__init__.py

@@ -1,7 +1,7 @@
 from kalliope.core.OrderAnalyser import OrderAnalyser
 from kalliope.core.OrderAnalyser import OrderAnalyser
 from kalliope.core.OrderListener import OrderListener
 from kalliope.core.OrderListener import OrderListener
 from kalliope.core.ShellGui import ShellGui
 from kalliope.core.ShellGui import ShellGui
-from kalliope.core.Utils import Utils
+from kalliope.core.Utils.Utils import Utils
 from kalliope.core.Utils import FileManager
 from kalliope.core.Utils import FileManager
 
 
 
 

+ 1 - 1
kalliope/neurons/ansible_playbook/tests/test_ansible_playbook.py

@@ -31,7 +31,7 @@ class TestAnsible_Playbook(unittest.TestCase):
         This test will use an ansible playbook the create a file. We check that the file has been created
         This test will use an ansible playbook the create a file. We check that the file has been created
         """
         """
         param = {
         param = {
-            "task_file": "./test_ansible_playbook_neuron.yml"
+            "task_file": "kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.yml"
         }
         }
 
 
         Ansible_playbook(**param)
         Ansible_playbook(**param)

+ 3 - 3
kalliope/neurons/script/tests/test_script.py

@@ -64,7 +64,7 @@ class TestScript(unittest.TestCase):
         Test we can run a script
         Test we can run a script
         """
         """
         param = {
         param = {
-            "path": "./test_script.sh"
+            "path": "kalliope/neurons/script/tests/test_script.sh"
         }
         }
 
 
         Script(**param)
         Script(**param)
@@ -78,7 +78,7 @@ class TestScript(unittest.TestCase):
         Test we can run a script asynchronously
         Test we can run a script asynchronously
         """
         """
         param = {
         param = {
-            "path": "./test_script.sh",
+            "path": "kalliope/neurons/script/tests/test_script.sh",
             "async": True
             "async": True
         }
         }
 
 
@@ -101,7 +101,7 @@ class TestScript(unittest.TestCase):
 
 
         # get the output with the neuron
         # get the output with the neuron
         parameters = {
         parameters = {
-            "path": "./test_script_cat.sh",
+            "path": "kalliope/neurons/script/tests/test_script_cat.sh",
         }
         }
 
 
         script = Script(**parameters)
         script = Script(**parameters)

+ 1 - 1
kalliope/neurons/uri/tests/test_uri_neuron.py

@@ -163,7 +163,7 @@ class TestUri(unittest.TestCase):
         parameters = {
         parameters = {
             "url": self.test_url,
             "url": self.test_url,
             "method": "POST",
             "method": "POST",
-            "data_from_file": "data_post_test.json",
+            "data_from_file": "kalliope/neurons/uri/tests/data_post_test.json",
             "headers": {
             "headers": {
                 "Content-Type": 'application/json'
                 "Content-Type": 'application/json'
             }
             }

+ 1 - 1
kalliope/trigger/snowboy/snowboydetect.py

@@ -6,7 +6,7 @@
 from kalliope.core.ConfigurationManager import SettingLoader
 from kalliope.core.ConfigurationManager import SettingLoader
 from sys import version_info
 from sys import version_info
 
 
-sl = SettingLoader.Instance()
+sl = SettingLoader()
 settings = sl.settings
 settings = sl.settings
 module_file_path = "%s/_snowboydetect" % settings.machine
 module_file_path = "%s/_snowboydetect" % settings.machine