test_models.py 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442
  1. import unittest
  2. import ast
  3. import mock
  4. from kalliope.core.Models.Tts import Tts
  5. from kalliope.core.Models.Trigger import Trigger
  6. from kalliope.core.Models.Stt import Stt
  7. from kalliope.core.Models.RestAPI import RestAPI
  8. from kalliope.core.Models.Dna import Dna
  9. from kalliope.core import LIFOBuffer
  10. from kalliope.core.Models.Settings import Settings
  11. from kalliope.core.Models import Neuron, Order, Synapse, Brain, Event, Resources
  12. from kalliope.core.Models.APIResponse import APIResponse
  13. from kalliope.core.Models.MatchedSynapse import MatchedSynapse
  14. class TestModels(unittest.TestCase):
  15. def setUp(self):
  16. # Init
  17. neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
  18. neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
  19. neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
  20. neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
  21. signal1 = Order(sentence="this is the sentence")
  22. signal2 = Order(sentence="this is the second sentence")
  23. signal3 = Order(sentence="that is part of the third sentence")
  24. self.synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
  25. self.synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
  26. self.synapse3 = Synapse(name="Synapse3", neurons=[neuron2, neuron4], signals=[signal3])
  27. self.all_synapse_list1 = [self.synapse1,
  28. self.synapse2,
  29. self.synapse3]
  30. self.all_synapse_list2 = [self.synapse2,
  31. self.synapse3]
  32. self.brain_test1 = Brain(synapses=self.all_synapse_list1)
  33. self.brain_test2 = Brain(synapses=self.all_synapse_list2)
  34. # this brain is the same as the first one
  35. self.brain_test3 = Brain(synapses=self.all_synapse_list1)
  36. self.settings_test = Settings(default_synapse="Synapse3")
  37. # clean the LiFO
  38. LIFOBuffer.lifo_list = list()
  39. def test_APIResponse(self):
  40. user_order = "user order"
  41. self.matched_synapse = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
  42. api_response = APIResponse()
  43. api_response.user_order = user_order
  44. api_response.list_processed_matched_synapse = [self.matched_synapse]
  45. expected_result_serialize = {
  46. 'status': None,
  47. 'matched_synapses':
  48. [
  49. {
  50. 'matched_order': 'user order',
  51. 'neuron_module_list': [],
  52. 'synapse_name': 'Synapse1'
  53. }
  54. ],
  55. 'user_order': 'user order'
  56. }
  57. self.assertDictEqual(expected_result_serialize, api_response.serialize())
  58. def test_Brain(self):
  59. # test get synapse by name
  60. expect_result = self.synapse1
  61. synapse_name = "Synapse1"
  62. self.assertEqual(self.brain_test1.get_synapse_by_name(synapse_name), expect_result)
  63. # test equals
  64. self.assertTrue(self.brain_test1.__eq__(self.brain_test3))
  65. # test not equals
  66. self.assertFalse(self.brain_test1.__eq__(self.brain_test2))
  67. def test_Dna(self):
  68. # create DNA object
  69. dna1 = Dna(name="dna1", module_type="neuron", author="kalliope",
  70. kalliope_supported_version="0.4.4", tags="test")
  71. dna2 = Dna(name="dna2", module_type="neuron", author="community",
  72. kalliope_supported_version="0.4.2", tags="other")
  73. # this dna is exactly the same as the first one
  74. dna3 = Dna(name="dna1", module_type="neuron", author="kalliope",
  75. kalliope_supported_version="0.4.4", tags="test")
  76. expected_result_serialize = {
  77. 'kalliope_supported_version': '0.4.4',
  78. 'tags': 'test',
  79. 'type': 'neuron',
  80. 'name': 'dna1',
  81. 'author': 'kalliope'
  82. }
  83. self.assertDictEqual(expected_result_serialize, dna1.serialize())
  84. self.assertTrue(dna1.__eq__(dna3))
  85. self.assertFalse(dna1.__eq__(dna2))
  86. def test_Event(self):
  87. event1 = Event(year=2017, month=12, day=31, week=53, day_of_week=2,
  88. hour=8, minute=30, second=0)
  89. event2 = Event(year=2018, month=11, day=30, week=25, day_of_week=4,
  90. hour=9, minute=40, second=0)
  91. # same as the event1
  92. event3 = Event(year=2017, month=12, day=31, week=53, day_of_week=2,
  93. hour=8, minute=30, second=0)
  94. expected_result_serialize = {
  95. 'event': {
  96. 'week': 53,
  97. 'second': 0,
  98. 'minute': 30,
  99. 'hour': 8,
  100. 'year': 2017,
  101. 'day': 31,
  102. 'day_of_week': 2,
  103. 'month': 12
  104. }
  105. }
  106. self.assertDictEqual(expected_result_serialize, event1.serialize())
  107. self.assertTrue(event1.__eq__(event3))
  108. self.assertFalse(event1.__eq__(event2))
  109. def test_MatchedSynapse(self):
  110. user_order = "user order"
  111. matched_synapse1 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
  112. matched_synapse2 = MatchedSynapse(matched_synapse=self.synapse2, matched_order=user_order)
  113. matched_synapse3 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
  114. expected_result_serialize = {
  115. 'matched_order': 'user order',
  116. 'neuron_module_list': [],
  117. 'synapse_name': 'Synapse1'
  118. }
  119. self.assertDictEqual(expected_result_serialize, matched_synapse1.serialize())
  120. self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
  121. self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
  122. # test neuron parameter loader is called
  123. with mock.patch("kalliope.core.NeuronParameterLoader.get_parameters") as mock_get_parameters:
  124. MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order, user_order=user_order)
  125. mock_get_parameters.assert_called_once_with(synapse_order=user_order,
  126. user_order=user_order)
  127. mock_get_parameters.reset_mock()
  128. def test_Neuron(self):
  129. neuron1 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
  130. neuron2 = Neuron(name="test", parameters={"key3": "val3", "key4": "val4"})
  131. neuron3 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
  132. expected_result_serialize = {'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}
  133. self.assertDictEqual(expected_result_serialize, neuron1.serialize())
  134. self.assertTrue(neuron1.__eq__(neuron3))
  135. self.assertFalse(neuron1.__eq__(neuron2))
  136. # test password
  137. neuron_name = "test"
  138. neuron_parameters = {
  139. "password": "my secret",
  140. "parameter": "test"
  141. }
  142. neuron = Neuron()
  143. neuron.name = neuron_name
  144. neuron.parameters = neuron_parameters
  145. expected_result_str = "{'name': 'test', 'parameters': {'password': '*****', 'parameter': 'test'}}"
  146. self.assertDictEqual(ast.literal_eval(neuron.__str__()), ast.literal_eval(expected_result_str))
  147. neuron_name = "test"
  148. neuron_parameters = {
  149. "password_parameter": "my secret",
  150. "parameter": "test"
  151. }
  152. neuron = Neuron()
  153. neuron.name = neuron_name
  154. neuron.parameters = neuron_parameters
  155. expected_result_str = "{'name': 'test', 'parameters': {'parameter': 'test', 'password_parameter': '*****'}}"
  156. self.assertDictEqual(ast.literal_eval(neuron.__str__()), ast.literal_eval(expected_result_str))
  157. def test_Order(self):
  158. order1 = Order(sentence="this is an order")
  159. order2 = Order(sentence="this is an other order")
  160. order3 = Order(sentence="this is an order")
  161. expected_result_serialize = {'order': 'this is an order'}
  162. expected_result_str = "{'order': 'this is an order'}"
  163. self.assertEqual(expected_result_serialize, order1.serialize())
  164. self.assertEqual(expected_result_str, order1.__str__())
  165. self.assertTrue(order1.__eq__(order3))
  166. self.assertFalse(order1.__eq__(order2))
  167. def test_Resources(self):
  168. resource1 = Resources(neuron_folder="/path/neuron", stt_folder="/path/stt",
  169. tts_folder="/path/tts", trigger_folder="/path/trigger")
  170. resource2 = Resources(neuron_folder="/other_path/neuron", stt_folder="/other_path/stt",
  171. tts_folder="/other_path/tts", trigger_folder="/other_path/trigger")
  172. resource3 = Resources(neuron_folder="/path/neuron", stt_folder="/path/stt",
  173. tts_folder="/path/tts", trigger_folder="/path/trigger")
  174. expected_result_serialize = {
  175. 'tts_folder': '/path/tts',
  176. 'neuron_folder': '/path/neuron',
  177. 'stt_folder': '/path/stt',
  178. 'trigger_folder': '/path/trigger'
  179. }
  180. self.assertDictEqual(expected_result_serialize, resource1.serialize())
  181. self.assertTrue(resource1.__eq__(resource3))
  182. self.assertFalse(resource1.__eq__(resource2))
  183. def test_RestAPI(self):
  184. rest_api1 = RestAPI(password_protected=True, login="admin", password="password", active=True,
  185. port=5000, allowed_cors_origin="*")
  186. rest_api2 = RestAPI(password_protected=False, active=False,
  187. port=5000, allowed_cors_origin=None)
  188. rest_api3 = RestAPI(password_protected=True, login="admin", password="password", active=True,
  189. port=5000, allowed_cors_origin="*")
  190. expected_result_serialize = {
  191. 'password_protected': True,
  192. 'port': 5000,
  193. 'active': True,
  194. 'allowed_cors_origin': '*',
  195. 'password': 'password',
  196. 'login': 'admin'
  197. }
  198. self.assertDictEqual(expected_result_serialize, rest_api1.serialize())
  199. self.assertTrue(rest_api1.__eq__(rest_api3))
  200. self.assertFalse(rest_api1.__eq__(rest_api2))
  201. def test_Settings(self):
  202. with mock.patch('platform.machine', return_value='pumpkins'):
  203. rest_api1 = RestAPI(password_protected=True, login="admin", password="password", active=True,
  204. port=5000, allowed_cors_origin="*")
  205. setting1 = Settings(default_tts_name="pico2wav",
  206. default_stt_name="google",
  207. default_trigger_name="swoyboy",
  208. ttss=["ttts"],
  209. stts=["stts"],
  210. random_wake_up_answers=["yes"],
  211. random_wake_up_sounds=None,
  212. play_on_ready_notification=False,
  213. on_ready_answers=None,
  214. on_ready_sounds=None,
  215. triggers=["snowboy"],
  216. rest_api=rest_api1,
  217. cache_path="/tmp/kalliope",
  218. default_synapse="default_synapse",
  219. resources=None,
  220. variables={"key1": "val1"})
  221. setting2 = Settings(default_tts_name="accapela",
  222. default_stt_name="bing",
  223. default_trigger_name="swoyboy",
  224. ttss=["ttts"],
  225. stts=["stts"],
  226. random_wake_up_answers=["no"],
  227. random_wake_up_sounds=None,
  228. play_on_ready_notification=False,
  229. on_ready_answers=None,
  230. on_ready_sounds=None,
  231. triggers=["snowboy"],
  232. rest_api=rest_api1,
  233. cache_path="/tmp/kalliope_tmp",
  234. default_synapse="my_default_synapse",
  235. resources=None,
  236. variables={"key1": "val1"})
  237. setting3 = Settings(default_tts_name="pico2wav",
  238. default_stt_name="google",
  239. default_trigger_name="swoyboy",
  240. ttss=["ttts"],
  241. stts=["stts"],
  242. random_wake_up_answers=["yes"],
  243. random_wake_up_sounds=None,
  244. play_on_ready_notification=False,
  245. on_ready_answers=None,
  246. on_ready_sounds=None,
  247. triggers=["snowboy"],
  248. rest_api=rest_api1,
  249. cache_path="/tmp/kalliope",
  250. default_synapse="default_synapse",
  251. resources=None,
  252. variables={"key1": "val1"})
  253. expected_result_serialize = {
  254. 'default_synapse': 'default_synapse',
  255. 'default_tts_name': 'pico2wav',
  256. 'rest_api':
  257. {
  258. 'password_protected': True,
  259. 'port': 5000,
  260. 'active': True,
  261. 'allowed_cors_origin': '*',
  262. 'password': 'password',
  263. 'login': 'admin'
  264. },
  265. 'play_on_ready_notification': False,
  266. 'default_stt_name': 'google',
  267. 'kalliope_version': '0.4.4b',
  268. 'random_wake_up_sounds': None,
  269. 'on_ready_answers': None,
  270. 'default_trigger_name': 'swoyboy',
  271. 'cache_path': '/tmp/kalliope',
  272. 'stts': ['stts'],
  273. 'machine': 'pumpkins',
  274. 'random_wake_up_answers': ['yes'],
  275. 'on_ready_sounds': None,
  276. 'ttss': ['ttts'],
  277. 'variables': {'key1': 'val1'},
  278. 'resources': None,
  279. 'triggers': ['snowboy']
  280. }
  281. self.assertDictEqual(expected_result_serialize, setting1.serialize())
  282. self.assertTrue(setting1.__eq__(setting3))
  283. self.assertFalse(setting1.__eq__(setting2))
  284. def test_Stt(self):
  285. stt1 = Stt(name="stt1", parameters={"key1": "val1"})
  286. stt2 = Stt(name="stt2", parameters={"key2": "val2"})
  287. stt3 = Stt(name="stt1", parameters={"key1": "val1"})
  288. expected_result_serialize = {'name': 'stt1', 'parameters': {'key1': 'val1'}}
  289. self.assertDictEqual(expected_result_serialize, stt1.serialize())
  290. self.assertTrue(stt1.__eq__(stt3))
  291. self.assertFalse(stt1.__eq__(stt2))
  292. def test_Synapse(self):
  293. neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
  294. neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
  295. neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
  296. neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
  297. signal1 = Order(sentence="this is the sentence")
  298. signal2 = Order(sentence="this is the second sentence")
  299. synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
  300. synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
  301. synapse3 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
  302. expected_result_serialize = {
  303. 'signals': [
  304. {
  305. 'order': 'this is the sentence'
  306. }
  307. ],
  308. 'neurons': [
  309. {
  310. 'name': 'neurone1',
  311. 'parameters': {
  312. 'var1': 'val1'
  313. }
  314. },
  315. {
  316. 'name': 'neurone2',
  317. 'parameters':
  318. {
  319. 'var2': 'val2'
  320. }
  321. }
  322. ],
  323. 'name': 'Synapse1'
  324. }
  325. self.assertDictEqual(expected_result_serialize, synapse1.serialize())
  326. self.assertTrue(synapse1.__eq__(synapse3))
  327. self.assertFalse(synapse1.__eq__(synapse2))
  328. def test_Trigger(self):
  329. trigger1 = Trigger(name="trigger1", parameters={"key1": "val1"})
  330. trigger2 = Trigger(name="trigger2", parameters={"key2": "val2"})
  331. trigger3 = Trigger(name="trigger1", parameters={"key1": "val1"})
  332. expected_result_serialize = {'name': 'trigger1', 'parameters': {'key1': 'val1'}}
  333. self.assertDictEqual(expected_result_serialize, trigger1.serialize())
  334. self.assertTrue(trigger1.__eq__(trigger3))
  335. self.assertFalse(trigger1.__eq__(trigger2))
  336. def test_Tts(self):
  337. tts1 = Tts(name="tts1", parameters={"key1": "val1"})
  338. tts2 = Tts(name="tts2", parameters={"key2": "val2"})
  339. tts3 = Tts(name="tts1", parameters={"key1": "val1"})
  340. expected_result_serialize = {'name': 'tts1', 'parameters': {'key1': 'val1'}}
  341. self.assertDictEqual(expected_result_serialize, tts1.serialize())
  342. self.assertTrue(tts1.__eq__(tts3))
  343. self.assertFalse(tts1.__eq__(tts2))