Coverage for NG-RO/osm_ng_ro/tests/test_ns_thread.py: 100%

693 statements  

« prev     ^ index     » next       coverage.py v7.6.12, created at 2025-04-14 12:04 +0000

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####################################################################################### 

17import logging 

18import unittest 

19from unittest.mock import MagicMock, Mock, mock_open, patch 

20 

21from osm_common.dbmemory import DbMemory 

22from osm_ng_ro.ns_thread import ( 

23 ConfigValidate, 

24 NsWorker, 

25 NsWorkerException, 

26 VimInteractionAffinityGroup, 

27 VimInteractionMigration, 

28 VimInteractionNet, 

29 VimInteractionResize, 

30 VimInteractionSharedVolume, 

31) 

32from osm_ro_plugin.vimconn import VimConnConnectionException, VimConnException 

33 

34# Variables used in tests 

35db_vims_openstack = { 

36 "my_target_vim": {"vim_type": "openstack"}, 

37} 

38db_vims_aws = { 

39 "my_target_vim": {"vim_type": "aws"}, 

40} 

41 

42 

43class TestConfigValidate(unittest.TestCase): 

44 def setUp(self): 

45 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 def test__get_configuration(self): 

56 with self.subTest(i=1, t="Get config attributes with config input"): 

57 configuration = ConfigValidate(self.config_dict) 

58 self.assertEqual(configuration.active, 65) 

59 self.assertEqual(configuration.build, 20) 

60 self.assertEqual(configuration.image, 3600) 

61 self.assertEqual(configuration.error, 300) 

62 self.assertEqual(configuration.queue_size, 50) 

63 

64 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 self.config_dict["period"]["refresh_active"] = 20 

67 configuration = ConfigValidate(self.config_dict) 

68 self.assertEqual(configuration.active, 60) 

69 

70 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 self.config_dict["period"]["refresh_active"] = -1 

73 configuration = ConfigValidate(self.config_dict) 

74 self.assertEqual(configuration.active, -1) 

75 

76 

77class TestNsWorker(unittest.TestCase): 

78 @patch("logging.getLogger", autospec=True) 

79 def setUp(self, mock_logger): 

80 mock_logger = logging.getLogger() 

81 mock_logger.disabled = True 

82 self.task_depends = None 

83 self.plugins = {} 

84 self.db_vims = db_vims_openstack 

85 self.db = Mock(DbMemory()) 

86 self.worker_index = "worker-3" 

87 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 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 self.instance = NsWorker(self.worker_index, self.config, self.plugins, self.db) 

132 self.instance.db_vims = db_vims_openstack 

133 self.instance.refresh_config = Mock() 

134 

135 def get_disabled_tasks(self, db, status): 

136 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 return db_disabled_tasks 

144 

145 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 db = DbMemory() 

151 self.ro_task["tasks"][0]["status"] = "BUILD" 

152 self.config["period"]["refresh_active"] = 70 

153 self.ro_task["to_check_at"] = -1 

154 db.create("ro_tasks", self.ro_task) 

155 disabled_tasks_count = len(self.get_disabled_tasks(db, "BUILD")) 

156 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

157 instance.update_vm_refresh(self.ro_task) 

158 self.assertEqual( 

159 len(self.get_disabled_tasks(db, "BUILD")), disabled_tasks_count 

160 ) 

161 

162 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 db = DbMemory() 

168 self.config["period"]["refresh_active"] = -1 

169 self.ro_task["tasks"][0]["status"] = "DONE" 

170 self.ro_task["to_check_at"] = -1 

171 db.create("ro_tasks", self.ro_task) 

172 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

173 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

174 instance.update_vm_refresh(self.ro_task) 

175 self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) 

176 

177 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 db = DbMemory() 

183 self.config["period"]["refresh_active"] = 66 

184 self.ro_task["tasks"][0]["status"] = "DONE" 

185 self.ro_task["to_check_at"] = -1 

186 db.create("ro_tasks", self.ro_task) 

187 self.ro_task2 = self.ro_task 

188 self.ro_task2["_id"] = "122437:1" 

189 db.create("ro_tasks", self.ro_task2) 

190 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

191 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

192 with patch.object(instance, "db_vims", db_vims_aws): 

193 instance.update_vm_refresh(self.ro_task) 

194 self.assertEqual( 

195 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - 2 

196 ) 

197 

198 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 db = DbMemory() 

204 self.config["period"]["refresh_active"] = 66 

205 self.ro_task["tasks"][0]["status"] = "DONE" 

206 self.ro_task["to_check_at"] = 16373242400.994312 

207 db.create("ro_tasks", self.ro_task) 

208 self.ro_task2 = self.ro_task 

209 self.ro_task2["_id"] = "122437:1" 

210 db.create("ro_tasks", self.ro_task2) 

211 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

212 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

213 instance.update_vm_refresh(self.ro_task) 

214 self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) 

215 

216 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 db = DbMemory() 

222 self.ro_task["tasks"][0]["status"] = "DONE" 

223 self.ro_task["to_check_at"] = -1 

224 db.create("ro_tasks", self.ro_task) 

225 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

226 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

227 instance.update_vm_refresh(self.ro_task) 

228 self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) 

229 

230 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 db = DbMemory() 

234 self.config["period"]["refresh_active"] = -1 

235 self.ro_task["tasks"][0]["status"] = "DONE" 

236 self.ro_task["to_check_at"] = 16373242400.994312 

237 db.create("ro_tasks", self.ro_task) 

238 # Number of disabled tasks in DB 

239 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

240 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

241 with patch.object(instance, "db_vims", db_vims_aws): 

242 instance._process_pending_tasks(self.ro_task) 

243 self.assertEqual( 

244 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + 1 

245 ) 

246 

247 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 db = DbMemory() 

251 self.config["period"]["refresh_active"] = -1 

252 self.ro_task["tasks"][0]["status"] = "FAILED" 

253 self.ro_task["to_check_at"] = 16373242400.994312 

254 db.create("ro_tasks", self.ro_task) 

255 disabled_tasks_count = len(self.get_disabled_tasks(db, "FAILED")) 

256 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

257 with patch.object(instance, "db_vims", db_vims_aws): 

258 instance._process_pending_tasks(self.ro_task) 

259 self.assertEqual( 

260 len(self.get_disabled_tasks(db, "FAILED")), disabled_tasks_count 

261 ) 

262 

263 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 db = DbMemory() 

267 self.config["period"]["refresh_active"] = 70 

268 self.ro_task["tasks"][0]["status"] = "DONE" 

269 self.ro_task["to_check_at"] = 16373242400.994312 

270 db.create("ro_tasks", self.ro_task) 

271 disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) 

272 instance = NsWorker(self.worker_index, self.config, self.plugins, db) 

273 with patch.object(instance, "db_vims", db_vims_aws): 

274 instance._process_pending_tasks(self.ro_task) 

275 self.assertEqual( 

276 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count 

277 ) 

278 

279 @patch("osm_ng_ro.ns_thread.makedirs", return_value="") 

280 def test_create_file_cert(self, mock_makedirs): 

281 vim_config = {"config": {"ca_cert_content": "test"}} 

282 target_id = "1234" 

283 db = Mock() 

284 

285 with patch("builtins.open", mock_open()) as mocked_file: 

286 nsw = NsWorker(self.worker_index, self.config, self.plugins, db) 

287 nsw._process_vim_config(target_id, vim_config) 

288 mocked_file.assert_called_once_with( 

289 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" 

290 ) 

291 assert ( 

292 vim_config["config"]["ca_cert"] 

293 == f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert" 

294 ) 

295 

296 @patch("osm_ng_ro.ns_thread.makedirs") 

297 @patch("osm_ng_ro.ns_thread.path") 

298 def test_create_file_cert_exists(self, mock_path, mock_makedirs): 

299 vim_config = {"config": {"ca_cert_content": "test"}} 

300 target_id = "1234" 

301 db = Mock() 

302 mock_path.isdir.return_value = True 

303 

304 with patch("builtins.open", mock_open()) as mocked_file: 

305 nsw = NsWorker(self.worker_index, self.config, self.plugins, db) 

306 nsw._process_vim_config(target_id, vim_config) 

307 mock_makedirs.assert_not_called() 

308 mocked_file.assert_called_once_with( 

309 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" 

310 ) 

311 assert ( 

312 vim_config["config"]["ca_cert"] 

313 == f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert" 

314 ) 

315 

316 @patch("osm_ng_ro.ns_thread.path") 

317 @patch("osm_ng_ro.ns_thread.makedirs", side_effect=Exception) 

318 def test_create_file_cert_makedirs_except(self, mock_makedirs, mock_path): 

319 vim_config = {"config": {"ca_cert_content": "test"}} 

320 target_id = "1234" 

321 db = Mock() 

322 mock_path.isdir.return_value = False 

323 

324 with patch("builtins.open", mock_open()) as mocked_file: 

325 nsw = NsWorker(self.worker_index, self.config, self.plugins, db) 

326 with self.assertRaises(NsWorkerException): 

327 nsw._process_vim_config(target_id, vim_config) 

328 mocked_file.assert_not_called() 

329 assert vim_config["config"]["ca_cert_content"] == "test" 

330 

331 @patch("osm_ng_ro.ns_thread.makedirs", return_value="") 

332 def test_create_file_cert_open_excepts(self, mock_makedirs): 

333 vim_config = {"config": {"ca_cert_content": "test"}} 

334 target_id = "1234" 

335 db = Mock() 

336 

337 with patch("builtins.open", mock_open()) as mocked_file: 

338 mocked_file.side_effect = Exception 

339 nsw = NsWorker(self.worker_index, self.config, self.plugins, db) 

340 with self.assertRaises(NsWorkerException): 

341 nsw._process_vim_config(target_id, vim_config) 

342 mocked_file.assert_called_once_with( 

343 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w" 

344 ) 

345 assert vim_config["config"]["ca_cert_content"] == "test" 

346 

347 def test_get_next_refresh_vim_type_openstack(self): 

348 next_refresh = 163535353434.3434 

349 result = self.instance._get_next_refresh(self.ro_task, next_refresh) 

350 self.assertEqual(result, -1) 

351 

352 def test_get_next_refresh_vim_type_openstack_refresh_disabled(self): 

353 next_refresh = 163535353434.3434 

354 self.instance.refresh_config.active = -1 

355 result = self.instance._get_next_refresh(self.ro_task, next_refresh) 

356 self.assertEqual(result, -1) 

357 

358 def test_get_next_refresh_vim_type_aws_refresh_disabled(self): 

359 self.db_vims = db_vims_aws 

360 next_refresh = 163535353434.3434 

361 self.instance.refresh_config.active = -1 

362 result = self.instance._get_next_refresh(self.ro_task, next_refresh) 

363 self.assertEqual(result, -1) 

364 

365 def test_get_next_refresh_vim_type_aws(self): 

366 self.instance.db_vims = db_vims_aws 

367 next_refresh = 163535353434.3434 

368 self.instance.refresh_config.active = 140 

369 result = self.instance._get_next_refresh(self.ro_task, next_refresh) 

370 self.assertEqual(result, next_refresh + 140) 

371 

372 

373class TestVimInteractionNet(unittest.TestCase): 

374 def setUp(self): 

375 module_name = "osm_ro_plugin" 

376 self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") 

377 self.task_depends = None 

378 

379 patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] 

380 

381 # Enabling mocks and add cleanups 

382 for mock in patches: 

383 mock.start() 

384 self.addCleanup(mock.stop) 

385 

386 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 db = "test_db" 

393 logger = "test_logger" 

394 my_vims = "test-vim" 

395 db_vims = { 

396 0: { 

397 "config": { 

398 "management_network_id": "test_mgmt_id", 

399 }, 

400 }, 

401 } 

402 

403 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

404 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

405 instance, "logger", logging 

406 ), patch.object(instance, "db_vims", db_vims): 

407 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 task_index = "task_index_2" 

432 self.target_vim.get_network_list.return_value = [ 

433 {"id": "existing_net_1"}, 

434 {"id": "existing_net_2"}, 

435 ] 

436 with self.assertLogs() as captured: 

437 result = instance.new(ro_task, task_index, self.task_depends) 

438 self.assertEqual(len(captured.records), 1) 

439 self.assertTrue( 

440 "More than one network found with this criteria" 

441 in captured.records[0].getMessage() 

442 ) 

443 self.assertEqual(captured.records[0].levelname, "ERROR") 

444 self.assertEqual(result[0], "FAILED") 

445 self.assertEqual(result[1].get("created"), False) 

446 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

447 

448 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 db = "test_db" 

455 logger = "test_logger" 

456 my_vims = "test-vim" 

457 db_vims = { 

458 0: { 

459 "config": { 

460 "management_network_id": "test_mgmt_id", 

461 }, 

462 }, 

463 } 

464 

465 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

466 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

467 instance, "db_vims", db_vims 

468 ), patch.object(instance, "logger", logging): 

469 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 task_index = "task_index_3" 

494 self.target_vim.get_network_list.return_value = [] 

495 with self.assertLogs() as captured: 

496 result = instance.new(ro_task, task_index, self.task_depends) 

497 self.assertEqual(len(captured.records), 1) 

498 self.assertTrue( 

499 "Network not found with this criteria" 

500 in captured.records[0].getMessage() 

501 ) 

502 self.assertEqual(captured.records[0].levelname, "ERROR") 

503 self.assertEqual(result[0], "FAILED") 

504 self.assertEqual(result[1].get("created"), False) 

505 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

506 

507 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 db = "test_db" 

514 logger = "test_logger" 

515 my_vims = "test-vim" 

516 db_vims = { 

517 0: { 

518 "config": {}, 

519 }, 

520 } 

521 

522 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

523 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

524 instance, "db_vims", db_vims 

525 ), patch.object(instance, "logger", logging): 

526 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 task_index = "task_index_3" 

551 self.target_vim.get_network_list.return_value = [] 

552 self.target_vim.new_network.return_value = "sample_net_id", { 

553 "item1": "sample_created_item" 

554 } 

555 result = instance.new(ro_task, task_index, self.task_depends) 

556 self.assertEqual(result[0], "BUILD") 

557 self.assertEqual(result[1].get("vim_id"), "sample_net_id") 

558 self.assertEqual(result[1].get("created"), True) 

559 self.assertDictEqual( 

560 result[1].get("created_items"), {"item1": "sample_created_item"} 

561 ) 

562 self.assertEqual(result[1].get("vim_status"), "BUILD") 

563 

564 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 db = "test_db" 

571 logger = "test_logger" 

572 my_vims = "test-vim" 

573 db_vims = { 

574 0: { 

575 "config": { 

576 "management_network_name": "test_mgmt_name", 

577 }, 

578 }, 

579 } 

580 

581 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

582 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

583 instance, "logger", logging 

584 ), patch.object(instance, "db_vims", db_vims): 

585 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 task_index = "task_index_4" 

610 self.target_vim.get_network_list.return_value = [ 

611 {"id": "existing_net_1"}, 

612 {"id": "existing_net_2"}, 

613 ] 

614 with self.assertLogs() as captured: 

615 result = instance.new(ro_task, task_index, self.task_depends) 

616 self.assertEqual(len(captured.records), 1) 

617 self.assertTrue( 

618 "More than one network found with this criteria" 

619 in captured.records[0].getMessage() 

620 ) 

621 self.assertEqual(captured.records[0].levelname, "ERROR") 

622 self.assertEqual(result[0], "FAILED") 

623 self.assertEqual(result[1].get("created"), False) 

624 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

625 

626 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 db = "test_db" 

633 logger = "test_logger" 

634 my_vims = "test-vim" 

635 db_vims = { 

636 0: { 

637 "config": { 

638 "management_network_name": "test_mgmt_name", 

639 }, 

640 }, 

641 } 

642 

643 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

644 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

645 instance, "logger", logging 

646 ), patch.object(instance, "db_vims", db_vims): 

647 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 task_index = "task_index_5" 

672 self.target_vim.get_network_list.return_value = [] 

673 with self.assertLogs() as captured: 

674 result = instance.new(ro_task, task_index, self.task_depends) 

675 self.assertEqual(len(captured.records), 1) 

676 self.assertTrue( 

677 "Network not found with this criteria" 

678 in captured.records[0].getMessage() 

679 ) 

680 self.assertEqual(captured.records[0].levelname, "ERROR") 

681 self.assertEqual(result[0], "FAILED") 

682 self.assertEqual(result[1].get("created"), False) 

683 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

684 

685 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 db = "test_db" 

693 logger = "test_logger" 

694 my_vims = "test-vim" 

695 db_vims = { 

696 0: { 

697 "config": { 

698 "management_network_name": "test_mgmt_name", 

699 }, 

700 }, 

701 } 

702 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

703 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

704 instance, "logger", logging 

705 ), patch.object(instance, "db_vims", db_vims): 

706 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 task_index = "task_index_6" 

734 self.target_vim.get_network_list.return_value = [ 

735 {"id": "existing_net_1"}, 

736 {"id": "existing_net_2"}, 

737 ] 

738 with self.assertLogs() as captured: 

739 result = instance.new(ro_task, task_index, self.task_depends) 

740 self.assertEqual(len(captured.records), 1) 

741 self.assertTrue( 

742 "More than one network found with this criteria" 

743 in captured.records[0].getMessage() 

744 ) 

745 self.assertEqual(captured.records[0].levelname, "ERROR") 

746 self.assertEqual(result[0], "FAILED") 

747 self.assertEqual(result[1].get("created"), False) 

748 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

749 

750 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 db = "test_db" 

757 logger = "test_logger" 

758 my_vims = "test-vim" 

759 db_vims = { 

760 0: { 

761 "config": { 

762 "management_network_name": "test_mgmt_name", 

763 }, 

764 }, 

765 } 

766 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

767 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

768 instance, "logger", logging 

769 ), patch.object(instance, "db_vims", db_vims): 

770 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 task_index = "task_index_4" 

792 with self.assertLogs() as captured: 

793 result = instance.new(ro_task, task_index, self.task_depends) 

794 self.assertEqual(len(captured.records), 1) 

795 self.assertTrue( 

796 "Invalid find_params for new_net" 

797 in captured.records[0].getMessage() 

798 ) 

799 self.assertEqual(captured.records[0].levelname, "ERROR") 

800 self.assertEqual(result[0], "FAILED") 

801 self.assertEqual(result[1].get("created"), False) 

802 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

803 

804 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 db = "test_db" 

811 logger = "test_logger" 

812 my_vims = "test-vim" 

813 db_vims = { 

814 0: { 

815 "config": { 

816 "management_network_name": "test_mgmt_name", 

817 }, 

818 }, 

819 } 

820 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

821 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

822 instance, "logger", logging 

823 ), patch.object(instance, "db_vims", db_vims): 

824 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 task_index = "task_index_8" 

854 self.target_vim.get_network_list.return_value = [] 

855 result = instance.new(ro_task, task_index, self.task_depends) 

856 self.assertEqual(result[0], "BUILD") 

857 self.assertEqual(result[1].get("created"), False) 

858 self.assertEqual(result[1].get("vim_id"), None) 

859 self.assertEqual(result[1].get("created_items"), {}) 

860 self.assertEqual(result[1].get("vim_status"), "BUILD") 

861 

862 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 db = "test_db" 

870 logger = "test_logger" 

871 my_vims = "test-vim" 

872 db_vims = { 

873 0: { 

874 "config": { 

875 "management_network_name": "test_mgmt_name", 

876 }, 

877 }, 

878 } 

879 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

880 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

881 instance, "logger", logging 

882 ), patch.object(instance, "db_vims", db_vims): 

883 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 task_index = "task_index_9" 

911 self.target_vim.get_network_list.return_value = [] 

912 with self.assertLogs() as captured: 

913 result = instance.new(ro_task, task_index, self.task_depends) 

914 self.assertEqual(len(captured.records), 1) 

915 self.assertTrue( 

916 "Network not found with this criteria" 

917 in captured.records[0].getMessage() 

918 ) 

919 self.assertEqual(captured.records[0].levelname, "ERROR") 

920 self.assertEqual(result[0], "FAILED") 

921 self.assertEqual(result[1].get("created"), False) 

922 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

923 

924 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 db = "test_db" 

932 logger = "test_logger" 

933 my_vims = "test-vim" 

934 db_vims = { 

935 0: { 

936 "config": {}, 

937 }, 

938 } 

939 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

940 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

941 instance, "logger", logging 

942 ), patch.object(instance, "db_vims", db_vims): 

943 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 task_index = "task_index_9" 

971 self.target_vim.get_network_list.return_value = [] 

972 with self.assertLogs() as captured: 

973 result = instance.new(ro_task, task_index, self.task_depends) 

974 self.assertEqual(len(captured.records), 1) 

975 self.assertTrue( 

976 "Network not found with this criteria" 

977 in captured.records[0].getMessage() 

978 ) 

979 self.assertEqual(captured.records[0].levelname, "ERROR") 

980 self.assertEqual(result[0], "FAILED") 

981 self.assertEqual(result[1].get("created"), False) 

982 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

983 

984 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 db = "test_db" 

991 logger = "test_logger" 

992 my_vims = "test-vim" 

993 db_vims = { 

994 0: { 

995 "config": {}, 

996 }, 

997 } 

998 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

999 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1000 instance, "logger", logging 

1001 ), patch.object(instance, "db_vims", db_vims): 

1002 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 task_index = "task_index_2" 

1027 self.target_vim.get_network_list.return_value = [ 

1028 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"} 

1029 ] 

1030 result = instance.new(ro_task, task_index, self.task_depends) 

1031 self.assertEqual(result[0], "BUILD") 

1032 self.assertEqual(result[1].get("created"), False) 

1033 self.assertEqual(result[1].get("vim_status"), "BUILD") 

1034 

1035 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 db = "test_db" 

1041 logger = "test_logger" 

1042 my_vims = "test-vim" 

1043 db_vims = { 

1044 0: { 

1045 "config": { 

1046 "management_network_name": "test_mgmt_name", 

1047 }, 

1048 }, 

1049 } 

1050 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1051 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1052 instance, "logger", logging 

1053 ), patch.object(instance, "db_vims", db_vims): 

1054 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 task_index = "task_index_11" 

1078 self.target_vim.new_network.return_value = "sample_net_id", { 

1079 "item1": "sample_created_item" 

1080 } 

1081 result = instance.new(ro_task, task_index, self.task_depends) 

1082 self.assertEqual(result[0], "BUILD") 

1083 self.assertEqual(result[1].get("vim_id"), "sample_net_id") 

1084 self.assertEqual(result[1].get("created"), True) 

1085 self.assertEqual( 

1086 result[1].get("created_items"), {"item1": "sample_created_item"} 

1087 ) 

1088 self.assertEqual(result[1].get("vim_status"), "BUILD") 

1089 

1090 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 db = "test_db" 

1096 logger = "test_logger" 

1097 my_vims = "test-vim" 

1098 db_vims = { 

1099 0: { 

1100 "config": { 

1101 "management_network_name": "test_mgmt_name", 

1102 }, 

1103 }, 

1104 } 

1105 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1106 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1107 instance, "logger", logging 

1108 ), patch.object(instance, "db_vims", db_vims): 

1109 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 task_index = "task_index_12" 

1130 self.target_vim.new_network.side_effect = VimConnConnectionException( 

1131 "VimConnConnectionException occurred." 

1132 ) 

1133 with self.assertLogs() as captured: 

1134 instance.new(ro_task, task_index, self.task_depends) 

1135 self.assertEqual(captured.records[0].levelname, "ERROR") 

1136 

1137 def test__refresh_ro_task_vim_status_active(self): 

1138 """ 

1139 vim_info.get('status') is ACTIVE 

1140 """ 

1141 db = "test_db" 

1142 logger = "test_logger" 

1143 my_vims = "test-vim" 

1144 db_vims = { 

1145 "vim_openstack_1": { 

1146 "config": {}, 

1147 "vim_type": "openstack", 

1148 }, 

1149 } 

1150 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1151 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 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 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 task_status = "DONE" 

1186 ro_vim_item_update = { 

1187 "vim_status": "ACTIVE", 

1188 } 

1189 result = instance.refresh(ro_task) 

1190 self.assertEqual(result[0], task_status) 

1191 self.assertDictEqual(result[1], ro_vim_item_update) 

1192 

1193 def test__refresh_ro_task_vim_status_build(self): 

1194 """ 

1195 vim_info.get('status') is BUILD 

1196 """ 

1197 db = "test_db" 

1198 logger = "test_logger" 

1199 my_vims = "test-vim" 

1200 db_vims = { 

1201 "vim_openstack_1": { 

1202 "config": {}, 

1203 "vim_type": "openstack", 

1204 }, 

1205 } 

1206 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1207 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 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 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 task_status = "BUILD" 

1242 ro_vim_item_update = { 

1243 "vim_name": "other-vim", 

1244 "vim_details": "some-details", 

1245 } 

1246 result = instance.refresh(ro_task) 

1247 self.assertEqual(result[0], task_status) 

1248 self.assertDictEqual(result[1], ro_vim_item_update) 

1249 

1250 def test__refresh_ro_task_vim_status_error(self): 

1251 """ 

1252 vim_info.get('status') is ERROR 

1253 """ 

1254 db = "test_db" 

1255 logger = "test_logger" 

1256 my_vims = "test-vim" 

1257 db_vims = { 

1258 "vim_openstack_1": { 

1259 "config": {}, 

1260 "vim_type": "openstack", 

1261 }, 

1262 } 

1263 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1264 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 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 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 task_status = "FAILED" 

1299 ro_vim_item_update = { 

1300 "vim_status": "ERROR", 

1301 "vim_message": "some error message", 

1302 } 

1303 result = instance.refresh(ro_task) 

1304 self.assertEqual(result[0], task_status) 

1305 self.assertDictEqual(result[1], ro_vim_item_update) 

1306 

1307 def test__refresh_ro_task_VimConnException_occurred(self): 

1308 """ 

1309 vimconn.VimConnException has occured 

1310 """ 

1311 db = "test_db" 

1312 logger = "test_logger" 

1313 my_vims = "test-vim" 

1314 db_vims = { 

1315 "vim_openstack_1": { 

1316 "config": {}, 

1317 "vim_type": "openstack", 

1318 }, 

1319 } 

1320 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1321 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 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 self.target_vim.refresh_nets_status.side_effect = VimConnException( 

1347 "VimConnException occurred." 

1348 ) 

1349 with self.assertLogs() as captured: 

1350 instance.refresh(ro_task) 

1351 self.assertEqual(captured.records[0].levelname, "ERROR") 

1352 

1353 def test__refresh_ro_task_vim_status_deleted(self): 

1354 """ 

1355 vim_info.get('status') is DELETED 

1356 """ 

1357 db = "test_db" 

1358 logger = "test_logger" 

1359 my_vims = "test-vim" 

1360 db_vims = { 

1361 "vim_openstack_1": { 

1362 "config": {}, 

1363 "vim_type": "openstack", 

1364 }, 

1365 } 

1366 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1367 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 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 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 task_status = "FAILED" 

1401 ro_vim_item_update = { 

1402 "vim_status": "DELETED", 

1403 "vim_message": "Deleted externally", 

1404 "vim_id": None, 

1405 } 

1406 result = instance.refresh(ro_task) 

1407 self.assertEqual(result[0], task_status) 

1408 self.assertDictEqual(result[1], ro_vim_item_update) 

1409 

1410 def test__refresh_ro_task_empty_vim_dict(self): 

1411 """ 

1412 vim_dict does not include vim_id key 

1413 Raises KeyError 

1414 """ 

1415 db = "test_db" 

1416 logger = "test_logger" 

1417 my_vims = "test-vim" 

1418 db_vims = { 

1419 "vim_openstack_2": { 

1420 "config": {}, 

1421 }, 

1422 } 

1423 instance = VimInteractionNet(db, logger, my_vims, db_vims) 

1424 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 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 self.target_vim.refresh_nets_status.return_value = {} 

1450 with self.assertRaises(KeyError): 

1451 instance.refresh(ro_task) 

1452 

1453 

1454class TestVimInteractionSharedVolume(unittest.TestCase): 

1455 def setUp(self): 

1456 module_name = "osm_ro_plugin" 

1457 self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") 

1458 self.task_depends = None 

1459 

1460 patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] 

1461 

1462 # Enabling mocks and add cleanups 

1463 for mock in patches: 

1464 mock.start() 

1465 self.addCleanup(mock.stop) 

1466 

1467 def test__new_shared_volume_ok(self): 

1468 """ 

1469 create a shared volume with attributes set in params 

1470 """ 

1471 db = "test_db" 

1472 logger = "test_logger" 

1473 my_vims = "test-vim" 

1474 db_vims = { 

1475 0: { 

1476 "config": {}, 

1477 }, 

1478 } 

1479 

1480 instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) 

1481 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1482 instance, "logger", logging 

1483 ), patch.object(instance, "db_vims", db_vims): 

1484 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 task_index = "task_index_1" 

1511 self.target_vim.new_shared_volumes.return_value = ("", "shared-volume") 

1512 result = instance.new(ro_task, task_index, self.task_depends) 

1513 self.assertEqual(result[0], "DONE") 

1514 self.assertEqual(result[1].get("vim_id"), "shared-volume") 

1515 self.assertEqual(result[1].get("created"), True) 

1516 self.assertEqual(result[1].get("vim_status"), "ACTIVE") 

1517 

1518 def test__new_shared_volume_failed(self): 

1519 """ 

1520 create a shared volume with attributes set in params failed 

1521 """ 

1522 db = "test_db" 

1523 logger = "test_logger" 

1524 my_vims = "test-vim" 

1525 db_vims = { 

1526 0: { 

1527 "config": {}, 

1528 }, 

1529 } 

1530 

1531 instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) 

1532 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1533 instance, "logger", logging 

1534 ), patch.object(instance, "db_vims", db_vims): 

1535 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 task_index = "task_index_1" 

1562 self.target_vim.new_shared_volumes.side_effect = VimConnException( 

1563 "Connection failed." 

1564 ) 

1565 result = instance.new(ro_task, task_index, self.task_depends) 

1566 self.assertEqual(result[0], "FAILED") 

1567 self.assertEqual(result[1].get("vim_message"), "Connection failed.") 

1568 self.assertEqual(result[1].get("created"), False) 

1569 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

1570 

1571 def test__delete_shared_volume_ok(self): 

1572 """ 

1573 Delete a shared volume with attributes set in params 

1574 """ 

1575 db = "test_db" 

1576 logger = "test_logger" 

1577 my_vims = "test-vim" 

1578 db_vims = { 

1579 0: { 

1580 "config": {}, 

1581 }, 

1582 } 

1583 

1584 instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) 

1585 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1586 instance, "logger", logging 

1587 ), patch.object(instance, "db_vims", db_vims): 

1588 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 task_index = "task_index_3" 

1609 self.target_vim.delete_shared_volumes.return_value = True 

1610 result = instance.delete(ro_task, task_index) 

1611 self.assertEqual(result[0], "DONE") 

1612 self.assertEqual(result[1].get("vim_id"), None) 

1613 self.assertEqual(result[1].get("created"), False) 

1614 self.assertEqual(result[1].get("vim_status"), "DELETED") 

1615 

1616 def test__delete_shared_volume_failed(self): 

1617 """ 

1618 Delete a shared volume with attributes set in params failed 

1619 """ 

1620 db = "test_db" 

1621 logger = "test_logger" 

1622 my_vims = "test-vim" 

1623 db_vims = { 

1624 0: { 

1625 "config": {}, 

1626 }, 

1627 } 

1628 

1629 instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) 

1630 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1631 instance, "logger", logging 

1632 ), patch.object(instance, "db_vims", db_vims): 

1633 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 task_index = "task_index_3" 

1655 self.target_vim.delete_shared_volumes.side_effect = VimConnException( 

1656 "Connection failed." 

1657 ) 

1658 result = instance.delete(ro_task, task_index) 

1659 self.assertEqual(result[0], "FAILED") 

1660 self.assertEqual( 

1661 result[1].get("vim_message"), "Error while deleting: Connection failed." 

1662 ) 

1663 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") 

1664 

1665 

1666class TestVimInteractionAffinityGroup(unittest.TestCase): 

1667 def setUp(self): 

1668 module_name = "osm_ro_plugin" 

1669 self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") 

1670 self.task_depends = None 

1671 

1672 patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] 

1673 

1674 # Enabling mocks and add cleanups 

1675 for mock in patches: 

1676 mock.start() 

1677 self.addCleanup(mock.stop) 

1678 

1679 def test__new_affinity_group_ok(self): 

1680 """ 

1681 create affinity group with attributes set in params 

1682 """ 

1683 db = "test_db" 

1684 logger = "test_logger" 

1685 my_vims = "test-vim" 

1686 db_vims = { 

1687 0: { 

1688 "config": {}, 

1689 }, 

1690 } 

1691 

1692 instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) 

1693 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1694 instance, "logger", logging 

1695 ), patch.object(instance, "db_vims", db_vims): 

1696 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 task_index = "task_index_1" 

1724 self.target_vim.new_affinity_group.return_value = ( 

1725 "sample_affinity_group_id_1" 

1726 ) 

1727 result = instance.new(ro_task, task_index, self.task_depends) 

1728 self.assertEqual(result[0], "DONE") 

1729 self.assertEqual(result[1].get("vim_id"), "sample_affinity_group_id_1") 

1730 self.assertEqual(result[1].get("created"), True) 

1731 self.assertEqual(result[1].get("vim_status"), "ACTIVE") 

1732 

1733 def test__new_affinity_group_failed(self): 

1734 """ 

1735 create affinity group with no attributes set in params 

1736 """ 

1737 db = "test_db" 

1738 logger = "test_logger" 

1739 my_vims = "test-vim" 

1740 db_vims = { 

1741 0: { 

1742 "config": {}, 

1743 }, 

1744 } 

1745 

1746 instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) 

1747 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1748 instance, "logger", logging 

1749 ), patch.object(instance, "db_vims", db_vims): 

1750 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 task_index = "task_index_2" 

1772 self.target_vim.new_affinity_group.return_value = ( 

1773 "sample_affinity_group_id_1" 

1774 ) 

1775 result = instance.new(ro_task, task_index, self.task_depends) 

1776 self.assertEqual(result[0], "DONE") 

1777 self.assertEqual(result[1].get("vim_id"), None) 

1778 self.assertEqual(result[1].get("created"), False) 

1779 self.assertEqual(result[1].get("vim_status"), "ACTIVE") 

1780 

1781 def test__delete_affinity_group_ok(self): 

1782 """ 

1783 delete affinity group with a proper vim_id 

1784 """ 

1785 db = "test_db" 

1786 logger = "test_logger" 

1787 my_vims = "test-vim" 

1788 db_vims = { 

1789 0: { 

1790 "config": {}, 

1791 }, 

1792 } 

1793 

1794 instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) 

1795 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1796 instance, "logger", logging 

1797 ), patch.object(instance, "db_vims", db_vims): 

1798 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 task_index = "task_index_3" 

1819 self.target_vim.delete_affinity_group.return_value = ( 

1820 "sample_affinity_group_id_3" 

1821 ) 

1822 result = instance.delete(ro_task, task_index) 

1823 self.assertEqual(result[0], "DONE") 

1824 self.assertEqual(result[1].get("vim_message"), "DELETED") 

1825 self.assertEqual(result[1].get("created"), False) 

1826 self.assertEqual(result[1].get("vim_status"), "DELETED") 

1827 

1828 def test__delete_affinity_group_failed(self): 

1829 """ 

1830 delete affinity group with missing vim_id 

1831 """ 

1832 db = "test_db" 

1833 logger = "test_logger" 

1834 my_vims = "test-vim" 

1835 db_vims = { 

1836 0: { 

1837 "config": {}, 

1838 }, 

1839 } 

1840 

1841 instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims) 

1842 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1843 instance, "logger", logging 

1844 ), patch.object(instance, "db_vims", db_vims): 

1845 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 task_index = "task_index_4" 

1866 self.target_vim.delete_affinity_group.return_value = "" 

1867 result = instance.delete(ro_task, task_index) 

1868 self.assertEqual(result[0], "DONE") 

1869 self.assertEqual(result[1].get("vim_message"), "DELETED") 

1870 self.assertEqual(result[1].get("created"), False) 

1871 self.assertEqual(result[1].get("vim_status"), "DELETED") 

1872 

1873 

1874class TestVimInteractionResize(unittest.TestCase): 

1875 def setUp(self): 

1876 module_name = "osm_ro_plugin" 

1877 self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") 

1878 self.task_depends = None 

1879 

1880 patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] 

1881 

1882 # Enabling mocks and add cleanups 

1883 for mock in patches: 

1884 mock.start() 

1885 self.addCleanup(mock.stop) 

1886 

1887 def test__exec_resize_done(self): 

1888 """ 

1889 create verticalscale task 

1890 """ 

1891 db = "test_db" 

1892 logger = "test_logger" 

1893 my_vims = "test-vim" 

1894 db_vims = { 

1895 0: { 

1896 "config": {}, 

1897 }, 

1898 } 

1899 target_record_id = ( 

1900 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:" 

1901 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1" 

1902 ) 

1903 

1904 instance = VimInteractionResize(db, logger, my_vims, db_vims) 

1905 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1906 instance, "logger", logging 

1907 ), patch.object(instance, "db_vims", db_vims): 

1908 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 task_depends = { 

1930 "TASK-nsrs:993166fe-723e-4680-ac4b-b1af2541ae31:flavor.0": "1" 

1931 } 

1932 task_index = "task_index_1" 

1933 result = instance.exec(ro_task, task_index, task_depends) 

1934 self.assertEqual(result[0], "DONE") 

1935 self.assertEqual(result[1].get("vim_status"), "ACTIVE") 

1936 

1937 

1938class TestVimInteractionMigration(unittest.TestCase): 

1939 def setUp(self): 

1940 module_name = "osm_ro_plugin" 

1941 self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") 

1942 self.task_depends = None 

1943 

1944 patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] 

1945 

1946 # Enabling mocks and add cleanups 

1947 for mock in patches: 

1948 mock.start() 

1949 self.addCleanup(mock.stop) 

1950 

1951 def test__exec_migration_done(self): 

1952 """ 

1953 create migrate task 

1954 """ 

1955 db = "test_db" 

1956 logger = "test_logger" 

1957 my_vims = "test-vim" 

1958 db_vims = { 

1959 0: { 

1960 "config": {}, 

1961 }, 

1962 } 

1963 target_record_id = ( 

1964 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:" 

1965 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1" 

1966 ) 

1967 

1968 instance = VimInteractionMigration(db, logger, my_vims, db_vims) 

1969 with patch.object(instance, "my_vims", [self.target_vim]), patch.object( 

1970 instance, "logger", logging 

1971 ), patch.object(instance, "db_vims", db_vims): 

1972 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 self.target_vim.migrate_instance.return_value = "ACTIVE", "test" 

1994 

1995 task_index = "task_index_1" 

1996 result = instance.exec(ro_task, task_index, self.task_depends) 

1997 self.assertEqual(result[0], "DONE") 

1998 self.assertEqual(result[1].get("vim_status"), "ACTIVE")