X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=NG-RO%2Fosm_ng_ro%2Ftests%2Ftest_ns_thread.py;h=ad3efe82285b5ae1f1c1ccca0eacf2b71e95b7cd;hb=17852167b8cb19a82c07cf763a58e9e0261b3cc6;hp=3c73a7d4ba2cde01b79d63e83a6ba737309891d3;hpb=ffee660727620a5d5c1e069ac28c09850ac57299;p=osm%2FRO.git diff --git a/NG-RO/osm_ng_ro/tests/test_ns_thread.py b/NG-RO/osm_ng_ro/tests/test_ns_thread.py index 3c73a7d4..ad3efe82 100644 --- a/NG-RO/osm_ng_ro/tests/test_ns_thread.py +++ b/NG-RO/osm_ng_ro/tests/test_ns_thread.py @@ -14,7 +14,6 @@ # See the License for the specific language governing permissions and # limitations under the License. ####################################################################################### - import logging import unittest from unittest.mock import MagicMock, Mock, mock_open, patch @@ -28,9 +27,18 @@ from osm_ng_ro.ns_thread import ( VimInteractionMigration, VimInteractionNet, VimInteractionResize, + VimInteractionSharedVolume, ) from osm_ro_plugin.vimconn import VimConnConnectionException, VimConnException +# Variables used in tests +db_vims_openstack = { + "my_target_vim": {"vim_type": "openstack"}, +} +db_vims_aws = { + "my_target_vim": {"vim_type": "aws"}, +} + class TestConfigValidate(unittest.TestCase): def setUp(self): @@ -67,9 +75,14 @@ class TestConfigValidate(unittest.TestCase): class TestNsWorker(unittest.TestCase): - def setUp(self): + @patch("logging.getLogger", autospec=True) + def setUp(self, mock_logger): + mock_logger = logging.getLogger() + mock_logger.disabled = True self.task_depends = None self.plugins = {} + self.db_vims = db_vims_openstack + self.db = Mock(DbMemory()) self.worker_index = "worker-3" self.config = { "period": { @@ -87,7 +100,7 @@ class TestNsWorker(unittest.TestCase): "_id": "122436:1", "locked_by": None, "locked_at": 0.0, - "target_id": "vim_openstack_1", + "target_id": "my_target_vim", "vim_info": { "created": False, "created_items": None, @@ -115,6 +128,9 @@ class TestNsWorker(unittest.TestCase): }, ], } + self.instance = NsWorker(self.worker_index, self.config, self.plugins, self.db) + self.instance.db_vims = db_vims_openstack + self.instance.refresh_config = Mock() def get_disabled_tasks(self, db, status): db_disabled_tasks = db.get_list( @@ -126,137 +142,139 @@ class TestNsWorker(unittest.TestCase): ) return db_disabled_tasks - def test__update_vm_refresh(self): - with self.subTest( - i=1, - t="1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1", - ): - # Disabled task with status build will not enabled again - db = DbMemory() - self.ro_task["tasks"][0]["status"] = "BUILD" - self.ro_task["to_check_at"] = -1 - db.create("ro_tasks", self.ro_task) - disabled_tasks_count = len(self.get_disabled_tasks(db, "BUILD")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance.update_vm_refresh() - self.assertEqual( - len(self.get_disabled_tasks(db, "BUILD")), disabled_tasks_count - ) - - with self.subTest( - i=2, - t="1 disabled task with status DONE in DB, refresh_active parameter is equal to -1", - ): - # As refresh_active parameter is equal to -1, task will not be enabled to process again - db = DbMemory() - self.config["period"]["refresh_active"] = -1 - self.ro_task["tasks"][0]["status"] = "DONE" - self.ro_task["to_check_at"] = -1 - db.create("ro_tasks", self.ro_task) - disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance.update_vm_refresh() - self.assertEqual( - len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - ) - - with self.subTest( - i=3, - t="2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1", - ): - # Disabled tasks should be enabled to process again - db = DbMemory() - self.config["period"]["refresh_active"] = 66 - self.ro_task["tasks"][0]["status"] = "DONE" - self.ro_task["to_check_at"] = -1 - db.create("ro_tasks", self.ro_task) - self.ro_task2 = self.ro_task - self.ro_task2["_id"] = "122437:1" - db.create("ro_tasks", self.ro_task2) - disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance.update_vm_refresh() - self.assertEqual( - len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - 2 - ) + def test_update_vm_refresh_disabled_task_with_status_build_vim_openstack_with_refresh( + self, + ): + """1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1.""" + # Disabled task with status build is not enabled again + db = DbMemory() + self.ro_task["tasks"][0]["status"] = "BUILD" + self.config["period"]["refresh_active"] = 70 + self.ro_task["to_check_at"] = -1 + db.create("ro_tasks", self.ro_task) + disabled_tasks_count = len(self.get_disabled_tasks(db, "BUILD")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + instance.update_vm_refresh(self.ro_task) + self.assertEqual( + len(self.get_disabled_tasks(db, "BUILD")), disabled_tasks_count + ) - with self.subTest( - i=4, - t="No disabled task with status DONE in DB, refresh_active parameter is not equal to -1", - ): - # If there is not any disabled task, method will not change anything - db = DbMemory() - self.config["period"]["refresh_active"] = 66 - self.ro_task["tasks"][0]["status"] = "DONE" - self.ro_task["to_check_at"] = 16373242400.994312 - db.create("ro_tasks", self.ro_task) - self.ro_task2 = self.ro_task - self.ro_task2["_id"] = "122437:1" - db.create("ro_tasks", self.ro_task2) - disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance.update_vm_refresh() - self.assertEqual( - len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - ) + def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_no_refresh( + self, + ): + """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1.""" + # As refresh_active parameter is equal to -1, task is not be enabled to process again + db = DbMemory() + self.config["period"]["refresh_active"] = -1 + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = -1 + db.create("ro_tasks", self.ro_task) + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + instance.update_vm_refresh(self.ro_task) + self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) + + def test_update_vm_refresh_disabled_task_with_status_done_vim_aws_with_refresh( + self, + ): + """2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1.""" + # Disabled tasks should be enabled to process again as vim type aws + db = DbMemory() + self.config["period"]["refresh_active"] = 66 + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = -1 + db.create("ro_tasks", self.ro_task) + self.ro_task2 = self.ro_task + self.ro_task2["_id"] = "122437:1" + db.create("ro_tasks", self.ro_task2) + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + with patch.object(instance, "db_vims", db_vims_aws): + instance.update_vm_refresh(self.ro_task) + self.assertEqual( + len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - 2 + ) - def test__process_pending_tasks(self): - with self.subTest( - i=1, - t="refresh_active parameter is equal to -1, task status is DONE", - ): - # Task should be disabled to process again - db = DbMemory() - self.config["period"]["refresh_active"] = -1 - self.ro_task["tasks"][0]["status"] = "DONE" - self.ro_task["to_check_at"] = 16373242400.994312 - db.create("ro_tasks", self.ro_task) - # Number of disabled tasks in DB - disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance._process_pending_tasks(self.ro_task) - self.assertEqual( - len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + 1 - ) + def test_update_vm_refresh_no_disabled_task_with_status_done_vim_openstack_with_refresh( + self, + ): + """No disabled task with status DONE in DB, refresh_active parameter is not equal to -1.""" + # There is not any disabled task, method does not change anything + db = DbMemory() + self.config["period"]["refresh_active"] = 66 + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = 16373242400.994312 + db.create("ro_tasks", self.ro_task) + self.ro_task2 = self.ro_task + self.ro_task2["_id"] = "122437:1" + db.create("ro_tasks", self.ro_task2) + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + instance.update_vm_refresh(self.ro_task) + self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) + + def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_with_refresh( + self, + ): + """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1, vim type is Openstack.""" + # Disabled task with status done is not enabled again as vim type is openstack + db = DbMemory() + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = -1 + db.create("ro_tasks", self.ro_task) + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + instance.update_vm_refresh(self.ro_task) + self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count) + + def test_process_pending_tasks_status_done_vim_aws_no_refresh(self): + """Refresh_active parameter is equal to -1, task status is DONE.""" + # Task should be disabled to process again + db = DbMemory() + self.config["period"]["refresh_active"] = -1 + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = 16373242400.994312 + db.create("ro_tasks", self.ro_task) + # Number of disabled tasks in DB + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + with patch.object(instance, "db_vims", db_vims_aws): + instance._process_pending_tasks(self.ro_task) + self.assertEqual( + len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + 1 + ) - with self.subTest( - i=2, t="refresh_active parameter is equal to -1, task status is FAILED" - ): - # Task will not be disabled to process as task status is not DONE - db = DbMemory() - self.config["period"]["refresh_active"] = -1 - self.ro_task["tasks"][0]["status"] = "FAILED" - self.ro_task["to_check_at"] = 16373242400.994312 - db.create("ro_tasks", self.ro_task) - disabled_tasks_count = len(self.get_disabled_tasks(db, "FAILED")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance._process_pending_tasks(self.ro_task) - self.assertEqual( - len(self.get_disabled_tasks(db, "FAILED")), disabled_tasks_count - ) + def test_process_pending_tasks_status_failed_vim_aws_no_refresh(self): + """Refresh_active parameter is equal to -1, task status is FAILED.""" + # Task is not disabled to process as task status is not DONE + db = DbMemory() + self.config["period"]["refresh_active"] = -1 + self.ro_task["tasks"][0]["status"] = "FAILED" + self.ro_task["to_check_at"] = 16373242400.994312 + db.create("ro_tasks", self.ro_task) + disabled_tasks_count = len(self.get_disabled_tasks(db, "FAILED")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + with patch.object(instance, "db_vims", db_vims_aws): + instance._process_pending_tasks(self.ro_task) + self.assertEqual( + len(self.get_disabled_tasks(db, "FAILED")), disabled_tasks_count + ) - with self.subTest( - i=3, t="refresh_active parameter is not equal to -1, task status is DONE" - ): - # Task will not be disabled to process as refresh_active parameter is not -1 - db = DbMemory() - self.config["period"]["refresh_active"] = 70 - self.ro_task["tasks"][0]["status"] = "DONE" - self.ro_task["to_check_at"] = 16373242400.994312 - db.create("ro_tasks", self.ro_task) - disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) - instance = NsWorker(self.worker_index, self.config, self.plugins, db) - with patch.object(instance, "logger", logging): - instance._process_pending_tasks(self.ro_task) - self.assertEqual( - len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - ) + def test_process_pending_tasks_status_done_vim_aws_with_refresh(self): + """Refresh_active parameter is not equal to -1, task status is DONE.""" + # Task is not disabled to process as refresh_active parameter is not -1 + db = DbMemory() + self.config["period"]["refresh_active"] = 70 + self.ro_task["tasks"][0]["status"] = "DONE" + self.ro_task["to_check_at"] = 16373242400.994312 + db.create("ro_tasks", self.ro_task) + disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE")) + instance = NsWorker(self.worker_index, self.config, self.plugins, db) + with patch.object(instance, "db_vims", db_vims_aws): + instance._process_pending_tasks(self.ro_task) + self.assertEqual( + len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + ) @patch("osm_ng_ro.ns_thread.makedirs", return_value="") def test_create_file_cert(self, mock_makedirs): @@ -326,6 +344,31 @@ class TestNsWorker(unittest.TestCase): ) assert vim_config["config"]["ca_cert_content"] == "test" + def test_get_next_refresh_vim_type_openstack(self): + next_refresh = 163535353434.3434 + result = self.instance._get_next_refresh(self.ro_task, next_refresh) + self.assertEqual(result, -1) + + def test_get_next_refresh_vim_type_openstack_refresh_disabled(self): + next_refresh = 163535353434.3434 + self.instance.refresh_config.active = -1 + result = self.instance._get_next_refresh(self.ro_task, next_refresh) + self.assertEqual(result, -1) + + def test_get_next_refresh_vim_type_aws_refresh_disabled(self): + self.db_vims = db_vims_aws + next_refresh = 163535353434.3434 + self.instance.refresh_config.active = -1 + result = self.instance._get_next_refresh(self.ro_task, next_refresh) + self.assertEqual(result, -1) + + def test_get_next_refresh_vim_type_aws(self): + self.instance.db_vims = db_vims_aws + next_refresh = 163535353434.3434 + self.instance.refresh_config.active = 140 + result = self.instance._get_next_refresh(self.ro_task, next_refresh) + self.assertEqual(result, next_refresh + 140) + class TestVimInteractionNet(unittest.TestCase): def setUp(self): @@ -1101,6 +1144,7 @@ class TestVimInteractionNet(unittest.TestCase): db_vims = { "vim_openstack_1": { "config": {}, + "vim_type": "openstack", }, } instance = VimInteractionNet(db, logger, my_vims, db_vims) @@ -1156,6 +1200,7 @@ class TestVimInteractionNet(unittest.TestCase): db_vims = { "vim_openstack_1": { "config": {}, + "vim_type": "openstack", }, } instance = VimInteractionNet(db, logger, my_vims, db_vims) @@ -1212,6 +1257,7 @@ class TestVimInteractionNet(unittest.TestCase): db_vims = { "vim_openstack_1": { "config": {}, + "vim_type": "openstack", }, } instance = VimInteractionNet(db, logger, my_vims, db_vims) @@ -1268,6 +1314,7 @@ class TestVimInteractionNet(unittest.TestCase): db_vims = { "vim_openstack_1": { "config": {}, + "vim_type": "openstack", }, } instance = VimInteractionNet(db, logger, my_vims, db_vims) @@ -1313,6 +1360,7 @@ class TestVimInteractionNet(unittest.TestCase): db_vims = { "vim_openstack_1": { "config": {}, + "vim_type": "openstack", }, } instance = VimInteractionNet(db, logger, my_vims, db_vims) @@ -1403,6 +1451,218 @@ class TestVimInteractionNet(unittest.TestCase): instance.refresh(ro_task) +class TestVimInteractionSharedVolume(unittest.TestCase): + def setUp(self): + module_name = "osm_ro_plugin" + self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector") + self.task_depends = None + + patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)] + + # Enabling mocks and add cleanups + for mock in patches: + mock.start() + self.addCleanup(mock.stop) + + def test__new_shared_volume_ok(self): + """ + create a shared volume with attributes set in params + """ + db = "test_db" + logger = "test_logger" + my_vims = "test-vim" + db_vims = { + 0: { + "config": {}, + }, + } + + instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) + with patch.object(instance, "my_vims", [self.target_vim]), patch.object( + instance, "logger", logging + ), patch.object(instance, "db_vims", db_vims): + ro_task = { + "target_id": 0, + "tasks": { + "task_index_1": { + "target_id": 0, + "action_id": "123456", + "nsr_id": "654321", + "task_id": "123456:1", + "status": "SCHEDULED", + "action": "CREATE", + "item": "test_item", + "target_record": "test_target_record", + "target_record_id": "test_target_record_id", + # values coming from extra_dict + "params": { + "shared_volume_data": { + "size": "10", + "name": "shared-volume", + "type": "multiattach", + } + }, + "find_params": {}, + "depends_on": "test_depends_on", + }, + }, + } + task_index = "task_index_1" + self.target_vim.new_shared_volumes.return_value = ("", "shared-volume") + result = instance.new(ro_task, task_index, self.task_depends) + self.assertEqual(result[0], "DONE") + self.assertEqual(result[1].get("vim_id"), "shared-volume") + self.assertEqual(result[1].get("created"), True) + self.assertEqual(result[1].get("vim_status"), "ACTIVE") + + def test__new_shared_volume_failed(self): + """ + create a shared volume with attributes set in params failed + """ + db = "test_db" + logger = "test_logger" + my_vims = "test-vim" + db_vims = { + 0: { + "config": {}, + }, + } + + instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) + with patch.object(instance, "my_vims", [self.target_vim]), patch.object( + instance, "logger", logging + ), patch.object(instance, "db_vims", db_vims): + ro_task = { + "target_id": 0, + "tasks": { + "task_index_1": { + "target_id": 0, + "action_id": "123456", + "nsr_id": "654321", + "task_id": "123456:1", + "status": "SCHEDULED", + "action": "CREATE", + "item": "test_item", + "target_record": "test_target_record", + "target_record_id": "test_target_record_id", + # values coming from extra_dict + "params": { + "shared_volume_data": { + "size": "10", + "name": "shared-volume", + "type": "multiattach", + } + }, + "find_params": {}, + "depends_on": "test_depends_on", + }, + }, + } + task_index = "task_index_1" + self.target_vim.new_shared_volumes.side_effect = VimConnException( + "Connection failed." + ) + result = instance.new(ro_task, task_index, self.task_depends) + self.assertEqual(result[0], "FAILED") + self.assertEqual(result[1].get("vim_message"), "Connection failed.") + self.assertEqual(result[1].get("created"), False) + self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") + + def test__delete_shared_volume_ok(self): + """ + Delete a shared volume with attributes set in params + """ + db = "test_db" + logger = "test_logger" + my_vims = "test-vim" + db_vims = { + 0: { + "config": {}, + }, + } + + instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) + with patch.object(instance, "my_vims", [self.target_vim]), patch.object( + instance, "logger", logging + ), patch.object(instance, "db_vims", db_vims): + ro_task = { + "target_id": 0, + "tasks": { + "task_index_3": { + "target_id": 0, + "task_id": "123456:1", + }, + }, + "vim_info": { + "created": False, + "created_items": None, + "vim_id": "sample_shared_volume_id_3", + "vim_name": "sample_shared_volume_3", + "vim_status": None, + "vim_details": "some-details", + "vim_message": None, + "refresh_at": None, + }, + } + + task_index = "task_index_3" + self.target_vim.delete_shared_volumes.return_value = True + result = instance.delete(ro_task, task_index) + self.assertEqual(result[0], "DONE") + self.assertEqual(result[1].get("vim_id"), None) + self.assertEqual(result[1].get("created"), False) + self.assertEqual(result[1].get("vim_status"), "DELETED") + + def test__delete_shared_volume_failed(self): + """ + Delete a shared volume with attributes set in params failed + """ + db = "test_db" + logger = "test_logger" + my_vims = "test-vim" + db_vims = { + 0: { + "config": {}, + }, + } + + instance = VimInteractionSharedVolume(db, logger, my_vims, db_vims) + with patch.object(instance, "my_vims", [self.target_vim]), patch.object( + instance, "logger", logging + ), patch.object(instance, "db_vims", db_vims): + ro_task = { + "_id": "122436:1", + "target_id": 0, + "tasks": { + "task_index_3": { + "target_id": 0, + "task_id": "123456:1", + }, + }, + "vim_info": { + "created": False, + "created_items": None, + "vim_id": "sample_shared_volume_id_3", + "vim_name": "sample_shared_volume_3", + "vim_status": None, + "vim_details": "some-details", + "vim_message": None, + "refresh_at": None, + }, + } + + task_index = "task_index_3" + self.target_vim.delete_shared_volumes.side_effect = VimConnException( + "Connection failed." + ) + result = instance.delete(ro_task, task_index) + self.assertEqual(result[0], "FAILED") + self.assertEqual( + result[1].get("vim_message"), "Error while deleting: Connection failed." + ) + self.assertEqual(result[1].get("vim_status"), "VIM_ERROR") + + class TestVimInteractionAffinityGroup(unittest.TestCase): def setUp(self): module_name = "osm_ro_plugin" @@ -1468,7 +1728,7 @@ class TestVimInteractionAffinityGroup(unittest.TestCase): self.assertEqual(result[0], "DONE") self.assertEqual(result[1].get("vim_id"), "sample_affinity_group_id_1") self.assertEqual(result[1].get("created"), True) - self.assertEqual(result[1].get("vim_status"), "DONE") + self.assertEqual(result[1].get("vim_status"), "ACTIVE") def test__new_affinity_group_failed(self): """ @@ -1516,7 +1776,7 @@ class TestVimInteractionAffinityGroup(unittest.TestCase): self.assertEqual(result[0], "DONE") self.assertEqual(result[1].get("vim_id"), None) self.assertEqual(result[1].get("created"), False) - self.assertEqual(result[1].get("vim_status"), "DONE") + self.assertEqual(result[1].get("vim_status"), "ACTIVE") def test__delete_affinity_group_ok(self): """ @@ -1668,7 +1928,7 @@ class TestVimInteractionResize(unittest.TestCase): task_index = "task_index_1" result = instance.exec(ro_task, task_index, self.task_depends) self.assertEqual(result[0], "DONE") - self.assertEqual(result[1].get("vim_status"), "DONE") + self.assertEqual(result[1].get("vim_status"), "ACTIVE") class TestVimInteractionMigration(unittest.TestCase):