1
|
|
|
"""kytos.core.napps tests.""" |
2
|
|
|
import asyncio |
3
|
|
|
import unittest |
4
|
|
|
from unittest.mock import MagicMock, patch |
5
|
|
|
|
6
|
|
|
from kytos.core import Controller |
7
|
|
|
from kytos.core.config import KytosConfig |
8
|
|
|
from kytos.core.napps import NAppsManager |
9
|
|
|
|
10
|
|
|
|
11
|
|
|
# pylint: disable=protected-access, too-many-public-methods |
12
|
|
|
class TestNAppsManager(unittest.TestCase): |
13
|
|
|
"""NAppsManager tests.""" |
14
|
|
|
|
15
|
|
|
def setUp(self): |
16
|
|
|
"""Execute steps before each tests.""" |
17
|
|
|
self.loop = asyncio.new_event_loop() |
18
|
|
|
asyncio.set_event_loop(None) |
19
|
|
|
|
20
|
|
|
self.options = KytosConfig().options['daemon'] |
21
|
|
|
self.controller = Controller(self.options, loop=self.loop) |
22
|
|
|
self.controller.log = MagicMock() |
23
|
|
|
self.controller.load_napp = MagicMock() |
24
|
|
|
self.controller.unload_napp = MagicMock() |
25
|
|
|
|
26
|
|
|
self.napps_manager = NAppsManager(self.controller) |
27
|
|
|
|
28
|
|
|
@staticmethod |
29
|
|
|
def get_path(files): |
30
|
|
|
"""Return a Path mock.""" |
31
|
|
|
path = MagicMock() |
32
|
|
|
path.exists.return_value = True |
33
|
|
|
path.glob.return_value = files |
34
|
|
|
return path |
35
|
|
|
|
36
|
|
|
@staticmethod |
37
|
|
|
def get_napp_mock(username='kytos', name='napp'): |
38
|
|
|
"""Return a NApp mock.""" |
39
|
|
|
napp = MagicMock() |
40
|
|
|
napp.username = username |
41
|
|
|
napp.name = name |
42
|
|
|
return napp |
43
|
|
|
|
44
|
|
|
@staticmethod |
45
|
|
|
def get_new_napps_manager(): |
46
|
|
|
"""Return a NewNappsManager mock.""" |
47
|
|
|
napp = MagicMock() |
48
|
|
|
napp.napp_dependencies = ['file://any/kytos/napp2:1.0'] |
49
|
|
|
|
50
|
|
|
napp_2 = MagicMock() |
51
|
|
|
napp_2.napp_dependencies = [] |
52
|
|
|
|
53
|
|
|
new_napp_manager = MagicMock() |
54
|
|
|
new_napp_manager.napps = {'kytos/napp': napp, 'kytos/napp2': napp_2} |
55
|
|
|
return new_napp_manager |
56
|
|
|
|
57
|
|
|
@patch('shutil.rmtree') |
58
|
|
|
@patch('shutil.move') |
59
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
60
|
|
|
@patch('kytos.core.napps.NApp.create_from_uri') |
61
|
|
|
@patch('kytos.core.napps.NAppsManager.get_all_napps') |
62
|
|
|
@patch('kytos.core.napps.NAppsManager._find_napp') |
63
|
|
|
def test_install(self, *args): |
64
|
|
|
"""Test install method.""" |
65
|
|
|
(_, _, mock_create_from_uri, mock_create_from_json, _, _) = args |
66
|
|
|
napp = MagicMock() |
67
|
|
|
mock_create_from_uri.return_value = napp |
68
|
|
|
mock_create_from_json.return_value = napp |
69
|
|
|
|
70
|
|
|
uri = 'file://any/kytos/napp:1.0' |
71
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
72
|
|
|
installed = self.napps_manager.install(uri, False) |
73
|
|
|
|
74
|
|
|
self.assertTrue(installed) |
75
|
|
|
|
76
|
|
|
@patch('shutil.rmtree') |
77
|
|
|
@patch('shutil.move') |
78
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
79
|
|
|
@patch('kytos.core.napps.NApp.create_from_uri') |
80
|
|
|
@patch('kytos.core.napps.NAppsManager.enable') |
81
|
|
|
@patch('kytos.core.napps.NAppsManager.get_all_napps') |
82
|
|
|
@patch('kytos.core.napps.NAppsManager._find_napp') |
83
|
|
|
def test_install_and_enable(self, *args): |
84
|
|
|
"""Test install method enabling the napp.""" |
85
|
|
|
(_, _, mock_enable, mock_create_from_uri, mock_create_from_json, _, |
86
|
|
|
_) = args |
87
|
|
|
napp = MagicMock() |
88
|
|
|
napp.username = 'kytos' |
89
|
|
|
napp.name = 'napp' |
90
|
|
|
mock_create_from_uri.return_value = napp |
91
|
|
|
mock_create_from_json.return_value = napp |
92
|
|
|
|
93
|
|
|
uri = 'file://any/kytos/napp:1.0' |
94
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
95
|
|
|
installed = self.napps_manager.install(uri, True) |
96
|
|
|
|
97
|
|
|
self.assertTrue(installed) |
98
|
|
|
mock_enable.assert_called_with('kytos', 'napp') |
99
|
|
|
|
100
|
|
|
@patch('kytos.core.napps.NApp.create_from_uri') |
101
|
|
|
@patch('kytos.core.napps.NAppsManager.get_all_napps') |
102
|
|
|
def test_install__installed(self, *args): |
103
|
|
|
"""Test install method when napp is already installed.""" |
104
|
|
|
(mock_get_all_napps, mock_create_from_uri) = args |
105
|
|
|
napp = MagicMock() |
106
|
|
|
mock_create_from_uri.return_value = napp |
107
|
|
|
mock_get_all_napps.return_value = [napp] |
108
|
|
|
|
109
|
|
|
uri = 'file://any/kytos/napp:1.0' |
110
|
|
|
installed = self.napps_manager.install(uri, False) |
111
|
|
|
|
112
|
|
|
self.assertFalse(installed) |
113
|
|
|
|
114
|
|
|
@patch('kytos.core.napps.NAppsManager.is_installed', return_value=True) |
115
|
|
|
@patch('kytos.core.napps.manager.NewNAppManager') |
116
|
|
|
def test_uninstall(self, *args): |
117
|
|
|
"""Test uninstall method.""" |
118
|
|
|
(mock_new_napp_manager, _) = args |
119
|
|
|
mock_new_napp_manager.return_value = self.get_new_napps_manager() |
120
|
|
|
|
121
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
122
|
|
|
uninstalled = self.napps_manager.uninstall('kytos', 'napp') |
123
|
|
|
|
124
|
|
|
self.assertTrue(uninstalled) |
125
|
|
|
|
126
|
|
|
@patch('kytos.core.napps.NAppsManager.is_installed', return_value=False) |
127
|
|
|
@patch('kytos.core.napps.manager.NewNAppManager') |
128
|
|
|
def test_uninstall__not_installed(self, *args): |
129
|
|
|
"""Test uninstall method when napp is not installed.""" |
130
|
|
|
(mock_new_napp_manager, _) = args |
131
|
|
|
mock_new_napp_manager.return_value = self.get_new_napps_manager() |
132
|
|
|
|
133
|
|
|
uninstalled = self.napps_manager.uninstall('kytos', 'napp') |
134
|
|
|
|
135
|
|
|
self.assertTrue(uninstalled) |
136
|
|
|
|
137
|
|
|
@patch('kytos.core.napps.NAppsManager.is_enabled', return_value=True) |
138
|
|
|
def test_uninstall__enabled(self, _): |
139
|
|
|
"""Test uninstall method when napp is enabled.""" |
140
|
|
|
uninstalled = self.napps_manager.uninstall('kytos', 'napp') |
141
|
|
|
|
142
|
|
|
self.assertFalse(uninstalled) |
143
|
|
|
|
144
|
|
|
@patch('kytos.core.napps.manager.NewNAppManager') |
145
|
|
|
def test_enable(self, mock_new_napp_manager): |
146
|
|
|
"""Test enable method.""" |
147
|
|
|
mock_new_napp_manager.return_value = self.get_new_napps_manager() |
148
|
|
|
|
149
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
150
|
|
|
self.napps_manager._enabled_path = self.get_path(['json']) |
151
|
|
|
|
152
|
|
|
(self.napps_manager._installed_path / 'kytos/napp').is_dir. \ |
153
|
|
|
return_value = True |
154
|
|
|
(self.napps_manager._enabled_path / 'kytos/napp').exists. \ |
155
|
|
|
return_value = False |
156
|
|
|
|
157
|
|
|
enabled = self.napps_manager.enable('kytos', 'napp') |
158
|
|
|
|
159
|
|
|
self.assertTrue(enabled) |
160
|
|
|
|
161
|
|
|
@patch('kytos.core.napps.manager.NewNAppManager') |
162
|
|
|
def test_disable(self, mock_new_napp_manager): |
163
|
|
|
"""Test disable method.""" |
164
|
|
|
mock_new_napp_manager.return_value = self.get_new_napps_manager() |
165
|
|
|
|
166
|
|
|
self.napps_manager._enabled_path = self.get_path(['json']) |
167
|
|
|
|
168
|
|
|
disabled = self.napps_manager.disable('kytos', 'napp') |
169
|
|
|
|
170
|
|
|
self.assertTrue(disabled) |
171
|
|
|
|
172
|
|
|
@patch('kytos.core.napps.NAppsManager.enable') |
173
|
|
|
@patch('kytos.core.napps.NAppsManager.get_disabled_napps') |
174
|
|
|
def test_enable_all(self, *args): |
175
|
|
|
"""Test enable_all method.""" |
176
|
|
|
(mock_get_disabled_napps, mock_enable) = args |
177
|
|
|
napp = self.get_napp_mock() |
178
|
|
|
mock_get_disabled_napps.return_value = [napp] |
179
|
|
|
|
180
|
|
|
self.napps_manager.enable_all() |
181
|
|
|
|
182
|
|
|
mock_enable.assert_called_once() |
183
|
|
|
|
184
|
|
|
@patch('kytos.core.napps.NAppsManager.disable') |
185
|
|
|
@patch('kytos.core.napps.NAppsManager.get_enabled_napps') |
186
|
|
|
def test_disable_all(self, *args): |
187
|
|
|
"""Test disable_all method.""" |
188
|
|
|
(mock_get_enabled_napps, mock_disable) = args |
189
|
|
|
napp = self.get_napp_mock() |
190
|
|
|
mock_get_enabled_napps.return_value = [napp] |
191
|
|
|
|
192
|
|
|
self.napps_manager.disable_all() |
193
|
|
|
|
194
|
|
|
mock_disable.assert_called_once() |
195
|
|
|
|
196
|
|
|
@patch('kytos.core.napps.NApp.create_from_uri') |
197
|
|
|
@patch('kytos.core.napps.NAppsManager.get_enabled_napps') |
198
|
|
|
def test_is_enabled(self, *args): |
199
|
|
|
"""Test is_enabled method.""" |
200
|
|
|
(mock_get_enabled_napps, mock_create_from_uri) = args |
201
|
|
|
napp = MagicMock() |
202
|
|
|
mock_create_from_uri.return_value = napp |
203
|
|
|
mock_get_enabled_napps.return_value = [napp] |
204
|
|
|
|
205
|
|
|
is_enabled = self.napps_manager.is_enabled('kytos', 'napp') |
206
|
|
|
|
207
|
|
|
mock_create_from_uri.assert_called_with('kytos/napp') |
208
|
|
|
self.assertTrue(is_enabled) |
209
|
|
|
|
210
|
|
|
@patch('kytos.core.napps.NApp.create_from_uri') |
211
|
|
|
@patch('kytos.core.napps.NAppsManager.get_installed_napps') |
212
|
|
|
def test_is_installed(self, *args): |
213
|
|
|
"""Test is_installed method.""" |
214
|
|
|
(mock_get_installed_napps, mock_create_from_uri) = args |
215
|
|
|
napp = MagicMock() |
216
|
|
|
mock_create_from_uri.return_value = napp |
217
|
|
|
mock_get_installed_napps.return_value = [napp] |
218
|
|
|
|
219
|
|
|
is_installed = self.napps_manager.is_installed('kytos', 'napp') |
220
|
|
|
|
221
|
|
|
mock_create_from_uri.assert_called_with('kytos/napp') |
222
|
|
|
self.assertTrue(is_installed) |
223
|
|
|
|
224
|
|
|
def test_get_napp_fullname_from_uri(self): |
225
|
|
|
"""Test get_napp_fullname_from_uri method.""" |
226
|
|
|
uri = 'file://any/kytos/napp:1.0' |
227
|
|
|
username, name = self.napps_manager.get_napp_fullname_from_uri(uri) |
228
|
|
|
|
229
|
|
|
self.assertEqual(username, 'kytos') |
230
|
|
|
self.assertEqual(name, 'napp') |
231
|
|
|
|
232
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
233
|
|
|
def test_get_all_napps(self, mock_create_from_json): |
234
|
|
|
"""Test get_all_napps method.""" |
235
|
|
|
napp = MagicMock() |
236
|
|
|
mock_create_from_json.return_value = napp |
237
|
|
|
|
238
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
239
|
|
|
napps = self.napps_manager.get_all_napps() |
240
|
|
|
|
241
|
|
|
self.assertEqual(napps, [napp]) |
242
|
|
|
|
243
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
244
|
|
|
def test_get_enabled_napps(self, mock_create_from_json): |
245
|
|
|
"""Test get_enabled_napps method.""" |
246
|
|
|
napp = MagicMock() |
247
|
|
|
napp.enabled = False |
248
|
|
|
mock_create_from_json.return_value = napp |
249
|
|
|
|
250
|
|
|
self.napps_manager._enabled_path = self.get_path(['json']) |
251
|
|
|
napps = self.napps_manager.get_enabled_napps() |
252
|
|
|
|
253
|
|
|
self.assertEqual(napps, [napp]) |
254
|
|
|
self.assertTrue(napp.enabled) |
255
|
|
|
|
256
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
257
|
|
|
def test_get_disabled_napps(self, mock_create_from_json): |
258
|
|
|
"""Test get_disabled_napps method.""" |
259
|
|
|
napp_1 = MagicMock() |
260
|
|
|
napp_2 = MagicMock() |
261
|
|
|
mock_create_from_json.side_effect = [napp_1, napp_2, napp_1] |
262
|
|
|
|
263
|
|
|
self.napps_manager._installed_path = self.get_path(['json1', 'json2']) |
264
|
|
|
self.napps_manager._enabled_path = self.get_path(['json1']) |
265
|
|
|
napps = self.napps_manager.get_disabled_napps() |
266
|
|
|
|
267
|
|
|
self.assertEqual(napps, [napp_2]) |
268
|
|
|
|
269
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
270
|
|
|
def test_get_installed_napps(self, mock_create_from_json): |
271
|
|
|
"""Test get_installed_napps method.""" |
272
|
|
|
napp = MagicMock() |
273
|
|
|
mock_create_from_json.return_value = napp |
274
|
|
|
|
275
|
|
|
self.napps_manager._installed_path = self.get_path(['json']) |
276
|
|
|
napps = self.napps_manager.get_installed_napps() |
277
|
|
|
|
278
|
|
|
self.assertEqual(napps, [napp]) |
279
|
|
|
|
280
|
|
|
@patch('pathlib.Path.open') |
281
|
|
|
def test_get_napp_metadata__success(self, mock_open): |
282
|
|
|
"""Test get_napp_metadata method to success case.""" |
283
|
|
|
data_file = MagicMock() |
284
|
|
|
data_file.read.return_value = '{"username": "kytos", \ |
285
|
|
|
"name": "napp", \ |
286
|
|
|
"version": "1.0"}' |
287
|
|
|
mock_open.return_value.__enter__.return_value = data_file |
288
|
|
|
|
289
|
|
|
meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'version') |
290
|
|
|
|
291
|
|
|
self.assertEqual(meta, '1.0') |
292
|
|
|
|
293
|
|
|
def test_get_napp_metadata__error(self): |
294
|
|
|
"""Test get_napp_metadata method to error case.""" |
295
|
|
|
meta = self.napps_manager.get_napp_metadata('kytos', 'napp', 'key') |
296
|
|
|
|
297
|
|
|
self.assertEqual(meta, '') |
298
|
|
|
|
299
|
|
|
def test_get_napps_from_path__error(self): |
300
|
|
|
"""Test get_napps_from_path method to error case.""" |
301
|
|
|
path = MagicMock() |
302
|
|
|
path.exists.return_value = False |
303
|
|
|
napps = self.napps_manager.get_napps_from_path(path) |
304
|
|
|
|
305
|
|
|
self.assertEqual(napps, []) |
306
|
|
|
|
307
|
|
|
@patch('kytos.core.napps.NApp.create_from_json') |
308
|
|
|
def test_get_napps_from_path__success(self, mock_create_from_json): |
309
|
|
|
"""Test get_napps_from_path method to success case.""" |
310
|
|
|
napp = MagicMock() |
311
|
|
|
mock_create_from_json.return_value = napp |
312
|
|
|
|
313
|
|
|
path = self.get_path(['json']) |
314
|
|
|
napps = self.napps_manager.get_napps_from_path(path) |
315
|
|
|
|
316
|
|
|
self.assertEqual(napps, [napp]) |
317
|
|
|
|
318
|
|
|
def test_create_module(self): |
319
|
|
|
"""Test _create_module method.""" |
320
|
|
|
path = MagicMock() |
321
|
|
|
path.exists.return_value = False |
322
|
|
|
self.napps_manager._create_module(path) |
323
|
|
|
|
324
|
|
|
path.mkdir.assert_called() |
325
|
|
|
(path / '__init__.py').touch.assert_called() |
326
|
|
|
|
327
|
|
|
@patch('pathlib.Path.open') |
328
|
|
|
@patch('pathlib.Path.parent', 'parent') |
329
|
|
|
@patch('pathlib.Path.exists', return_value=True) |
330
|
|
|
def test_find_napp(self, *args): |
331
|
|
|
"""Test _find_napp method.""" |
332
|
|
|
(_, mock_open) = args |
333
|
|
|
data_file = MagicMock() |
334
|
|
|
data_file.read.return_value = '{"username": "kytos", \ |
335
|
|
|
"name": "napp", \ |
336
|
|
|
"version": "1.0"}' |
337
|
|
|
mock_open.return_value.__enter__.return_value = data_file |
338
|
|
|
|
339
|
|
|
napp = self.get_napp_mock() |
340
|
|
|
folder = self.napps_manager._find_napp(napp) |
341
|
|
|
|
342
|
|
|
self.assertEqual(folder, 'parent') |
343
|
|
|
|