Browse Source

Merged branch draft_FIFO into draft_FIFO_tests

monf 8 years ago
parent
commit
49a1f6ea09

+ 60 - 78
Tests/test_rest_api.py

@@ -5,6 +5,7 @@ import unittest
 from flask import Flask
 from flask_testing import LiveServerTestCase
 
+from kalliope.core import LIFOBuffer
 from kalliope.core.Models import Singleton
 from kalliope._version import version_str
 from kalliope.core.ConfigurationManager import BrainLoader
@@ -16,6 +17,8 @@ class TestRestAPI(LiveServerTestCase):
 
     def tearDown(self):
         Singleton._instances = {}
+        # clean the lifo
+        LIFOBuffer.lifo_list = list()
 
     def create_app(self):
         """
@@ -175,26 +178,14 @@ class TestRestAPI(LiveServerTestCase):
         url = self.get_server_url() + "/synapses/start/id/test"
         result = self.client.post(url)
 
-        expected_content = {
-            "synapses": {
-                "name": "test",
-                "neurons": [
-                    {
-                        "name": "say",
-                        "parameters": {
-                            "message": [
-                                "test message"
-                            ]
-                        }
-                    }
-                ],
-                "signals": [
-                    {
-                        "order": "test_order"
-                    }
-                ]
-            }
-        }
+        expected_content = {'status': 'complete',
+                            'matched_synapses':
+                                [{'matched_order': None,
+                                  'neuron_module_list':
+                                      [{'generated_message': 'test message', 'neuron_name': 'Say'}],
+                                  'synapse_name': 'test'}],
+                            'user_order': None
+                            }
         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))
         self.assertEqual(result.status_code, 201)
 
@@ -217,28 +208,14 @@ class TestRestAPI(LiveServerTestCase):
         data = {"order": "test_order"}
         result = self.client.post(url, headers=headers, data=json.dumps(data))
 
-        expected_content = {
-            "synapses": [
-                {
-                    "name": "test",
-                    "neurons": [
-                        {
-                            "name": "say",
-                            "parameters": {
-                                "message": [
-                                    "test message"
-                                ]
+        expected_content = {'status': 'complete',
+                            'matched_synapses':
+                                [{'matched_order': "test_order",
+                                  'neuron_module_list':
+                                      [{'generated_message': 'test message', 'neuron_name': 'Say'}],
+                                  'synapse_name': 'test'}],
+                            'user_order': "test_order"
                             }
-                        }
-                    ],
-                    "signals": [
-                        {
-                            "order": "test_order"
-                        }
-                    ]
-                }
-            ]
-        }
         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))
         self.assertEqual(result.status_code, 201)
 
@@ -250,46 +227,51 @@ class TestRestAPI(LiveServerTestCase):
                                   headers=headers,
                                   data=json.dumps(data))
 
-        expected_content = {'error': {'error': "The given order doesn't match any synapses"}}
+        expected_content = {'status': None, 'matched_synapses': [], 'user_order': u'non existing order'}
 
         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))
-        self.assertEqual(result.status_code, 400)
+        self.assertEqual(result.status_code, 201)
 
-    # TODO this doesn't work on travis but works locally with python -m unittest discover
-    # def test_post_synapse_by_audio(self):
-    #     url = self.get_server_url() + "/synapses/start/audio"
-    #     with open(os.path.join(self.audio_file), 'rb') as fp:
-    #         file = FileStorage(fp)
-    #         data = {
-    #             'file': file
-    #         }
-    #         result = self.client.post(url, data=data, content_type='multipart/form-data')
-    #
-    #         expected_content = {
-    #             "synapses": [
-    #                 {
-    #                     "name": "test2",
-    #                     "neurons": [
-    #                         {
-    #                             "name": "say",
-    #                             "parameters": {
-    #                                 "message": [
-    #                                     "test message"
-    #                                 ]
-    #                             }
-    #                         }
-    #                     ],
-    #                     "signals": [
-    #                         {
-    #                             "order": "bonjour"
-    #                         }
-    #                     ]
-    #                 }
-    #             ]
-    #         }
-    #
-    #         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))
-    #         self.assertEqual(result.status_code, 201)
+        # TODO this doesn't work on travis but works locally with python -m unittest discover
+        # def test_post_synapse_by_audio(self):
+        #     url = self.get_server_url() + "/synapses/start/audio"
+        #     with open(os.path.join(self.audio_file), 'rb') as fp:
+        #         file = FileStorage(fp)
+        #         data = {
+        #             'file': file
+        #         }
+        #         result = self.client.post(url, data=data, content_type='multipart/form-data')
+        #
+        #         expected_content = {
+        #             "synapses": [
+        #                 {
+        #                     "name": "test2",
+        #                     "neurons": [
+        #                         {
+        #                             "name": "say",
+        #                             "parameters": {
+        #                                 "message": [
+        #                                     "test message"
+        #                                 ]
+        #                             }
+        #                         }
+        #                     ],
+        #                     "signals": [
+        #                         {
+        #                             "order": "bonjour"
+        #                         }
+        #                     ]
+        #                 }
+        #             ]
+        #         }
+        #
+        #         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))
+        #         self.assertEqual(result.status_code, 201)
 
 if __name__ == '__main__':
     unittest.main()
+
+    # suite = unittest.TestSuite()
+    # suite.addTest(TestRestAPI("test_post_synapse_by_order_not_found"))
+    # runner = unittest.TextTestRunner()
+    # runner.run(suite)

+ 31 - 16
Tests/test_synapse_launcher.py

@@ -1,6 +1,7 @@
 import unittest
 
 import mock
+from kalliope.core.ConfigurationManager import BrainLoader
 
 from kalliope.core import LIFOBuffer
 from kalliope.core.Models import Brain
@@ -33,11 +34,11 @@ class TestSynapseLauncher(unittest.TestCase):
         self.synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
         self.synapse3 = Synapse(name="Synapse3", neurons=[neuron2, neuron4], signals=[signal3])
 
-        all_synapse_list = [self.synapse1,
-                            self.synapse2,
-                            self.synapse3]
+        self.all_synapse_list = [self.synapse1,
+                                 self.synapse2,
+                                 self.synapse3]
 
-        self.brain_test = Brain(synapses=all_synapse_list)
+        self.brain_test = Brain(synapses=self.all_synapse_list)
         self.settings_test = Settings(default_synapse="Synapse3")
 
         # clean the LiFO
@@ -97,15 +98,29 @@ class TestSynapseLauncher(unittest.TestCase):
         # test_match_default_synapse
         # -------------------------
         # clean LIFO
-        # LIFOBuffer.lifo_list = list()
-        # with mock.patch("kalliope.core.LIFOBuffer.execute"):
-        #     order_to_match = "not existing sentence"
-        #     should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse3,
-        #                                                        user_order=order_to_match,
-        #                                                        matched_order=None)
-        #
-        #     expected_result = [[should_be_created_matched_synapse]]
-        #     SynapseLauncher.run_matching_synapse_from_order(order_to_match,
-        #                                                     brain=self.brain_test,
-        #                                                     settings=self.settings_test)
-        #     self.assertEqual(expected_result, LIFOBuffer.lifo_list)
+        LIFOBuffer.lifo_list = list()
+        with mock.patch("kalliope.core.LIFOBuffer.execute"):
+            order_to_match = "not existing sentence"
+            should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse3,
+                                                               user_order=order_to_match,
+                                                               matched_order=None)
+
+            expected_result = [[should_be_created_matched_synapse]]
+            SynapseLauncher.run_matching_synapse_from_order(order_to_match,
+                                                            brain=self.brain_test,
+                                                            settings=self.settings_test)
+            self.assertEqual(expected_result, LIFOBuffer.lifo_list)
+
+        # -------------------------
+        # test_no_match_and_no_default_synapse
+        # -------------------------
+        # clean LIFO
+        LIFOBuffer.lifo_list = list()
+        with mock.patch("kalliope.core.LIFOBuffer.execute"):
+            order_to_match = "not existing sentence"
+            new_settings= Settings()
+            expected_result = [[]]
+            SynapseLauncher.run_matching_synapse_from_order(order_to_match,
+                                                            brain=self.brain_test,
+                                                            settings=new_settings)
+            self.assertEqual(expected_result, LIFOBuffer.lifo_list)

+ 2 - 9
kalliope/core/RestAPI/FlaskAPI.py

@@ -182,16 +182,9 @@ class FlaskAPI(threading.Thread):
                                                                            self.brain,
                                                                            self.settings,
                                                                            is_api_call=True)
-            if api_response:
-                # if the list is not empty, we have launched one or more synapses
-                data = jsonify(api_response)
-                return data, 201
-            else:
-                data = {
-                    "error": "The given order doesn't match any synapses"
-                }
-                return jsonify(error=data), 400
 
+            data = jsonify(api_response)
+            return data, 201
         else:
             data = {
                 "error": "order cannot be null"

+ 1 - 2
kalliope/core/SynapseLauncher.py

@@ -74,8 +74,7 @@ class SynapseLauncher(object):
                 if settings.default_synapse:
                     logger.debug("[SynapseLauncher] No matching Synapse-> running default synapse ")
                     # get the default synapse
-                    default_synapse = BrainLoader().get_brain().get_synapse_by_name(settings.default_synapse)
-
+                    default_synapse = brain.get_synapse_by_name(settings.default_synapse)
                     new_matching_synapse = MatchedSynapse(matched_synapse=default_synapse,
                                                           matched_order=None,
                                                           user_order=order_to_process)