Back to Project

Status

Changes

Console Output

View Build Information

Artifactory Build Info

See Fingerprints

Pipeline Steps

Workspaces

Embeddable Build Status

Previous Build

Code Coverage

Cobertura Coverage Report > NG-RO.osm_ng_ro.tests >

test_ns_thread.py

Trend

File Coverage summary

Name

Classes

Lines

Conditionals

test_ns_thread.py

100%

1/1

100%

693/693

100%

0/0

Coverage Breakdown by Class

Name

Lines

Conditionals

test_ns_thread.py

100%

693/693

N/A

Source

NG-RO/osm_ng_ro/tests/test_ns_thread.py
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")