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.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):
"""Test class for PhasedSubcloudDeployController"""
@ -216,8 +185,10 @@ class BaseTestPhasedSubcloudDeployPatch(BaseTestPhasedSubcloudDeployController):
self.mock_get_vault_load_files = self._mock_object(
dutils, "get_vault_load_files"
)
self._mock_is_initial_deployment()
self._mock_is_valid_software_deploy_state()
self.mock_is_initial_deployment = self._mock_object(
psd_common, "is_initial_deployment"
)
self._mock_object(SubcloudsController, "is_valid_software_deploy_state")
self.mock_get_network_address_pools = self._mock_object(
psd_common, "get_network_address_pools"
)
@ -471,8 +442,8 @@ class TestPhasedSubcloudDeployPatchConfigure(BaseTestPhasedSubcloudDeployPatch):
data_install=json.dumps(self.data_install),
)
self._mock_populate_payload()
self._mock_get_request_data()
self._mock_object(psd_common, "populate_payload_with_pre_existing_data")
self.mock_get_request_data = self._mock_object(psd_common, "get_request_data")
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
)
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_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_request_data.return_value = self.install_payload
@ -986,9 +959,11 @@ class TestPhasedSubcloudDeployPatchResume(BaseTestPhasedSubcloudDeployPatch):
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_get_request_data()
self.mock_get_request_data = self._mock_object(psd_common, "get_request_data")
self._setup_mock_get_request_data()
self.mock_load_yaml_file = self._mock_object(dutils, "load_yaml_file")
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),
("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):
"""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_remove = self._mock_object(os, "remove")
self._mock_object(os, "mkdir")
self._mock_os_open()
self._mock_os_write()
self.mock_os_open = self._mock_object(os, "open")
self._mock_object(os, "write")
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()
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):
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.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(
read_data=fake_subcloud.FAKE_UPGRADES_METADATA
)
@ -376,7 +354,7 @@ class TestSubcloudDeployDelete(BaseTestSubcloudDeployController):
self.method = self.app.delete
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.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_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):
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 = (
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._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._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()
def _setup_mock_sysinv_client_prestage(self):
@ -2946,27 +2952,6 @@ class BaseTestSubcloudsPatchPrestage(BaseTestSubcloudsPatch):
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):
if "release" not in self.params:
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 mock
from oslo_messaging import RemoteError
from dccommon import consts as dccommon_consts
@ -38,14 +37,9 @@ class BaseTestSwUpdateStrategyController(DCManagerApiTest):
self.url = "/v1.0/sw-update-strategy"
self._mock_rpc_orchestrator_client()
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)
self.mock_rpc_orchestrator_client = self._mock_object(
rpc_client, "ManagerOrchestratorClient"
)
class TestSwUpdateStrategyController(BaseTestSwUpdateStrategyController):
@ -233,12 +227,10 @@ class TestSwUpdateStrategyPost(BaseTestSwUpdateStrategyPost):
self.create_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"
)
self.mock_get_releases = self.get_releases_patcher.start()
self.mock_get_releases.return_value = ["stx-10.0.0"]
self.addCleanup(self.get_releases_patcher.stop)
self.mock_get_sc_installed_releases_id.return_value = ["stx-10.0.0"]
def test_post_succeeds(self):
"""Test post succeeds"""

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

@ -14,7 +14,6 @@
# under the License.
#
import mock
from oslo_config import cfg
from dccommon import consts as dccommon_consts
@ -402,7 +401,11 @@ class TestFirmwareAudit(base.DCManagerTestCase):
super().setUp()
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"
)
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)
return firmware_audit_data
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_firmware_audit_data_to_sync(
self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
):
def test_no_firmware_audit_data_to_sync(self):
mock_fw_sysinv_client.side_effect = FakeSysinvClientNoAuditData
self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientNoAuditData
firmware_audit_data = self.get_fw_audit_data()
subclouds = {
@ -449,20 +446,18 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_enabled_devices_on_subcloud(
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()
subclouds = {
@ -471,19 +466,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_apply_image_to_all_devices(
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()
subclouds = {
@ -492,20 +487,20 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_not_applied(
self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
self.mock_audit_worker_manager_sysinv_client.side_effect = (
FakeSysinvClientImageNotApplied
)
firmware_audit_data = self.get_fw_audit_data()
subclouds = {
@ -514,20 +509,20 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_not_written(
self,
mock_fw_openstack_driver,
mock_fw_sysinv_client,
):
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
self.mock_fw_audit_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
self.mock_audit_worker_manager_sysinv_client.side_effect = (
FakeSysinvClientImageNotWritten
)
firmware_audit_data = self.get_fw_audit_data()
subclouds = {
@ -536,19 +531,17 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_image_with_labels(
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()
subclouds = {
@ -557,19 +550,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_matching_label_for_device_on_subcloud(
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()
subclouds = {
@ -578,19 +571,19 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)
@mock.patch.object(firmware_audit, "SysinvClient")
@mock.patch.object(firmware_audit, "OpenStackDriver")
def test_no_matching_device_id_on_subcloud(
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()
subclouds = {
@ -599,7 +592,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
}
for name, _ in subclouds.items():
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)

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

@ -19,6 +19,7 @@ import sys
import mock
from dccommon import consts as dccommon_consts
from dcmanager.audit import rpcapi
from dcmanager.audit import subcloud_audit_manager
from dcmanager.common import consts
from dcmanager.db.sqlalchemy import api as db_api
@ -250,49 +251,38 @@ class TestAuditManager(base.DCManagerTestCase):
super(TestAuditManager, self).setUp()
# Mock the Audit Worker API
self.fake_audit_worker_api = FakeAuditWorkerAPI()
p = mock.patch("dcmanager.audit.rpcapi.ManagerAuditWorkerClient")
self.mock_audit_worker_api = p.start()
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
self.mock_audit_worker_api = self._mock_object(
rpcapi, "ManagerAuditWorkerClient"
)
self.mock_audit_worker_api.return_value = FakeAuditWorkerAPI()
# Mock the context
p = mock.patch.object(subcloud_audit_manager, "context")
self.mock_context = p.start()
self.mock_context = self._mock_object(subcloud_audit_manager, "context")
self.mock_context.get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
# Mock patch audit
self.fake_patch_audit = FakePatchAudit()
p = mock.patch.object(subcloud_audit_manager, "patch_audit")
self.mock_patch_audit = p.start()
self.mock_patch_audit.PatchAudit.return_value = self.fake_patch_audit
self.addCleanup(p.stop)
self.mock_patch_audit = self._mock_object(subcloud_audit_manager, "patch_audit")
self.mock_patch_audit.PatchAudit.return_value = FakePatchAudit()
# Mock firmware audit
self.fake_firmware_audit = FakeFirmwareAudit()
p = mock.patch.object(subcloud_audit_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.mock_firmware_audit = self._mock_object(
subcloud_audit_manager, "firmware_audit"
)
self.mock_firmware_audit.FirmwareAudit.return_value = FakeFirmwareAudit()
# Mock kubernetes audit
self.fake_kubernetes_audit = FakeKubernetesAudit()
p = mock.patch.object(subcloud_audit_manager, "kubernetes_audit")
self.mock_kubernetes_audit = p.start()
self.mock_kubernetes_audit.KubernetesAudit.return_value = (
self.fake_kubernetes_audit
self.mock_kubernetes_audit = self._mock_object(
subcloud_audit_manager, "kubernetes_audit"
)
self.addCleanup(p.stop)
self.mock_kubernetes_audit.KubernetesAudit.return_value = FakeKubernetesAudit()
# Mock kube rootca update audit
self.fake_kube_rootca_update_audit = FakeKubeRootcaUpdateAudit()
p = mock.patch.object(subcloud_audit_manager, "kube_rootca_update_audit")
self.mock_kube_rootca_update_audit = p.start()
self.mock_kubernetes_audit.KubeRootcaUpdateAudit.return_value = (
self.fake_kube_rootca_update_audit
self.mock_kube_rootca_update_audit = self._mock_object(
subcloud_audit_manager, "kube_rootca_update_audit"
)
self.mock_kubernetes_audit.KubeRootcaUpdateAudit.return_value = (
FakeKubeRootcaUpdateAudit()
)
self.addCleanup(p.stop)
@staticmethod
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
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_worker_manager
from dcmanager.common import consts
from dcmanager.common import scheduler
from dcmanager.db.sqlalchemy import api as db_api
from dcmanager.rpc import client as rpc_client
from dcmanager.tests import base
from dcorch.rpc import client as dcorch_rpc_client
sys.modules["fm_core"] = mock.Mock()
@ -272,126 +275,85 @@ FAKE_APPLICATIONS = [
class TestAuditWorkerManager(base.DCManagerTestCase):
def setUp(self):
super(TestAuditWorkerManager, self).setUp()
super().setUp()
# Mock the DCManager API
self.fake_dcmanager_api = FakeDCManagerAPI()
p = mock.patch("dcmanager.rpc.client.ManagerClient")
self.mock_dcmanager_api = p.start()
self.mock_dcmanager_api.return_value = self.fake_dcmanager_api
self.addCleanup(p.stop)
self.mock_dcmanager_api = self._mock_object(rpc_client, "ManagerClient")
self.mock_dcmanager_api().return_value = FakeDCManagerAPI()
# Mock the DCManager subcloud state API
p = mock.patch("dcmanager.rpc.client.SubcloudStateClient")
self.mock_dcmanager_state_api = p.start()
self.addCleanup(p.stop)
self.mock_dcmanager_state_api = self._mock_object(
rpc_client, "SubcloudStateClient"
)
# Mock the Audit Worker API
self.fake_audit_worker_api = FakeAuditWorkerAPI()
p = mock.patch("dcmanager.audit.rpcapi.ManagerAuditWorkerClient")
self.mock_audit_worker_api = p.start()
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
self.mock_audit_worker_api = self._mock_object(
rpcapi, "ManagerAuditWorkerClient"
)
self.mock_audit_worker_api.return_value = FakeAuditWorkerAPI()
# Mock the DCOrch Worker API
self.fake_dcorch_worker_api = FakeDCOrchWorkerAPI()
p = mock.patch("dcorch.rpc.client.EngineWorkerClient")
self.mock_dcorch_worker_api = p.start()
self.mock_dcorch_worker_api.return_value = self.fake_dcorch_worker_api
self.addCleanup(p.stop)
self.mock_dcorch_worker_api = self._mock_object(
dcorch_rpc_client, "EngineWorkerClient"
)
self.mock_dcorch_worker_api.return_value = FakeDCOrchWorkerAPI()
# Mock the context
p = mock.patch.object(subcloud_audit_worker_manager, "context")
self.mock_context = p.start()
self.mock_context.get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
self.mock_audit_worker_manager_context = self._mock_object(
subcloud_audit_worker_manager, "context"
)
self.mock_audit_worker_manager_context.get_admin_context.return_value = self.ctx
# Mock the context
p = mock.patch.object(subcloud_audit_manager, "context")
self.mock_context2 = p.start()
self.mock_context2.get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
self.mock_subcloud_audit_manager_context = self._mock_object(
subcloud_audit_manager, "context"
)
self.mock_subcloud_audit_manager_context.get_admin_context.return_value = (
self.ctx
)
# Mock alarm aggregation
self.fake_alarm_aggr = FakeAlarmAggregation()
p = mock.patch.object(subcloud_audit_worker_manager, "alarm_aggregation")
self.mock_alarm_aggr = p.start()
self.mock_alarm_aggr.AlarmAggregation.return_value = self.fake_alarm_aggr
self.addCleanup(p.stop)
self.mock_alarm_aggr = self._mock_object(
subcloud_audit_worker_manager.alarm_aggregation, "AlarmAggregation"
)
self.mock_alarm_aggr().return_value = FakeAlarmAggregation()
# Mock patch audit
# Mock all audits
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()
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()
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()
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()
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()
p = mock.patch.object(subcloud_audit_manager, "software_audit")
self.mock_software_audit2 = p.start()
self.mock_software_audit2.SoftwareAudit.return_value = self.fake_software_audit2
self.addCleanup(p.stop)
audits = {
"patch_audit": {
"value": self.fake_patch_audit,
"class": "PatchAudit",
},
"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(
subcloud_audit_worker_manager, "OpenStackDriver"
@ -565,14 +527,14 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called()
# 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
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.fake_alarm_aggr.update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value
self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
)
# Verify patch audit is called
@ -679,11 +641,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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
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.fake_alarm_aggr.update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value
self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
)
# Verify patch audit is called once
@ -1069,8 +1031,8 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
)
# Verify alarm update is called only once
self.fake_alarm_aggr.get_alarm_summary.assert_called_once()
self.fake_alarm_aggr.update_alarm_summary.assert_called_once()
self.mock_alarm_aggr().get_alarm_summary.assert_called_once()
self.mock_alarm_aggr().update_alarm_summary.assert_called_once()
# Verify patch audit is called only 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()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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()
# 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
self.fake_alarm_aggr.get_alarm_summary.assert_not_called()
self.fake_alarm_aggr.update_alarm_summary.assert_not_called()
self.mock_alarm_aggr().get_alarm_summary.assert_not_called()
self.mock_alarm_aggr().update_alarm_summary.assert_not_called()
# Verify patch audit is 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()
# 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',
# dccommon_consts.ENDPOINT_TYPES_LIST_OS,
# True)
# 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.fake_alarm_aggr.update_alarm_summary.assert_called_with(
"subcloud1", self.fake_alarm_aggr.get_alarm_summary.return_value
self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
"subcloud1", self.mock_alarm_aggr().get_alarm_summary.return_value
)
# Verify patch audit is not called
@ -1519,7 +1481,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called()
# 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,
subcloud.region_name,
dccommon_consts.ENDPOINT_TYPES_LIST_OS,
@ -1527,11 +1489,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
)
# 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.fake_alarm_aggr.update_alarm_summary.assert_called_with(
subcloud.name, self.fake_alarm_aggr.get_alarm_summary.return_value
self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
subcloud.name, self.mock_alarm_aggr().get_alarm_summary.return_value
)
# Verify patch audit is not called
@ -1599,7 +1561,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
mock_update_subcloud_audit_fail_count.assert_not_called()
# 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,
subcloud.region_name,
dccommon_consts.ENDPOINT_TYPES_LIST_OS,
@ -1607,11 +1569,11 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
)
# 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.fake_alarm_aggr.update_alarm_summary.assert_called_with(
"subcloud1", self.fake_alarm_aggr.get_alarm_summary.return_value
self.mock_alarm_aggr().update_alarm_summary.assert_called_with(
"subcloud1", self.mock_alarm_aggr().get_alarm_summary.return_value
)
# 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):
"""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"
)
self.mock_get_peer_dc_client = mock_patch.start()
self.addCleanup(mock_patch.stop)
self.peer = tpm.TestPeerMonitor.create_system_peer_static(
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_group2 = copy.deepcopy(FAKE_SITE2_PEER_GROUP_DATA)
mock_patch = mock.patch.object(SystemPeerManager, "update_sync_status")
self.addCleanup(mock_patch.stop)
self.mock_update_sync_status = mock_patch.start()
self.mock_update_sync_status = self._mock_object(
SystemPeerManager, "update_sync_status"
)
self.mock_get_local_system = self._mock_object(utils, "get_local_system")
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"
)
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.system_peer_manager = test_system_peer_manager.TestSystemPeerManager
@ -74,15 +76,6 @@ class TestPeerMonitor(base.DCManagerTestCase):
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
def create_system_peer_static(ctxt, **kwargs):
values = {
@ -123,11 +116,9 @@ class TestPeerMonitor(base.DCManagerTestCase):
)
# Mock update_sync_status
mock_patch = mock.patch.object(
mock_update_sync_status = self._mock_object(
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()
@ -140,11 +131,9 @@ class TestPeerMonitor(base.DCManagerTestCase):
def test_update_sync_status_and_association_is_in_sync(self):
# Mock update_sync_status
mock_patch = mock.patch.object(
mock_update_sync_status = self._mock_object(
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()

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

@ -23,7 +23,9 @@ import filecmp
import json
import os
from os import path as os_path
import shutil
import sys
import tempfile
import threading
import time
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.manager import test_system_peer_manager
from dcmanager.tests import utils
from dcorch.rpc import client as dcorch_rpc_client
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_object(rpc_client, "SubcloudStateClient")
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"
)
self.mock_openstack_driver = self._mock_object(
subcloud_manager, "OpenStackDriver"
)
self.mock_sysinv_client = self._mock_object(subcloud_manager, "SysinvClient")
self._mock_dcorch_api()
self._mock_dcmanager_api()
self._mock_context()
self.mock_dcorch_api = self._mock_object(
dcorch_rpc_client, "EngineWorkerClient"
)
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_subcloud_manager_keyring()
self._mock_utils_create_subcloud_inventory()
self._mock_utils_delete_subcloud_inventory()
self._mock_utils_get_playbook_for_software_version()
self._mock_subprocess_run()
self.mock_keyring = self._mock_object(subcloud_manager, "keyring")
self.mock_create_subcloud_inventory = self._mock_object(
cutils, "create_subcloud_inventory"
)
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(
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_exists = self._mock_object(os.path, "exists")
self.mock_os_remove = self._mock_object(os, "remove")
self._mock_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._mock_object(ostree_mount, "validate_ostree_iso_mount")
self.sm = subcloud_manager.SubcloudManager()
self.subcloud = self.create_subcloud_static(self.ctx)
@ -439,185 +453,6 @@ class BaseTestSubcloudManager(base.DCManagerTestCase):
def patched_isdir(self, path):
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
def create_subcloud_static(ctxt, **kwargs):
values = {
@ -677,7 +512,7 @@ class TestSubcloudManager(BaseTestSubcloudManager):
def setUp(self):
super().setUp()
self._mock_netaddr_ipaddress()
self._mock_object(netaddr, "IPAddress")
self.values = utils.create_subcloud_dict(base.SUBCLOUD_SAMPLE_DATA_0)
self.test_system_peer_manager.create_peer_group_association_static(
self.ctx,
@ -707,7 +542,6 @@ class TestSubcloudManager(BaseTestSubcloudManager):
endpoint_1 = FakeEndpoint("endpoint1", "regionOne", "1")
keystone_client = self.mock_openstack_driver().keystone_client
keystone_client.endpoints.list.return_value = [endpoint_1]
self.mks_client = self.mock_openstack_driver()
db_api.subcloud_update(
self.ctx,
self.subcloud.id,
@ -717,7 +551,10 @@ class TestSubcloudManager(BaseTestSubcloudManager):
for endpoint_type in SERVICE_ENDPOINTS:
keystone_client.services.get.return_value.type = endpoint_type
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(
"Update services endpoint to 192.168.101.3 in subcloud region "
@ -739,8 +576,12 @@ class TestSubcloudManager(BaseTestSubcloudManager):
mock_kubeoperator.assert_called_once()
def test_generate_subcloud_ansible_config(self):
self._mock_subcloud_manager_write_subcloud_ansible_config()
self._mock_subcloud_manager_create_intermediate_ca_cert()
self.mock_write_subcloud_ansible_config = self._mock_object(
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"]
initial_deployment = False
self.sm.generate_subcloud_ansible_config(
@ -904,7 +745,9 @@ class TestSubcloudManager(BaseTestSubcloudManager):
def test_update_subcloud_network_reconfiguration(
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
db_api.subcloud_update(
self.ctx,
@ -1049,11 +892,19 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
def setUp(self):
super().setUp()
self._mock_subcloud_manager_create_addn_hosts_dc()
self._mock_subcloud_manager_run_subcloud_install()
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_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_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.payload = {
@ -1063,7 +914,9 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
}
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.fake_payload_install["software_version"] = FAKE_PREVIOUS_SW_VERSION
self.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INSTALL
@ -1100,7 +953,9 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
)
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["deploy_status"] = consts.DEPLOY_STATE_NONE
@ -1425,31 +1280,23 @@ class TestSubcloudDeploy(BaseTestSubcloudManager):
def test_deploy_subcloud_enroll(
self, mock_subcloud_enrollment_prep, mock_get_region_name
):
mock_run_patch_patch = mock.patch("eventlet.green.subprocess.run")
mock_mkdtemp_patch = mock.patch("tempfile.mkdtemp")
mock_makedirs_patch = mock.patch("os.makedirs")
mock_rmtree_patch = mock.patch("shutil.rmtree")
mock_mkdtemp = self._mock_object(tempfile, "mkdtemp")
self._mock_object(os, "makedirs")
self._mock_object(shutil, "rmtree")
self.seed_data_dir = "/temp/seed_data"
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_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_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.subcloud["deploy_status"] = consts.DEPLOY_STATE_PRE_INIT_ENROLL
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
)
# 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_manager.SubcloudManager, "_deploy_install_prep")
def test_subcloud_deploy_pre_init_enroll_failed(
@ -1551,16 +1392,30 @@ class TestSubcloudAdd(BaseTestSubcloudManager):
def setUp(self):
super().setUp()
self._mock_subcloud_manager_write_subcloud_ansible_config()
self._mock_subcloud_manager_create_addn_hosts_dc()
self._mock_subcloud_manager_create_intermediate_ca_cert()
self.mock_write_subcloud_ansible_config = self._mock_object(
subcloud_manager.SubcloudManager, "_write_subcloud_ansible_config"
)
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_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_subcloud_manager_init_enroll()
self._mock_subcloud_get_region_name()
self._mock_subcloud_manager_run_subcloud_enroll()
self._mock_subcloud_manager_complete()
self.mock_subcloud_init_enroll = self._mock_object(
subcloud_manager.SubcloudManager, "subcloud_init_enroll"
)
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["software_version"] = SW_VERSION
@ -1762,13 +1617,19 @@ class TestSubcloudDelete(BaseTestSubcloudManager):
def setUp(self):
super().setUp()
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_utils_is_system_controller_deploying()
self.mock_is_system_controller_deploying = self._mock_object(
cutils, "is_system_controller_deploying"
)
@mock.patch.object(kubeoperator, "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.sm.delete_subcloud(self.ctx, subcloud_id=self.subcloud.id)
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):
# In this test, the mocking is required
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"]
mock_start.side_effect = Exception("boom")
@ -3269,7 +3132,9 @@ class TestSubcloudRedeploy(BaseTestSubcloudManager):
def test_subcloud_redeploy(
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_ansible_run_playbook.return_value = False
self.mock_run_subcloud_install.return_value = True
@ -4183,7 +4048,9 @@ class TestSubcloudBackupRestore(BaseTestSubcloudManager):
mock_create_overrides,
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_listdir.return_value = ["test.iso", "test.sig"]
mock_create_inventory_file.return_value = "inventory_file.yml"
@ -4755,7 +4622,9 @@ class TestSubcloudMigrate(BaseTestSubcloudManager):
)
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_subprocess_run.return_value.returncode = 0
self.mock_ansible_run_playbook.side_effect = PlaybookExecutionFailed()
@ -4773,8 +4642,10 @@ class TestSubcloudInstall(BaseTestSubcloudManager):
def setUp(self):
super().setUp()
self._mock_netaddr_ipaddress()
self._mock_subcloud_manager_compose_install_command()
self.mock_netaddr_ipaddress = self._mock_object(netaddr, "IPAddress")
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["software_version"] = SW_VERSION
self.fake_log_file = (
@ -4783,9 +4654,10 @@ class TestSubcloudInstall(BaseTestSubcloudManager):
)
+ "_playbook_output.log"
)
self.mock_install_sysinv_client().get_oam_address_pools.return_value = (
FAKE_OAM_POOLS
get_oam_address_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.subcloud.update(
{
@ -4940,31 +4812,23 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
"bmc_password": "bmc_pass",
}
mock_run_patch_patch = mock.patch("eventlet.green.subprocess.run")
mock_TemporaryDirectory_patch = mock.patch("tempfile.TemporaryDirectory")
mock_makedirs_patch = mock.patch("os.makedirs")
mock_rmtree_patch = mock.patch("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_temporary_directory = self._mock_object(
tempfile, "TemporaryDirectory"
)
self.mock_os_makedirs = self._mock_object(os, "makedirs")
self._mock_object(shutil, "rmtree")
self.mock_log_subcloud_enrollment = self._mock_object(
subcloud_enrollment, "LOG"
)
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.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):
return path != self.iso_dir
@ -5032,9 +4896,9 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
)
# 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
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
self.mock_builtins_open.assert_any_call(
f"{self.seed_data_dir}/meta-data", "w"
@ -5073,8 +4937,8 @@ class TestSubcloudEnrollment(BaseTestSubcloudManager):
mock_validate.assert_called_once_with(self.iso_values)
# ISO dir must be created
self.mock_makedirs.assert_called_once()
self.assertEqual(self.mock_makedirs.call_args.args[0], self.iso_dir)
self.mock_os_makedirs.assert_called_once()
self.assertEqual(self.mock_os_makedirs.call_args.args[0], self.iso_dir)
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)
# 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(
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
)
expected_log_file = f"{subcloud_log_base_path}_playbook_output.log"
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 threading
import mock
from dccommon import ostree_mount
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_PRE_CHECK
from dcmanager.common import exceptions
from dcmanager.common import prestage
from dcmanager.db.sqlalchemy import api as db_api
from dcmanager.tests.unit.common import fake_strategy
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._mock_validate_prestage()
self._mock_threading_start()
def _mock_validate_prestage(self):
"""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()
# 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.
self.mock_prestage_subcloud = self._mock_object(prestage, "validate_prestage")
self.mock_prestage_subcloud.return_value = OAM_FLOATING_IP
self.addCleanup(mock_class.stop)
def _mock_threading_start(self):
"""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)
self._mock_object(threading.Thread, "start")
def test_prestage_pre_check_without_extra_args(self):
"""Test prestage pre check without extra args"""
@ -168,15 +153,8 @@ class TestPrestagePackagesState(TestPrestage):
self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_PACKAGES)
self._mock_object(builtins, "open")
self._mock_ansible_playbook()
self.mock_validate_ostree_iso_mount = self._mock_object(
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)
self._mock_object(AnsiblePlaybook, "run_playbook")
self._mock_object(ostree_mount, "validate_ostree_iso_mount")
def test_prestage_package_succeeds(self):
"""Test prestage package succeeds"""
@ -200,8 +178,8 @@ class TestPrestageImagesState(TestPrestage):
self._setup_strategy_step(STRATEGY_STATE_PRESTAGE_IMAGES)
self.mock_os_path_isdir = self._mock_object(os.path, "isdir")
self.mock_os_path_isdir.return_value = False
mock_os_path_isdir = self._mock_object(os.path, "isdir")
mock_os_path_isdir.return_value = False
def test_prestage_images_succeeds(self):
"""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
#
import mock
from dcmanager.common import consts
from dcmanager.orchestrator.states.software.cache import clients
from dcmanager.tests.unit.orchestrator.test_base import TestSwUpdate
CACHE_CLIENT_PATH = "dcmanager.orchestrator.states.software.cache.clients"
class TestSoftwareOrchestrator(TestSwUpdate):
# Setting DEFAULT_STRATEGY_TYPE to software will setup the software
@ -21,17 +18,8 @@ class TestSoftwareOrchestrator(TestSwUpdate):
super().setUp()
# Modify cache helpers to return client mocks
self.software_cache_client_mock = mock.patch(
f"{CACHE_CLIENT_PATH}.get_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()
mock_get_software_client = self._mock_object(clients, "get_software_client")
mock_get_software_client.return_value = self.software_client
def tearDown(self):
self.software_cache_client_mock.stop()
self.sysinv_cache_client_mock.stop()
super().tearDown()
mock_get_sysinv_client = self._mock_object(clients, "get_sysinv_client")
mock_get_sysinv_client.return_value = self.sysinv_client

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.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
# invoked by this state
@ -95,8 +96,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_success(self):
"""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]
# invoke the strategy state operation on the orch thread
@ -113,8 +112,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_no_operation_required(self):
"""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]
# 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):
"""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.worker.perform_state_action(self.strategy_step)
@ -143,8 +138,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
def test_finish_strategy_fails_when_delete_exception(self):
"""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.delete.side_effect = Exception()
@ -157,7 +150,6 @@ class TestFinishStrategyState(TestSoftwareOrchestrator):
@mock.patch.object(BaseState, "stopped")
def test_finish_strategy_fails_when_stopped(self, mock_base_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]

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 FakeSysinvClient
from dcmanager.tests.unit.orchestrator.test_sw_update_manager import FakeOrchThread
from dcmanager.tests import utils
CONF = cfg.CONF
@ -42,149 +41,101 @@ class TestSwUpdate(base.DCManagerTestCase):
DEFAULT_STRATEGY_TYPE = consts.SW_UPDATE_TYPE_SOFTWARE
def setUp(self):
super(TestSwUpdate, self).setUp()
super().setUp()
# construct an upgrade orch thread
self.worker = self.setup_orch_worker(self.DEFAULT_STRATEGY_TYPE)
# Mock the context
self.ctxt = utils.dummy_context()
p = mock.patch.object(context, "get_admin_context")
self.mock_get_admin_context = p.start()
self.mock_get_admin_context.return_value = self.ctx
self.addCleanup(p.stop)
mock_get_admin_context = self._mock_object(context, "get_admin_context")
mock_get_admin_context.return_value = self.ctx
# Mock the keystone client defined in the base state class
# Mock the clients defined in the base state class
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()
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()
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()
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()
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()
p = mock.patch.object(BaseState, "get_fm_client")
self.mock_fm_client = p.start()
self.mock_fm_client.return_value = self.fm_client
self.addCleanup(p.stop)
clients = {
"get_keystone_client": self.keystone_client,
"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):
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
if strategy_type == consts.SW_UPDATE_TYPE_SOFTWARE:
sw_update_manager.SoftwareOrchThread.stopped = lambda x: False
worker = sw_update_manager.SoftwareOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
)
worker = sw_update_manager.SoftwareOrchThread(mock.Mock(), mock.Mock())
else:
# mock the software orch thread
self.fake_software_orch_thread = FakeOrchThread()
p = mock.patch.object(sw_update_manager, "SoftwareOrchThread")
self.mock_software_orch_thread = p.start()
self.mock_software_orch_thread.return_value = self.fake_software_orch_thread
self.addCleanup(p.stop)
mock_software_orch_thread = self._mock_object(
sw_update_manager, "SoftwareOrchThread"
)
mock_software_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_PATCH:
sw_update_manager.PatchOrchThread.stopped = lambda x: False
worker = sw_update_manager.PatchOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
)
worker = sw_update_manager.PatchOrchThread(mock.Mock(), mock.Mock())
else:
# mock the patch orch thread
self.fake_sw_patch_orch_thread = FakeOrchThread()
p = mock.patch.object(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
self.addCleanup(p.stop)
mock_sw_patch_orch_thread = self._mock_object(
sw_update_manager, "PatchOrchThread"
)
mock_sw_patch_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_FIRMWARE:
sw_update_manager.FwUpdateOrchThread.stopped = lambda x: False
worker = sw_update_manager.FwUpdateOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
)
worker = sw_update_manager.FwUpdateOrchThread(mock.Mock(), mock.Mock())
else:
# mock the firmware orch thread
self.fake_fw_update_orch_thread = FakeOrchThread()
p = mock.patch.object(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
mock_fw_update_orch_thread = self._mock_object(
sw_update_manager, "FwUpdateOrchThread"
)
self.addCleanup(p.stop)
mock_fw_update_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_KUBERNETES:
sw_update_manager.KubeUpgradeOrchThread.stopped = lambda x: False
worker = sw_update_manager.KubeUpgradeOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
)
worker = sw_update_manager.KubeUpgradeOrchThread(mock.Mock(), mock.Mock())
else:
# mock the kube upgrade orch thread
self.fake_kube_upgrade_orch_thread = FakeOrchThread()
p = mock.patch.object(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
mock_kube_upgrade_orch_thread = self._mock_object(
sw_update_manager, "KubeUpgradeOrchThread"
)
self.addCleanup(p.stop)
mock_kube_upgrade_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_KUBE_ROOTCA_UPDATE:
sw_update_manager.KubeRootcaUpdateOrchThread.stopped = lambda x: False
worker = sw_update_manager.KubeRootcaUpdateOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
mock.Mock(), mock.Mock()
)
else:
# mock the kube rootca update orch thread
self.fake_kube_rootca_update_orch_thread = FakeOrchThread()
p = mock.patch.object(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
mock_kube_rootca_update_orch_thread = self._mock_object(
sw_update_manager, "KubeRootcaUpdateOrchThread"
)
self.addCleanup(p.stop)
mock_kube_rootca_update_orch_thread.return_value = FakeOrchThread()
if strategy_type == consts.SW_UPDATE_TYPE_PRESTAGE:
sw_update_manager.PrestageOrchThread.stopped = lambda x: False
worker = sw_update_manager.PrestageOrchThread(
mock_strategy_lock, mock_dcmanager_audit_api
)
worker = sw_update_manager.PrestageOrchThread(mock.Mock(), mock.Mock())
else:
# mock the prestage orch thread
self.fake_prestage_orch_thread = FakeOrchThread()
p = mock.patch.object(sw_update_manager, "PrestageOrchThread")
self.mock_prestage_orch_thread = p.start()
self.mock_prestage_orch_thread.return_value = self.fake_prestage_orch_thread
self.addCleanup(p.stop)
mock_prestage_orch_thread = self._mock_object(
sw_update_manager, "PrestageOrchThread"
)
mock_prestage_orch_thread.return_value = FakeOrchThread()
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):
@staticmethod
def create_subcloud(ctxt, name, group_id):
def create_subcloud(ctx, name, group_id):
values = {
"name": name,
"description": "subcloud1 description",
@ -46,9 +46,9 @@ class TestFwOrchThread(TestSwUpdate):
"group_id": group_id,
"data_install": "data from install",
}
subcloud = db_api.subcloud_create(ctxt, **values)
subcloud = db_api.subcloud_create(ctx, **values)
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
# 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):
mock_start.side_effect = non_threaded_start
self.strategy = self.setup_strategy(state=consts.SW_UPDATE_STATE_APPLYING)
subcloud2 = self.create_subcloud(self.ctxt, "subcloud2", 1)
subcloud3 = self.create_subcloud(self.ctxt, "subcloud3", 1)
subcloud4 = self.create_subcloud(self.ctxt, "subcloud4", 1)
subcloud2 = self.create_subcloud(self.ctx, "subcloud2", 1)
subcloud3 = self.create_subcloud(self.ctx, "subcloud3", 1)
subcloud4 = self.create_subcloud(self.ctx, "subcloud4", 1)
self.setup_strategy_step(subcloud2.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.
#
import mock
from dcmanager.common import config
from dcmanager.common import messaging
from dcmanager.rpc import client as rpc_client
from dcmanager.tests import base
from dcmanager.tests import utils
config.register_options()
@ -28,59 +26,48 @@ class ManagerRpcAPITestCase(base.DCManagerTestCase):
def setUp(self):
messaging.setup("fake://", optional=True)
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()
super(ManagerRpcAPITestCase, self).setUp()
@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)
self.msg = self.rpcapi.make_msg(self.method, **self.kwargs)
def test_call(self):
# with no version
res = rpcapi.call(self.context, msg)
res = self.rpcapi.call(self.ctx, self.msg)
self.assertEqual(client, rpcapi._client)
client.call.assert_called_once_with(self.context, "fake_method", key="value")
self.assertEqual(res, client.call.return_value)
self.assertEqual(self.mock_get_rpc_client(), self.rpcapi._client)
self.mock_get_rpc_client().call.assert_called_once_with(
self.ctx, self.method, key="value"
)
self.assertEqual(res, self.mock_get_rpc_client().call.return_value)
# with version
res = rpcapi.call(self.context, msg, version="123")
client.prepare.assert_called_once_with(version="123")
new_client = client.prepare.return_value
new_client.call.assert_called_once_with(
self.context, "fake_method", key="value"
)
res = self.rpcapi.call(self.ctx, self.msg, version="123")
self.mock_get_rpc_client().prepare.assert_called_once_with(version="123")
new_client = self.mock_get_rpc_client().prepare.return_value
new_client.call.assert_called_once_with(self.ctx, "fake_method", key="value")
self.assertEqual(res, new_client.call.return_value)
@mock.patch.object(messaging, "get_rpc_client")
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)
def test_cast(self):
# with no version
res = rpcapi.cast(self.context, msg)
res = self.rpcapi.cast(self.ctx, self.msg)
self.assertEqual(client, rpcapi._client)
client.cast.assert_called_once_with(self.context, "fake_method", key="value")
self.assertEqual(res, client.cast.return_value)
self.assertEqual(self.mock_get_rpc_client(), self.rpcapi._client)
self.mock_get_rpc_client().cast.assert_called_once_with(
self.ctx, "fake_method", key="value"
)
self.assertEqual(res, self.mock_get_rpc_client().cast.return_value)
# with version
res = rpcapi.cast(self.context, msg, version="123")
client.prepare.assert_called_once_with(fanout=None, version="123")
new_client = client.prepare.return_value
new_client.cast.assert_called_once_with(
self.context, "fake_method", key="value"
res = self.rpcapi.cast(self.ctx, self.msg, version="123")
self.mock_get_rpc_client().prepare.assert_called_once_with(
fanout=None, version="123"
)
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)