瀏覽代碼

Use assertDictEqual

Julien Schueller 8 年之前
父節點
當前提交
11a4f8f41f
共有 1 個文件被更改,包括 14 次插入50 次删除
  1. 14 50
      Tests/test_models.py

+ 14 - 50
Tests/test_models.py

@@ -1,5 +1,5 @@
 import unittest
 import unittest
-
+import ast
 import mock
 import mock
 from kalliope.core.Models.Tts import Tts
 from kalliope.core.Models.Tts import Tts
 
 
@@ -75,12 +75,7 @@ class TestModels(unittest.TestCase):
                 'user_order': 'user order'
                 'user_order': 'user order'
         }
         }
 
 
-        self.assertEqual(expected_result_serialize, api_response.serialize())
-
-        expected_result_str = "{'status': None, 'matched_synapses': [{'matched_order': 'user order', " \
-                              "'neuron_module_list': [], 'synapse_name': 'Synapse1'}], 'user_order': 'user order'}"
-
-        self.assertEqual(expected_result_str, api_response.__str__())
+        self.assertDictEqual(expected_result_serialize, api_response.serialize())
 
 
     def test_Brain(self):
     def test_Brain(self):
         # test get synapse by name
         # test get synapse by name
@@ -113,11 +108,8 @@ class TestModels(unittest.TestCase):
             'name': 'dna1',
             'name': 'dna1',
             'author': 'kalliope'
             'author': 'kalliope'
         }
         }
-        expected_result_str = "{'kalliope_supported_version': '0.4.4', 'tags': 'test', 'type':" \
-                              " 'neuron', 'name': 'dna1', 'author': 'kalliope'}"
 
 
-        self.assertEqual(expected_result_serialize, dna1.serialize())
-        self.assertEqual(expected_result_str, dna1.__str__())
+        self.assertDictEqual(expected_result_serialize, dna1.serialize())
 
 
         self.assertTrue(dna1.__eq__(dna3))
         self.assertTrue(dna1.__eq__(dna3))
         self.assertFalse(dna1.__eq__(dna2))
         self.assertFalse(dna1.__eq__(dna2))
@@ -145,11 +137,8 @@ class TestModels(unittest.TestCase):
                 'month': 12
                 'month': 12
             }
             }
         }
         }
-        expected_result_str = "{'event': {'week': 53, 'second': 0, 'minute': 30, 'hour': 8, " \
-                              "'year': 2017, 'day': 31, 'day_of_week': 2, 'month': 12}}"
 
 
-        self.assertEqual(expected_result_serialize, event1.serialize())
-        self.assertEqual(expected_result_str, event1.__str__())
+        self.assertDictEqual(expected_result_serialize, event1.serialize())
 
 
         self.assertTrue(event1.__eq__(event3))
         self.assertTrue(event1.__eq__(event3))
         self.assertFalse(event1.__eq__(event2))
         self.assertFalse(event1.__eq__(event2))
@@ -165,10 +154,8 @@ class TestModels(unittest.TestCase):
             'neuron_module_list': [],
             'neuron_module_list': [],
             'synapse_name': 'Synapse1'
             'synapse_name': 'Synapse1'
         }
         }
-        expected_result_str = "{'matched_order': 'user order', 'neuron_module_list': [], 'synapse_name': 'Synapse1'}"
 
 
-        self.assertEqual(expected_result_serialize, matched_synapse1.serialize())
-        self.assertEqual(expected_result_str, matched_synapse1.__str__())
+        self.assertDictEqual(expected_result_serialize, matched_synapse1.serialize())
 
 
         self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
         self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
         self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
         self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
@@ -188,10 +175,8 @@ class TestModels(unittest.TestCase):
         neuron3 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
         neuron3 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
 
 
         expected_result_serialize = {'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}
         expected_result_serialize = {'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}
-        expected_result_str = "{'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}"
 
 
-        self.assertEqual(expected_result_serialize, neuron1.serialize())
-        self.assertEqual(expected_result_str, neuron1.__str__())
+        self.assertDictEqual(expected_result_serialize, neuron1.serialize())
 
 
         self.assertTrue(neuron1.__eq__(neuron3))
         self.assertTrue(neuron1.__eq__(neuron3))
         self.assertFalse(neuron1.__eq__(neuron2))
         self.assertFalse(neuron1.__eq__(neuron2))
@@ -207,9 +192,9 @@ class TestModels(unittest.TestCase):
         neuron.name = neuron_name
         neuron.name = neuron_name
         neuron.parameters = neuron_parameters
         neuron.parameters = neuron_parameters
 
 
-        expected_result = "{'name': 'test', 'parameters': {'password': '*****', 'parameter': 'test'}}"
+        expected_result_str = "{'name': 'test', 'parameters': {'password': '*****', 'parameter': 'test'}}"
 
 
-        self.assertEqual(neuron.__str__(), expected_result)
+        self.assertDictEqual(ast.literal_eval(neuron.__str__()), ast.literal_eval(expected_result_str))
 
 
         neuron_name = "test"
         neuron_name = "test"
         neuron_parameters = {
         neuron_parameters = {
@@ -221,9 +206,9 @@ class TestModels(unittest.TestCase):
         neuron.name = neuron_name
         neuron.name = neuron_name
         neuron.parameters = neuron_parameters
         neuron.parameters = neuron_parameters
 
 
-        expected_result = "{'name': 'test', 'parameters': {'parameter': 'test', 'password_parameter': '*****'}}"
+        expected_result_str = "{'name': 'test', 'parameters': {'parameter': 'test', 'password_parameter': '*****'}}"
 
 
-        self.assertEqual(neuron.__str__(), expected_result)
+        self.assertDictEqual(ast.literal_eval(neuron.__str__()), ast.literal_eval(expected_result_str))
 
 
     def test_Order(self):
     def test_Order(self):
         order1 = Order(sentence="this is an order")
         order1 = Order(sentence="this is an order")
@@ -255,11 +240,8 @@ class TestModels(unittest.TestCase):
             'stt_folder': '/path/stt',
             'stt_folder': '/path/stt',
             'trigger_folder': '/path/trigger'
             'trigger_folder': '/path/trigger'
         }
         }
-        expected_result_str = "{'tts_folder': '/path/tts', 'neuron_folder': '/path/neuron', " \
-                              "'stt_folder': '/path/stt', 'trigger_folder': '/path/trigger'}"
 
 
-        self.assertEqual(expected_result_serialize, resource1.serialize())
-        self.assertEqual(expected_result_str, resource1.__str__())
+        self.assertDictEqual(expected_result_serialize, resource1.serialize())
 
 
         self.assertTrue(resource1.__eq__(resource3))
         self.assertTrue(resource1.__eq__(resource3))
         self.assertFalse(resource1.__eq__(resource2))
         self.assertFalse(resource1.__eq__(resource2))
@@ -283,11 +265,8 @@ class TestModels(unittest.TestCase):
             'password': 'password',
             'password': 'password',
             'login': 'admin'
             'login': 'admin'
         }
         }
-        expected_result_str = "{'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': '*', " \
-                              "'password': 'password', 'login': 'admin'}"
 
 
-        self.assertEqual(expected_result_serialize, rest_api1.serialize())
-        self.assertEqual(expected_result_str, rest_api1.__str__())
+        self.assertDictEqual(expected_result_serialize, rest_api1.serialize())
 
 
         self.assertTrue(rest_api1.__eq__(rest_api3))
         self.assertTrue(rest_api1.__eq__(rest_api3))
         self.assertFalse(rest_api1.__eq__(rest_api2))
         self.assertFalse(rest_api1.__eq__(rest_api2))
@@ -377,17 +356,7 @@ class TestModels(unittest.TestCase):
                 'triggers': ['snowboy']
                 'triggers': ['snowboy']
             }
             }
 
 
-            expected_result_str = "{'default_synapse': 'default_synapse', 'default_tts_name': 'pico2wav', 'rest_api': " \
-                                  "{'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': " \
-                                  "'*', 'password': 'password', 'login': 'admin'}, 'play_on_ready_notification': " \
-                                  "False, 'default_stt_name': 'google', 'kalliope_version': '0.4.4b', " \
-                                  "'random_wake_up_sounds': None, 'on_ready_answers': None, 'default_trigger_name': " \
-                                  "'swoyboy', 'cache_path': '/tmp/kalliope', 'stts': ['stts'], 'machine': 'pumpkins', " \
-                                  "'random_wake_up_answers': ['yes'], 'on_ready_sounds': None, 'ttss': ['ttts'], " \
-                                  "'variables': {'key1': 'val1'}, 'resources': None, 'triggers': ['snowboy']}"
-
-            self.assertEqual(expected_result_serialize, setting1.serialize())
-            self.assertEqual(expected_result_str, setting1.__str__())
+            self.assertDictEqual(expected_result_serialize, setting1.serialize())
 
 
             self.assertTrue(setting1.__eq__(setting3))
             self.assertTrue(setting1.__eq__(setting3))
             self.assertFalse(setting1.__eq__(setting2))
             self.assertFalse(setting1.__eq__(setting2))
@@ -443,12 +412,7 @@ class TestModels(unittest.TestCase):
             'name': 'Synapse1'
             'name': 'Synapse1'
         }
         }
 
 
-        expected_result_str = "{'signals': [{'order': 'this is the sentence'}], 'neurons': [{'name': 'neurone1', " \
-                              "'parameters': {'var1': 'val1'}}, {'name': 'neurone2', 'parameters': {'var2': " \
-                              "'val2'}}], 'name': 'Synapse1'}"
-
-        self.assertEqual(expected_result_serialize, synapse1.serialize())
-        self.assertEqual(expected_result_str, synapse1.__str__())
+        self.assertDictEqual(expected_result_serialize, synapse1.serialize())
 
 
         self.assertTrue(synapse1.__eq__(synapse3))
         self.assertTrue(synapse1.__eq__(synapse3))
         self.assertFalse(synapse1.__eq__(synapse2))
         self.assertFalse(synapse1.__eq__(synapse2))