starlingx/distcloud
Code Issues Proposed changes

Update the mock methods in dcmanager to use _mock_object

Browse Source 
Previously, there wasn't a common method for managing the creation of
mocks, which resulted in multiple files having their own logic for that.
In 1 and 2, the _mock_object was updated in order to create the
functionality and this commit updates dcmanager code to use it.

Test plan:
1. PASS: Run tox -c distributedcloud/tox.ini -e py39 multiple times and
   verify that there isn't any test failures.

Story: 2007082
Task: 51466

[1] https://review.opendev.org/c/starlingx/distcloud/+/934254
[2] https://review.opendev.org/c/starlingx/distcloud/+/937209

Change-Id: I821e6e9add88e8e3bd74c18ef834019b740c49c6
Signed-off-by: Raphael Lima <Raphael.Lima@windriver.com>
This commit is contained in:
Raphael Lima 2024-12-11 17:49:01 -03:00
parent 0578e65372
commit ec7201ae0b
17 changed files with 706 additions and 1130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
distributedcloud/dcmanager/tests/unit/api/controllers/v1/test_phased_subcloud_deploy.py
View File

@ -42,37 +42,6 @@ class BaseTestPhasedSubcloudDeployController(DCManagerApiTest):
self._mock_object(psd_common, "get_ks_client") self._mock_object(psd_common, "get_ks_client")
self._mock_object(psd_common.PatchingClient, "query") self._mock_object(psd_common.PatchingClient, "query")
def _mock_populate_payload(self):
mock_patch_object = mock.patch.object(
psd_common, "populate_payload_with_pre_existing_data"
)
self.mock_populate_payload = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_get_request_data(self):
mock_patch_object = mock.patch.object(psd_common, "get_request_data")
self.mock_get_request_data = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_get_subcloud_db_install_values(self):
mock_patch_object = mock.patch.object(
psd_common, "get_subcloud_db_install_values"
)
self.mock_get_subcloud_db_install_values = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_is_initial_deployment(self):
mock_patch_object = mock.patch.object(psd_common, "is_initial_deployment")
self.mock_is_initial_deployment = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_is_valid_software_deploy_state(self):
mock_patch_object = mock.patch.object(
SubcloudsController, "is_valid_software_deploy_state"
)
self.mock_is_valid_software_deploy_state = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
class TestPhasedSubcloudDeployController(BaseTestPhasedSubcloudDeployController): class TestPhasedSubcloudDeployController(BaseTestPhasedSubcloudDeployController):
"""Test class for PhasedSubcloudDeployController""" """Test class for PhasedSubcloudDeployController"""
@ -216,8 +185,10 @@ class BaseTestPhasedSubcloudDeployPatch(BaseTestPhasedSubcloudDeployController):
self.mock_get_vault_load_files = self._mock_object( self.mock_get_vault_load_files = self._mock_object(
dutils, "get_vault_load_files" dutils, "get_vault_load_files"
) )
self._mock_is_initial_deployment() self.mock_is_initial_deployment = self._mock_object(
self._mock_is_valid_software_deploy_state() psd_common, "is_initial_deployment"
)
self._mock_object(SubcloudsController, "is_valid_software_deploy_state")
self.mock_get_network_address_pools = self._mock_object( self.mock_get_network_address_pools = self._mock_object(
psd_common, "get_network_address_pools" psd_common, "get_network_address_pools"
) )
@ -471,8 +442,8 @@ class TestPhasedSubcloudDeployPatchConfigure(BaseTestPhasedSubcloudDeployPatch):
data_install=json.dumps(self.data_install), data_install=json.dumps(self.data_install),
) )
self._mock_populate_payload() self._mock_object(psd_common, "populate_payload_with_pre_existing_data")
self._mock_get_request_data() self.mock_get_request_data = self._mock_object(psd_common, "get_request_data")
self.mock_get_request_data.return_value = self.params self.mock_get_request_data.return_value = self.params
@ -643,9 +614,11 @@ class TestPhasedSubcloudDeployPatchInstall(BaseTestPhasedSubcloudDeployPatch):
deploy_status=consts.DEPLOY_STATE_CREATED, software_version=SW_VERSION deploy_status=consts.DEPLOY_STATE_CREATED, software_version=SW_VERSION
) )
self._mock_get_subcloud_db_install_values() self.mock_get_subcloud_db_install_values = self._mock_object(
psd_common, "get_subcloud_db_install_values"
)
self._mock_object(psd_common, "validate_k8s_version") self._mock_object(psd_common, "validate_k8s_version")
self._mock_get_request_data() self.mock_get_request_data = self._mock_object(psd_common, "get_request_data")
self.mock_get_subcloud_db_install_values.return_value = self.data_install self.mock_get_subcloud_db_install_values.return_value = self.data_install
self.mock_get_request_data.return_value = self.install_payload self.mock_get_request_data.return_value = self.install_payload
@ -986,9 +959,11 @@ class TestPhasedSubcloudDeployPatchResume(BaseTestPhasedSubcloudDeployPatch):
data_install=json.dumps(self.data_install), data_install=json.dumps(self.data_install),
) )
self._mock_get_subcloud_db_install_values() self.mock_get_subcloud_db_install_values = self._mock_object(
psd_common, "get_subcloud_db_install_values"
)
self._mock_object(psd_common, "validate_k8s_version") self._mock_object(psd_common, "validate_k8s_version")
self._mock_get_request_data() self.mock_get_request_data = self._mock_object(psd_common, "get_request_data")
self._setup_mock_get_request_data() self._setup_mock_get_request_data()
self.mock_load_yaml_file = self._mock_object(dutils, "load_yaml_file") self.mock_load_yaml_file = self._mock_object(dutils, "load_yaml_file")
self.mock_os_path_isdir = self._mock_object(os.path, "isdir") self.mock_os_path_isdir = self._mock_object(os.path, "isdir")
@ -1250,7 +1225,9 @@ class TestPhasedSubcloudDeployPatchEnroll(BaseTestPhasedSubcloudDeployPatch):
("bootstrap_values", "bootstrap_fake_filename", fake_content), ("bootstrap_values", "bootstrap_fake_filename", fake_content),
("install_values", "install_values_fake_filename", install_fake_content), ("install_values", "install_values_fake_filename", install_fake_content),
] ]
self._mock_get_subcloud_db_install_values() self.mock_get_subcloud_db_install_values = self._mock_object(
psd_common, "get_subcloud_db_install_values"
)
def test_patch_enroll_fails_invalid_deploy_status(self): def test_patch_enroll_fails_invalid_deploy_status(self):
"""Test patch enroll fails with invalid deploy status""" """Test patch enroll fails with invalid deploy status"""

39
distributedcloud/dcmanager/tests/unit/api/controllers/v1/test_subcloud_deploy.py
View File

@ -51,33 +51,14 @@ class BaseTestSubcloudDeployController(DCManagerApiTest):
self.mock_os_path_isdir = self._mock_object(os.path, "isdir") self.mock_os_path_isdir = self._mock_object(os.path, "isdir")
self.mock_os_remove = self._mock_object(os, "remove") self.mock_os_remove = self._mock_object(os, "remove")
self._mock_object(os, "mkdir") self._mock_object(os, "mkdir")
self._mock_os_open() self.mock_os_open = self._mock_object(os, "open")
self._mock_os_write() self._mock_object(os, "write")
self.mock_builtins_open = self._mock_object(builtins, "open") self.mock_builtins_open = self._mock_object(builtins, "open")
self._mock_get_filename_by_prefix() self.mock_get_filename_by_prefix = self._mock_object(
dutils, "get_filename_by_prefix"
)
self._setup_get_filename_by_prefix() self._setup_get_filename_by_prefix()
def _mock_os_open(self):
"""Mock os' open"""
mock_patch_object = mock.patch.object(os, "open")
self.mock_os_open = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_os_write(self):
"""Mock os' write"""
mock_patch_object = mock.patch.object(os, "write")
self.mock_os_write = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_get_filename_by_prefix(self):
"""Mock dutils' get_filename_by_prefix"""
mock_patch_object = mock.patch.object(dutils, "get_filename_by_prefix")
self.mock_get_filename_by_prefix = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _setup_get_filename_by_prefix(self): def _setup_get_filename_by_prefix(self):
self.mock_get_filename_by_prefix.side_effect = ( self.mock_get_filename_by_prefix.side_effect = (
self._mock_get_filename_by_prefix_side_effect self._mock_get_filename_by_prefix_side_effect
@ -311,9 +292,6 @@ class TestSubcloudDeployGet(BaseTestSubcloudDeployController):
self.url = f"{self.url}/{FAKE_SOFTWARE_VERSION}" self.url = f"{self.url}/{FAKE_SOFTWARE_VERSION}"
self.method = self.app.get self.method = self.app.get
self._mock_get_filename_by_prefix()
self._setup_get_filename_by_prefix()
self.mock_builtins_open.side_effect = mock.mock_open( self.mock_builtins_open.side_effect = mock.mock_open(
read_data=fake_subcloud.FAKE_UPGRADES_METADATA read_data=fake_subcloud.FAKE_UPGRADES_METADATA
) )
@ -376,7 +354,7 @@ class TestSubcloudDeployDelete(BaseTestSubcloudDeployController):
self.method = self.app.delete self.method = self.app.delete
self.mock_log = self._mock_object(subcloud_deploy, "LOG") self.mock_log = self._mock_object(subcloud_deploy, "LOG")
self._mock_get_sw_version() self.mock_get_sw_version = self._mock_object(dutils, "get_sw_version")
self.sw_version_directory = "/opt/platform/deploy/" self.sw_version_directory = "/opt/platform/deploy/"
self.version = FAKE_SOFTWARE_VERSION self.version = FAKE_SOFTWARE_VERSION
@ -385,11 +363,6 @@ class TestSubcloudDeployDelete(BaseTestSubcloudDeployController):
self.mock_os_path_isdir.side_effect = self._mock_os_path_isdir_side_effect self.mock_os_path_isdir.side_effect = self._mock_os_path_isdir_side_effect
self.mock_os_remove.return_value = None self.mock_os_remove.return_value = None
def _mock_get_sw_version(self):
mock_patch_object = mock.patch.object(dutils, "get_sw_version")
self.mock_get_sw_version = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_os_path_isdir_side_effect(self, dir_path): def _mock_os_path_isdir_side_effect(self, dir_path):
return dir_path == f"{self.sw_version_directory}{self.version}" return dir_path == f"{self.sw_version_directory}{self.version}"

33
distributedcloud/dcmanager/tests/unit/api/controllers/v1/test_subclouds.py
View File

@ -2925,11 +2925,17 @@ class BaseTestSubcloudsPatchPrestage(BaseTestSubcloudsPatch):
self.original_get_validated_sw_version_for_prestage = ( self.original_get_validated_sw_version_for_prestage = (
cutils.get_validated_sw_version_for_prestage cutils.get_validated_sw_version_for_prestage
) )
self._mock_get_validated_sw_version_for_prestage(cutils) self.mock_get_validated_sw_version_for_prestage = self._mock_object(
cutils, "get_validated_sw_version_for_prestage"
)
self._setup_mock_get_validated_sw_version_for_prestage() self._setup_mock_get_validated_sw_version_for_prestage()
self._mock_get_current_supported_upgrade_versions(cutils) self.mock_get_current_supported_upgrade_versions = self._mock_object(
cutils, "get_current_supported_upgrade_versions"
)
self._setup_mock_get_current_supported_upgrade_versions() self._setup_mock_get_current_supported_upgrade_versions()
self._mock_get_system_controller_software_list(cutils) self.mock_get_system_controller_software_list = self._mock_object(
cutils, "get_system_controller_software_list"
)
self._setup_mock_get_system_controller_software_list() self._setup_mock_get_system_controller_software_list()
def _setup_mock_sysinv_client_prestage(self): def _setup_mock_sysinv_client_prestage(self):
@ -2946,27 +2952,6 @@ class BaseTestSubcloudsPatchPrestage(BaseTestSubcloudsPatch):
mock_get_oam_addresses mock_get_oam_addresses
) )
def _mock_get_validated_sw_version_for_prestage(self, target):
mock_patch_object = mock.patch.object(
target, "get_validated_sw_version_for_prestage"
)
self.mock_get_validated_sw_version_for_prestage = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_get_current_supported_upgrade_versions(self, target):
mock_patch_object = mock.patch.object(
target, "get_current_supported_upgrade_versions"
)
self.mock_get_current_supported_upgrade_versions = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_get_system_controller_software_list(self, target):
mock_patch_object = mock.patch.object(
target, "get_system_controller_software_list"
)
self.mock_get_system_controller_software_list = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _setup_mock_get_validated_sw_version_for_prestage(self): def _setup_mock_get_validated_sw_version_for_prestage(self):
if "release" not in self.params: if "release" not in self.params:
self.params["release"] = "24.09" self.params["release"] = "24.09"

18
distributedcloud/dcmanager/tests/unit/api/controllers/v1/test_sw_update_strategy.py
View File

@ -17,7 +17,6 @@
import http.client import http.client
import mock
from oslo_messaging import RemoteError from oslo_messaging import RemoteError
from dccommon import consts as dccommon_consts from dccommon import consts as dccommon_consts
@ -38,14 +37,9 @@ class BaseTestSwUpdateStrategyController(DCManagerApiTest):
self.url = "/v1.0/sw-update-strategy" self.url = "/v1.0/sw-update-strategy"
self._mock_rpc_orchestrator_client() self.mock_rpc_orchestrator_client = self._mock_object(
rpc_client, "ManagerOrchestratorClient"
def _mock_rpc_orchestrator_client(self): )
"""Mock rpc's manager orchestrator client"""
mock_patch = mock.patch.object(rpc_client, "ManagerOrchestratorClient")
self.mock_rpc_orchestrator_client = mock_patch.start()
self.addCleanup(mock_patch.stop)
class TestSwUpdateStrategyController(BaseTestSwUpdateStrategyController): class TestSwUpdateStrategyController(BaseTestSwUpdateStrategyController):
@ -233,12 +227,10 @@ class TestSwUpdateStrategyPost(BaseTestSwUpdateStrategyPost):
self.create_update_strategy = ( self.create_update_strategy = (
self.mock_rpc_orchestrator_client().create_sw_update_strategy self.mock_rpc_orchestrator_client().create_sw_update_strategy
) )
self.get_releases_patcher = mock.patch.object( self.mock_get_sc_installed_releases_id = self._mock_object(
utils, "get_systemcontroller_installed_releases_ids" utils, "get_systemcontroller_installed_releases_ids"
) )
self.mock_get_releases = self.get_releases_patcher.start() self.mock_get_sc_installed_releases_id.return_value = ["stx-10.0.0"]
self.mock_get_releases.return_value = ["stx-10.0.0"]
self.addCleanup(self.get_releases_patcher.stop)
def test_post_succeeds(self): def test_post_succeeds(self):
"""Test post succeeds""" """Test post succeeds"""

105
distributedcloud/dcmanager/tests/unit/audit/test_firmware_audit_manager.py
View File

@ -14,7 +14,6 @@
# under the License. # under the License.
# #
import mock
from oslo_config import cfg from oslo_config import cfg
from dccommon import consts as dccommon_consts from dccommon import consts as dccommon_consts
@ -402,7 +401,11 @@ class TestFirmwareAudit(base.DCManagerTestCase):
super().setUp() super().setUp()
self._mock_object(rpcapi, "ManagerAuditWorkerClient") self._mock_object(rpcapi, "ManagerAuditWorkerClient")
self.mock_sysinv_client = self._mock_object( self.mock_fw_audit_sysinv_client = self._mock_object(
firmware_audit, "SysinvClient"
)
self._mock_object(firmware_audit, "OpenStackDriver")
self.mock_audit_worker_manager_sysinv_client = self._mock_object(
subcloud_audit_worker_manager, "SysinvClient" subcloud_audit_worker_manager, "SysinvClient"
) )
self.mock_subcloud_audit_manager_context = self._mock_object( self.mock_subcloud_audit_manager_context = self._mock_object(
@ -432,15 +435,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
firmware_audit_data = self._rpc_convert(firmware_audit_data) firmware_audit_data = self._rpc_convert(firmware_audit_data)
return firmware_audit_data return firmware_audit_data
@mock.patch.object(firmware_audit, "SysinvClient") def test_no_firmware_audit_data_to_sync(self):
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_firmware_audit_data_to_sync(
self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
):
mock_fw_sysinv_client.side_effect = FakeSysinvClientNoAuditData self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientNoAuditData
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -449,20 +446,18 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_enabled_devices_on_subcloud( def test_no_enabled_devices_on_subcloud(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientNoEnabledDevices self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientNoEnabledDevices
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -471,19 +466,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_apply_image_to_all_devices( def test_apply_image_to_all_devices(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageWithoutLabels self.mock_fw_audit_sysinv_client.side_effect = (
FakeSysinvClientImageWithoutLabels
)
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -492,20 +487,20 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_not_applied( def test_image_not_applied(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotApplied self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotApplied self.mock_audit_worker_manager_sysinv_client.side_effect = (
FakeSysinvClientImageNotApplied
)
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -514,20 +509,20 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_OUT_OF_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_not_written( def test_image_not_written(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotWritten self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotWritten self.mock_audit_worker_manager_sysinv_client.side_effect = (
FakeSysinvClientImageNotWritten
)
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -536,19 +531,17 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_OUT_OF_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_with_labels( def test_image_with_labels(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageWithLabels self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientImageWithLabels
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -557,19 +550,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_matching_label_for_device_on_subcloud( def test_no_matching_label_for_device_on_subcloud(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientNoMatchingDeviceLabel self.mock_fw_audit_sysinv_client.side_effect = (
FakeSysinvClientNoMatchingDeviceLabel
)
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -578,19 +571,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_matching_device_id_on_subcloud( def test_no_matching_device_id_on_subcloud(
self, self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
): ):
mock_fw_sysinv_client.side_effect = FakeSysinvClientNoMatchingDeviceId self.mock_fw_audit_sysinv_client.side_effect = (
FakeSysinvClientNoMatchingDeviceId
)
firmware_audit_data = self.get_fw_audit_data() firmware_audit_data = self.get_fw_audit_data()
subclouds = { subclouds = {
@ -599,7 +592,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
} }
for name, _ in subclouds.items(): for name, _ in subclouds.items():
response = self.fm.subcloud_firmware_audit( response = self.fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, firmware_audit_data self.mock_audit_worker_manager_sysinv_client(),
name,
firmware_audit_data,
) )
self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC) self.assertEqual(response, dccommon_consts.SYNC_STATUS_IN_SYNC)

50
distributedcloud/dcmanager/tests/unit/audit/test_subcloud_audit_manager.py
View File

@ -19,6 +19,7 @@ import sys
import mock import mock
from dccommon import consts as dccommon_consts from dccommon import consts as dccommon_consts
from dcmanager.audit import rpcapi
from dcmanager.audit import subcloud_audit_manager from dcmanager.audit import subcloud_audit_manager
from dcmanager.common import consts from dcmanager.common import consts
from dcmanager.db.sqlalchemy import api as db_api from dcmanager.db.sqlalchemy import api as db_api
@ -250,49 +251,38 @@ class TestAuditManager(base.DCManagerTestCase):
super(TestAuditManager, self).setUp() super(TestAuditManager, self).setUp()
# Mock the Audit Worker API # Mock the Audit Worker API
self.fake_audit_worker_api = FakeAuditWorkerAPI() self.mock_audit_worker_api = self._mock_object(
p = mock.patch("dcmanager.audit.rpcapi.ManagerAuditWorkerClient") rpcapi, "ManagerAuditWorkerClient"
self.mock_audit_worker_api = p.start() )
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api self.mock_audit_worker_api.return_value = FakeAuditWorkerAPI()
self.addCleanup(p.stop)
# Mock the context # Mock the context
p = mock.patch.object(subcloud_audit_manager, "context") self.mock_context = self._mock_object(subcloud_audit_manager, "context")
self.mock_context = p.start()
self.mock_context.get_admin_context.return_value = self.ctx self.mock_context.get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
# Mock patch audit # Mock patch audit
self.fake_patch_audit = FakePatchAudit() self.mock_patch_audit = self._mock_object(subcloud_audit_manager, "patch_audit")
p = mock.patch.object(subcloud_audit_manager, "patch_audit") self.mock_patch_audit.PatchAudit.return_value = FakePatchAudit()
self.mock_patch_audit = p.start()
self.mock_patch_audit.PatchAudit.return_value = self.fake_patch_audit
self.addCleanup(p.stop)
# Mock firmware audit # Mock firmware audit
self.fake_firmware_audit = FakeFirmwareAudit() self.mock_firmware_audit = self._mock_object(
p = mock.patch.object(subcloud_audit_manager, "firmware_audit") subcloud_audit_manager, "firmware_audit"
self.mock_firmware_audit = p.start() )
self.mock_firmware_audit.FirmwareAudit.return_value = self.fake_firmware_audit self.mock_firmware_audit.FirmwareAudit.return_value = FakeFirmwareAudit()
self.addCleanup(p.stop)
# Mock kubernetes audit # Mock kubernetes audit
self.fake_kubernetes_audit = FakeKubernetesAudit() self.mock_kubernetes_audit = self._mock_object(
p = mock.patch.object(subcloud_audit_manager, "kubernetes_audit") subcloud_audit_manager, "kubernetes_audit"
self.mock_kubernetes_audit = p.start()
self.mock_kubernetes_audit.KubernetesAudit.return_value = (
self.fake_kubernetes_audit
) )
self.addCleanup(p.stop) self.mock_kubernetes_audit.KubernetesAudit.return_value = FakeKubernetesAudit()
# Mock kube rootca update audit # Mock kube rootca update audit
self.fake_kube_rootca_update_audit = FakeKubeRootcaUpdateAudit() self.mock_kube_rootca_update_audit = self._mock_object(
p = mock.patch.object(subcloud_audit_manager, "kube_rootca_update_audit") subcloud_audit_manager, "kube_rootca_update_audit"
self.mock_kube_rootca_update_audit = p.start() )
self.mock_kubernetes_audit.KubeRootcaUpdateAudit.return_value = ( self.mock_kubernetes_audit.KubeRootcaUpdateAudit.return_value = (
self.fake_kube_rootca_update_audit FakeKubeRootcaUpdateAudit()
) )
self.addCleanup(p.stop)
@staticmethod @staticmethod
def create_subcloud_static(ctxt, **kwargs): def create_subcloud_static(ctxt, **kwargs):

238
distributedcloud/dcmanager/tests/unit/audit/test_subcloud_audit_worker_manager.py
View File

@ -22,12 +22,15 @@ from keystoneauth1 import exceptions as keystone_exceptions
import mock import mock
from dccommon import consts as dccommon_consts from dccommon import consts as dccommon_consts
from dcmanager.audit import rpcapi
from dcmanager.audit import subcloud_audit_manager from dcmanager.audit import subcloud_audit_manager
from dcmanager.audit import subcloud_audit_worker_manager from dcmanager.audit import subcloud_audit_worker_manager
from dcmanager.common import consts from dcmanager.common import consts
from dcmanager.common import scheduler from dcmanager.common import scheduler
from dcmanager.db.sqlalchemy import api as db_api from dcmanager.db.sqlalchemy import api as db_api
from dcmanager.rpc import client as rpc_client
from dcmanager.tests import base from dcmanager.tests import base
from dcorch.rpc import client as dcorch_rpc_client
sys.modules["fm_core"] = mock.Mock() sys.modules["fm_core"] = mock.Mock()
@ -272,126 +275,85 @@ FAKE_APPLICATIONS = [
class TestAuditWorkerManager(base.DCManagerTestCase): class TestAuditWorkerManager(base.DCManagerTestCase):
def setUp(self): def setUp(self):
super(TestAuditWorkerManager, self).setUp() super().setUp()
# Mock the DCManager API # Mock the DCManager API
self.fake_dcmanager_api = FakeDCManagerAPI() self.mock_dcmanager_api = self._mock_object(rpc_client, "ManagerClient")
p = mock.patch("dcmanager.rpc.client.ManagerClient") self.mock_dcmanager_api().return_value = FakeDCManagerAPI()
self.mock_dcmanager_api = p.start()
self.mock_dcmanager_api.return_value = self.fake_dcmanager_api
self.addCleanup(p.stop)
# Mock the DCManager subcloud state API # Mock the DCManager subcloud state API
p = mock.patch("dcmanager.rpc.client.SubcloudStateClient") self.mock_dcmanager_state_api = self._mock_object(
self.mock_dcmanager_state_api = p.start() rpc_client, "SubcloudStateClient"
self.addCleanup(p.stop) )
# Mock the Audit Worker API # Mock the Audit Worker API
self.fake_audit_worker_api = FakeAuditWorkerAPI() self.mock_audit_worker_api = self._mock_object(
p = mock.patch("dcmanager.audit.rpcapi.ManagerAuditWorkerClient") rpcapi, "ManagerAuditWorkerClient"
self.mock_audit_worker_api = p.start() )
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api self.mock_audit_worker_api.return_value = FakeAuditWorkerAPI()
self.addCleanup(p.stop)
# Mock the DCOrch Worker API # Mock the DCOrch Worker API
self.fake_dcorch_worker_api = FakeDCOrchWorkerAPI() self.mock_dcorch_worker_api = self._mock_object(
p = mock.patch("dcorch.rpc.client.EngineWorkerClient") dcorch_rpc_client, "EngineWorkerClient"
self.mock_dcorch_worker_api = p.start() )
self.mock_dcorch_worker_api.return_value = self.fake_dcorch_worker_api self.mock_dcorch_worker_api.return_value = FakeDCOrchWorkerAPI()
self.addCleanup(p.stop)
# Mock the context # Mock the context
p = mock.patch.object(subcloud_audit_worker_manager, "context") self.mock_audit_worker_manager_context = self._mock_object(
self.mock_context = p.start() subcloud_audit_worker_manager, "context"
self.mock_context.get_admin_context.return_value = self.ctx )
self.addCleanup(p.stop) self.mock_audit_worker_manager_context.get_admin_context.return_value = self.ctx
# Mock the context # Mock the context
p = mock.patch.object(subcloud_audit_manager, "context") self.mock_subcloud_audit_manager_context = self._mock_object(
self.mock_context2 = p.start() subcloud_audit_manager, "context"
self.mock_context2.get_admin_context.return_value = self.ctx )
self.addCleanup(p.stop) self.mock_subcloud_audit_manager_context.get_admin_context.return_value = (
self.ctx
)
# Mock alarm aggregation # Mock alarm aggregation
self.fake_alarm_aggr = FakeAlarmAggregation() self.mock_alarm_aggr = self._mock_object(
p = mock.patch.object(subcloud_audit_worker_manager, "alarm_aggregation") subcloud_audit_worker_manager.alarm_aggregation, "AlarmAggregation"
self.mock_alarm_aggr = p.start() )
self.mock_alarm_aggr.AlarmAggregation.return_value = self.fake_alarm_aggr self.mock_alarm_aggr().return_value = FakeAlarmAggregation()
self.addCleanup(p.stop)
# Mock patch audit # Mock all audits
self.fake_patch_audit = FakePatchAudit() self.fake_patch_audit = FakePatchAudit()
p = mock.patch.object(subcloud_audit_worker_manager, "patch_audit")
self.mock_patch_audit = p.start()
self.mock_patch_audit.PatchAudit.return_value = self.fake_patch_audit
self.addCleanup(p.stop)
# Mock patch audit
self.fake_patch_audit2 = FakePatchAudit()
p = mock.patch.object(subcloud_audit_manager, "patch_audit")
self.mock_patch_audit2 = p.start()
self.mock_patch_audit2.PatchAudit.return_value = self.fake_patch_audit2
self.addCleanup(p.stop)
# Mock firmware audit
self.fake_firmware_audit = FakeFirmwareAudit() self.fake_firmware_audit = FakeFirmwareAudit()
p = mock.patch.object(subcloud_audit_worker_manager, "firmware_audit")
self.mock_firmware_audit = p.start()
self.mock_firmware_audit.FirmwareAudit.return_value = self.fake_firmware_audit
self.addCleanup(p.stop)
self.fake_firmware_audit2 = FakeFirmwareAudit()
p = mock.patch.object(subcloud_audit_manager, "firmware_audit")
self.mock_firmware_audit2 = p.start()
self.mock_firmware_audit2.FirmwareAudit.return_value = self.fake_firmware_audit2
self.addCleanup(p.stop)
# Mock kubernetes audit in Audit Worker and Audit Manager
self.fake_kubernetes_audit = FakeKubernetesAudit() self.fake_kubernetes_audit = FakeKubernetesAudit()
p = mock.patch.object(subcloud_audit_worker_manager, "kubernetes_audit")
self.mock_kubernetes_audit = p.start()
self.mock_kubernetes_audit.KubernetesAudit.return_value = (
self.fake_kubernetes_audit
)
self.addCleanup(p.stop)
self.fake_kubernetes_audit2 = FakeKubernetesAudit()
p = mock.patch.object(subcloud_audit_manager, "kubernetes_audit")
self.mock_kubernetes_audit2 = p.start()
self.mock_kubernetes_audit2.KubernetesAudit.return_value = (
self.fake_kubernetes_audit2
)
self.addCleanup(p.stop)
# Mock kube rootca update audit in Audit Worker and Audit Manager
self.fake_kube_rootca_update_audit = FakeKubeRootcaUpdateAudit() self.fake_kube_rootca_update_audit = FakeKubeRootcaUpdateAudit()
p = mock.patch.object(subcloud_audit_worker_manager, "kube_rootca_update_audit")
self.mock_kube_rootca_update_audit = p.start()
self.mock_kube_rootca_update_audit.KubeRootcaUpdateAudit.return_value = (
self.fake_kube_rootca_update_audit
)
self.addCleanup(p.stop)
self.fake_kube_rootca_update_audit2 = FakeKubeRootcaUpdateAudit()
p = mock.patch.object(subcloud_audit_manager, "kube_rootca_update_audit")
self.mock_kube_rootca_update_audit2 = p.start()
self.mock_kube_rootca_update_audit2.KubeRootcaUpdateAudit.return_value = (
self.fake_kube_rootca_update_audit2
)
self.addCleanup(p.stop)
# Mock software audit in Audit Worker and Audit Manager
self.fake_software_audit = FakeSoftwareAudit() self.fake_software_audit = FakeSoftwareAudit()
p = mock.patch.object(subcloud_audit_worker_manager, "software_audit")
self.mock_software_audit = p.start()
self.mock_software_audit.SoftwareAudit.return_value = self.fake_software_audit
self.addCleanup(p.stop)
self.fake_software_audit2 = FakeSoftwareAudit() audits = {
p = mock.patch.object(subcloud_audit_manager, "software_audit") "patch_audit": {
self.mock_software_audit2 = p.start() "value": self.fake_patch_audit,
self.mock_software_audit2.SoftwareAudit.return_value = self.fake_software_audit2 "class": "PatchAudit",
self.addCleanup(p.stop) },
"firmware_audit": {
"value": self.fake_firmware_audit,
"class": "FirmwareAudit",
},
"kubernetes_audit": {
"value": self.fake_kubernetes_audit,
"class": "KubernetesAudit",
},
"kube_rootca_update_audit": {
"value": self.fake_kube_rootca_update_audit,
"class": "KubeRootcaUpdateAudit",
},
"software_audit": {
"value": self.fake_software_audit,
"class": "SoftwareAudit",
},
}
for key, value in audits.items():
self.temporary_mock = self._mock_object(subcloud_audit_worker_manager, key)
getattr(self.temporary_mock, value["class"]).return_value = value["value"]
self.temporary_mock = self._mock_object(subcloud_audit_manager, key)
getattr(self.temporary_mock, value["class"]).return_value = value["value"]
self.mock_openstack_driver = self._mock_object( self.mock_openstack_driver = self._mock_object(
subcloud_audit_worker_manager, "OpenStackDriver" subcloud_audit_worker_manager, "OpenStackDriver"
@ -565,14 +527,14 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not updated # Verify the openstack endpoints were not updated
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is called # Verify alarm update is called
self.fake_alarm_aggr.get_alarm_summary.assert_called_with( self.mock_alarm_aggr().get_alarm_summary.assert_called_with(
self.mock_fm_client(), subcloud.name self.mock_fm_client(), subcloud.name
) )
self.fake_alarm_aggr.update_alarm_summary.assert_called_with( self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
) )
# Verify patch audit is called # Verify patch audit is called
@ -679,11 +641,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not added # Verify the openstack endpoints were not added
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -769,11 +731,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not added # Verify the openstack endpoints were not added
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -834,11 +796,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not added # Verify the openstack endpoints were not added
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -896,11 +858,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not updated # Verify the openstack endpoints were not updated
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -981,11 +943,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
) )
# Verify alarm update is called once # Verify alarm update is called once
self.fake_alarm_aggr.get_alarm_summary.assert_called_with( self.mock_alarm_aggr().get_alarm_summary.assert_called_with(
self.mock_fm_client(), subcloud.name self.mock_fm_client(), subcloud.name
) )
self.fake_alarm_aggr.update_alarm_summary.assert_called_with( self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
) )
# Verify patch audit is called once # Verify patch audit is called once
@ -1069,8 +1031,8 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
) )
# Verify alarm update is called only once # Verify alarm update is called only once
self.fake_alarm_aggr.get_alarm_summary.assert_called_once() self.mock_alarm_aggr().get_alarm_summary.assert_called_once()
self.fake_alarm_aggr.update_alarm_summary.assert_called_once() self.mock_alarm_aggr().update_alarm_summary.assert_called_once()
# Verify patch audit is called only once # Verify patch audit is called only once
self.fake_patch_audit.subcloud_patch_audit.assert_called_once() self.fake_patch_audit.subcloud_patch_audit.assert_called_once()
@ -1154,11 +1116,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were not updated # Verify the openstack endpoints were not updated
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -1354,11 +1316,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
self.update_subcloud_availability_and_endpoint_status.assert_not_called() self.update_subcloud_availability_and_endpoint_status.assert_not_called()
# Verify the openstack endpoints were not updated # Verify the openstack endpoints were not updated
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_not_called() self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_not_called()
# Verify alarm update is not called # Verify alarm update is not called
self.fake_alarm_aggr.get_alarm_summary.assert_not_called() self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called() self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is not called # Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called() self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@ -1441,17 +1403,17 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were added # Verify the openstack endpoints were added
# self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.\ # self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.\
# assert_called_with(mock.ANY, 'subcloud1', # assert_called_with(mock.ANY, 'subcloud1',
# dccommon_consts.ENDPOINT_TYPES_LIST_OS, # dccommon_consts.ENDPOINT_TYPES_LIST_OS,
# True) # True)
# Verify alarm update is called # Verify alarm update is called
self.fake_alarm_aggr.get_alarm_summary.assert_called_with( self.mock_alarm_aggr().get_alarm_summary.assert_called_with(
self.mock_fm_client(), "subcloud1" self.mock_fm_client(), "subcloud1"
) )
self.fake_alarm_aggr.update_alarm_summary.assert_called_with( self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
"subcloud1", self.fake_alarm_aggr.get_alarm_summary.return_value "subcloud1", self.mock_alarm_aggr().get_alarm_summary.return_value
) )
# Verify patch audit is not called # Verify patch audit is not called
@ -1519,7 +1481,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were removed # Verify the openstack endpoints were removed
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_called_with( self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_called_with(
mock.ANY, mock.ANY,
subcloud.region_name, subcloud.region_name,
dccommon_consts.ENDPOINT_TYPES_LIST_OS, dccommon_consts.ENDPOINT_TYPES_LIST_OS,
@ -1527,11 +1489,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
) )
# Verify alarm update is called # Verify alarm update is called
self.fake_alarm_aggr.get_alarm_summary.assert_called_with( self.mock_alarm_aggr().get_alarm_summary.assert_called_with(
self.mock_fm_client(), subcloud.name self.mock_fm_client(), subcloud.name
) )
self.fake_alarm_aggr.update_alarm_summary.assert_called_with( self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
) )
# Verify patch audit is not called # Verify patch audit is not called
@ -1599,7 +1561,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called() mock_update_subcloud_audit_fail_count.assert_not_called()
# Verify the openstack endpoints were removed # Verify the openstack endpoints were removed
self.fake_dcmanager_api.update_subcloud_sync_endpoint_type.assert_called_with( self.mock_dcmanager_api().update_subcloud_sync_endpoint_type.assert_called_with(
mock.ANY, mock.ANY,
subcloud.region_name, subcloud.region_name,
dccommon_consts.ENDPOINT_TYPES_LIST_OS, dccommon_consts.ENDPOINT_TYPES_LIST_OS,
@ -1607,11 +1569,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
) )
# Verify alarm update is called # Verify alarm update is called
self.fake_alarm_aggr.get_alarm_summary.assert_called_with( self.mock_alarm_aggr().get_alarm_summary.assert_called_with(
self.mock_fm_client(), "subcloud1" self.mock_fm_client(), "subcloud1"
) )
self.fake_alarm_aggr.update_alarm_summary.assert_called_with( self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
"subcloud1", self.fake_alarm_aggr.get_alarm_summary.return_value "subcloud1", self.mock_alarm_aggr().get_alarm_summary.return_value
) )
# Verify patch audit is not called # Verify patch audit is not called

10
distributedcloud/dcmanager/tests/unit/manager/test_peer_group_audit_manager.py
View File

@ -129,11 +129,9 @@ class TestPeerGroupAudit(DCManagerTestCase):
def _mock_peer_monitor_manager_get_peer_dc_client(self): def _mock_peer_monitor_manager_get_peer_dc_client(self):
"""Mock peer_monitor_manager's get_peer_dc_client""" """Mock peer_monitor_manager's get_peer_dc_client"""
mock_patch = mock.patch.object( self.mock_get_peer_dc_client = self._mock_object(
peer_group_audit_manager.SystemPeerManager, "get_peer_dc_client" peer_group_audit_manager.SystemPeerManager, "get_peer_dc_client"
) )
self.mock_get_peer_dc_client = mock_patch.start()
self.addCleanup(mock_patch.stop)
self.peer = tpm.TestPeerMonitor.create_system_peer_static( self.peer = tpm.TestPeerMonitor.create_system_peer_static(
self.ctx, peer_name="SystemPeer1" self.ctx, peer_name="SystemPeer1"
@ -175,9 +173,9 @@ class TestPeerGroupAudit(DCManagerTestCase):
self.remote_peer_group = copy.deepcopy(FAKE_SITE1_PEER_GROUP_DATA) self.remote_peer_group = copy.deepcopy(FAKE_SITE1_PEER_GROUP_DATA)
self.remote_peer_group2 = copy.deepcopy(FAKE_SITE2_PEER_GROUP_DATA) self.remote_peer_group2 = copy.deepcopy(FAKE_SITE2_PEER_GROUP_DATA)
mock_patch = mock.patch.object(SystemPeerManager, "update_sync_status") self.mock_update_sync_status = self._mock_object(
self.addCleanup(mock_patch.stop) SystemPeerManager, "update_sync_status"
self.mock_update_sync_status = mock_patch.start() )
self.mock_get_local_system = self._mock_object(utils, "get_local_system") self.mock_get_local_system = self._mock_object(utils, "get_local_system")
def run_audit(self, remote_peer_group=None): def run_audit(self, remote_peer_group=None):

21
distributedcloud/dcmanager/tests/unit/manager/test_peer_monitor_manager.py
View File

@ -51,7 +51,9 @@ class TestPeerMonitor(base.DCManagerTestCase):
subcloud_manager, "SubcloudManager" subcloud_manager, "SubcloudManager"
) )
self.mock_log = self._mock_object(peer_monitor_manager, "LOG") self.mock_log = self._mock_object(peer_monitor_manager, "LOG")
self._mock_peer_monitor_manager_get_peer_dc_client() self.mock_get_peer_dc_client = self._mock_object(
peer_monitor_manager.SystemPeerManager, "get_peer_dc_client"
)
self.peer = self.create_system_peer_static(self.ctx) self.peer = self.create_system_peer_static(self.ctx)
self.system_peer_manager = test_system_peer_manager.TestSystemPeerManager self.system_peer_manager = test_system_peer_manager.TestSystemPeerManager
@ -74,15 +76,6 @@ class TestPeerMonitor(base.DCManagerTestCase):
self.mock_subcloud_manager self.mock_subcloud_manager
) )
def _mock_peer_monitor_manager_get_peer_dc_client(self):
"""Mock peer_monitor_manager's get_peer_dc_client"""
mock_patch = mock.patch.object(
peer_monitor_manager.SystemPeerManager, "get_peer_dc_client"
)
self.mock_get_peer_dc_client = mock_patch.start()
self.addCleanup(mock_patch.stop)
@staticmethod @staticmethod
def create_system_peer_static(ctxt, **kwargs): def create_system_peer_static(ctxt, **kwargs):
values = { values = {
@ -123,11 +116,9 @@ class TestPeerMonitor(base.DCManagerTestCase):
) )
# Mock update_sync_status # Mock update_sync_status
mock_patch = mock.patch.object( mock_update_sync_status = self._mock_object(
peer_monitor_manager.SystemPeerManager, "update_sync_status" peer_monitor_manager.SystemPeerManager, "update_sync_status"
) )
mock_update_sync_status = mock_patch.start()
self.addCleanup(mock_patch.stop)
self.peer_monitor._update_sync_status_secondary_site_becomes_reachable() self.peer_monitor._update_sync_status_secondary_site_becomes_reachable()
@ -140,11 +131,9 @@ class TestPeerMonitor(base.DCManagerTestCase):
def test_update_sync_status_and_association_is_in_sync(self): def test_update_sync_status_and_association_is_in_sync(self):
# Mock update_sync_status # Mock update_sync_status
mock_patch = mock.patch.object( mock_update_sync_status = self._mock_object(
peer_monitor_manager.SystemPeerManager, "update_sync_status" peer_monitor_manager.SystemPeerManager, "update_sync_status"
) )
mock_update_sync_status = mock_patch.start()
self.addCleanup(mock_patch.stop)
self.peer_monitor._update_sync_status_secondary_site_becomes_reachable() self.peer_monitor._update_sync_status_secondary_site_becomes_reachable()

401
distributedcloud/dcmanager/tests/unit/manager/test_subcloud_manager.py
View File

@ -23,7 +23,9 @@ import filecmp
import json import json
import os import os
from os import path as os_path from os import path as os_path
import shutil
import sys import sys
import tempfile
import threading import threading
import time import time
from urllib import request from urllib import request
@ -60,6 +62,7 @@ from dcmanager.tests.unit.common import fake_subcloud
from dcmanager.tests.unit.db import test_subcloud_alarms from dcmanager.tests.unit.db import test_subcloud_alarms
from dcmanager.tests.unit.manager import test_system_peer_manager from dcmanager.tests.unit.manager import test_system_peer_manager
from dcmanager.tests import utils from dcmanager.tests import utils
from dcorch.rpc import client as dcorch_rpc_client
sys.modules["fm_core"] = mock.Mock() sys.modules["fm_core"] = mock.Mock()
@ -358,22 +361,35 @@ class BaseTestSubcloudManager(base.DCManagerTestCase):
self.mock_audit_rpc_client = self._mock_object(rpcapi, "ManagerAuditClient") self.mock_audit_rpc_client = self._mock_object(rpcapi, "ManagerAuditClient")
self._mock_object(rpc_client, "SubcloudStateClient") self._mock_object(rpc_client, "SubcloudStateClient")
self._mock_object(subcloud_install, "OpenStackDriver") self._mock_object(subcloud_install, "OpenStackDriver")
self.mock_install_sysinv_client = self._mock_object( self.mock_subcloud_install_sysinv_client = self._mock_object(
subcloud_install, "SysinvClient" subcloud_install, "SysinvClient"
) )
self.mock_openstack_driver = self._mock_object( self.mock_openstack_driver = self._mock_object(
subcloud_manager, "OpenStackDriver" subcloud_manager, "OpenStackDriver"
) )
self.mock_sysinv_client = self._mock_object(subcloud_manager, "SysinvClient") self.mock_sysinv_client = self._mock_object(subcloud_manager, "SysinvClient")
self._mock_dcorch_api() self.mock_dcorch_api = self._mock_object(
self._mock_dcmanager_api() dcorch_rpc_client, "EngineWorkerClient"
self._mock_context() )
self.mock_dcmanager_api = self._mock_object(
rpc_client, "DCManagerNotifications"
)
mock_context = self._mock_object(subcloud_manager, "dcmanager_context")
mock_context.get_admin_context.return_value = self.ctx
self.mock_log_subcloud_manager = self._mock_object(subcloud_manager, "LOG") self.mock_log_subcloud_manager = self._mock_object(subcloud_manager, "LOG")
self._mock_subcloud_manager_keyring() self.mock_keyring = self._mock_object(subcloud_manager, "keyring")
self._mock_utils_create_subcloud_inventory() self.mock_create_subcloud_inventory = self._mock_object(
self._mock_utils_delete_subcloud_inventory() cutils, "create_subcloud_inventory"
self._mock_utils_get_playbook_for_software_version() )
self._mock_subprocess_run() self.mock_delete_subcloud_inventory = self._mock_object(
cutils, "delete_subcloud_inventory"
)
self.mock_get_playbook_for_software_version = self._mock_object(
cutils, "get_playbook_for_software_version"
)
self.mock_get_local_system = self._mock_object(cutils, "get_local_system")
self._mock_object(cutils, "get_pool_by_ip_family")
self.mock_subprocess_run = self._mock_object(subprocess, "run")
self.mock_ansible_run_playbook = self._mock_object( self.mock_ansible_run_playbook = self._mock_object(
AnsiblePlaybook, "run_playbook" AnsiblePlaybook, "run_playbook"
) )
@ -384,9 +400,7 @@ class BaseTestSubcloudManager(base.DCManagerTestCase):
self.mock_os_path_isdir = self._mock_object(os.path, "isdir") self.mock_os_path_isdir = self._mock_object(os.path, "isdir")
self.mock_os_path_exists = self._mock_object(os.path, "exists") self.mock_os_path_exists = self._mock_object(os.path, "exists")
self.mock_os_remove = self._mock_object(os, "remove") self.mock_os_remove = self._mock_object(os, "remove")
self._mock_ostree_mount_validate_ostree_iso_mount() self._mock_object(ostree_mount, "validate_ostree_iso_mount")
self.mock_get_local_system = self._mock_object(cutils, "get_local_system")
self._mock_utils_get_pool_by_ip_family()
self.sm = subcloud_manager.SubcloudManager() self.sm = subcloud_manager.SubcloudManager()
self.subcloud = self.create_subcloud_static(self.ctx) self.subcloud = self.create_subcloud_static(self.ctx)
@ -439,185 +453,6 @@ class BaseTestSubcloudManager(base.DCManagerTestCase):
def patched_isdir(self, path): def patched_isdir(self, path):
return path != self.iso_dir return path != self.iso_dir
def _mock_dcorch_api(self):
"""Mock the DCOrch API"""
p = mock.patch("dcorch.rpc.client.EngineWorkerClient")
self.mock_dcorch_api = p.start()
self.addCleanup(p.stop)
def _mock_dcmanager_api(self):
"""Mock the DCManager notifications"""
p = mock.patch("dcmanager.rpc.client.DCManagerNotifications")
self.mock_dcmanager_api = p.start()
self.addCleanup(p.stop)
def _mock_utils_create_subcloud_inventory(self):
"""Mock utils create_subcloud_inventory"""
mock_patch = mock.patch.object(cutils, "create_subcloud_inventory")
self.mock_create_subcloud_inventory = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_utils_delete_subcloud_inventory(self):
"""Mock utils's delete_subcloud_inventory"""
mock_patch = mock.patch.object(cutils, "delete_subcloud_inventory")
self.mock_delete_subcloud_inventory = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_utils_is_system_controller_deploying(self):
mock_patch = mock.patch.object(cutils, "is_system_controller_deploying")
self.mock_is_system_controller_deploying = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_utils_get_playbook_for_software_version(self):
"""Mock utils's get_playbook_for_software_version"""
mock_patch = mock.patch.object(cutils, "get_playbook_for_software_version")
self.mock_get_playbook_for_software_version = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_keyring(self):
"""Mock subcloud manager's keyring"""
mock_patch = mock.patch.object(subcloud_manager, "keyring")
self.mock_keyring = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_get_cached_regionone_data(self):
"""Mock subcloud manager's _get_cached_regionone_data"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_get_cached_regionone_data"
)
self.mock_get_cached_regionone_data = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_create_addn_hosts_dc(self):
"""Mock subcloud manager's _create_addn_hosts_dc"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_create_addn_hosts_dc"
)
self.mock_create_addn_hosts = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_write_subcloud_ansible_config(self):
"""Mock subcloud manager's _write_subcloud_ansible_config"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_write_subcloud_ansible_config"
)
self.mock_write_subcloud_ansible_config = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_run_subcloud_install(self):
"""Mock subcloud manager's _run_subcloud_install"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_run_subcloud_install"
)
self.mock_run_subcloud_install = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_ostree_mount_validate_ostree_iso_mount(self):
"""Mock ostree_mount validate_ostree_iso_mount"""
mock_patch = mock.patch.object(ostree_mount, "validate_ostree_iso_mount")
self.addCleanup(mock_patch.stop)
self.mock_validate_ostree_iso_mount = mock_patch.start()
def _mock_subcloud_manager_run_subcloud_enroll(self):
"""Mock subcloud manager's _run_subcloud_enroll"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_run_subcloud_enroll"
)
self.mock_run_subcloud_enroll = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_create_intermediate_ca_cert(self):
"""Mock subcloud manager's _create_intermediate_ca_cert"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "_create_intermediate_ca_cert"
)
self.mock_create_intermediate_ca_cert = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_compose_install_command(self):
"""Mock subcloud manager's compose_install_command"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "compose_install_command"
)
self.mock_compose_install_command = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_compose_enroll_command(self):
"""Mock subcloud manager compose_enroll_command"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "compose_enroll_command"
)
self.mock_compose_enroll_command = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_init_enroll(self):
"""Mock subcloud manager init_enroll process"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "subcloud_init_enroll"
)
self.mock_subcloud_init_enroll = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_manager_complete(self):
"""Mock subcloud manager completion process"""
mock_patch = mock.patch.object(
subcloud_manager.SubcloudManager, "subcloud_deploy_complete"
)
self.mock_subcloud_deploy_complete = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subcloud_get_region_name(self):
"""Mock region name"""
mock_patch = mock.patch.object(cutils, "get_region_name")
self.mock_get_region_name = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_netaddr_ipaddress(self):
"""Mock netaddr's IPAddress"""
mock_patch = mock.patch.object(netaddr, "IPAddress")
self.mock_netaddr_ipaddress = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_utils_get_pool_by_ip_family(self):
"""Mock utils's get_pool_by_ip_family"""
mock_patch = mock.patch.object(cutils, "get_pool_by_ip_family")
self.mock_get_pool_by_ip_family = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_subprocess_run(self):
"""Mock subprocess' run"""
mock_patch = mock.patch.object(subprocess, "run")
self.mock_subprocess_run = mock_patch.start()
self.addCleanup(mock_patch.stop)
def _mock_context(self):
"""Mock the context"""
p = mock.patch.object(subcloud_manager, "dcmanager_context")
self.mock_context = p.start()
self.mock_context.get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
@staticmethod @staticmethod
def create_subcloud_static(ctxt, **kwargs): def create_subcloud_static(ctxt, **kwargs):
values = { values = {
@ -677,7 +512,7 @@ class TestSubcloudManager(BaseTestSubcloudManager):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self._mock_netaddr_ipaddress() self._mock_object(netaddr, "IPAddress")
self.values = utils.create_subcloud_dict(base.SUBCLOUD_SAMPLE_DATA_0) self.values = utils.create_subcloud_dict(base.SUBCLOUD_SAMPLE_DATA_0)
self.test_system_peer_manager.create_peer_group_association_static( self.test_system_peer_manager.create_peer_group_association_static(
self.ctx, self.ctx,
@ -707,7 +542,6 @@ class TestSubcloudManager(BaseTestSubcloudManager):
endpoint_1 = FakeEndpoint("endpoint1", "regionOne", "1") endpoint_1 = FakeEndpoint("endpoint1", "regionOne", "1")
keystone_client = self.mock_openstack_driver().keystone_client keystone_client = self.mock_openstack_driver().keystone_client
keystone_client.endpoints.list.return_value = [endpoint_1] keystone_client.endpoints.list.return_value = [endpoint_1]
self.mks_client = self.mock_openstack_driver()
db_api.subcloud_update( db_api.subcloud_update(
self.ctx, self.ctx,
self.subcloud.id, self.subcloud.id,
@ -717,7 +551,10 @@ class TestSubcloudManager(BaseTestSubcloudManager):
for endpoint_type in SERVICE_ENDPOINTS: for endpoint_type in SERVICE_ENDPOINTS:
keystone_client.services.get.return_value.type = endpoint_type keystone_client.services.get.return_value.type = endpoint_type
self.sm._update_services_endpoint( self.sm._update_services_endpoint(
self.ctx, self.payload, self.subcloud.region_name, self.mks_client self.ctx,
self.payload,
self.subcloud.region_name,
self.mock_openstack_driver,
) )
self.mock_log_subcloud_manager.info.assert_called_with( self.mock_log_subcloud_manager.info.assert_called_with(
"Update services endpoint to 192.168.101.3 in subcloud region " "Update services endpoint to 192.168.101.3 in subcloud region "
@ -739,8 +576,12 @@ class TestSubcloudManager(BaseTestSubcloudManager):
mock_kubeoperator.assert_called_once() mock_kubeoperator.assert_called_once()
def test_generate_subcloud_ansible_config(self): def test_generate_subcloud_ansible_config(self):
self._mock_subcloud_manager_write_subcloud_ansible_config() self.mock_write_subcloud_ansible_config = self._mock_object(
self._mock_subcloud_manager_create_intermediate_ca_cert() subcloud_manager.SubcloudManager, "_write_subcloud_ansible_config"
)
self.mock_create_intermediate_ca_cert = self._mock_object(
subcloud_manager.SubcloudManager, "_create_intermediate_ca_cert"
)
self.subcloud["region_name"] = self.values["region_name"] self.subcloud["region_name"] = self.values["region_name"]
initial_deployment = False initial_deployment = False
self.sm.generate_subcloud_ansible_config( self.sm.generate_subcloud_ansible_config(
@ -904,7 +745,9 @@ class TestSubcloudManager(BaseTestSubcloudManager):
def test_update_subcloud_network_reconfiguration( def test_update_subcloud_network_reconfiguration(
self, mock_create_route, mock_update_endpoints, mock_delete_route self, mock_create_route, mock_update_endpoints, mock_delete_route
): ):
self._mock_subcloud_manager_create_addn_hosts_dc() self.mock_create_addn_hosts = self._mock_object(
subcloud_manager.SubcloudManager, "_create_addn_hosts_dc"
)
self.subcloud["deploy_status"] = consts.DEPLOY_STATE_RECONFIGURING_NETWORK self.subcloud["deploy_status"] = consts.DEPLOY_STATE_RECONFIGURING_NETWORK
db_api.subcloud_update( db_api.subcloud_update(
self.ctx, self.ctx,
@ -1049,11 +892,19 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self._mock_subcloud_manager_create_addn_hosts_dc() self.mock_create_addn_hosts = self._mock_object(
self._mock_subcloud_manager_run_subcloud_install() subcloud_manager.SubcloudManager, "_create_addn_hosts_dc"
self._mock_subcloud_manager_create_intermediate_ca_cert() )
self.mock_run_subcloud_install = self._mock_object(
subcloud_manager.SubcloudManager, "_run_subcloud_install"
)
self.mock_create_intermediate_ca_cert = self._mock_object(
subcloud_manager.SubcloudManager, "_create_intermediate_ca_cert"
)
self.mock_openstack_driver().keystone_client = FakeKeystoneClient() self.mock_openstack_driver().keystone_client = FakeKeystoneClient()
self._mock_subcloud_manager_get_cached_regionone_data() self.mock_get_cached_regionone_data = self._mock_object(
subcloud_manager.SubcloudManager, "_get_cached_regionone_data"
)
self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA
self.payload = { self.payload = {
@ -1063,7 +914,9 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
} }
def test_subcloud_deploy_install(self): def test_subcloud_deploy_install(self):
self._mock_subcloud_manager_compose_install_command() self.mock_compose_install_command = self._mock_object(
subcloud_manager.SubcloudManager, "compose_install_command"
)
self.mock_run_subcloud_install.return_value = True self.mock_run_subcloud_install.return_value = True
self.fake_payload_install["software_version"] = FAKE_PREVIOUS_SW_VERSION self.fake_payload_install["software_version"] = FAKE_PREVIOUS_SW_VERSION
self.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INSTALL self.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INSTALL
@ -1100,7 +953,9 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
) )
def test_subcloud_deploy_create(self): def test_subcloud_deploy_create(self):
self._mock_subcloud_manager_write_subcloud_ansible_config() self.mock_write_subcloud_ansible_config = self._mock_object(
subcloud_manager.SubcloudManager, "_write_subcloud_ansible_config"
)
values = utils.create_subcloud_dict(base.SUBCLOUD_SAMPLE_DATA_0) values = utils.create_subcloud_dict(base.SUBCLOUD_SAMPLE_DATA_0)
values["deploy_status"] = consts.DEPLOY_STATE_NONE values["deploy_status"] = consts.DEPLOY_STATE_NONE
@ -1425,31 +1280,23 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
def test_deploy_subcloud_enroll( def test_deploy_subcloud_enroll(
self, mock_subcloud_enrollment_prep, mock_get_region_name self, mock_subcloud_enrollment_prep, mock_get_region_name
): ):
mock_mkdtemp = self._mock_object(tempfile, "mkdtemp")
mock_run_patch_patch = mock.patch("eventlet.green.subprocess.run") self._mock_object(os, "makedirs")
mock_mkdtemp_patch = mock.patch("tempfile.mkdtemp") self._mock_object(shutil, "rmtree")
mock_makedirs_patch = mock.patch("os.makedirs")
mock_rmtree_patch = mock.patch("shutil.rmtree")
self.seed_data_dir = "/temp/seed_data" self.seed_data_dir = "/temp/seed_data"
mock_get_region_name.return_value = "11111" mock_get_region_name.return_value = "11111"
self.mock_run = mock_run_patch_patch.start()
self.mock_mkdtemp = mock_mkdtemp_patch.start()
self.mock_makedirs = mock_makedirs_patch.start()
self.mock_rmtree = mock_rmtree_patch.start()
self.addCleanup(mock_run_patch_patch.stop)
self.addCleanup(mock_mkdtemp_patch.stop)
self.addCleanup(mock_makedirs_patch.stop)
self.addCleanup(mock_rmtree_patch.stop)
self.mock_os_path_exists.return_value = True self.mock_os_path_exists.return_value = True
self.mock_mkdtemp.return_value = self.seed_data_dir mock_mkdtemp.return_value = self.seed_data_dir
self.mock_os_path_isdir.return_value = True self.mock_os_path_isdir.return_value = True
self.mock_run.return_value = mock.MagicMock(returncode=0, stdout=b"Success") self.mock_subprocess_run.return_value = mock.MagicMock(
returncode=0, stdout=b"Success"
)
self._mock_subcloud_manager_compose_enroll_command() self.mock_compose_enroll_command = self._mock_object(
subcloud_manager.SubcloudManager, "compose_enroll_command"
)
self.fake_payload_enroll["software_version"] = FAKE_PREVIOUS_SW_VERSION self.fake_payload_enroll["software_version"] = FAKE_PREVIOUS_SW_VERSION
self.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INIT_ENROLL self.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INIT_ENROLL
self.fake_payload_enroll["software_version"] = SW_VERSION self.fake_payload_enroll["software_version"] = SW_VERSION
@ -1459,12 +1306,6 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
self.ctx, self.subcloud.id, payload=self.fake_payload_enroll self.ctx, self.subcloud.id, payload=self.fake_payload_enroll
) )
# Verify subcloud was updated with correct values
updated_subcloud = db_api.subcloud_get_by_name(self.ctx, self.subcloud.name)
self.assertEqual(
consts.DEPLOY_STATE_ENROLLED, updated_subcloud.deploy_status
)
@mock.patch.object(subcloud_enrollment.SubcloudEnrollmentInit, "prep") @mock.patch.object(subcloud_enrollment.SubcloudEnrollmentInit, "prep")
@mock.patch.object(subcloud_manager.SubcloudManager, "_deploy_install_prep") @mock.patch.object(subcloud_manager.SubcloudManager, "_deploy_install_prep")
def test_subcloud_deploy_pre_init_enroll_failed( def test_subcloud_deploy_pre_init_enroll_failed(
@ -1551,16 +1392,30 @@ class TestSubcloudAdd(BaseTestSubcloudManager):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self._mock_subcloud_manager_write_subcloud_ansible_config() self.mock_write_subcloud_ansible_config = self._mock_object(
self._mock_subcloud_manager_create_addn_hosts_dc() subcloud_manager.SubcloudManager, "_write_subcloud_ansible_config"
self._mock_subcloud_manager_create_intermediate_ca_cert() )
self.mock_create_addn_hosts = self._mock_object(
subcloud_manager.SubcloudManager, "_create_addn_hosts_dc"
)
self.mock_create_intermediate_ca_cert = self._mock_object(
subcloud_manager.SubcloudManager, "_create_intermediate_ca_cert"
)
self.mock_openstack_driver().keystone_client = FakeKeystoneClient() self.mock_openstack_driver().keystone_client = FakeKeystoneClient()
self._mock_subcloud_manager_get_cached_regionone_data() self.mock_get_cached_regionone_data = self._mock_object(
subcloud_manager.SubcloudManager, "_get_cached_regionone_data"
)
self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA
self._mock_subcloud_manager_init_enroll() self.mock_subcloud_init_enroll = self._mock_object(
self._mock_subcloud_get_region_name() subcloud_manager.SubcloudManager, "subcloud_init_enroll"
self._mock_subcloud_manager_run_subcloud_enroll() )
self._mock_subcloud_manager_complete() self.mock_get_region_name = self._mock_object(cutils, "get_region_name")
self.mock_run_subcloud_enroll = self._mock_object(
subcloud_manager.SubcloudManager, "_run_subcloud_enroll"
)
self.mock_subcloud_deploy_complete = self._mock_object(
subcloud_manager.SubcloudManager, "subcloud_deploy_complete"
)
self.fake_install_values = copy.copy(fake_subcloud.FAKE_SUBCLOUD_INSTALL_VALUES) self.fake_install_values = copy.copy(fake_subcloud.FAKE_SUBCLOUD_INSTALL_VALUES)
self.fake_install_values["software_version"] = SW_VERSION self.fake_install_values["software_version"] = SW_VERSION
@ -1762,13 +1617,19 @@ class TestSubcloudDelete(BaseTestSubcloudManager):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.mock_openstack_driver().keystone_client = FakeKeystoneClient() self.mock_openstack_driver().keystone_client = FakeKeystoneClient()
self._mock_subcloud_manager_get_cached_regionone_data() self.mock_get_cached_regionone_data = self._mock_object(
subcloud_manager.SubcloudManager, "_get_cached_regionone_data"
)
self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA self.mock_get_cached_regionone_data.return_value = FAKE_CACHED_REGIONONE_DATA
self._mock_utils_is_system_controller_deploying() self.mock_is_system_controller_deploying = self._mock_object(
cutils, "is_system_controller_deploying"
)
@mock.patch.object(kubeoperator, "KubeOperator") @mock.patch.object(kubeoperator, "KubeOperator")
def test_delete_subcloud(self, mock_kubeoperator): def test_delete_subcloud(self, mock_kubeoperator):
self._mock_subcloud_manager_create_addn_hosts_dc() self.mock_create_addn_hosts = self._mock_object(
subcloud_manager.SubcloudManager, "_create_addn_hosts_dc"
)
self.mock_is_system_controller_deploying.return_value = False self.mock_is_system_controller_deploying.return_value = False
self.sm.delete_subcloud(self.ctx, subcloud_id=self.subcloud.id) self.sm.delete_subcloud(self.ctx, subcloud_id=self.subcloud.id)
self.mock_get_cached_regionone_data.assert_called_once() self.mock_get_cached_regionone_data.assert_called_once()
@ -2983,7 +2844,9 @@ class TestSubcloudUpdate(BaseTestSubcloudManager):
def test_update_subcloud_with_network_reconfig_failed(self, mock_start): def test_update_subcloud_with_network_reconfig_failed(self, mock_start):
# In this test, the mocking is required # In this test, the mocking is required
self.mock_builtins_open.side_effect = mock.mock_open() self.mock_builtins_open.side_effect = mock.mock_open()
self._mock_subcloud_manager_create_intermediate_ca_cert() self.mock_create_intermediate_ca_cert = self._mock_object(
subcloud_manager.SubcloudManager, "_create_intermediate_ca_cert"
)
self.mock_os_listdir.return_value = ["testfile1", "testfile2"] self.mock_os_listdir.return_value = ["testfile1", "testfile2"]
mock_start.side_effect = Exception("boom") mock_start.side_effect = Exception("boom")
@ -3269,7 +3132,9 @@ class TestSubcloudRedeploy(BaseTestSubcloudManager):
def test_subcloud_redeploy( def test_subcloud_redeploy(
self, mock_update_yml, mock_prepare_for_deployment, mock_oam_address self, mock_update_yml, mock_prepare_for_deployment, mock_oam_address
): ):
self._mock_subcloud_manager_run_subcloud_install() self.mock_run_subcloud_install = self._mock_object(
subcloud_manager.SubcloudManager, "_run_subcloud_install"
)
self.mock_get_playbook_for_software_version.return_value = FAKE_SW_VERSION self.mock_get_playbook_for_software_version.return_value = FAKE_SW_VERSION
self.mock_ansible_run_playbook.return_value = False self.mock_ansible_run_playbook.return_value = False
self.mock_run_subcloud_install.return_value = True self.mock_run_subcloud_install.return_value = True
@ -4183,7 +4048,9 @@ class TestSubcloudBackupRestore(BaseTestSubcloudManager):
mock_create_overrides, mock_create_overrides,
mock_run_restore_playbook, mock_run_restore_playbook,
): ):
self._mock_subcloud_manager_run_subcloud_install() self.mock_run_subcloud_install = self._mock_object(
subcloud_manager.SubcloudManager, "_run_subcloud_install"
)
self.mock_os_path_isdir.return_value = True self.mock_os_path_isdir.return_value = True
self.mock_os_listdir.return_value = ["test.iso", "test.sig"] self.mock_os_listdir.return_value = ["test.iso", "test.sig"]
mock_create_inventory_file.return_value = "inventory_file.yml" mock_create_inventory_file.return_value = "inventory_file.yml"
@ -4755,7 +4622,9 @@ class TestSubcloudMigrate(BaseTestSubcloudManager):
) )
def test_rehome_subcloud_failed(self): def test_rehome_subcloud_failed(self):
self._mock_utils_get_playbook_for_software_version() self.mock_get_playbook_for_software_version = self._mock_object(
cutils, "get_playbook_for_software_version"
)
self.mock_get_playbook_for_software_version.return_value = SW_VERSION self.mock_get_playbook_for_software_version.return_value = SW_VERSION
self.mock_subprocess_run.return_value.returncode = 0 self.mock_subprocess_run.return_value.returncode = 0
self.mock_ansible_run_playbook.side_effect = PlaybookExecutionFailed() self.mock_ansible_run_playbook.side_effect = PlaybookExecutionFailed()
@ -4773,8 +4642,10 @@ class TestSubcloudInstall(BaseTestSubcloudManager):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self._mock_netaddr_ipaddress() self.mock_netaddr_ipaddress = self._mock_object(netaddr, "IPAddress")
self._mock_subcloud_manager_compose_install_command() self.mock_compose_install_command = self._mock_object(
subcloud_manager.SubcloudManager, "compose_install_command"
)
self.fake_install_values = copy.copy(fake_subcloud.FAKE_SUBCLOUD_INSTALL_VALUES) self.fake_install_values = copy.copy(fake_subcloud.FAKE_SUBCLOUD_INSTALL_VALUES)
self.fake_install_values["software_version"] = SW_VERSION self.fake_install_values["software_version"] = SW_VERSION
self.fake_log_file = ( self.fake_log_file = (
@ -4783,9 +4654,10 @@ class TestSubcloudInstall(BaseTestSubcloudManager):
) )
+ "_playbook_output.log" + "_playbook_output.log"
) )
self.mock_install_sysinv_client().get_oam_address_pools.return_value = ( get_oam_address_pools = (
FAKE_OAM_POOLS self.mock_subcloud_install_sysinv_client().get_oam_address_pools
) )
get_oam_address_pools.return_value = FAKE_OAM_POOLS
self.mock_subprocess_run.return_value.returncode = 0 self.mock_subprocess_run.return_value.returncode = 0
self.subcloud.update( self.subcloud.update(
{ {
@ -4940,31 +4812,23 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
"bmc_password": "bmc_pass", "bmc_password": "bmc_pass",
} }
mock_run_patch_patch = mock.patch("eventlet.green.subprocess.run") self.mock_temporary_directory = self._mock_object(
mock_TemporaryDirectory_patch = mock.patch("tempfile.TemporaryDirectory") tempfile, "TemporaryDirectory"
mock_makedirs_patch = mock.patch("os.makedirs") )
mock_rmtree_patch = mock.patch("shutil.rmtree") self.mock_os_makedirs = self._mock_object(os, "makedirs")
self._mock_object(shutil, "rmtree")
self.mock_run = mock_run_patch_patch.start()
self.mock_TemporaryDirectory = mock_TemporaryDirectory_patch.start()
self.mock_makedirs = mock_makedirs_patch.start()
self.mock_rmtree = mock_rmtree_patch.start()
self.addCleanup(mock_run_patch_patch.stop)
self.addCleanup(mock_TemporaryDirectory_patch.stop)
self.addCleanup(mock_makedirs_patch.stop)
self.addCleanup(mock_rmtree_patch.stop)
self.mock_log_subcloud_enrollment = self._mock_object( self.mock_log_subcloud_enrollment = self._mock_object(
subcloud_enrollment, "LOG" subcloud_enrollment, "LOG"
) )
self.mock_os_path_exists.return_value = True self.mock_os_path_exists.return_value = True
self.mock_TemporaryDirectory.return_value.__enter__.return_value = ( self.mock_temporary_directory.return_value.__enter__.return_value = (
self.seed_data_dir self.seed_data_dir
) )
self.mock_os_path_isdir.return_value = True self.mock_os_path_isdir.return_value = True
self.mock_run.return_value = mock.MagicMock(returncode=0, stdout=b"Success") self.mock_subprocess_run.return_value = mock.MagicMock(
returncode=0, stdout=b"Success"
)
def patched_isdir(self, path): def patched_isdir(self, path):
return path != self.iso_dir return path != self.iso_dir
@ -5032,9 +4896,9 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
) )
# Iso command must be invoked (subprocess.run) # Iso command must be invoked (subprocess.run)
self.mock_run.assert_called_once() self.mock_subprocess_run.assert_called_once()
# Temp seed data dir must be created # Temp seed data dir must be created
self.mock_TemporaryDirectory.assert_called_once_with(prefix="seed_") self.mock_temporary_directory.assert_called_once_with(prefix="seed_")
# Seed files must be generated in temp seed dir # Seed files must be generated in temp seed dir
self.mock_builtins_open.assert_any_call( self.mock_builtins_open.assert_any_call(
f"{self.seed_data_dir}/meta-data", "w" f"{self.seed_data_dir}/meta-data", "w"
@ -5073,8 +4937,8 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
mock_validate.assert_called_once_with(self.iso_values) mock_validate.assert_called_once_with(self.iso_values)
# ISO dir must be created # ISO dir must be created
self.mock_makedirs.assert_called_once() self.mock_os_makedirs.assert_called_once()
self.assertEqual(self.mock_makedirs.call_args.args[0], self.iso_dir) self.assertEqual(self.mock_os_makedirs.call_args.args[0], self.iso_dir)
mock_generate_seed_iso.assert_called_once_with(self.iso_values) mock_generate_seed_iso.assert_called_once_with(self.iso_values)
@ -5117,7 +4981,7 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
self.mock_os_remove.assert_called_once_with(self.iso_file) self.mock_os_remove.assert_called_once_with(self.iso_file)
# Makedirs shouldn't be invoked, given that prev iso exisited # Makedirs shouldn't be invoked, given that prev iso exisited
self.mock_makedirs.assert_not_called() self.mock_os_makedirs.assert_not_called()
self.mock_log_subcloud_enrollment.info.assert_any_call( self.mock_log_subcloud_enrollment.info.assert_any_call(
f"Found preexisting seed iso for subcloud {self.subcloud_name}, cleaning up" f"Found preexisting seed iso for subcloud {self.subcloud_name}, cleaning up"
@ -5136,5 +5000,4 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
consts.DC_ANSIBLE_LOG_DIR, self.subcloud_name consts.DC_ANSIBLE_LOG_DIR, self.subcloud_name
) )
expected_log_file = f"{subcloud_log_base_path}_playbook_output.log" expected_log_file = f"{subcloud_log_base_path}_playbook_output.log"
self.mock_ansible_run_playbook.assert_called_with(expected_log_file, mock.ANY) self.mock_ansible_run_playbook.assert_called_with(expected_log_file, mock.ANY)

42
distributedcloud/dcmanager/tests/unit/orchestrator/states/prestage/test_states.py
View File

@ -10,7 +10,6 @@ import copy
import os import os
import threading import threading
import mock
from dccommon import ostree_mount from dccommon import ostree_mount
from dccommon.utils import AnsiblePlaybook from dccommon.utils import AnsiblePlaybook
@ -21,6 +20,7 @@ from dcmanager.common.consts import STRATEGY_STATE_PRESTAGE_IMAGES
from dcmanager.common.consts import STRATEGY_STATE_PRESTAGE_PACKAGES from dcmanager.common.consts import STRATEGY_STATE_PRESTAGE_PACKAGES
from dcmanager.common.consts import STRATEGY_STATE_PRESTAGE_PRE_CHECK from dcmanager.common.consts import STRATEGY_STATE_PRESTAGE_PRE_CHECK
from dcmanager.common import exceptions from dcmanager.common import exceptions
from dcmanager.common import prestage
from dcmanager.db.sqlalchemy import api as db_api from dcmanager.db.sqlalchemy import api as db_api
from dcmanager.tests.unit.common import fake_strategy from dcmanager.tests.unit.common import fake_strategy
from dcmanager.tests.unit.orchestrator.test_base import TestSwUpdate from dcmanager.tests.unit.orchestrator.test_base import TestSwUpdate
@ -70,28 +70,13 @@ class TestPrestagePreCheckState(TestPrestage):
self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_PRE_CHECK) self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_PRE_CHECK)
self._mock_validate_prestage() # The validate_prestage method is mocked because the focus is on testing
self._mock_threading_start() # the orchestrator logic only. Any specifc prestage functionality is covered on
# individual tests.
def _mock_validate_prestage(self): self.mock_prestage_subcloud = self._mock_object(prestage, "validate_prestage")
"""Mock dcmanager's common validate_prestage method
The validate_prestage method is mocked because the focus is on testing
the orchestrator logic only. Any specifc prestage functionality is covered on
individual tests.
"""
mock_class = mock.patch("dcmanager.common.prestage.validate_prestage")
self.mock_prestage_subcloud = mock_class.start()
self.mock_prestage_subcloud.return_value = OAM_FLOATING_IP self.mock_prestage_subcloud.return_value = OAM_FLOATING_IP
self.addCleanup(mock_class.stop)
def _mock_threading_start(self): self._mock_object(threading.Thread, "start")
"""Mock threading's Thread.start"""
mock_thread = mock.patch.object(threading.Thread, "start")
self.mock_thread_start = mock_thread.start()
self.addCleanup(mock_thread.stop)
def test_prestage_pre_check_without_extra_args(self): def test_prestage_pre_check_without_extra_args(self):
"""Test prestage pre check without extra args""" """Test prestage pre check without extra args"""
@ -168,15 +153,8 @@ class TestPrestagePackagesState(TestPrestage):
self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_PACKAGES) self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_PACKAGES)
self._mock_object(builtins, "open") self._mock_object(builtins, "open")
self._mock_ansible_playbook() self._mock_object(AnsiblePlaybook, "run_playbook")
self.mock_validate_ostree_iso_mount = self._mock_object( self._mock_object(ostree_mount, "validate_ostree_iso_mount")
ostree_mount, "validate_ostree_iso_mount"
)
def _mock_ansible_playbook(self):
mock_patch_object = mock.patch.object(AnsiblePlaybook, "run_playbook")
self.mock_ansible_playbook = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def test_prestage_package_succeeds(self): def test_prestage_package_succeeds(self):
"""Test prestage package succeeds""" """Test prestage package succeeds"""
@ -200,8 +178,8 @@ class TestPrestageImagesState(TestPrestage):
self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_IMAGES) self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_IMAGES)
self.mock_os_path_isdir = self._mock_object(os.path, "isdir") mock_os_path_isdir = self._mock_object(os.path, "isdir")
self.mock_os_path_isdir.return_value = False mock_os_path_isdir.return_value = False
def test_prestage_images_succeeds(self): def test_prestage_images_succeeds(self):
"""Test prestage images succeeds""" """Test prestage images succeeds"""

22
distributedcloud/dcmanager/tests/unit/orchestrator/states/software/test_base.py
View File

@ -4,13 +4,10 @@
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
# #
import mock
from dcmanager.common import consts from dcmanager.common import consts
from dcmanager.orchestrator.states.software.cache import clients
from dcmanager.tests.unit.orchestrator.test_base import TestSwUpdate from dcmanager.tests.unit.orchestrator.test_base import TestSwUpdate
CACHE_CLIENT_PATH = "dcmanager.orchestrator.states.software.cache.clients"
class TestSoftwareOrchestrator(TestSwUpdate): class TestSoftwareOrchestrator(TestSwUpdate):
# Setting DEFAULT_STRATEGY_TYPE to software will setup the software # Setting DEFAULT_STRATEGY_TYPE to software will setup the software
@ -21,17 +18,8 @@ class TestSoftwareOrchestrator(TestSwUpdate):
super().setUp() super().setUp()
# Modify cache helpers to return client mocks # Modify cache helpers to return client mocks
self.software_cache_client_mock = mock.patch( mock_get_software_client = self._mock_object(clients, "get_software_client")
f"{CACHE_CLIENT_PATH}.get_software_client", mock_get_software_client.return_value = self.software_client
return_value=self.software_client,
)
self.sysinv_cache_client_mock = mock.patch(
f"{CACHE_CLIENT_PATH}.get_sysinv_client", return_value=self.sysinv_client
)
self.software_cache_client_mock.start()
self.sysinv_cache_client_mock.start()
def tearDown(self): mock_get_sysinv_client = self._mock_object(clients, "get_sysinv_client")
self.software_cache_client_mock.stop() mock_get_sysinv_client.return_value = self.sysinv_client
self.sysinv_cache_client_mock.stop()
super().tearDown()

10
distributedcloud/dcmanager/tests/unit/orchestrator/states/software/test_finish_strategy.py
View File

@ -85,6 +85,7 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
self.strategy_step = self.setup_strategy_step( self.strategy_step = self.setup_strategy_step(
self.subcloud.id, consts.STRATEGY_STATE_SW_FINISH_STRATEGY self.subcloud.id, consts.STRATEGY_STATE_SW_FINISH_STRATEGY
) )
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
# Add mock API endpoints for software client calls # Add mock API endpoints for software client calls
# invoked by this state # invoked by this state
@ -95,8 +96,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_success(self): def test_finish_strategy_success(self):
"""Test software finish strategy when the API call succeeds.""" """Test software finish strategy when the API call succeeds."""
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
self.software_client.list.side_effect = [SUBCLOUD_RELEASES] self.software_client.list.side_effect = [SUBCLOUD_RELEASES]
# invoke the strategy state operation on the orch thread # invoke the strategy state operation on the orch thread
@ -113,8 +112,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_no_operation_required(self): def test_finish_strategy_no_operation_required(self):
"""Test software finish strategy when no operation is required.""" """Test software finish strategy when no operation is required."""
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
self.software_client.list.side_effect = [REGION_ONE_RELEASES] self.software_client.list.side_effect = [REGION_ONE_RELEASES]
# invoke the strategy state operation on the orch thread # invoke the strategy state operation on the orch thread
@ -130,8 +127,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_fails_when_query_exception(self): def test_finish_strategy_fails_when_query_exception(self):
"""Test finish strategy fails when software client query raises exception""" """Test finish strategy fails when software client query raises exception"""
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
self.software_client.list.side_effect = Exception() self.software_client.list.side_effect = Exception()
self.worker.perform_state_action(self.strategy_step) self.worker.perform_state_action(self.strategy_step)
@ -143,8 +138,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_fails_when_delete_exception(self): def test_finish_strategy_fails_when_delete_exception(self):
"""Test finish strategy fails when software client delete raises exception""" """Test finish strategy fails when software client delete raises exception"""
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
self.software_client.list.side_effect = [SUBCLOUD_RELEASES] self.software_client.list.side_effect = [SUBCLOUD_RELEASES]
self.software_client.delete.side_effect = Exception() self.software_client.delete.side_effect = Exception()
@ -157,7 +150,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
@mock.patch.object(BaseState, "stopped") @mock.patch.object(BaseState, "stopped")
def test_finish_strategy_fails_when_stopped(self, mock_base_stopped): def test_finish_strategy_fails_when_stopped(self, mock_base_stopped):
"""Test finish strategy fails when stopped""" """Test finish strategy fails when stopped"""
self.mock_read_from_cache.return_value = REGION_ONE_RELEASES
self.software_client.list.side_effect = [SUBCLOUD_RELEASES] self.software_client.list.side_effect = [SUBCLOUD_RELEASES]

137
distributedcloud/dcmanager/tests/unit/orchestrator/test_base.py
View File

@ -32,7 +32,6 @@ from dcmanager.tests.unit.orchestrator.states.fakes import FakePatchingClient
from dcmanager.tests.unit.orchestrator.states.fakes import FakeSoftwareClient from dcmanager.tests.unit.orchestrator.states.fakes import FakeSoftwareClient
from dcmanager.tests.unit.orchestrator.states.fakes import FakeSysinvClient from dcmanager.tests.unit.orchestrator.states.fakes import FakeSysinvClient
from dcmanager.tests.unit.orchestrator.test_sw_update_manager import FakeOrchThread from dcmanager.tests.unit.orchestrator.test_sw_update_manager import FakeOrchThread
from dcmanager.tests import utils
CONF = cfg.CONF CONF = cfg.CONF
@ -42,149 +41,101 @@ class TestSwUpdate(base.DCManagerTestCase):
DEFAULT_STRATEGY_TYPE = consts.SW_UPDATE_TYPE_SOFTWARE DEFAULT_STRATEGY_TYPE = consts.SW_UPDATE_TYPE_SOFTWARE
def setUp(self): def setUp(self):
super(TestSwUpdate, self).setUp() super().setUp()
# construct an upgrade orch thread # construct an upgrade orch thread
self.worker = self.setup_orch_worker(self.DEFAULT_STRATEGY_TYPE) self.worker = self.setup_orch_worker(self.DEFAULT_STRATEGY_TYPE)
# Mock the context # Mock the context
self.ctxt = utils.dummy_context() mock_get_admin_context = self._mock_object(context, "get_admin_context")
p = mock.patch.object(context, "get_admin_context") mock_get_admin_context.return_value = self.ctx
self.mock_get_admin_context = p.start()
self.mock_get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
# Mock the keystone client defined in the base state class # Mock the clients defined in the base state class
self.keystone_client = FakeKeystoneClient() self.keystone_client = FakeKeystoneClient()
p = mock.patch.object(BaseState, "get_keystone_client")
self.mock_keystone_client = p.start()
self.mock_keystone_client.return_value = self.keystone_client
self.addCleanup(p.stop)
# Mock the sysinv client defined in the base state class
self.sysinv_client = FakeSysinvClient() self.sysinv_client = FakeSysinvClient()
p = mock.patch.object(BaseState, "get_sysinv_client")
self.mock_sysinv_client = p.start()
self.mock_sysinv_client.return_value = self.sysinv_client
self.addCleanup(p.stop)
# Mock the software client defined in the base state class
self.software_client = FakeSoftwareClient() self.software_client = FakeSoftwareClient()
p = mock.patch.object(BaseState, "get_software_client")
self.mock_software_client = p.start()
self.mock_software_client.return_value = self.software_client
self.addCleanup(p.stop)
# Mock the patching client defined in the base state class
self.patching_client = FakePatchingClient() self.patching_client = FakePatchingClient()
p = mock.patch.object(BaseState, "get_patching_client")
self.mock_patching_client = p.start()
self.mock_patching_client.return_value = self.patching_client
self.addCleanup(p.stop)
# Mock the vim client defined in the base state class
self.vim_client = FakeVimClient() self.vim_client = FakeVimClient()
p = mock.patch.object(BaseState, "get_vim_client")
self.mock_vim_client = p.start()
self.mock_vim_client.return_value = self.vim_client
self.addCleanup(p.stop)
# Mock the fm client defined in the base state class
self.fm_client = FakeFmClient() self.fm_client = FakeFmClient()
p = mock.patch.object(BaseState, "get_fm_client")
self.mock_fm_client = p.start() clients = {
self.mock_fm_client.return_value = self.fm_client "get_keystone_client": self.keystone_client,
self.addCleanup(p.stop) "get_sysinv_client": self.sysinv_client,
"get_software_client": self.software_client,
"get_patching_client": self.patching_client,
"get_vim_client": self.vim_client,
"get_fm_client": self.fm_client,
}
for key, value in clients.items():
mock_get_keystone_client = self._mock_object(BaseState, key)
mock_get_keystone_client.return_value = value
def setup_orch_worker(self, strategy_type): def setup_orch_worker(self, strategy_type):
worker = None worker = None
mock_strategy_lock = mock.Mock()
mock_dcmanager_audit_api = mock.Mock()
# There are many orch threads. Only one needs to be setup based on type # There are many orch threads. Only one needs to be setup based on type
if strategy_type == consts.SW_UPDATE_TYPE_SOFTWARE: if strategy_type == consts.SW_UPDATE_TYPE_SOFTWARE:
sw_update_manager.SoftwareOrchThread.stopped = lambda x: False sw_update_manager.SoftwareOrchThread.stopped = lambda x: False
worker = sw_update_manager.SoftwareOrchThread( worker = sw_update_manager.SoftwareOrchThread(mock.Mock(), mock.Mock())
mock_strategy_lock, mock_dcmanager_audit_api
)
else: else:
# mock the software orch thread # mock the software orch thread
self.fake_software_orch_thread = FakeOrchThread() mock_software_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "SoftwareOrchThread") sw_update_manager, "SoftwareOrchThread"
self.mock_software_orch_thread = p.start() )
self.mock_software_orch_thread.return_value = self.fake_software_orch_thread mock_software_orch_thread.return_value = FakeOrchThread()
self.addCleanup(p.stop)
if strategy_type == consts.SW_UPDATE_TYPE_PATCH: if strategy_type == consts.SW_UPDATE_TYPE_PATCH:
sw_update_manager.PatchOrchThread.stopped = lambda x: False sw_update_manager.PatchOrchThread.stopped = lambda x: False
worker = sw_update_manager.PatchOrchThread( worker = sw_update_manager.PatchOrchThread(mock.Mock(), mock.Mock())
mock_strategy_lock, mock_dcmanager_audit_api
)
else: else:
# mock the patch orch thread # mock the patch orch thread
self.fake_sw_patch_orch_thread = FakeOrchThread() mock_sw_patch_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "PatchOrchThread") sw_update_manager, "PatchOrchThread"
self.mock_sw_patch_orch_thread = p.start() )
self.mock_sw_patch_orch_thread.return_value = self.fake_sw_patch_orch_thread mock_sw_patch_orch_thread.return_value = FakeOrchThread()
self.addCleanup(p.stop)
if strategy_type == consts.SW_UPDATE_TYPE_FIRMWARE: if strategy_type == consts.SW_UPDATE_TYPE_FIRMWARE:
sw_update_manager.FwUpdateOrchThread.stopped = lambda x: False sw_update_manager.FwUpdateOrchThread.stopped = lambda x: False
worker = sw_update_manager.FwUpdateOrchThread( worker = sw_update_manager.FwUpdateOrchThread(mock.Mock(), mock.Mock())
mock_strategy_lock, mock_dcmanager_audit_api
)
else: else:
# mock the firmware orch thread # mock the firmware orch thread
self.fake_fw_update_orch_thread = FakeOrchThread() mock_fw_update_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "FwUpdateOrchThread") sw_update_manager, "FwUpdateOrchThread"
self.mock_fw_update_orch_thread = p.start()
self.mock_fw_update_orch_thread.return_value = (
self.fake_fw_update_orch_thread
) )
self.addCleanup(p.stop) mock_fw_update_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_KUBERNETES: if strategy_type == consts.SW_UPDATE_TYPE_KUBERNETES:
sw_update_manager.KubeUpgradeOrchThread.stopped = lambda x: False sw_update_manager.KubeUpgradeOrchThread.stopped = lambda x: False
worker = sw_update_manager.KubeUpgradeOrchThread( worker = sw_update_manager.KubeUpgradeOrchThread(mock.Mock(), mock.Mock())
mock_strategy_lock, mock_dcmanager_audit_api
)
else: else:
# mock the kube upgrade orch thread # mock the kube upgrade orch thread
self.fake_kube_upgrade_orch_thread = FakeOrchThread() mock_kube_upgrade_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "KubeUpgradeOrchThread") sw_update_manager, "KubeUpgradeOrchThread"
self.mock_kube_upgrade_orch_thread = p.start()
self.mock_kube_upgrade_orch_thread.return_value = (
self.fake_kube_upgrade_orch_thread
) )
self.addCleanup(p.stop) mock_kube_upgrade_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_KUBE_ROOTCA_UPDATE: if strategy_type == consts.SW_UPDATE_TYPE_KUBE_ROOTCA_UPDATE:
sw_update_manager.KubeRootcaUpdateOrchThread.stopped = lambda x: False sw_update_manager.KubeRootcaUpdateOrchThread.stopped = lambda x: False
worker = sw_update_manager.KubeRootcaUpdateOrchThread( worker = sw_update_manager.KubeRootcaUpdateOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api mock.Mock(), mock.Mock()
) )
else: else:
# mock the kube rootca update orch thread # mock the kube rootca update orch thread
self.fake_kube_rootca_update_orch_thread = FakeOrchThread() mock_kube_rootca_update_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "KubeRootcaUpdateOrchThread") sw_update_manager, "KubeRootcaUpdateOrchThread"
self.mock_kube_rootca_update_orch_thread = p.start()
self.mock_kube_rootca_update_orch_thread.return_value = (
self.fake_kube_rootca_update_orch_thread
) )
self.addCleanup(p.stop) mock_kube_rootca_update_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_PRESTAGE: if strategy_type == consts.SW_UPDATE_TYPE_PRESTAGE:
sw_update_manager.PrestageOrchThread.stopped = lambda x: False sw_update_manager.PrestageOrchThread.stopped = lambda x: False
worker = sw_update_manager.PrestageOrchThread( worker = sw_update_manager.PrestageOrchThread(mock.Mock(), mock.Mock())
mock_strategy_lock, mock_dcmanager_audit_api
)
else: else:
# mock the prestage orch thread # mock the prestage orch thread
self.fake_prestage_orch_thread = FakeOrchThread() mock_prestage_orch_thread = self._mock_object(
p = mock.patch.object(sw_update_manager, "PrestageOrchThread") sw_update_manager, "PrestageOrchThread"
self.mock_prestage_orch_thread = p.start() )
self.mock_prestage_orch_thread.return_value = self.fake_prestage_orch_thread mock_prestage_orch_thread.return_value = FakeOrchThread()
self.addCleanup(p.stop)
return worker return worker

12
distributedcloud/dcmanager/tests/unit/orchestrator/test_fw_orch_thread.py
View File

@ -27,7 +27,7 @@ def non_threaded_start(some_function, some_arguments):
class TestFwOrchThread(TestSwUpdate): class TestFwOrchThread(TestSwUpdate):
@staticmethod @staticmethod
def create_subcloud(ctxt, name, group_id): def create_subcloud(ctx, name, group_id):
values = { values = {
"name": name, "name": name,
"description": "subcloud1 description", "description": "subcloud1 description",
@ -46,9 +46,9 @@ class TestFwOrchThread(TestSwUpdate):
"group_id": group_id, "group_id": group_id,
"data_install": "data from install", "data_install": "data from install",
} }
subcloud = db_api.subcloud_create(ctxt, **values) subcloud = db_api.subcloud_create(ctx, **values)
state = dccommon_consts.MANAGEMENT_MANAGED state = dccommon_consts.MANAGEMENT_MANAGED
subcloud = db_api.subcloud_update(ctxt, subcloud.id, management_state=state) subcloud = db_api.subcloud_update(ctx, subcloud.id, management_state=state)
return subcloud return subcloud
# Setting DEFAULT_STRATEGY_TYPE to firmware will setup the firmware # Setting DEFAULT_STRATEGY_TYPE to firmware will setup the firmware
@ -100,9 +100,9 @@ class TestFwOrchThread(TestSwUpdate):
def test_apply_strategy(self, mock_perform_state_action, mock_start): def test_apply_strategy(self, mock_perform_state_action, mock_start):
mock_start.side_effect = non_threaded_start mock_start.side_effect = non_threaded_start
self.strategy = self.setup_strategy(state=consts.SW_UPDATE_STATE_APPLYING) self.strategy = self.setup_strategy(state=consts.SW_UPDATE_STATE_APPLYING)
subcloud2 = self.create_subcloud(self.ctxt, "subcloud2", 1) subcloud2 = self.create_subcloud(self.ctx, "subcloud2", 1)
subcloud3 = self.create_subcloud(self.ctxt, "subcloud3", 1) subcloud3 = self.create_subcloud(self.ctx, "subcloud3", 1)
subcloud4 = self.create_subcloud(self.ctxt, "subcloud4", 1) subcloud4 = self.create_subcloud(self.ctx, "subcloud4", 1)
self.setup_strategy_step(subcloud2.id, consts.STRATEGY_STATE_INITIAL) self.setup_strategy_step(subcloud2.id, consts.STRATEGY_STATE_INITIAL)
self.setup_strategy_step(subcloud3.id, consts.STRATEGY_STATE_INITIAL) self.setup_strategy_step(subcloud3.id, consts.STRATEGY_STATE_INITIAL)

566
distributedcloud/dcmanager/tests/unit/orchestrator/test_sw_update_manager.py
View File

File diff suppressed because it is too large Load Diff

75
distributedcloud/dcmanager/tests/unit/rpc/test_rpc_client.py
View File

@ -12,13 +12,11 @@
# under the License. # under the License.
# #
import mock
from dcmanager.common import config from dcmanager.common import config
from dcmanager.common import messaging from dcmanager.common import messaging
from dcmanager.rpc import client as rpc_client from dcmanager.rpc import client as rpc_client
from dcmanager.tests import base from dcmanager.tests import base
from dcmanager.tests import utils
config.register_options() config.register_options()
@ -28,59 +26,48 @@ class ManagerRpcAPITestCase(base.DCManagerTestCase):
def setUp(self): def setUp(self):
messaging.setup("fake://", optional=True) messaging.setup("fake://", optional=True)
self.addCleanup(messaging.cleanup) self.addCleanup(messaging.cleanup)
self.context = utils.dummy_context()
# self.stubs = stubout.StubOutForTesting() super().setUp()
self.mock_get_rpc_client = self._mock_object(messaging, "get_rpc_client")
self.method = "fake_method"
self.kwargs = {"key": "value"}
self.rpcapi = rpc_client.ManagerClient() self.rpcapi = rpc_client.ManagerClient()
super(ManagerRpcAPITestCase, self).setUp() self.msg = self.rpcapi.make_msg(self.method, **self.kwargs)
@mock.patch.object(messaging, "get_rpc_client")
def test_call(self, mock_client):
client = mock.Mock()
mock_client.return_value = client
method = "fake_method"
kwargs = {"key": "value"}
rpcapi = rpc_client.ManagerClient()
msg = rpcapi.make_msg(method, **kwargs)
def test_call(self):
# with no version # with no version
res = rpcapi.call(self.context, msg) res = self.rpcapi.call(self.ctx, self.msg)
self.assertEqual(client, rpcapi._client) self.assertEqual(self.mock_get_rpc_client(), self.rpcapi._client)
client.call.assert_called_once_with(self.context, "fake_method", key="value") self.mock_get_rpc_client().call.assert_called_once_with(
self.assertEqual(res, client.call.return_value) self.ctx, self.method, key="value"
)
self.assertEqual(res, self.mock_get_rpc_client().call.return_value)
# with version # with version
res = rpcapi.call(self.context, msg, version="123") res = self.rpcapi.call(self.ctx, self.msg, version="123")
client.prepare.assert_called_once_with(version="123") self.mock_get_rpc_client().prepare.assert_called_once_with(version="123")
new_client = client.prepare.return_value new_client = self.mock_get_rpc_client().prepare.return_value
new_client.call.assert_called_once_with( new_client.call.assert_called_once_with(self.ctx, "fake_method", key="value")
self.context, "fake_method", key="value"
)
self.assertEqual(res, new_client.call.return_value) self.assertEqual(res, new_client.call.return_value)
@mock.patch.object(messaging, "get_rpc_client") def test_cast(self):
def test_cast(self, mock_client):
client = mock.Mock()
mock_client.return_value = client
method = "fake_method"
kwargs = {"key": "value"}
rpcapi = rpc_client.ManagerClient()
msg = rpcapi.make_msg(method, **kwargs)
# with no version # with no version
res = rpcapi.cast(self.context, msg) res = self.rpcapi.cast(self.ctx, self.msg)
self.assertEqual(client, rpcapi._client) self.assertEqual(self.mock_get_rpc_client(), self.rpcapi._client)
client.cast.assert_called_once_with(self.context, "fake_method", key="value") self.mock_get_rpc_client().cast.assert_called_once_with(
self.assertEqual(res, client.cast.return_value) self.ctx, "fake_method", key="value"
)
self.assertEqual(res, self.mock_get_rpc_client().cast.return_value)
# with version # with version
res = rpcapi.cast(self.context, msg, version="123") res = self.rpcapi.cast(self.ctx, self.msg, version="123")
client.prepare.assert_called_once_with(fanout=None, version="123") self.mock_get_rpc_client().prepare.assert_called_once_with(
new_client = client.prepare.return_value fanout=None, version="123"
new_client.cast.assert_called_once_with(
self.context, "fake_method", key="value"
) )
new_client = self.mock_get_rpc_client().prepare.return_value
new_client.cast.assert_called_once_with(self.ctx, "fake_method", key="value")
self.assertEqual(res, new_client.cast.return_value) self.assertEqual(res, new_client.cast.return_value)