X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_lcm%2Ftests%2Ftest_ns.py;h=d7192c9196846a1908db0f963a4e739780b94fe6;hb=refs%2Fchanges%2F84%2F11984%2F12;hp=ef87a4c4bc9e76b972c72059a672f6d75bd0cfa6;hpb=4554a700d861c477360b6360920a5cb8c1f61718;p=osm%2FLCM.git diff --git a/osm_lcm/tests/test_ns.py b/osm_lcm/tests/test_ns.py index ef87a4c..d7192c9 100644 --- a/osm_lcm/tests/test_ns.py +++ b/osm_lcm/tests/test_ns.py @@ -27,7 +27,11 @@ from osm_lcm.lcm_utils import TaskRegistry from osm_lcm.ng_ro import NgRoClient from osm_lcm.data_utils.database.database import Database from osm_lcm.data_utils.filesystem.filesystem import Filesystem +from osm_lcm.data_utils.vnfd import find_software_version +from osm_lcm.lcm_utils import check_juju_bundle_existence, get_charm_artifact_path +from osm_lcm.lcm_utils import LcmException from uuid import uuid4 +from unittest.mock import Mock, patch from osm_lcm.tests import test_db_descriptors as descriptors @@ -116,6 +120,13 @@ class TestMyNS(asynctest.TestCase): def _ro_status(self, *args, **kwargs): print("Args > {}".format(args)) print("kwargs > {}".format(kwargs)) + if args: + if "update" in args: + ro_ns_desc = yaml.load( + descriptors.ro_update_action_text, Loader=yaml.Loader + ) + while True: + yield ro_ns_desc if kwargs.get("delete"): ro_ns_desc = yaml.load( descriptors.ro_delete_action_text, Loader=yaml.Loader @@ -168,6 +179,10 @@ class TestMyNS(asynctest.TestCase): self.db.create_list( "vnfds", yaml.load(descriptors.db_vnfds_text, Loader=yaml.Loader) ) + self.db.create_list( + "vnfds_revisions", + yaml.load(descriptors.db_vnfds_revisions_text, Loader=yaml.Loader), + ) self.db.create_list( "nsds", yaml.load(descriptors.db_nsds_text, Loader=yaml.Loader) ) @@ -375,6 +390,38 @@ class TestMyNS(asynctest.TestCase): # await self.test_instantiate() # # this will check that the initial-congig-primitive 'not_to_be_called' is not called + @asynctest.fail_on(active_handles=True) + async def test_start_stop_rebuild_pass(self): + nsr_id = descriptors.test_ids["TEST-OP-VNF"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-OP-VNF"]["nslcmops"] + vnf_id = descriptors.test_ids["TEST-OP-VNF"]["vnfrs"] + additional_param = {"count-index": "0"} + operation_type = "start" + await self.my_ns.rebuild_start_stop( + nsr_id, nslcmop_id, vnf_id, additional_param, operation_type + ) + expected_value = "COMPLETED" + return_value = self.db.get_one("nslcmops", {"_id": nslcmop_id}).get( + "operationState" + ) + self.assertEqual(return_value, expected_value) + + @asynctest.fail_on(active_handles=True) + async def test_start_stop_rebuild_fail(self): + nsr_id = descriptors.test_ids["TEST-OP-VNF"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-OP-VNF"]["nslcmops1"] + vnf_id = descriptors.test_ids["TEST-OP-VNF"]["vnfrs"] + additional_param = {"count-index": "0"} + operation_type = "stop" + await self.my_ns.rebuild_start_stop( + nsr_id, nslcmop_id, vnf_id, additional_param, operation_type + ) + expected_value = "Error" + return_value = self.db.get_one("nslcmops", {"_id": nslcmop_id}).get( + "operationState" + ) + self.assertEqual(return_value, expected_value) + # Test scale() and related methods @asynctest.fail_on(active_handles=True) # all async tasks must be completed async def test_scale(self): @@ -775,6 +822,58 @@ class TestMyNS(asynctest.TestCase): or expected_kdu_model in nsr_kdu_model_result ) + # Test remove_vnf() and related methods + @asynctest.fail_on(active_handles=True) # all async tasks must be completed + async def test_remove_vnf(self): + # Test REMOVE_VNF + nsr_id = descriptors.test_ids["TEST-UPDATE"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-UPDATE"]["removeVnf"] + vnf_instance_id = descriptors.test_ids["TEST-UPDATE"]["vnf"] + mock_wait_ng_ro = asynctest.CoroutineMock() + with patch("osm_lcm.ns.NsLcm._wait_ng_ro", mock_wait_ng_ro): + await self.my_ns.update(nsr_id, nslcmop_id) + expected_value = "COMPLETED" + return_value = self.db.get_one("nslcmops", {"_id": nslcmop_id}).get( + "operationState" + ) + self.assertEqual(return_value, expected_value) + with self.assertRaises(Exception) as context: + self.db.get_one("vnfrs", {"_id": vnf_instance_id}) + self.assertTrue("database exception Not found entry with filter" in str(context.exception)) + + # test vertical scale executes sucessfully + # @patch("osm_lcm.ng_ro.status.response") + @asynctest.fail_on(active_handles=True) + async def test_vertical_scaling(self): + nsr_id = descriptors.test_ids["TEST-V-SCALE"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-V-SCALE"]["instantiate"] + + # calling the vertical scale fucntion + # self.my_ns.RO.status = asynctest.CoroutineMock(self.my_ns.RO.status, side_effect=self._ro_status("update")) + mock_wait_ng_ro = asynctest.CoroutineMock() + with patch("osm_lcm.ns.NsLcm._wait_ng_ro", mock_wait_ng_ro): + await self.my_ns.vertical_scale(nsr_id, nslcmop_id) + return_value = self.db.get_one("nslcmops", {"_id": nslcmop_id}).get( + "operationState" + ) + expected_value = "COMPLETED" + self.assertEqual(return_value, expected_value) + + # test vertical scale executes fail + @asynctest.fail_on(active_handles=True) + async def test_vertical_scaling_fail(self): + # get th nsr nad nslcmops id from descriptors + nsr_id = descriptors.test_ids["TEST-V-SCALE"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-V-SCALE"]["instantiate-1"] + + # calling the vertical scale fucntion + await self.my_ns.vertical_scale(nsr_id, nslcmop_id) + return_value = self.db.get_one("nslcmops", {"_id": nslcmop_id}).get( + "operationState" + ) + expected_value = "FAILED" + self.assertEqual(return_value, expected_value) + # async def test_instantiate_pdu(self): # nsr_id = descriptors.test_ids["TEST-A"]["ns"] # nslcmop_id = descriptors.test_ids["TEST-A"]["instantiate"] @@ -855,6 +954,748 @@ class TestMyNS(asynctest.TestCase): # self.assertEqual(db_nsr.get("errorDescription "), None, "errorDescription different than None") # self.assertEqual(db_nsr.get("errorDetail"), None, "errorDetail different than None") + # Test update method + + async def test_update(self): + + nsr_id = descriptors.test_ids["TEST-A"]["ns"] + nslcmop_id = descriptors.test_ids["TEST-A"]["update"] + vnfr_id = "6421c7c9-d865-4fb4-9a13-d4275d243e01" + vnfd_id = "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77" + + def mock_reset(): + mock_charm_hash.reset_mock() + mock_juju_bundle.reset_mock() + fs.sync.reset_mock() + mock_charm_upgrade.reset_mock() + mock_software_version.reset_mock() + + with self.subTest( + i=1, + t="Update type: CHANGE_VNFPKG, latest_vnfd revision changed," + "Charm package changed, sw-version is not changed.", + ): + + self.db.set_one( + "vnfds", + q_filter={"_id": vnfd_id}, + update_dict={"_admin.revision": 3, "kdu": []}, + ) + + self.db.set_one( + "vnfds_revisions", + q_filter={"_id": vnfd_id + ":1"}, + update_dict={"_admin.revision": 1, "kdu": []}, + ) + + self.db.set_one( + "vnfrs", q_filter={"_id": vnfr_id}, update_dict={"revision": 1} + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = True + + mock_juju_bundle = Mock(return_value=None) + + mock_software_version = Mock(autospec=True) + mock_software_version.side_effect = ["1.0", "1.0"] + + mock_charm_upgrade = asynctest.Mock(autospec=True) + task = asyncio.Future() + task.set_result(("COMPLETED", "some_output")) + mock_charm_upgrade.return_value = task + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "COMPLETED" + expected_operation_error = "" + expected_vnfr_revision = 3 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.ns.NsLcm._ns_charm_upgrade", mock_charm_upgrade), patch( + "osm_lcm.data_utils.vnfd.find_software_version", mock_software_version + ), patch( + "osm_lcm.lcm_utils.check_juju_bundle_existence", mock_juju_bundle + ): + + await instance.update(nsr_id, nslcmop_id) + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + mock_charm_hash.assert_called_with( + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:1/hackfest_3charmed_vnfd/charms/simple", + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:3/hackfest_3charmed_vnfd/charms/simple", + ) + + self.assertEqual(fs.sync.call_count, 2) + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + with self.subTest( + i=2, t="Update type: CHANGE_VNFPKG, latest_vnfd revision not changed" + ): + + self.db.set_one( + "vnfds", q_filter={"_id": vnfd_id}, update_dict={"_admin.revision": 1} + ) + + self.db.set_one( + "vnfrs", q_filter={"_id": vnfr_id}, update_dict={"revision": 1} + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = True + + mock_juju_bundle = Mock(return_value=None) + mock_software_version = Mock(autospec=True) + + mock_charm_upgrade = asynctest.Mock(autospec=True) + task = asyncio.Future() + task.set_result(("COMPLETED", "some_output")) + mock_charm_upgrade.return_value = task + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "COMPLETED" + expected_operation_error = "" + expected_vnfr_revision = 1 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.ns.NsLcm._ns_charm_upgrade", mock_charm_upgrade), patch( + "osm_lcm.lcm_utils.check_juju_bundle_existence", mock_juju_bundle + ): + + await instance.update(nsr_id, nslcmop_id) + + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + mock_charm_hash.assert_not_called() + mock_software_version.assert_not_called() + mock_juju_bundle.assert_not_called() + mock_charm_upgrade.assert_not_called() + fs.sync.assert_not_called() + + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + with self.subTest( + i=3, + t="Update type: CHANGE_VNFPKG, latest_vnfd revision changed, " + "Charm package is not changed, sw-version is not changed.", + ): + + self.db.set_one( + "vnfds", q_filter={"_id": vnfd_id}, update_dict={"_admin.revision": 3} + ) + + self.db.set_one( + "vnfds_revisions", + q_filter={"_id": vnfd_id + ":1"}, + update_dict={"_admin.revision": 1}, + ) + + self.db.set_one( + "vnfrs", q_filter={"_id": vnfr_id}, update_dict={"revision": 1} + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = False + + mock_juju_bundle = Mock(return_value=None) + + mock_software_version = Mock(autospec=True) + + mock_charm_upgrade = asynctest.Mock(autospec=True) + task = asyncio.Future() + task.set_result(("COMPLETED", "some_output")) + mock_charm_upgrade.return_value = task + mock_software_version.side_effect = ["1.0", "1.0"] + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "COMPLETED" + expected_operation_error = "" + expected_vnfr_revision = 3 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.ns.NsLcm._ns_charm_upgrade", mock_charm_upgrade), patch( + "osm_lcm.lcm_utils.check_juju_bundle_existence", mock_juju_bundle + ): + + await instance.update(nsr_id, nslcmop_id) + + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + mock_charm_hash.assert_called_with( + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:1/hackfest_3charmed_vnfd/charms/simple", + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:3/hackfest_3charmed_vnfd/charms/simple", + ) + + self.assertEqual(fs.sync.call_count, 2) + self.assertEqual(mock_charm_hash.call_count, 1) + + mock_juju_bundle.assert_not_called() + mock_charm_upgrade.assert_not_called() + + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + with self.subTest( + i=4, + t="Update type: CHANGE_VNFPKG, latest_vnfd revision changed, " + "Charm package exists, sw-version changed.", + ): + + self.db.set_one( + "vnfds", + q_filter={"_id": vnfd_id}, + update_dict={"_admin.revision": 3, "software-version": "3.0"}, + ) + + self.db.set_one( + "vnfds_revisions", + q_filter={"_id": vnfd_id + ":1"}, + update_dict={"_admin.revision": 1}, + ) + + self.db.set_one( + "vnfrs", + q_filter={"_id": vnfr_id}, + update_dict={"revision": 1}, + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = False + + mock_juju_bundle = Mock(return_value=None) + + mock_charm_upgrade = asynctest.Mock(autospec=True) + task = asyncio.Future() + task.set_result(("COMPLETED", "some_output")) + mock_charm_upgrade.return_value = task + + mock_charm_artifact = Mock(autospec=True) + mock_charm_artifact.side_effect = [ + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:1/hackfest_3charmed_vnfd/charms/simple", + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77/hackfest_3charmed_vnfd/charms/simple", + ] + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "FAILED" + expected_operation_error = "FAILED Checking if existing VNF has charm: Software version change is not supported as VNF instance 6421c7c9-d865-4fb4-9a13-d4275d243e01 has charm." + expected_vnfr_revision = 1 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.ns.NsLcm._ns_charm_upgrade", mock_charm_upgrade), patch( + "osm_lcm.lcm_utils.get_charm_artifact_path", mock_charm_artifact + ): + + await instance.update(nsr_id, nslcmop_id) + + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + self.assertEqual(fs.sync.call_count, 2) + mock_charm_hash.assert_not_called() + + mock_juju_bundle.assert_not_called() + mock_charm_upgrade.assert_not_called() + + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + with self.subTest( + i=5, + t="Update type: CHANGE_VNFPKG, latest_vnfd revision changed," + "Charm package exists, sw-version not changed, juju-bundle exists", + ): + + self.db.set_one( + "vnfds", + q_filter={"_id": vnfd_id}, + update_dict={ + "_admin.revision": 3, + "software-version": "1.0", + "kdu.0.juju-bundle": "stable/native-kdu", + }, + ) + + self.db.set_one( + "vnfds_revisions", + q_filter={"_id": vnfd_id + ":1"}, + update_dict={ + "_admin.revision": 1, + "software-version": "1.0", + "kdu.0.juju-bundle": "stable/native-kdu", + }, + ) + + self.db.set_one( + "vnfrs", q_filter={"_id": vnfr_id}, update_dict={"revision": 1} + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = True + + mock_charm_artifact = Mock(autospec=True) + mock_charm_artifact.side_effect = [ + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:1/hackfest_3charmed_vnfd/charms/simple", + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77/hackfest_3charmed_vnfd/charms/simple", + ] + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "FAILED" + expected_operation_error = "FAILED Checking whether VNF uses juju bundle: Charm upgrade is not supported for the instance which uses juju-bundle: stable/native-kdu" + expected_vnfr_revision = 1 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.lcm_utils.get_charm_artifact_path", mock_charm_artifact): + + await instance.update(nsr_id, nslcmop_id) + + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + self.assertEqual(fs.sync.call_count, 2) + self.assertEqual(mock_charm_hash.call_count, 1) + self.assertEqual(mock_charm_hash.call_count, 1) + + mock_charm_upgrade.assert_not_called() + + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + with self.subTest( + i=6, + t="Update type: CHANGE_VNFPKG, latest_vnfd revision changed," + "Charm package exists, sw-version not changed, charm-upgrade failed", + ): + + self.db.set_one( + "vnfds", + q_filter={"_id": vnfd_id}, + update_dict={ + "_admin.revision": 3, + "software-version": "1.0", + "kdu": [], + }, + ) + + self.db.set_one( + "vnfds_revisions", + q_filter={"_id": vnfd_id + ":1"}, + update_dict={ + "_admin.revision": 1, + "software-version": "1.0", + "kdu": [], + }, + ) + + self.db.set_one( + "vnfrs", q_filter={"_id": vnfr_id}, update_dict={"revision": 1} + ) + + mock_charm_hash = Mock(autospec=True) + mock_charm_hash.return_value = True + + mock_charm_upgrade = asynctest.Mock(autospec=True) + task = asyncio.Future() + task.set_result(("FAILED", "some_error")) + mock_charm_upgrade.return_value = task + + mock_charm_artifact = Mock(autospec=True) + mock_charm_artifact.side_effect = [ + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:1/hackfest_3charmed_vnfd/charms/simple", + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77/hackfest_3charmed_vnfd/charms/simple", + ] + + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + fs.sync.side_effect = [None, None] + + instance = self.my_ns + + expected_operation_state = "FAILED" + expected_operation_error = "some_error" + expected_vnfr_revision = 1 + expected_ns_state = "INSTANTIATED" + expected_ns_operational_state = "running" + + with patch.object(instance, "fs", fs), patch( + "osm_lcm.lcm_utils.LcmBase.check_charm_hash_changed", mock_charm_hash + ), patch("osm_lcm.ns.NsLcm._ns_charm_upgrade", mock_charm_upgrade): + + await instance.update(nsr_id, nslcmop_id) + + return_operation_state = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("operationState") + + return_operation_error = self.db.get_one( + "nslcmops", {"_id": nslcmop_id} + ).get("errorMessage") + + return_ns_operational_state = self.db.get_one( + "nsrs", {"_id": nsr_id} + ).get("operational-status") + + return_vnfr_revision = self.db.get_one("vnfrs", {"_id": vnfr_id}).get( + "revision" + ) + + return_ns_state = self.db.get_one("nsrs", {"_id": nsr_id}).get( + "nsState" + ) + + self.assertEqual(fs.sync.call_count, 2) + self.assertEqual(mock_charm_hash.call_count, 1) + self.assertEqual(mock_charm_upgrade.call_count, 1) + + self.assertEqual(return_ns_state, expected_ns_state) + self.assertEqual(return_operation_state, expected_operation_state) + self.assertEqual(return_operation_error, expected_operation_error) + self.assertEqual( + return_ns_operational_state, expected_ns_operational_state + ) + self.assertEqual(return_vnfr_revision, expected_vnfr_revision) + + mock_reset() + + def test_ns_update_helper_methods(self): + def mock_reset(): + fs.mock_reset() + mock_path.mock_reset() + mock_checksumdir.mock_reset() + + with self.subTest( + i=1, t="Find software version, VNFD does not have have software version" + ): + # Testing method find_software_version + + db_vnfd = self.db.get_one( + "vnfds", {"_id": "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77"} + ) + expected_result = "1.0" + result = find_software_version(db_vnfd) + self.assertEqual( + result, expected_result, "Default sw version should be 1.0" + ) + + with self.subTest( + i=2, t="Find software version, VNFD includes software version" + ): + # Testing method find_software_version + + db_vnfd = self.db.get_one( + "vnfds", {"_id": "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77"} + ) + db_vnfd["software-version"] = "3.1" + expected_result = "3.1" + result = find_software_version(db_vnfd) + self.assertEqual(result, expected_result, "VNFD software version is wrong") + + with self.subTest(i=3, t="Check charm hash, Hash has did not change"): + # Testing method check_charm_hash_changed + + current_path, target_path = "/tmp/charm1", "/tmp/charm1" + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + + mock_path = Mock(autospec=True) + mock_path.exists.side_effect = [True, True] + + mock_checksumdir = Mock(autospec=True) + mock_checksumdir.dirhash.side_effect = ["hash_value", "hash_value"] + + instance = self.my_ns + expected_result = False + + with patch.object(instance, "fs", fs), patch( + "checksumdir.dirhash", mock_checksumdir.dirhash + ), patch("os.path.exists", mock_path.exists): + + result = instance.check_charm_hash_changed(current_path, target_path) + self.assertEqual( + result, expected_result, "Wrong charm hash control value" + ) + self.assertEqual(mock_path.exists.call_count, 2) + self.assertEqual(mock_checksumdir.dirhash.call_count, 2) + + mock_reset() + + with self.subTest(i=4, t="Check charm hash, Hash has changed"): + # Testing method check_charm_hash_changed + + current_path, target_path = "/tmp/charm1", "/tmp/charm2" + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + + mock_path = Mock(autospec=True) + mock_path.exists.side_effect = [True, True] + + mock_checksumdir = Mock(autospec=True) + mock_checksumdir.dirhash.side_effect = ["hash_value", "another_hash_value"] + + instance = self.my_ns + expected_result = True + + with patch.object(instance, "fs", fs), patch( + "checksumdir.dirhash", mock_checksumdir.dirhash + ), patch("os.path.exists", mock_path.exists): + + result = instance.check_charm_hash_changed(current_path, target_path) + self.assertEqual( + result, expected_result, "Wrong charm hash control value" + ) + self.assertEqual(mock_path.exists.call_count, 2) + self.assertEqual(mock_checksumdir.dirhash.call_count, 2) + + mock_reset() + + with self.subTest(i=5, t="Check charm hash, Charm path does not exists"): + # Testing method check_charm_hash_changed + + current_path, target_path = "/tmp/charm1", "/tmp/charm2" + fs = Mock(autospec=True) + fs.path.__add__ = Mock() + fs.path.side_effect = ["/", "/", "/", "/"] + + mock_path = Mock(autospec=True) + mock_path.exists.side_effect = [True, False] + + mock_checksumdir = Mock(autospec=True) + mock_checksumdir.dirhash.side_effect = ["hash_value", "hash_value"] + + instance = self.my_ns + + with patch.object(instance, "fs", fs), patch( + "checksumdir.dirhash", mock_checksumdir.dirhash + ), patch("os.path.exists", mock_path.exists): + + with self.assertRaises(LcmException): + + instance.check_charm_hash_changed(current_path, target_path) + self.assertEqual(mock_path.exists.call_count, 2) + self.assertEqual(mock_checksumdir.dirhash.call_count, 0) + + mock_reset() + + with self.subTest(i=6, t="Check juju bundle existence"): + # Testing method check_juju_bundle_existence + + test_vnfd1 = self.db.get_one( + "vnfds", {"_id": "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77"} + ) + test_vnfd2 = self.db.get_one( + "vnfds", {"_id": "d96b1cdf-5ad6-49f7-bf65-907ada989293"} + ) + + expected_result = None + result = check_juju_bundle_existence(test_vnfd1) + self.assertEqual(result, expected_result, "Wrong juju bundle name") + + expected_result = "stable/native-kdu" + result = check_juju_bundle_existence(test_vnfd2) + self.assertEqual(result, expected_result, "Wrong juju bundle name") + + with self.subTest(i=7, t="Check charm artifacts"): + # Testing method check_juju_bundle_existence + + base_folder = { + "folder": "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77", + "pkg-dir": "hackfest_3charmed_vnfd", + } + charm_name = "simple" + charm_type = "lxc_proxy_charm" + revision = 3 + + expected_result = "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77:3/hackfest_3charmed_vnfd/charms/simple" + result = get_charm_artifact_path( + base_folder, charm_name, charm_type, revision + ) + self.assertEqual(result, expected_result, "Wrong charm artifact path") + + # SOL004 packages + base_folder = { + "folder": "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77", + } + charm_name = "basic" + charm_type = "" + revision = "" + + expected_result = ( + "7637bcf8-cf14-42dc-ad70-c66fcf1e6e77/Scripts/helm-charts/basic" + ) + result = get_charm_artifact_path( + base_folder, charm_name, charm_type, revision + ) + self.assertEqual(result, expected_result, "Wrong charm artifact path") + if __name__ == "__main__": asynctest.main()