1 |
|
####################################################################################### |
2 |
|
# Copyright ETSI Contributors and Others. |
3 |
|
# |
4 |
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
5 |
|
# you may not use this file except in compliance with the License. |
6 |
|
# You may obtain a copy of the License at |
7 |
|
# |
8 |
|
# http://www.apache.org/licenses/LICENSE-2.0 |
9 |
|
# |
10 |
|
# Unless required by applicable law or agreed to in writing, software |
11 |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
12 |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
13 |
|
# implied. |
14 |
|
# See the License for the specific language governing permissions and |
15 |
|
# limitations under the License. |
16 |
|
####################################################################################### |
17 |
1 |
import logging |
18 |
1 |
import unittest |
19 |
1 |
from unittest.mock import MagicMock, Mock, mock_open, patch |
20 |
|
|
21 |
1 |
from osm_common.dbmemory import DbMemory |
22 |
1 |
from osm_ng_ro.ns_thread import ( |
23 |
|
ConfigValidate, |
24 |
|
NsWorker, |
25 |
|
NsWorkerException, |
26 |
|
VimInteractionAffinityGroup, |
27 |
|
VimInteractionMigration, |
28 |
|
VimInteractionNet, |
29 |
|
VimInteractionResize, |
30 |
|
VimInteractionSharedVolume, |
31 |
|
) |
32 |
1 |
from osm_ro_plugin.vimconn import VimConnConnectionException, VimConnException |
33 |
|
|
34 |
|
# Variables used in tests |
35 |
1 |
db_vims_openstack = { |
36 |
|
"my_target_vim": {"vim_type": "openstack"}, |
37 |
|
} |
38 |
1 |
db_vims_aws = { |
39 |
|
"my_target_vim": {"vim_type": "aws"}, |
40 |
|
} |
41 |
|
|
42 |
|
|
43 |
1 |
class TestConfigValidate(unittest.TestCase): |
44 |
1 |
def setUp(self): |
45 |
1 |
self.config_dict = { |
46 |
|
"period": { |
47 |
|
"refresh_active": 65, |
48 |
|
"refresh_build": 20, |
49 |
|
"refresh_image": 3600, |
50 |
|
"refresh_error": 300, |
51 |
|
"queue_size": 50, |
52 |
|
} |
53 |
|
} |
54 |
|
|
55 |
1 |
def test__get_configuration(self): |
56 |
1 |
with self.subTest(i=1, t="Get config attributes with config input"): |
57 |
1 |
configuration = ConfigValidate(self.config_dict) |
58 |
1 |
self.assertEqual(configuration.active, 65) |
59 |
1 |
self.assertEqual(configuration.build, 20) |
60 |
1 |
self.assertEqual(configuration.image, 3600) |
61 |
1 |
self.assertEqual(configuration.error, 300) |
62 |
1 |
self.assertEqual(configuration.queue_size, 50) |
63 |
|
|
64 |
1 |
with self.subTest(i=2, t="Unallowed refresh active input"): |
65 |
|
# > 60 (except -1) is not allowed to set, so it should return default value 60 |
66 |
1 |
self.config_dict["period"]["refresh_active"] = 20 |
67 |
1 |
configuration = ConfigValidate(self.config_dict) |
68 |
1 |
self.assertEqual(configuration.active, 60) |
69 |
|
|
70 |
1 |
with self.subTest(i=3, t="Config to disable VM status periodic checks"): |
71 |
|
# -1 is allowed to set to disable VM status updates |
72 |
1 |
self.config_dict["period"]["refresh_active"] = -1 |
73 |
1 |
configuration = ConfigValidate(self.config_dict) |
74 |
1 |
self.assertEqual(configuration.active, -1) |
75 |
|
|
76 |
|
|
77 |
1 |
class TestNsWorker(unittest.TestCase): |
78 |
1 |
@patch("logging.getLogger", autospec=True) |
79 |
1 |
def setUp(self, mock_logger): |
80 |
1 |
mock_logger = logging.getLogger() |
81 |
1 |
mock_logger.disabled = True |
82 |
1 |
self.task_depends = None |
83 |
1 |
self.plugins = {} |
84 |
1 |
self.db_vims = db_vims_openstack |
85 |
1 |
self.db = Mock(DbMemory()) |
86 |
1 |
self.worker_index = "worker-3" |
87 |
1 |
self.config = { |
88 |
|
"period": { |
89 |
|
"refresh_active": 60, |
90 |
|
"refresh_build": 20, |
91 |
|
"refresh_image": 3600, |
92 |
|
"refresh_error": 600, |
93 |
|
"queue_size": 100, |
94 |
|
}, |
95 |
|
"process_id": "343435353", |
96 |
|
"global": {"task_locked_time": 16373242100.994312}, |
97 |
|
} |
98 |
|
|
99 |
1 |
self.ro_task = { |
100 |
|
"_id": "122436:1", |
101 |
|
"locked_by": None, |
102 |
|
"locked_at": 0.0, |
103 |
|
"target_id": "my_target_vim", |
104 |
|
"vim_info": { |
105 |
|
"created": False, |
106 |
|
"created_items": None, |
107 |
|
"vim_id": "test-vim-id", |
108 |
|
"vim_name": "test-vim", |
109 |
|
"vim_status": "DONE", |
110 |
|
"vim_details": "", |
111 |
|
"vim_message": None, |
112 |
|
"refresh_at": None, |
113 |
|
}, |
114 |
|
"modified_at": 1637324200.994312, |
115 |
|
"created_at": 1637324200.994312, |
116 |
|
"to_check_at": 16373242400.994312, |
117 |
|
"tasks": [ |
118 |
|
{ |
119 |
|
"target_id": 0, |
120 |
|
"action_id": "123456", |
121 |
|
"nsr_id": "654321", |
122 |
|
"task_id": "123456:1", |
123 |
|
"status": "DONE", |
124 |
|
"action": "CREATE", |
125 |
|
"item": "test_item", |
126 |
|
"target_record": "test_target_record", |
127 |
|
"target_record_id": "test_target_record_id", |
128 |
|
}, |
129 |
|
], |
130 |
|
} |
131 |
1 |
self.instance = NsWorker(self.worker_index, self.config, self.plugins, self.db) |
132 |
1 |
self.instance.db_vims = db_vims_openstack |
133 |
1 |
self.instance.refresh_config = Mock() |
134 |
|
|
135 |
1 |
def get_disabled_tasks(self, db, status): |
136 |
1 |
db_disabled_tasks = db.get_list( |
137 |
|
"ro_tasks", |
138 |
|
q_filter={ |
139 |
|
"tasks.status": status, |
140 |
|
"to_check_at.lt": 0, |
141 |
|
}, |
142 |
|
) |
143 |
1 |
return db_disabled_tasks |
144 |
|
|
145 |
1 |
def test_update_vm_refresh_disabled_task_with_status_build_vim_openstack_with_refresh( |
146 |
|
self, |
147 |
|
): |
148 |
|
"""1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1.""" |
149 |
|
# Disabled task with status build is not enabled again |
150 |
1 |
db = DbMemory() |
151 |
1 |
self.ro_task["tasks"][0]["status"] = "BUILD" |
152 |
1 |
self.config["period"]["refresh_active"] = 70 |
153 |
1 |
self.ro_task["to_check_at"] = -1 |
154 |
1 |
db.create("ro_tasks", self.ro_task) |
155 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "BUILD")) |
156 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
157 |
1 |
instance.update_vm_refresh(self.ro_task) |
158 |
1 |
self.assertEqual( |
159 |
|
len(self.get_disabled_tasks(db, "BUILD")), disabled_tasks_count |
160 |
|
) |
161 |
|
|
162 |
1 |
def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_no_refresh( |
163 |
|
self, |
164 |
|
): |
165 |
|
"""1 disabled task with status DONE in DB, refresh_active parameter is equal to -1.""" |
166 |
|
# As refresh_active parameter is equal to -1, task is not be enabled to process again |
167 |
1 |
db = DbMemory() |
168 |
1 |
self.config["period"]["refresh_active"] = -1 |
169 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
170 |
1 |
self.ro_task["to_check_at"] = -1 |
171 |
1 |
db.create("ro_tasks", self.ro_task) |
172 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
173 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
174 |
1 |
instance.update_vm_refresh(self.ro_task) |
175 |
1 |
self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) |
176 |
|
|
177 |
1 |
def test_update_vm_refresh_disabled_task_with_status_done_vim_aws_with_refresh( |
178 |
|
self, |
179 |
|
): |
180 |
|
"""2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1.""" |
181 |
|
# Disabled tasks should be enabled to process again as vim type aws |
182 |
1 |
db = DbMemory() |
183 |
1 |
self.config["period"]["refresh_active"] = 66 |
184 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
185 |
1 |
self.ro_task["to_check_at"] = -1 |
186 |
1 |
db.create("ro_tasks", self.ro_task) |
187 |
1 |
self.ro_task2 = self.ro_task |
188 |
1 |
self.ro_task2["_id"] = "122437:1" |
189 |
1 |
db.create("ro_tasks", self.ro_task2) |
190 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
191 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
192 |
1 |
with patch.object(instance, "db_vims", db_vims_aws): |
193 |
1 |
instance.update_vm_refresh(self.ro_task) |
194 |
1 |
self.assertEqual( |
195 |
|
len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - 2 |
196 |
|
) |
197 |
|
|
198 |
1 |
def test_update_vm_refresh_no_disabled_task_with_status_done_vim_openstack_with_refresh( |
199 |
|
self, |
200 |
|
): |
201 |
|
"""No disabled task with status DONE in DB, refresh_active parameter is not equal to -1.""" |
202 |
|
# There is not any disabled task, method does not change anything |
203 |
1 |
db = DbMemory() |
204 |
1 |
self.config["period"]["refresh_active"] = 66 |
205 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
206 |
1 |
self.ro_task["to_check_at"] = 16373242400.994312 |
207 |
1 |
db.create("ro_tasks", self.ro_task) |
208 |
1 |
self.ro_task2 = self.ro_task |
209 |
1 |
self.ro_task2["_id"] = "122437:1" |
210 |
1 |
db.create("ro_tasks", self.ro_task2) |
211 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
212 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
213 |
1 |
instance.update_vm_refresh(self.ro_task) |
214 |
1 |
self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) |
215 |
|
|
216 |
1 |
def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_with_refresh( |
217 |
|
self, |
218 |
|
): |
219 |
|
"""1 disabled task with status DONE in DB, refresh_active parameter is equal to -1, vim type is Openstack.""" |
220 |
|
# Disabled task with status done is not enabled again as vim type is openstack |
221 |
1 |
db = DbMemory() |
222 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
223 |
1 |
self.ro_task["to_check_at"] = -1 |
224 |
1 |
db.create("ro_tasks", self.ro_task) |
225 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
226 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
227 |
1 |
instance.update_vm_refresh(self.ro_task) |
228 |
1 |
self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) |
229 |
|
|
230 |
1 |
def test_process_pending_tasks_status_done_vim_aws_no_refresh(self): |
231 |
|
"""Refresh_active parameter is equal to -1, task status is DONE.""" |
232 |
|
# Task should be disabled to process again |
233 |
1 |
db = DbMemory() |
234 |
1 |
self.config["period"]["refresh_active"] = -1 |
235 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
236 |
1 |
self.ro_task["to_check_at"] = 16373242400.994312 |
237 |
1 |
db.create("ro_tasks", self.ro_task) |
238 |
|
# Number of disabled tasks in DB |
239 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
240 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
241 |
1 |
with patch.object(instance, "db_vims", db_vims_aws): |
242 |
1 |
instance._process_pending_tasks(self.ro_task) |
243 |
1 |
self.assertEqual( |
244 |
|
len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + 1 |
245 |
|
) |
246 |
|
|
247 |
1 |
def test_process_pending_tasks_status_failed_vim_aws_no_refresh(self): |
248 |
|
"""Refresh_active parameter is equal to -1, task status is FAILED.""" |
249 |
|
# Task is not disabled to process as task status is not DONE |
250 |
1 |
db = DbMemory() |
251 |
1 |
self.config["period"]["refresh_active"] = -1 |
252 |
1 |
self.ro_task["tasks"][0]["status"] = "FAILED" |
253 |
1 |
self.ro_task["to_check_at"] = 16373242400.994312 |
254 |
1 |
db.create("ro_tasks", self.ro_task) |
255 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "FAILED")) |
256 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
257 |
1 |
with patch.object(instance, "db_vims", db_vims_aws): |
258 |
1 |
instance._process_pending_tasks(self.ro_task) |
259 |
1 |
self.assertEqual( |
260 |
|
len(self.get_disabled_tasks(db, "FAILED")), disabled_tasks_count |
261 |
|
) |
262 |
|
|
263 |
1 |
def test_process_pending_tasks_status_done_vim_aws_with_refresh(self): |
264 |
|
"""Refresh_active parameter is not equal to -1, task status is DONE.""" |
265 |
|
# Task is not disabled to process as refresh_active parameter is not -1 |
266 |
1 |
db = DbMemory() |
267 |
1 |
self.config["period"]["refresh_active"] = 70 |
268 |
1 |
self.ro_task["tasks"][0]["status"] = "DONE" |
269 |
1 |
self.ro_task["to_check_at"] = 16373242400.994312 |
270 |
1 |
db.create("ro_tasks", self.ro_task) |
271 |
1 |
disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) |
272 |
1 |
instance = NsWorker(self.worker_index, self.config, self.plugins, db) |
273 |
1 |
with patch.object(instance, "db_vims", db_vims_aws): |
274 |
1 |
instance._process_pending_tasks(self.ro_task) |
275 |
1 |
self.assertEqual( |
276 |
|
len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count |
277 |
|
) |
278 |
|
|
279 |
1 |
@patch("osm_ng_ro.ns_thread.makedirs", return_value="") |
280 |
1 |
def test_create_file_cert(self, mock_makedirs): |
281 |
1 |
vim_config = {"config": {"ca_cert_content": "test"}} |
282 |
1 |
target_id = "1234" |
283 |
1 |
db = Mock() |
284 |
|
|
285 |
1 |
with patch("builtins.open", mock_open()) as mocked_file: |
286 |
1 |
nsw = NsWorker(self.worker_index, self.config, self.plugins, db) |
287 |
1 |
nsw._process_vim_config(target_id, vim_config) |
288 |
1 |
mocked_file.assert_called_once_with( |
289 |
|
f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" |
290 |
|
) |
291 |
1 |
assert ( |
292 |
|
vim_config["config"]["ca_cert"] |
293 |
|
== f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert" |
294 |
|
) |
295 |
|
|
296 |
1 |
@patch("osm_ng_ro.ns_thread.makedirs") |
297 |
1 |
@patch("osm_ng_ro.ns_thread.path") |
298 |
1 |
def test_create_file_cert_exists(self, mock_path, mock_makedirs): |
299 |
1 |
vim_config = {"config": {"ca_cert_content": "test"}} |
300 |
1 |
target_id = "1234" |
301 |
1 |
db = Mock() |
302 |
1 |
mock_path.isdir.return_value = True |
303 |
|
|
304 |
1 |
with patch("builtins.open", mock_open()) as mocked_file: |
305 |
1 |
nsw = NsWorker(self.worker_index, self.config, self.plugins, db) |
306 |
1 |
nsw._process_vim_config(target_id, vim_config) |
307 |
1 |
mock_makedirs.assert_not_called() |
308 |
1 |
mocked_file.assert_called_once_with( |
309 |
|
f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" |
310 |
|
) |
311 |
1 |
assert ( |
312 |
|
vim_config["config"]["ca_cert"] |
313 |
|
== f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert" |
314 |
|
) |
315 |
|
|
316 |
1 |
@patch("osm_ng_ro.ns_thread.path") |
317 |
1 |
@patch("osm_ng_ro.ns_thread.makedirs", side_effect=Exception) |
318 |
1 |
def test_create_file_cert_makedirs_except(self, mock_makedirs, mock_path): |
319 |
1 |
vim_config = {"config": {"ca_cert_content": "test"}} |
320 |
1 |
target_id = "1234" |
321 |
1 |
db = Mock() |
322 |
1 |
mock_path.isdir.return_value = False |
323 |
|
|
324 |
1 |
with patch("builtins.open", mock_open()) as mocked_file: |
325 |
1 |
nsw = NsWorker(self.worker_index, self.config, self.plugins, db) |
326 |
1 |
with self.assertRaises(NsWorkerException): |
327 |
1 |
nsw._process_vim_config(target_id, vim_config) |
328 |
1 |
mocked_file.assert_not_called() |
329 |
1 |
assert vim_config["config"]["ca_cert_content"] == "test" |
330 |
|
|
331 |
1 |
@patch("osm_ng_ro.ns_thread.makedirs", return_value="") |
332 |
1 |
def test_create_file_cert_open_excepts(self, mock_makedirs): |
333 |
1 |
vim_config = {"config": {"ca_cert_content": "test"}} |
334 |
1 |
target_id = "1234" |
335 |
1 |
db = Mock() |
336 |
|
|
337 |
1 |
with patch("builtins.open", mock_open()) as mocked_file: |
338 |
1 |
mocked_file.side_effect = Exception |
339 |
1 |
nsw = NsWorker(self.worker_index, self.config, self.plugins, db) |
340 |
1 |
with self.assertRaises(NsWorkerException): |
341 |
1 |
nsw._process_vim_config(target_id, vim_config) |
342 |
1 |
mocked_file.assert_called_once_with( |
343 |
|
f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" |
344 |
|
) |
345 |
1 |
assert vim_config["config"]["ca_cert_content"] == "test" |
346 |
|
|
347 |
1 |
def test_get_next_refresh_vim_type_openstack(self): |
348 |
1 |
next_refresh = 163535353434.3434 |
349 |
1 |
result = self.instance._get_next_refresh(self.ro_task, next_refresh) |
350 |
1 |
self.assertEqual(result, -1) |
351 |
|
|
352 |
1 |
def test_get_next_refresh_vim_type_openstack_refresh_disabled(self): |
353 |
1 |
next_refresh = 163535353434.3434 |
354 |
1 |
self.instance.refresh_config.active = -1 |
355 |
1 |
result = self.instance._get_next_refresh(self.ro_task, next_refresh) |
356 |
1 |
self.assertEqual(result, -1) |
357 |
|
|
358 |
1 |
def test_get_next_refresh_vim_type_aws_refresh_disabled(self): |
359 |
1 |
self.db_vims = db_vims_aws |
360 |
1 |
next_refresh = 163535353434.3434 |
361 |
1 |
self.instance.refresh_config.active = -1 |
362 |
1 |
result = self.instance._get_next_refresh(self.ro_task, next_refresh) |
363 |
1 |
self.assertEqual(result, -1) |
364 |
|
|
365 |
1 |
def test_get_next_refresh_vim_type_aws(self): |
366 |
1 |
self.instance.db_vims = db_vims_aws |
367 |
1 |
next_refresh = 163535353434.3434 |
368 |
1 |
self.instance.refresh_config.active = 140 |
369 |
1 |
result = self.instance._get_next_refresh(self.ro_task, next_refresh) |
370 |
1 |
self.assertEqual(result, next_refresh + 140) |
371 |
|
|
372 |
|
|
373 |
1 |
class TestVimInteractionNet(unittest.TestCase): |
374 |
1 |
def setUp(self): |
375 |
1 |
module_name = "osm_ro_plugin" |
376 |
1 |
self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") |
377 |
1 |
self.task_depends = None |
378 |
|
|
379 |
1 |
patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] |
380 |
|
|
381 |
|
# Enabling mocks and add cleanups |
382 |
1 |
for mock in patches: |
383 |
1 |
mock.start() |
384 |
1 |
self.addCleanup(mock.stop) |
385 |
|
|
386 |
1 |
def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self): |
387 |
|
""" |
388 |
|
mgmt network is set in find_params |
389 |
|
management_network_id in vim config |
390 |
|
More than one network found in the VIM |
391 |
|
""" |
392 |
1 |
db = "test_db" |
393 |
1 |
logger = "test_logger" |
394 |
1 |
my_vims = "test-vim" |
395 |
1 |
db_vims = { |
396 |
|
0: { |
397 |
|
"config": { |
398 |
|
"management_network_id": "test_mgmt_id", |
399 |
|
}, |
400 |
|
}, |
401 |
|
} |
402 |
|
|
403 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
404 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
405 |
|
instance, "logger", logging |
406 |
|
), patch.object(instance, "db_vims", db_vims): |
407 |
1 |
ro_task = { |
408 |
|
"target_id": 0, |
409 |
|
"tasks": { |
410 |
|
"task_index_2": { |
411 |
|
"target_id": 0, |
412 |
|
"action_id": "123456", |
413 |
|
"nsr_id": "654321", |
414 |
|
"task_id": "123456:1", |
415 |
|
"status": "SCHEDULED", |
416 |
|
"action": "CREATE", |
417 |
|
"item": "test_item", |
418 |
|
"target_record": "test_target_record", |
419 |
|
"target_record_id": "test_target_record_id", |
420 |
|
# values coming from extra_dict |
421 |
|
"params": {}, |
422 |
|
"find_params": { |
423 |
|
"mgmt": True, |
424 |
|
"name": "some_mgmt_name", |
425 |
|
}, |
426 |
|
"depends_on": "test_depends_on", |
427 |
|
}, |
428 |
|
}, |
429 |
|
} |
430 |
|
|
431 |
1 |
task_index = "task_index_2" |
432 |
1 |
self.target_vim.get_network_list.return_value = [ |
433 |
|
{"id": "existing_net_1"}, |
434 |
|
{"id": "existing_net_2"}, |
435 |
|
] |
436 |
1 |
with self.assertLogs() as captured: |
437 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
438 |
1 |
self.assertEqual(len(captured.records), 1) |
439 |
1 |
self.assertTrue( |
440 |
|
"More than one network found with this criteria" |
441 |
|
in captured.records[0].getMessage() |
442 |
|
) |
443 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
444 |
1 |
self.assertEqual(result[0], "FAILED") |
445 |
1 |
self.assertEqual(result[1].get("created"), False) |
446 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
447 |
|
|
448 |
1 |
def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self): |
449 |
|
""" |
450 |
|
mgmt network is set in find_params |
451 |
|
management_network_id in vim config |
452 |
|
The network could not be found in the VIM |
453 |
|
""" |
454 |
1 |
db = "test_db" |
455 |
1 |
logger = "test_logger" |
456 |
1 |
my_vims = "test-vim" |
457 |
1 |
db_vims = { |
458 |
|
0: { |
459 |
|
"config": { |
460 |
|
"management_network_id": "test_mgmt_id", |
461 |
|
}, |
462 |
|
}, |
463 |
|
} |
464 |
|
|
465 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
466 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
467 |
|
instance, "db_vims", db_vims |
468 |
|
), patch.object(instance, "logger", logging): |
469 |
1 |
ro_task = { |
470 |
|
"target_id": 0, |
471 |
|
"tasks": { |
472 |
|
"task_index_3": { |
473 |
|
"target_id": 0, |
474 |
|
"action_id": "123456", |
475 |
|
"nsr_id": "654321", |
476 |
|
"task_id": "123456:1", |
477 |
|
"status": "SCHEDULED", |
478 |
|
"action": "CREATE", |
479 |
|
"item": "test_item", |
480 |
|
"target_record": "test_target_record", |
481 |
|
"target_record_id": "test_target_record_id", |
482 |
|
"params": {}, |
483 |
|
# values coming from extra_dict |
484 |
|
"find_params": { |
485 |
|
"mgmt": True, |
486 |
|
"name": "some_mgmt_name", |
487 |
|
}, |
488 |
|
"depends_on": "test_depends_on", |
489 |
|
}, |
490 |
|
}, |
491 |
|
} |
492 |
|
|
493 |
1 |
task_index = "task_index_3" |
494 |
1 |
self.target_vim.get_network_list.return_value = [] |
495 |
1 |
with self.assertLogs() as captured: |
496 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
497 |
1 |
self.assertEqual(len(captured.records), 1) |
498 |
1 |
self.assertTrue( |
499 |
|
"Network not found with this criteria" |
500 |
|
in captured.records[0].getMessage() |
501 |
|
) |
502 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
503 |
1 |
self.assertEqual(result[0], "FAILED") |
504 |
1 |
self.assertEqual(result[1].get("created"), False) |
505 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
506 |
|
|
507 |
1 |
def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self): |
508 |
|
""" |
509 |
|
mgmt network is set in find_params |
510 |
|
vim config does not have management_network_id or management_network_id |
511 |
|
The network could not be found in the VIM |
512 |
|
""" |
513 |
1 |
db = "test_db" |
514 |
1 |
logger = "test_logger" |
515 |
1 |
my_vims = "test-vim" |
516 |
1 |
db_vims = { |
517 |
|
0: { |
518 |
|
"config": {}, |
519 |
|
}, |
520 |
|
} |
521 |
|
|
522 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
523 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
524 |
|
instance, "db_vims", db_vims |
525 |
|
), patch.object(instance, "logger", logging): |
526 |
1 |
ro_task = { |
527 |
|
"target_id": 0, |
528 |
|
"tasks": { |
529 |
|
"task_index_3": { |
530 |
|
"target_id": 0, |
531 |
|
"action_id": "123456", |
532 |
|
"nsr_id": "654321", |
533 |
|
"task_id": "123456:1", |
534 |
|
"status": "SCHEDULED", |
535 |
|
"action": "CREATE", |
536 |
|
"item": "test_item", |
537 |
|
"target_record": "test_target_record", |
538 |
|
"target_record_id": "test_target_record_id", |
539 |
|
"params": {}, |
540 |
|
# values coming from extra_dict |
541 |
|
"find_params": { |
542 |
|
"mgmt": True, |
543 |
|
"name": "some_mgmt_name", |
544 |
|
}, |
545 |
|
"depends_on": "test_depends_on", |
546 |
|
}, |
547 |
|
}, |
548 |
|
} |
549 |
|
|
550 |
1 |
task_index = "task_index_3" |
551 |
1 |
self.target_vim.get_network_list.return_value = [] |
552 |
1 |
self.target_vim.new_network.return_value = "sample_net_id", { |
553 |
|
"item1": "sample_created_item" |
554 |
|
} |
555 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
556 |
1 |
self.assertEqual(result[0], "BUILD") |
557 |
1 |
self.assertEqual(result[1].get("vim_id"), "sample_net_id") |
558 |
1 |
self.assertEqual(result[1].get("created"), True) |
559 |
1 |
self.assertDictEqual( |
560 |
|
result[1].get("created_items"), {"item1": "sample_created_item"} |
561 |
|
) |
562 |
1 |
self.assertEqual(result[1].get("vim_status"), "BUILD") |
563 |
|
|
564 |
1 |
def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self): |
565 |
|
""" |
566 |
|
mgmt network is set in find_params |
567 |
|
management_network_name in vim config |
568 |
|
More than one network found in the VIM |
569 |
|
""" |
570 |
1 |
db = "test_db" |
571 |
1 |
logger = "test_logger" |
572 |
1 |
my_vims = "test-vim" |
573 |
1 |
db_vims = { |
574 |
|
0: { |
575 |
|
"config": { |
576 |
|
"management_network_name": "test_mgmt_name", |
577 |
|
}, |
578 |
|
}, |
579 |
|
} |
580 |
|
|
581 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
582 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
583 |
|
instance, "logger", logging |
584 |
|
), patch.object(instance, "db_vims", db_vims): |
585 |
1 |
ro_task = { |
586 |
|
"target_id": 0, |
587 |
|
"tasks": { |
588 |
|
"task_index_4": { |
589 |
|
"target_id": 0, |
590 |
|
"action_id": "123456", |
591 |
|
"nsr_id": "654321", |
592 |
|
"task_id": "123456:1", |
593 |
|
"status": "SCHEDULED", |
594 |
|
"action": "CREATE", |
595 |
|
"item": "test_item", |
596 |
|
"target_record": "test_target_record", |
597 |
|
"target_record_id": "test_target_record_id", |
598 |
|
# values coming from extra_dict |
599 |
|
"params": {}, |
600 |
|
"find_params": { |
601 |
|
"mgmt": True, |
602 |
|
"name": "some_mgmt_name", |
603 |
|
}, |
604 |
|
"depends_on": "test_depends_on", |
605 |
|
}, |
606 |
|
}, |
607 |
|
} |
608 |
|
|
609 |
1 |
task_index = "task_index_4" |
610 |
1 |
self.target_vim.get_network_list.return_value = [ |
611 |
|
{"id": "existing_net_1"}, |
612 |
|
{"id": "existing_net_2"}, |
613 |
|
] |
614 |
1 |
with self.assertLogs() as captured: |
615 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
616 |
1 |
self.assertEqual(len(captured.records), 1) |
617 |
1 |
self.assertTrue( |
618 |
|
"More than one network found with this criteria" |
619 |
|
in captured.records[0].getMessage() |
620 |
|
) |
621 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
622 |
1 |
self.assertEqual(result[0], "FAILED") |
623 |
1 |
self.assertEqual(result[1].get("created"), False) |
624 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
625 |
|
|
626 |
1 |
def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self): |
627 |
|
""" |
628 |
|
mgmt network is set in find_params |
629 |
|
management_network_name in vim config |
630 |
|
The network could not be found in the VIM |
631 |
|
""" |
632 |
1 |
db = "test_db" |
633 |
1 |
logger = "test_logger" |
634 |
1 |
my_vims = "test-vim" |
635 |
1 |
db_vims = { |
636 |
|
0: { |
637 |
|
"config": { |
638 |
|
"management_network_name": "test_mgmt_name", |
639 |
|
}, |
640 |
|
}, |
641 |
|
} |
642 |
|
|
643 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
644 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
645 |
|
instance, "logger", logging |
646 |
|
), patch.object(instance, "db_vims", db_vims): |
647 |
1 |
ro_task = { |
648 |
|
"target_id": 0, |
649 |
|
"tasks": { |
650 |
|
"task_index_5": { |
651 |
|
"target_id": 0, |
652 |
|
"action_id": "123456", |
653 |
|
"nsr_id": "654321", |
654 |
|
"task_id": "123456:1", |
655 |
|
"status": "SCHEDULED", |
656 |
|
"action": "CREATE", |
657 |
|
"item": "test_item", |
658 |
|
"target_record": "test_target_record", |
659 |
|
"target_record_id": "test_target_record_id", |
660 |
|
# values coming from extra_dict |
661 |
|
"params": {}, |
662 |
|
"find_params": { |
663 |
|
"mgmt": True, |
664 |
|
"name": "some_mgmt_name", |
665 |
|
}, |
666 |
|
"depends_on": "test_depends_on", |
667 |
|
}, |
668 |
|
}, |
669 |
|
} |
670 |
|
|
671 |
1 |
task_index = "task_index_5" |
672 |
1 |
self.target_vim.get_network_list.return_value = [] |
673 |
1 |
with self.assertLogs() as captured: |
674 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
675 |
1 |
self.assertEqual(len(captured.records), 1) |
676 |
1 |
self.assertTrue( |
677 |
|
"Network not found with this criteria" |
678 |
|
in captured.records[0].getMessage() |
679 |
|
) |
680 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
681 |
1 |
self.assertEqual(result[0], "FAILED") |
682 |
1 |
self.assertEqual(result[1].get("created"), False) |
683 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
684 |
|
|
685 |
1 |
def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self): |
686 |
|
""" |
687 |
|
mgmt network is set in find_params |
688 |
|
management_network_name in vim config |
689 |
|
network_name is set in find_params.get('filterdict') |
690 |
|
More than one network found in the VIM |
691 |
|
""" |
692 |
1 |
db = "test_db" |
693 |
1 |
logger = "test_logger" |
694 |
1 |
my_vims = "test-vim" |
695 |
1 |
db_vims = { |
696 |
|
0: { |
697 |
|
"config": { |
698 |
|
"management_network_name": "test_mgmt_name", |
699 |
|
}, |
700 |
|
}, |
701 |
|
} |
702 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
703 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
704 |
|
instance, "logger", logging |
705 |
|
), patch.object(instance, "db_vims", db_vims): |
706 |
1 |
ro_task = { |
707 |
|
"target_id": 0, |
708 |
|
"tasks": { |
709 |
|
"task_index_6": { |
710 |
|
"target_id": 0, |
711 |
|
"action_id": "123456", |
712 |
|
"nsr_id": "654321", |
713 |
|
"task_id": "123456:1", |
714 |
|
"status": "SCHEDULED", |
715 |
|
"action": "CREATE", |
716 |
|
"item": "test_item", |
717 |
|
"target_record": "test_target_record", |
718 |
|
"target_record_id": "test_target_record_id", |
719 |
|
# values coming from extra_dict |
720 |
|
"params": {}, |
721 |
|
"find_params": { |
722 |
|
"filter_dict": { |
723 |
|
"name": "some-network-name", |
724 |
|
}, |
725 |
|
"mgmt": True, |
726 |
|
"name": "some_mgmt_name", |
727 |
|
}, |
728 |
|
"depends_on": "test_depends_on", |
729 |
|
}, |
730 |
|
}, |
731 |
|
} |
732 |
|
|
733 |
1 |
task_index = "task_index_6" |
734 |
1 |
self.target_vim.get_network_list.return_value = [ |
735 |
|
{"id": "existing_net_1"}, |
736 |
|
{"id": "existing_net_2"}, |
737 |
|
] |
738 |
1 |
with self.assertLogs() as captured: |
739 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
740 |
1 |
self.assertEqual(len(captured.records), 1) |
741 |
1 |
self.assertTrue( |
742 |
|
"More than one network found with this criteria" |
743 |
|
in captured.records[0].getMessage() |
744 |
|
) |
745 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
746 |
1 |
self.assertEqual(result[0], "FAILED") |
747 |
1 |
self.assertEqual(result[1].get("created"), False) |
748 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
749 |
|
|
750 |
1 |
def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self): |
751 |
|
""" |
752 |
|
There is find_params in the task |
753 |
|
No mgmt in find_params |
754 |
|
No filter_dict in find_params |
755 |
|
""" |
756 |
1 |
db = "test_db" |
757 |
1 |
logger = "test_logger" |
758 |
1 |
my_vims = "test-vim" |
759 |
1 |
db_vims = { |
760 |
|
0: { |
761 |
|
"config": { |
762 |
|
"management_network_name": "test_mgmt_name", |
763 |
|
}, |
764 |
|
}, |
765 |
|
} |
766 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
767 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
768 |
|
instance, "logger", logging |
769 |
|
), patch.object(instance, "db_vims", db_vims): |
770 |
1 |
ro_task = { |
771 |
|
"target_id": 0, |
772 |
|
"tasks": { |
773 |
|
"task_index_4": { |
774 |
|
"target_id": 0, |
775 |
|
"action_id": "123456", |
776 |
|
"nsr_id": "654321", |
777 |
|
"task_id": "123456:1", |
778 |
|
"status": "SCHEDULED", |
779 |
|
"action": "CREATE", |
780 |
|
"item": "test_item", |
781 |
|
"target_record": "test_target_record", |
782 |
|
"target_record_id": "test_target_record_id", |
783 |
|
# values coming from extra_dict |
784 |
|
"params": {}, |
785 |
|
"find_params": {"wrong_param": "wrong_value"}, |
786 |
|
"depends_on": "test_depends_on", |
787 |
|
}, |
788 |
|
}, |
789 |
|
} |
790 |
|
|
791 |
1 |
task_index = "task_index_4" |
792 |
1 |
with self.assertLogs() as captured: |
793 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
794 |
1 |
self.assertEqual(len(captured.records), 1) |
795 |
1 |
self.assertTrue( |
796 |
|
"Invalid find_params for new_net" |
797 |
|
in captured.records[0].getMessage() |
798 |
|
) |
799 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
800 |
1 |
self.assertEqual(result[0], "FAILED") |
801 |
1 |
self.assertEqual(result[1].get("created"), False) |
802 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
803 |
|
|
804 |
1 |
def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self): |
805 |
|
""" |
806 |
|
management_network_name in find_params.get('filterdict') |
807 |
|
The network could not be found in the VIM |
808 |
|
There are items in the task.get(params) |
809 |
|
""" |
810 |
1 |
db = "test_db" |
811 |
1 |
logger = "test_logger" |
812 |
1 |
my_vims = "test-vim" |
813 |
1 |
db_vims = { |
814 |
|
0: { |
815 |
|
"config": { |
816 |
|
"management_network_name": "test_mgmt_name", |
817 |
|
}, |
818 |
|
}, |
819 |
|
} |
820 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
821 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
822 |
|
instance, "logger", logging |
823 |
|
), patch.object(instance, "db_vims", db_vims): |
824 |
1 |
ro_task = { |
825 |
|
"target_id": 0, |
826 |
|
"tasks": { |
827 |
|
"task_index_8": { |
828 |
|
"target_id": 0, |
829 |
|
"action_id": "123456", |
830 |
|
"nsr_id": "654321", |
831 |
|
"task_id": "123456:1", |
832 |
|
"status": "SCHEDULED", |
833 |
|
"action": "CREATE", |
834 |
|
"item": "test_item", |
835 |
|
"target_record": "test_target_record", |
836 |
|
"target_record_id": "test_target_record_id", |
837 |
|
# values coming from extra_dict |
838 |
|
"params": { |
839 |
|
"net_name": "test_params", |
840 |
|
}, |
841 |
|
"find_params": { |
842 |
|
"filter_dict": { |
843 |
|
"name": "some-network-name", |
844 |
|
}, |
845 |
|
"mgmt": True, |
846 |
|
"name": "some_mgmt_name", |
847 |
|
}, |
848 |
|
"depends_on": "test_depends_on", |
849 |
|
}, |
850 |
|
}, |
851 |
|
} |
852 |
|
|
853 |
1 |
task_index = "task_index_8" |
854 |
1 |
self.target_vim.get_network_list.return_value = [] |
855 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
856 |
1 |
self.assertEqual(result[0], "BUILD") |
857 |
1 |
self.assertEqual(result[1].get("created"), False) |
858 |
1 |
self.assertEqual(result[1].get("vim_id"), None) |
859 |
1 |
self.assertEqual(result[1].get("created_items"), {}) |
860 |
1 |
self.assertEqual(result[1].get("vim_status"), "BUILD") |
861 |
|
|
862 |
1 |
def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self): |
863 |
|
""" |
864 |
|
mgmt network is set in find_params |
865 |
|
management_network_name in vim config |
866 |
|
network_name is set in find_params.get('filterdict') |
867 |
|
Any network could not be found in the VIM |
868 |
|
""" |
869 |
1 |
db = "test_db" |
870 |
1 |
logger = "test_logger" |
871 |
1 |
my_vims = "test-vim" |
872 |
1 |
db_vims = { |
873 |
|
0: { |
874 |
|
"config": { |
875 |
|
"management_network_name": "test_mgmt_name", |
876 |
|
}, |
877 |
|
}, |
878 |
|
} |
879 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
880 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
881 |
|
instance, "logger", logging |
882 |
|
), patch.object(instance, "db_vims", db_vims): |
883 |
1 |
ro_task = { |
884 |
|
"target_id": 0, |
885 |
|
"tasks": { |
886 |
|
"task_index_9": { |
887 |
|
"target_id": 0, |
888 |
|
"action_id": "123456", |
889 |
|
"nsr_id": "654321", |
890 |
|
"task_id": "123456:1", |
891 |
|
"status": "SCHEDULED", |
892 |
|
"action": "CREATE", |
893 |
|
"item": "test_item", |
894 |
|
"target_record": "test_target_record", |
895 |
|
"target_record_id": "test_target_record_id", |
896 |
|
# values coming from extra_dict |
897 |
|
"params": "", |
898 |
|
"find_params": { |
899 |
|
"filter_dict": { |
900 |
|
"name": "some-network-name", |
901 |
|
}, |
902 |
|
"mgmt": True, |
903 |
|
"name": "some_mgmt_name", |
904 |
|
}, |
905 |
|
"depends_on": "test_depends_on", |
906 |
|
}, |
907 |
|
}, |
908 |
|
} |
909 |
|
|
910 |
1 |
task_index = "task_index_9" |
911 |
1 |
self.target_vim.get_network_list.return_value = [] |
912 |
1 |
with self.assertLogs() as captured: |
913 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
914 |
1 |
self.assertEqual(len(captured.records), 1) |
915 |
1 |
self.assertTrue( |
916 |
|
"Network not found with this criteria" |
917 |
|
in captured.records[0].getMessage() |
918 |
|
) |
919 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
920 |
1 |
self.assertEqual(result[0], "FAILED") |
921 |
1 |
self.assertEqual(result[1].get("created"), False) |
922 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
923 |
|
|
924 |
1 |
def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self): |
925 |
|
""" |
926 |
|
mgmt network is set in find_params |
927 |
|
vim config is empty |
928 |
|
network_name is set in find_params.get('filterdict') |
929 |
|
Any network could not be found in the VIM |
930 |
|
""" |
931 |
1 |
db = "test_db" |
932 |
1 |
logger = "test_logger" |
933 |
1 |
my_vims = "test-vim" |
934 |
1 |
db_vims = { |
935 |
|
0: { |
936 |
|
"config": {}, |
937 |
|
}, |
938 |
|
} |
939 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
940 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
941 |
|
instance, "logger", logging |
942 |
|
), patch.object(instance, "db_vims", db_vims): |
943 |
1 |
ro_task = { |
944 |
|
"target_id": 0, |
945 |
|
"tasks": { |
946 |
|
"task_index_9": { |
947 |
|
"target_id": 0, |
948 |
|
"action_id": "123456", |
949 |
|
"nsr_id": "654321", |
950 |
|
"task_id": "123456:1", |
951 |
|
"status": "SCHEDULED", |
952 |
|
"action": "CREATE", |
953 |
|
"item": "test_item", |
954 |
|
"target_record": "test_target_record", |
955 |
|
"target_record_id": "test_target_record_id", |
956 |
|
# values coming from extra_dict |
957 |
|
"params": {}, |
958 |
|
"find_params": { |
959 |
|
"filter_dict": { |
960 |
|
"name": "some-network-name", |
961 |
|
}, |
962 |
|
"mgmt": True, |
963 |
|
"name": "some_mgmt_name", |
964 |
|
}, |
965 |
|
"depends_on": "test_depends_on", |
966 |
|
}, |
967 |
|
}, |
968 |
|
} |
969 |
|
|
970 |
1 |
task_index = "task_index_9" |
971 |
1 |
self.target_vim.get_network_list.return_value = [] |
972 |
1 |
with self.assertLogs() as captured: |
973 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
974 |
1 |
self.assertEqual(len(captured.records), 1) |
975 |
1 |
self.assertTrue( |
976 |
|
"Network not found with this criteria" |
977 |
|
in captured.records[0].getMessage() |
978 |
|
) |
979 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
980 |
1 |
self.assertEqual(result[0], "FAILED") |
981 |
1 |
self.assertEqual(result[1].get("created"), False) |
982 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
983 |
|
|
984 |
1 |
def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self): |
985 |
|
""" |
986 |
|
mgmt network is set in find_params |
987 |
|
management_network_name is not in db_vims.get('config') |
988 |
|
One network found in the VIM |
989 |
|
""" |
990 |
1 |
db = "test_db" |
991 |
1 |
logger = "test_logger" |
992 |
1 |
my_vims = "test-vim" |
993 |
1 |
db_vims = { |
994 |
|
0: { |
995 |
|
"config": {}, |
996 |
|
}, |
997 |
|
} |
998 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
999 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1000 |
|
instance, "logger", logging |
1001 |
|
), patch.object(instance, "db_vims", db_vims): |
1002 |
1 |
ro_task = { |
1003 |
|
"target_id": 0, |
1004 |
|
"tasks": { |
1005 |
|
"task_index_2": { |
1006 |
|
"target_id": 0, |
1007 |
|
"action_id": "123456", |
1008 |
|
"nsr_id": "654321", |
1009 |
|
"task_id": "123456:1", |
1010 |
|
"status": "SCHEDULED", |
1011 |
|
"action": "CREATE", |
1012 |
|
"item": "test_item", |
1013 |
|
"target_record": "test_target_record", |
1014 |
|
"target_record_id": "test_target_record_id", |
1015 |
|
# values coming from extra_dict |
1016 |
|
"params": {}, |
1017 |
|
"find_params": { |
1018 |
|
"mgmt": True, |
1019 |
|
"name": "some_mgmt_name", |
1020 |
|
}, |
1021 |
|
"depends_on": "test_depends_on", |
1022 |
|
}, |
1023 |
|
}, |
1024 |
|
} |
1025 |
|
|
1026 |
1 |
task_index = "task_index_2" |
1027 |
1 |
self.target_vim.get_network_list.return_value = [ |
1028 |
|
{"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"} |
1029 |
|
] |
1030 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1031 |
1 |
self.assertEqual(result[0], "BUILD") |
1032 |
1 |
self.assertEqual(result[1].get("created"), False) |
1033 |
1 |
self.assertEqual(result[1].get("vim_status"), "BUILD") |
1034 |
|
|
1035 |
1 |
def test__params_in_task_no_find_params(self): |
1036 |
|
""" |
1037 |
|
params in the task |
1038 |
|
find_params does not exist in the task |
1039 |
|
""" |
1040 |
1 |
db = "test_db" |
1041 |
1 |
logger = "test_logger" |
1042 |
1 |
my_vims = "test-vim" |
1043 |
1 |
db_vims = { |
1044 |
|
0: { |
1045 |
|
"config": { |
1046 |
|
"management_network_name": "test_mgmt_name", |
1047 |
|
}, |
1048 |
|
}, |
1049 |
|
} |
1050 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1051 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1052 |
|
instance, "logger", logging |
1053 |
|
), patch.object(instance, "db_vims", db_vims): |
1054 |
1 |
ro_task = { |
1055 |
|
"target_id": 0, |
1056 |
|
"tasks": { |
1057 |
|
"task_index_11": { |
1058 |
|
"target_id": 0, |
1059 |
|
"action_id": "123456", |
1060 |
|
"nsr_id": "654321", |
1061 |
|
"task_id": "123456:1", |
1062 |
|
"status": "SCHEDULED", |
1063 |
|
"action": "CREATE", |
1064 |
|
"item": "test_item", |
1065 |
|
"target_record": "test_target_record", |
1066 |
|
"target_record_id": "test_target_record_id", |
1067 |
|
# values coming from extra_dict |
1068 |
|
"params": { |
1069 |
|
"net_name": "test-network", |
1070 |
|
"net_type": "vlan", |
1071 |
|
}, |
1072 |
|
"depends_on": "test_depends_on", |
1073 |
|
}, |
1074 |
|
}, |
1075 |
|
} |
1076 |
|
|
1077 |
1 |
task_index = "task_index_11" |
1078 |
1 |
self.target_vim.new_network.return_value = "sample_net_id", { |
1079 |
|
"item1": "sample_created_item" |
1080 |
|
} |
1081 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1082 |
1 |
self.assertEqual(result[0], "BUILD") |
1083 |
1 |
self.assertEqual(result[1].get("vim_id"), "sample_net_id") |
1084 |
1 |
self.assertEqual(result[1].get("created"), True) |
1085 |
1 |
self.assertEqual( |
1086 |
|
result[1].get("created_items"), {"item1": "sample_created_item"} |
1087 |
|
) |
1088 |
1 |
self.assertEqual(result[1].get("vim_status"), "BUILD") |
1089 |
|
|
1090 |
1 |
def test__no_params_in_task_no_find_params(self): |
1091 |
|
""" |
1092 |
|
empty params in the task |
1093 |
|
find_params does not exist in the task |
1094 |
|
""" |
1095 |
1 |
db = "test_db" |
1096 |
1 |
logger = "test_logger" |
1097 |
1 |
my_vims = "test-vim" |
1098 |
1 |
db_vims = { |
1099 |
|
0: { |
1100 |
|
"config": { |
1101 |
|
"management_network_name": "test_mgmt_name", |
1102 |
|
}, |
1103 |
|
}, |
1104 |
|
} |
1105 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1106 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1107 |
|
instance, "logger", logging |
1108 |
|
), patch.object(instance, "db_vims", db_vims): |
1109 |
1 |
ro_task = { |
1110 |
|
"target_id": 0, |
1111 |
|
"tasks": { |
1112 |
|
"task_index_12": { |
1113 |
|
"target_id": 0, |
1114 |
|
"action_id": "123456", |
1115 |
|
"nsr_id": "654321", |
1116 |
|
"task_id": "123456:1", |
1117 |
|
"status": "SCHEDULED", |
1118 |
|
"action": "CREATE", |
1119 |
|
"item": "test_item", |
1120 |
|
"target_record": "test_target_record", |
1121 |
|
"target_record_id": "test_target_record_id", |
1122 |
|
# values coming from extra_dict |
1123 |
|
"params": {}, |
1124 |
|
"depends_on": "test_depends_on", |
1125 |
|
}, |
1126 |
|
}, |
1127 |
|
} |
1128 |
|
|
1129 |
1 |
task_index = "task_index_12" |
1130 |
1 |
self.target_vim.new_network.side_effect = VimConnConnectionException( |
1131 |
|
"VimConnConnectionException occurred." |
1132 |
|
) |
1133 |
1 |
with self.assertLogs() as captured: |
1134 |
1 |
instance.new(ro_task, task_index, self.task_depends) |
1135 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
1136 |
|
|
1137 |
1 |
def test__refresh_ro_task_vim_status_active(self): |
1138 |
|
""" |
1139 |
|
vim_info.get('status') is ACTIVE |
1140 |
|
""" |
1141 |
1 |
db = "test_db" |
1142 |
1 |
logger = "test_logger" |
1143 |
1 |
my_vims = "test-vim" |
1144 |
1 |
db_vims = { |
1145 |
|
"vim_openstack_1": { |
1146 |
|
"config": {}, |
1147 |
|
"vim_type": "openstack", |
1148 |
|
}, |
1149 |
|
} |
1150 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1151 |
1 |
with patch.object( |
1152 |
|
instance, "my_vims", {"vim_openstack_1": self.target_vim} |
1153 |
|
), patch.object(instance, "logger", logging), patch.object( |
1154 |
|
instance, "db_vims", db_vims |
1155 |
|
): |
1156 |
1 |
ro_task = { |
1157 |
|
"_id": "122436:1", |
1158 |
|
"locked_by": None, |
1159 |
|
"locked_at": 0.0, |
1160 |
|
"target_id": "vim_openstack_1", |
1161 |
|
"vim_info": { |
1162 |
|
"created": False, |
1163 |
|
"created_items": None, |
1164 |
|
"vim_id": "test-vim-id", |
1165 |
|
"vim_name": "test-vim", |
1166 |
|
"vim_status": None, |
1167 |
|
"vim_details": "some-details", |
1168 |
|
"vim_message": None, |
1169 |
|
"refresh_at": None, |
1170 |
|
}, |
1171 |
|
"modified_at": 1637324200.994312, |
1172 |
|
"created_at": 1637324200.994312, |
1173 |
|
"to_check_at": 1637324200.994312, |
1174 |
|
"tasks": {}, |
1175 |
|
} |
1176 |
|
|
1177 |
1 |
self.target_vim.refresh_nets_status.return_value = { |
1178 |
|
"test-vim-id": { |
1179 |
|
"vim_info": "some-details", |
1180 |
|
"status": "ACTIVE", |
1181 |
|
"name": "test-vim", |
1182 |
|
"error_msg": "", |
1183 |
|
} |
1184 |
|
} |
1185 |
1 |
task_status = "DONE" |
1186 |
1 |
ro_vim_item_update = { |
1187 |
|
"vim_status": "ACTIVE", |
1188 |
|
} |
1189 |
1 |
result = instance.refresh(ro_task) |
1190 |
1 |
self.assertEqual(result[0], task_status) |
1191 |
1 |
self.assertDictEqual(result[1], ro_vim_item_update) |
1192 |
|
|
1193 |
1 |
def test__refresh_ro_task_vim_status_build(self): |
1194 |
|
""" |
1195 |
|
vim_info.get('status') is BUILD |
1196 |
|
""" |
1197 |
1 |
db = "test_db" |
1198 |
1 |
logger = "test_logger" |
1199 |
1 |
my_vims = "test-vim" |
1200 |
1 |
db_vims = { |
1201 |
|
"vim_openstack_1": { |
1202 |
|
"config": {}, |
1203 |
|
"vim_type": "openstack", |
1204 |
|
}, |
1205 |
|
} |
1206 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1207 |
1 |
with patch.object( |
1208 |
|
instance, "my_vims", {"vim_openstack_1": self.target_vim} |
1209 |
|
), patch.object(instance, "logger", logging), patch.object( |
1210 |
|
instance, "db_vims", db_vims |
1211 |
|
): |
1212 |
1 |
ro_task = { |
1213 |
|
"_id": "122436:1", |
1214 |
|
"locked_by": None, |
1215 |
|
"locked_at": 0.0, |
1216 |
|
"target_id": "vim_openstack_1", |
1217 |
|
"vim_info": { |
1218 |
|
"created": False, |
1219 |
|
"created_items": None, |
1220 |
|
"vim_id": "test-vim-id", |
1221 |
|
"vim_name": "test-vim", |
1222 |
|
"vim_status": "BUILD", |
1223 |
|
"vim_details": "", |
1224 |
|
"vim_message": None, |
1225 |
|
"refresh_at": None, |
1226 |
|
}, |
1227 |
|
"modified_at": 1637324200.994312, |
1228 |
|
"created_at": 1637324200.994312, |
1229 |
|
"to_check_at": 1637324200.994312, |
1230 |
|
"tasks": {}, |
1231 |
|
} |
1232 |
|
|
1233 |
1 |
self.target_vim.refresh_nets_status.return_value = { |
1234 |
|
"test-vim-id": { |
1235 |
|
"vim_info": "some-details", |
1236 |
|
"status": "BUILD", |
1237 |
|
"name": "other-vim", |
1238 |
|
"error_msg": "", |
1239 |
|
} |
1240 |
|
} |
1241 |
1 |
task_status = "BUILD" |
1242 |
1 |
ro_vim_item_update = { |
1243 |
|
"vim_name": "other-vim", |
1244 |
|
"vim_details": "some-details", |
1245 |
|
} |
1246 |
1 |
result = instance.refresh(ro_task) |
1247 |
1 |
self.assertEqual(result[0], task_status) |
1248 |
1 |
self.assertDictEqual(result[1], ro_vim_item_update) |
1249 |
|
|
1250 |
1 |
def test__refresh_ro_task_vim_status_error(self): |
1251 |
|
""" |
1252 |
|
vim_info.get('status') is ERROR |
1253 |
|
""" |
1254 |
1 |
db = "test_db" |
1255 |
1 |
logger = "test_logger" |
1256 |
1 |
my_vims = "test-vim" |
1257 |
1 |
db_vims = { |
1258 |
|
"vim_openstack_1": { |
1259 |
|
"config": {}, |
1260 |
|
"vim_type": "openstack", |
1261 |
|
}, |
1262 |
|
} |
1263 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1264 |
1 |
with patch.object( |
1265 |
|
instance, "my_vims", {"vim_openstack_1": self.target_vim} |
1266 |
|
), patch.object(instance, "logger", logging), patch.object( |
1267 |
|
instance, "db_vims", db_vims |
1268 |
|
): |
1269 |
1 |
ro_task = { |
1270 |
|
"_id": "122436:1", |
1271 |
|
"locked_by": None, |
1272 |
|
"locked_at": 0.0, |
1273 |
|
"target_id": "vim_openstack_1", |
1274 |
|
"vim_info": { |
1275 |
|
"created": False, |
1276 |
|
"created_items": None, |
1277 |
|
"vim_id": "test-vim-id", |
1278 |
|
"vim_name": "test-vim", |
1279 |
|
"vim_status": "BUILD", |
1280 |
|
"vim_details": "", |
1281 |
|
"vim_message": None, |
1282 |
|
"refresh_at": None, |
1283 |
|
}, |
1284 |
|
"modified_at": 1637324200.994312, |
1285 |
|
"created_at": 1637324200.994312, |
1286 |
|
"to_check_at": 1637324200.994312, |
1287 |
|
"tasks": {}, |
1288 |
|
} |
1289 |
|
|
1290 |
1 |
self.target_vim.refresh_nets_status.return_value = { |
1291 |
|
"test-vim-id": { |
1292 |
|
"vim_info": "some-details", |
1293 |
|
"status": "ERROR", |
1294 |
|
"name": "test-vim", |
1295 |
|
"error_msg": "some error message", |
1296 |
|
} |
1297 |
|
} |
1298 |
1 |
task_status = "FAILED" |
1299 |
1 |
ro_vim_item_update = { |
1300 |
|
"vim_status": "ERROR", |
1301 |
|
"vim_message": "some error message", |
1302 |
|
} |
1303 |
1 |
result = instance.refresh(ro_task) |
1304 |
1 |
self.assertEqual(result[0], task_status) |
1305 |
1 |
self.assertDictEqual(result[1], ro_vim_item_update) |
1306 |
|
|
1307 |
1 |
def test__refresh_ro_task_VimConnException_occurred(self): |
1308 |
|
""" |
1309 |
|
vimconn.VimConnException has occured |
1310 |
|
""" |
1311 |
1 |
db = "test_db" |
1312 |
1 |
logger = "test_logger" |
1313 |
1 |
my_vims = "test-vim" |
1314 |
1 |
db_vims = { |
1315 |
|
"vim_openstack_1": { |
1316 |
|
"config": {}, |
1317 |
|
"vim_type": "openstack", |
1318 |
|
}, |
1319 |
|
} |
1320 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1321 |
1 |
with patch.object( |
1322 |
|
instance, "my_vims", {"vim_openstack_1": self.target_vim} |
1323 |
|
), patch.object(instance, "logger", logging), patch.object( |
1324 |
|
instance, "db_vims", db_vims |
1325 |
|
): |
1326 |
1 |
ro_task = { |
1327 |
|
"_id": "122436:1", |
1328 |
|
"locked_by": None, |
1329 |
|
"locked_at": 0.0, |
1330 |
|
"target_id": "vim_openstack_1", |
1331 |
|
"vim_info": { |
1332 |
|
"created": False, |
1333 |
|
"created_items": None, |
1334 |
|
"vim_id": "test-vim-id", |
1335 |
|
"vim_name": "test-vim", |
1336 |
|
"vim_status": "BUILD", |
1337 |
|
"vim_details": "", |
1338 |
|
"vim_message": None, |
1339 |
|
"refresh_at": None, |
1340 |
|
}, |
1341 |
|
"modified_at": 1637324200.994312, |
1342 |
|
"created_at": 1637324200.994312, |
1343 |
|
"to_check_at": 1637324200.994312, |
1344 |
|
"tasks": {}, |
1345 |
|
} |
1346 |
1 |
self.target_vim.refresh_nets_status.side_effect = VimConnException( |
1347 |
|
"VimConnException occurred." |
1348 |
|
) |
1349 |
1 |
with self.assertLogs() as captured: |
1350 |
1 |
instance.refresh(ro_task) |
1351 |
1 |
self.assertEqual(captured.records[0].levelname, "ERROR") |
1352 |
|
|
1353 |
1 |
def test__refresh_ro_task_vim_status_deleted(self): |
1354 |
|
""" |
1355 |
|
vim_info.get('status') is DELETED |
1356 |
|
""" |
1357 |
1 |
db = "test_db" |
1358 |
1 |
logger = "test_logger" |
1359 |
1 |
my_vims = "test-vim" |
1360 |
1 |
db_vims = { |
1361 |
|
"vim_openstack_1": { |
1362 |
|
"config": {}, |
1363 |
|
"vim_type": "openstack", |
1364 |
|
}, |
1365 |
|
} |
1366 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1367 |
1 |
with patch.object( |
1368 |
|
instance, "my_vims", {"vim_openstack_1": self.target_vim} |
1369 |
|
), patch.object(instance, "logger", logging), patch.object( |
1370 |
|
instance, "db_vims", db_vims |
1371 |
|
): |
1372 |
1 |
ro_task = { |
1373 |
|
"_id": "122436:1", |
1374 |
|
"locked_by": None, |
1375 |
|
"locked_at": 0.0, |
1376 |
|
"target_id": "vim_openstack_1", |
1377 |
|
"vim_info": { |
1378 |
|
"created": False, |
1379 |
|
"created_items": None, |
1380 |
|
"vim_id": "test-vim-id", |
1381 |
|
"vim_name": "test-vim", |
1382 |
|
"vim_status": "BUILD", |
1383 |
|
"vim_details": "", |
1384 |
|
"vim_message": None, |
1385 |
|
"refresh_at": None, |
1386 |
|
}, |
1387 |
|
"modified_at": 163724200.994312, |
1388 |
|
"created_at": 1637324200.994312, |
1389 |
|
"to_check_at": 1637324200.994312, |
1390 |
|
"tasks": {}, |
1391 |
|
} |
1392 |
1 |
self.target_vim.refresh_nets_status.return_value = { |
1393 |
|
"test-vim-id": { |
1394 |
|
"vim_info": "some-details", |
1395 |
|
"status": "DELETED", |
1396 |
|
"name": "test-vim", |
1397 |
|
"error_msg": "some error message", |
1398 |
|
} |
1399 |
|
} |
1400 |
1 |
task_status = "FAILED" |
1401 |
1 |
ro_vim_item_update = { |
1402 |
|
"vim_status": "DELETED", |
1403 |
|
"vim_message": "Deleted externally", |
1404 |
|
"vim_id": None, |
1405 |
|
} |
1406 |
1 |
result = instance.refresh(ro_task) |
1407 |
1 |
self.assertEqual(result[0], task_status) |
1408 |
1 |
self.assertDictEqual(result[1], ro_vim_item_update) |
1409 |
|
|
1410 |
1 |
def test__refresh_ro_task_empty_vim_dict(self): |
1411 |
|
""" |
1412 |
|
vim_dict does not include vim_id key |
1413 |
|
Raises KeyError |
1414 |
|
""" |
1415 |
1 |
db = "test_db" |
1416 |
1 |
logger = "test_logger" |
1417 |
1 |
my_vims = "test-vim" |
1418 |
1 |
db_vims = { |
1419 |
|
"vim_openstack_2": { |
1420 |
|
"config": {}, |
1421 |
|
}, |
1422 |
|
} |
1423 |
1 |
instance = VimInteractionNet(db, logger, my_vims, db_vims) |
1424 |
1 |
with patch.object( |
1425 |
|
instance, "my_vims", {"vim_openstack_2": self.target_vim} |
1426 |
|
), patch.object(instance, "logger", logging), patch.object( |
1427 |
|
instance, "db_vims", db_vims |
1428 |
|
): |
1429 |
1 |
ro_task = { |
1430 |
|
"_id": "128436:1", |
1431 |
|
"locked_by": None, |
1432 |
|
"locked_at": 0.0, |
1433 |
|
"target_id": "vim_openstack_2", |
1434 |
|
"vim_info": { |
1435 |
|
"created": False, |
1436 |
|
"created_items": None, |
1437 |
|
"vim_id": "test-vim-id", |
1438 |
|
"vim_name": "test-vim", |
1439 |
|
"vim_status": "BUILD", |
1440 |
|
"vim_details": "", |
1441 |
|
"vim_message": None, |
1442 |
|
"refresh_at": None, |
1443 |
|
}, |
1444 |
|
"modified_at": 163724211.994312, |
1445 |
|
"created_at": 1637324211.994312, |
1446 |
|
"to_check_at": 1637324211.994312, |
1447 |
|
"tasks": {}, |
1448 |
|
} |
1449 |
1 |
self.target_vim.refresh_nets_status.return_value = {} |
1450 |
1 |
with self.assertRaises(KeyError): |
1451 |
1 |
instance.refresh(ro_task) |
1452 |
|
|
1453 |
|
|
1454 |
1 |
class TestVimInteractionSharedVolume(unittest.TestCase): |
1455 |
1 |
def setUp(self): |
1456 |
1 |
module_name = "osm_ro_plugin" |
1457 |
1 |
self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") |
1458 |
1 |
self.task_depends = None |
1459 |
|
|
1460 |
1 |
patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] |
1461 |
|
|
1462 |
|
# Enabling mocks and add cleanups |
1463 |
1 |
for mock in patches: |
1464 |
1 |
mock.start() |
1465 |
1 |
self.addCleanup(mock.stop) |
1466 |
|
|
1467 |
1 |
def test__new_shared_volume_ok(self): |
1468 |
|
""" |
1469 |
|
create a shared volume with attributes set in params |
1470 |
|
""" |
1471 |
1 |
db = "test_db" |
1472 |
1 |
logger = "test_logger" |
1473 |
1 |
my_vims = "test-vim" |
1474 |
1 |
db_vims = { |
1475 |
|
0: { |
1476 |
|
"config": {}, |
1477 |
|
}, |
1478 |
|
} |
1479 |
|
|
1480 |
1 |
instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) |
1481 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1482 |
|
instance, "logger", logging |
1483 |
|
), patch.object(instance, "db_vims", db_vims): |
1484 |
1 |
ro_task = { |
1485 |
|
"target_id": 0, |
1486 |
|
"tasks": { |
1487 |
|
"task_index_1": { |
1488 |
|
"target_id": 0, |
1489 |
|
"action_id": "123456", |
1490 |
|
"nsr_id": "654321", |
1491 |
|
"task_id": "123456:1", |
1492 |
|
"status": "SCHEDULED", |
1493 |
|
"action": "CREATE", |
1494 |
|
"item": "test_item", |
1495 |
|
"target_record": "test_target_record", |
1496 |
|
"target_record_id": "test_target_record_id", |
1497 |
|
# values coming from extra_dict |
1498 |
|
"params": { |
1499 |
|
"shared_volume_data": { |
1500 |
|
"size": "10", |
1501 |
|
"name": "shared-volume", |
1502 |
|
"type": "multiattach", |
1503 |
|
} |
1504 |
|
}, |
1505 |
|
"find_params": {}, |
1506 |
|
"depends_on": "test_depends_on", |
1507 |
|
}, |
1508 |
|
}, |
1509 |
|
} |
1510 |
1 |
task_index = "task_index_1" |
1511 |
1 |
self.target_vim.new_shared_volumes.return_value = ("", "shared-volume") |
1512 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1513 |
1 |
self.assertEqual(result[0], "DONE") |
1514 |
1 |
self.assertEqual(result[1].get("vim_id"), "shared-volume") |
1515 |
1 |
self.assertEqual(result[1].get("created"), True) |
1516 |
1 |
self.assertEqual(result[1].get("vim_status"), "ACTIVE") |
1517 |
|
|
1518 |
1 |
def test__new_shared_volume_failed(self): |
1519 |
|
""" |
1520 |
|
create a shared volume with attributes set in params failed |
1521 |
|
""" |
1522 |
1 |
db = "test_db" |
1523 |
1 |
logger = "test_logger" |
1524 |
1 |
my_vims = "test-vim" |
1525 |
1 |
db_vims = { |
1526 |
|
0: { |
1527 |
|
"config": {}, |
1528 |
|
}, |
1529 |
|
} |
1530 |
|
|
1531 |
1 |
instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) |
1532 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1533 |
|
instance, "logger", logging |
1534 |
|
), patch.object(instance, "db_vims", db_vims): |
1535 |
1 |
ro_task = { |
1536 |
|
"target_id": 0, |
1537 |
|
"tasks": { |
1538 |
|
"task_index_1": { |
1539 |
|
"target_id": 0, |
1540 |
|
"action_id": "123456", |
1541 |
|
"nsr_id": "654321", |
1542 |
|
"task_id": "123456:1", |
1543 |
|
"status": "SCHEDULED", |
1544 |
|
"action": "CREATE", |
1545 |
|
"item": "test_item", |
1546 |
|
"target_record": "test_target_record", |
1547 |
|
"target_record_id": "test_target_record_id", |
1548 |
|
# values coming from extra_dict |
1549 |
|
"params": { |
1550 |
|
"shared_volume_data": { |
1551 |
|
"size": "10", |
1552 |
|
"name": "shared-volume", |
1553 |
|
"type": "multiattach", |
1554 |
|
} |
1555 |
|
}, |
1556 |
|
"find_params": {}, |
1557 |
|
"depends_on": "test_depends_on", |
1558 |
|
}, |
1559 |
|
}, |
1560 |
|
} |
1561 |
1 |
task_index = "task_index_1" |
1562 |
1 |
self.target_vim.new_shared_volumes.side_effect = VimConnException( |
1563 |
|
"Connection failed." |
1564 |
|
) |
1565 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1566 |
1 |
self.assertEqual(result[0], "FAILED") |
1567 |
1 |
self.assertEqual(result[1].get("vim_message"), "Connection failed.") |
1568 |
1 |
self.assertEqual(result[1].get("created"), False) |
1569 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
1570 |
|
|
1571 |
1 |
def test__delete_shared_volume_ok(self): |
1572 |
|
""" |
1573 |
|
Delete a shared volume with attributes set in params |
1574 |
|
""" |
1575 |
1 |
db = "test_db" |
1576 |
1 |
logger = "test_logger" |
1577 |
1 |
my_vims = "test-vim" |
1578 |
1 |
db_vims = { |
1579 |
|
0: { |
1580 |
|
"config": {}, |
1581 |
|
}, |
1582 |
|
} |
1583 |
|
|
1584 |
1 |
instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) |
1585 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1586 |
|
instance, "logger", logging |
1587 |
|
), patch.object(instance, "db_vims", db_vims): |
1588 |
1 |
ro_task = { |
1589 |
|
"target_id": 0, |
1590 |
|
"tasks": { |
1591 |
|
"task_index_3": { |
1592 |
|
"target_id": 0, |
1593 |
|
"task_id": "123456:1", |
1594 |
|
}, |
1595 |
|
}, |
1596 |
|
"vim_info": { |
1597 |
|
"created": False, |
1598 |
|
"created_items": None, |
1599 |
|
"vim_id": "sample_shared_volume_id_3", |
1600 |
|
"vim_name": "sample_shared_volume_3", |
1601 |
|
"vim_status": None, |
1602 |
|
"vim_details": "some-details", |
1603 |
|
"vim_message": None, |
1604 |
|
"refresh_at": None, |
1605 |
|
}, |
1606 |
|
} |
1607 |
|
|
1608 |
1 |
task_index = "task_index_3" |
1609 |
1 |
self.target_vim.delete_shared_volumes.return_value = True |
1610 |
1 |
result = instance.delete(ro_task, task_index) |
1611 |
1 |
self.assertEqual(result[0], "DONE") |
1612 |
1 |
self.assertEqual(result[1].get("vim_id"), None) |
1613 |
1 |
self.assertEqual(result[1].get("created"), False) |
1614 |
1 |
self.assertEqual(result[1].get("vim_status"), "DELETED") |
1615 |
|
|
1616 |
1 |
def test__delete_shared_volume_failed(self): |
1617 |
|
""" |
1618 |
|
Delete a shared volume with attributes set in params failed |
1619 |
|
""" |
1620 |
1 |
db = "test_db" |
1621 |
1 |
logger = "test_logger" |
1622 |
1 |
my_vims = "test-vim" |
1623 |
1 |
db_vims = { |
1624 |
|
0: { |
1625 |
|
"config": {}, |
1626 |
|
}, |
1627 |
|
} |
1628 |
|
|
1629 |
1 |
instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) |
1630 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1631 |
|
instance, "logger", logging |
1632 |
|
), patch.object(instance, "db_vims", db_vims): |
1633 |
1 |
ro_task = { |
1634 |
|
"_id": "122436:1", |
1635 |
|
"target_id": 0, |
1636 |
|
"tasks": { |
1637 |
|
"task_index_3": { |
1638 |
|
"target_id": 0, |
1639 |
|
"task_id": "123456:1", |
1640 |
|
}, |
1641 |
|
}, |
1642 |
|
"vim_info": { |
1643 |
|
"created": False, |
1644 |
|
"created_items": None, |
1645 |
|
"vim_id": "sample_shared_volume_id_3", |
1646 |
|
"vim_name": "sample_shared_volume_3", |
1647 |
|
"vim_status": None, |
1648 |
|
"vim_details": "some-details", |
1649 |
|
"vim_message": None, |
1650 |
|
"refresh_at": None, |
1651 |
|
}, |
1652 |
|
} |
1653 |
|
|
1654 |
1 |
task_index = "task_index_3" |
1655 |
1 |
self.target_vim.delete_shared_volumes.side_effect = VimConnException( |
1656 |
|
"Connection failed." |
1657 |
|
) |
1658 |
1 |
result = instance.delete(ro_task, task_index) |
1659 |
1 |
self.assertEqual(result[0], "FAILED") |
1660 |
1 |
self.assertEqual( |
1661 |
|
result[1].get("vim_message"), "Error while deleting: Connection failed." |
1662 |
|
) |
1663 |
1 |
self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") |
1664 |
|
|
1665 |
|
|
1666 |
1 |
class TestVimInteractionAffinityGroup(unittest.TestCase): |
1667 |
1 |
def setUp(self): |
1668 |
1 |
module_name = "osm_ro_plugin" |
1669 |
1 |
self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") |
1670 |
1 |
self.task_depends = None |
1671 |
|
|
1672 |
1 |
patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] |
1673 |
|
|
1674 |
|
# Enabling mocks and add cleanups |
1675 |
1 |
for mock in patches: |
1676 |
1 |
mock.start() |
1677 |
1 |
self.addCleanup(mock.stop) |
1678 |
|
|
1679 |
1 |
def test__new_affinity_group_ok(self): |
1680 |
|
""" |
1681 |
|
create affinity group with attributes set in params |
1682 |
|
""" |
1683 |
1 |
db = "test_db" |
1684 |
1 |
logger = "test_logger" |
1685 |
1 |
my_vims = "test-vim" |
1686 |
1 |
db_vims = { |
1687 |
|
0: { |
1688 |
|
"config": {}, |
1689 |
|
}, |
1690 |
|
} |
1691 |
|
|
1692 |
1 |
instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) |
1693 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1694 |
|
instance, "logger", logging |
1695 |
|
), patch.object(instance, "db_vims", db_vims): |
1696 |
1 |
ro_task = { |
1697 |
|
"target_id": 0, |
1698 |
|
"tasks": { |
1699 |
|
"task_index_1": { |
1700 |
|
"target_id": 0, |
1701 |
|
"action_id": "123456", |
1702 |
|
"nsr_id": "654321", |
1703 |
|
"task_id": "123456:1", |
1704 |
|
"status": "SCHEDULED", |
1705 |
|
"action": "CREATE", |
1706 |
|
"item": "test_item", |
1707 |
|
"target_record": "test_target_record", |
1708 |
|
"target_record_id": "test_target_record_id", |
1709 |
|
# values coming from extra_dict |
1710 |
|
"params": { |
1711 |
|
"affinity_group_data": { |
1712 |
|
"name": "affinity_group_1", |
1713 |
|
"type": "affinity", |
1714 |
|
"scope": "nfvi-node", |
1715 |
|
} |
1716 |
|
}, |
1717 |
|
"find_params": {}, |
1718 |
|
"depends_on": "test_depends_on", |
1719 |
|
}, |
1720 |
|
}, |
1721 |
|
} |
1722 |
|
|
1723 |
1 |
task_index = "task_index_1" |
1724 |
1 |
self.target_vim.new_affinity_group.return_value = ( |
1725 |
|
"sample_affinity_group_id_1" |
1726 |
|
) |
1727 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1728 |
1 |
self.assertEqual(result[0], "DONE") |
1729 |
1 |
self.assertEqual(result[1].get("vim_id"), "sample_affinity_group_id_1") |
1730 |
1 |
self.assertEqual(result[1].get("created"), True) |
1731 |
1 |
self.assertEqual(result[1].get("vim_status"), "ACTIVE") |
1732 |
|
|
1733 |
1 |
def test__new_affinity_group_failed(self): |
1734 |
|
""" |
1735 |
|
create affinity group with no attributes set in params |
1736 |
|
""" |
1737 |
1 |
db = "test_db" |
1738 |
1 |
logger = "test_logger" |
1739 |
1 |
my_vims = "test-vim" |
1740 |
1 |
db_vims = { |
1741 |
|
0: { |
1742 |
|
"config": {}, |
1743 |
|
}, |
1744 |
|
} |
1745 |
|
|
1746 |
1 |
instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) |
1747 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1748 |
|
instance, "logger", logging |
1749 |
|
), patch.object(instance, "db_vims", db_vims): |
1750 |
1 |
ro_task = { |
1751 |
|
"target_id": 0, |
1752 |
|
"tasks": { |
1753 |
|
"task_index_2": { |
1754 |
|
"target_id": 0, |
1755 |
|
"action_id": "123456", |
1756 |
|
"nsr_id": "654321", |
1757 |
|
"task_id": "123456:1", |
1758 |
|
"status": "SCHEDULED", |
1759 |
|
"action": "CREATE", |
1760 |
|
"item": "test_item", |
1761 |
|
"target_record": "test_target_record", |
1762 |
|
"target_record_id": "test_target_record_id", |
1763 |
|
# values coming from extra_dict |
1764 |
|
"params": {}, |
1765 |
|
"find_params": {}, |
1766 |
|
"depends_on": "test_depends_on", |
1767 |
|
}, |
1768 |
|
}, |
1769 |
|
} |
1770 |
|
|
1771 |
1 |
task_index = "task_index_2" |
1772 |
1 |
self.target_vim.new_affinity_group.return_value = ( |
1773 |
|
"sample_affinity_group_id_1" |
1774 |
|
) |
1775 |
1 |
result = instance.new(ro_task, task_index, self.task_depends) |
1776 |
1 |
self.assertEqual(result[0], "DONE") |
1777 |
1 |
self.assertEqual(result[1].get("vim_id"), None) |
1778 |
1 |
self.assertEqual(result[1].get("created"), False) |
1779 |
1 |
self.assertEqual(result[1].get("vim_status"), "ACTIVE") |
1780 |
|
|
1781 |
1 |
def test__delete_affinity_group_ok(self): |
1782 |
|
""" |
1783 |
|
delete affinity group with a proper vim_id |
1784 |
|
""" |
1785 |
1 |
db = "test_db" |
1786 |
1 |
logger = "test_logger" |
1787 |
1 |
my_vims = "test-vim" |
1788 |
1 |
db_vims = { |
1789 |
|
0: { |
1790 |
|
"config": {}, |
1791 |
|
}, |
1792 |
|
} |
1793 |
|
|
1794 |
1 |
instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) |
1795 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1796 |
|
instance, "logger", logging |
1797 |
|
), patch.object(instance, "db_vims", db_vims): |
1798 |
1 |
ro_task = { |
1799 |
|
"target_id": 0, |
1800 |
|
"tasks": { |
1801 |
|
"task_index_3": { |
1802 |
|
"target_id": 0, |
1803 |
|
"task_id": "123456:1", |
1804 |
|
}, |
1805 |
|
}, |
1806 |
|
"vim_info": { |
1807 |
|
"created": False, |
1808 |
|
"created_items": None, |
1809 |
|
"vim_id": "sample_affinity_group_id_3", |
1810 |
|
"vim_name": "sample_affinity_group_id_3", |
1811 |
|
"vim_status": None, |
1812 |
|
"vim_details": "some-details", |
1813 |
|
"vim_message": None, |
1814 |
|
"refresh_at": None, |
1815 |
|
}, |
1816 |
|
} |
1817 |
|
|
1818 |
1 |
task_index = "task_index_3" |
1819 |
1 |
self.target_vim.delete_affinity_group.return_value = ( |
1820 |
|
"sample_affinity_group_id_3" |
1821 |
|
) |
1822 |
1 |
result = instance.delete(ro_task, task_index) |
1823 |
1 |
self.assertEqual(result[0], "DONE") |
1824 |
1 |
self.assertEqual(result[1].get("vim_message"), "DELETED") |
1825 |
1 |
self.assertEqual(result[1].get("created"), False) |
1826 |
1 |
self.assertEqual(result[1].get("vim_status"), "DELETED") |
1827 |
|
|
1828 |
1 |
def test__delete_affinity_group_failed(self): |
1829 |
|
""" |
1830 |
|
delete affinity group with missing vim_id |
1831 |
|
""" |
1832 |
1 |
db = "test_db" |
1833 |
1 |
logger = "test_logger" |
1834 |
1 |
my_vims = "test-vim" |
1835 |
1 |
db_vims = { |
1836 |
|
0: { |
1837 |
|
"config": {}, |
1838 |
|
}, |
1839 |
|
} |
1840 |
|
|
1841 |
1 |
instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) |
1842 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1843 |
|
instance, "logger", logging |
1844 |
|
), patch.object(instance, "db_vims", db_vims): |
1845 |
1 |
ro_task = { |
1846 |
|
"target_id": 0, |
1847 |
|
"tasks": { |
1848 |
|
"task_index_4": { |
1849 |
|
"target_id": 0, |
1850 |
|
"task_id": "123456:1", |
1851 |
|
}, |
1852 |
|
}, |
1853 |
|
"vim_info": { |
1854 |
|
"created": False, |
1855 |
|
"created_items": None, |
1856 |
|
"vim_id": None, |
1857 |
|
"vim_name": None, |
1858 |
|
"vim_status": None, |
1859 |
|
"vim_details": "some-details", |
1860 |
|
"vim_message": None, |
1861 |
|
"refresh_at": None, |
1862 |
|
}, |
1863 |
|
} |
1864 |
|
|
1865 |
1 |
task_index = "task_index_4" |
1866 |
1 |
self.target_vim.delete_affinity_group.return_value = "" |
1867 |
1 |
result = instance.delete(ro_task, task_index) |
1868 |
1 |
self.assertEqual(result[0], "DONE") |
1869 |
1 |
self.assertEqual(result[1].get("vim_message"), "DELETED") |
1870 |
1 |
self.assertEqual(result[1].get("created"), False) |
1871 |
1 |
self.assertEqual(result[1].get("vim_status"), "DELETED") |
1872 |
|
|
1873 |
|
|
1874 |
1 |
class TestVimInteractionResize(unittest.TestCase): |
1875 |
1 |
def setUp(self): |
1876 |
1 |
module_name = "osm_ro_plugin" |
1877 |
1 |
self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") |
1878 |
1 |
self.task_depends = None |
1879 |
|
|
1880 |
1 |
patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] |
1881 |
|
|
1882 |
|
# Enabling mocks and add cleanups |
1883 |
1 |
for mock in patches: |
1884 |
1 |
mock.start() |
1885 |
1 |
self.addCleanup(mock.stop) |
1886 |
|
|
1887 |
1 |
def test__exec_resize_done(self): |
1888 |
|
""" |
1889 |
|
create verticalscale task |
1890 |
|
""" |
1891 |
1 |
db = "test_db" |
1892 |
1 |
logger = "test_logger" |
1893 |
1 |
my_vims = "test-vim" |
1894 |
1 |
db_vims = { |
1895 |
|
0: { |
1896 |
|
"config": {}, |
1897 |
|
}, |
1898 |
|
} |
1899 |
1 |
target_record_id = ( |
1900 |
|
"vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:" |
1901 |
|
"vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1" |
1902 |
|
) |
1903 |
|
|
1904 |
1 |
instance = VimInteractionResize(db, logger, my_vims, db_vims) |
1905 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1906 |
|
instance, "logger", logging |
1907 |
|
), patch.object(instance, "db_vims", db_vims): |
1908 |
1 |
ro_task = { |
1909 |
|
"target_id": 0, |
1910 |
|
"tasks": { |
1911 |
|
"task_index_1": { |
1912 |
|
"target_id": 0, |
1913 |
|
"action_id": "bb937f49-3870-4169-b758-9732e1ff40f3", |
1914 |
|
"nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31", |
1915 |
|
"task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0", |
1916 |
|
"status": "SCHEDULED", |
1917 |
|
"action": "EXEC", |
1918 |
|
"item": "verticalscale", |
1919 |
|
"target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0", |
1920 |
|
"target_record_id": target_record_id, |
1921 |
|
"params": { |
1922 |
|
"vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396", |
1923 |
|
"flavor_dict": "flavor_dict", |
1924 |
|
"flavor_id": "TASK-nsrs:993166fe-723e-4680-ac4b-b1af2541ae31:flavor.0", |
1925 |
|
}, |
1926 |
|
} |
1927 |
|
}, |
1928 |
|
} |
1929 |
1 |
task_depends = { |
1930 |
|
"TASK-nsrs:993166fe-723e-4680-ac4b-b1af2541ae31:flavor.0": "1" |
1931 |
|
} |
1932 |
1 |
task_index = "task_index_1" |
1933 |
1 |
result = instance.exec(ro_task, task_index, task_depends) |
1934 |
1 |
self.assertEqual(result[0], "DONE") |
1935 |
1 |
self.assertEqual(result[1].get("vim_status"), "ACTIVE") |
1936 |
|
|
1937 |
|
|
1938 |
1 |
class TestVimInteractionMigration(unittest.TestCase): |
1939 |
1 |
def setUp(self): |
1940 |
1 |
module_name = "osm_ro_plugin" |
1941 |
1 |
self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") |
1942 |
1 |
self.task_depends = None |
1943 |
|
|
1944 |
1 |
patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] |
1945 |
|
|
1946 |
|
# Enabling mocks and add cleanups |
1947 |
1 |
for mock in patches: |
1948 |
1 |
mock.start() |
1949 |
1 |
self.addCleanup(mock.stop) |
1950 |
|
|
1951 |
1 |
def test__exec_migration_done(self): |
1952 |
|
""" |
1953 |
|
create migrate task |
1954 |
|
""" |
1955 |
1 |
db = "test_db" |
1956 |
1 |
logger = "test_logger" |
1957 |
1 |
my_vims = "test-vim" |
1958 |
1 |
db_vims = { |
1959 |
|
0: { |
1960 |
|
"config": {}, |
1961 |
|
}, |
1962 |
|
} |
1963 |
1 |
target_record_id = ( |
1964 |
|
"vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:" |
1965 |
|
"vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1" |
1966 |
|
) |
1967 |
|
|
1968 |
1 |
instance = VimInteractionMigration(db, logger, my_vims, db_vims) |
1969 |
1 |
with patch.object(instance, "my_vims", [self.target_vim]), patch.object( |
1970 |
|
instance, "logger", logging |
1971 |
|
), patch.object(instance, "db_vims", db_vims): |
1972 |
1 |
ro_task = { |
1973 |
|
"target_id": 0, |
1974 |
|
"tasks": { |
1975 |
|
"task_index_1": { |
1976 |
|
"target_id": 0, |
1977 |
|
"action_id": "bb937f49-3870-4169-b758-9732e1ff40f3", |
1978 |
|
"nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31", |
1979 |
|
"task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0", |
1980 |
|
"status": "SCHEDULED", |
1981 |
|
"action": "EXEC", |
1982 |
|
"item": "migrate", |
1983 |
|
"target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0", |
1984 |
|
"target_record_id": target_record_id, |
1985 |
|
"params": { |
1986 |
|
"vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396", |
1987 |
|
"migrate_host": "osm-test2", |
1988 |
|
"vdu_vim_info": {0: {"interfaces": []}}, |
1989 |
|
}, |
1990 |
|
} |
1991 |
|
}, |
1992 |
|
} |
1993 |
1 |
self.target_vim.migrate_instance.return_value = "ACTIVE", "test" |
1994 |
|
|
1995 |
1 |
task_index = "task_index_1" |
1996 |
1 |
result = instance.exec(ro_task, task_index, self.task_depends) |
1997 |
1 |
self.assertEqual(result[0], "DONE") |
1998 |
1 |
self.assertEqual(result[1].get("vim_status"), "ACTIVE") |