diff options
Diffstat (limited to 'tests/unit')
| -rw-r--r-- | tests/unit/post/test_keystoneauth.py | 22 | ||||
| -rw-r--r-- | tests/unit/test_daisy_server.py | 346 | ||||
| -rw-r--r-- | tests/unit/test_environment.py | 385 | ||||
| -rw-r--r-- | tests/unit/test_utils.py | 19 |
4 files changed, 771 insertions, 1 deletions
diff --git a/tests/unit/post/test_keystoneauth.py b/tests/unit/post/test_keystoneauth.py index afd9062a..1ae86452 100644 --- a/tests/unit/post/test_keystoneauth.py +++ b/tests/unit/post/test_keystoneauth.py @@ -80,3 +80,25 @@ def test_session(openrc_conf_file_dir): openrc = os.path.join(openrc_conf_file_dir, 'admin-openrc.sh') KeystoneClient = Keystoneauth(openrc) assert KeystoneClient.session + + +@pytest.mark.parametrize('openrc_file_name, expected', [ + ( + 'admin-openrc.sh', + { + 'OS_PROJECT_DOMAIN_NAME': 'Default', + 'OS_USER_DOMAIN_NAME': 'Default', + 'OS_PROJECT_NAME': 'admin', + 'OS_TENANT_NAME': 'admin', + 'OS_USERNAME': 'admin', + 'OS_PASSWORD': 'keystone', + 'OS_AUTH_URL': 'http://10.20.11.11:35357/v3', + 'OS_INTERFACE': 'internal', + 'OS_IDENTITY_API_VERSION': '3' + } + )]) +def test__parse_openrc(openrc_conf_file_dir, openrc_file_name, expected): + openrc = os.path.join(openrc_conf_file_dir, openrc_file_name) + KeystoneClient = Keystoneauth(openrc) + ret_openrc_dict = KeystoneClient._parse_openrc() + assert expected == ret_openrc_dict diff --git a/tests/unit/test_daisy_server.py b/tests/unit/test_daisy_server.py new file mode 100644 index 00000000..ada3c96d --- /dev/null +++ b/tests/unit/test_daisy_server.py @@ -0,0 +1,346 @@ +import os +import pytest +import mock + +from deploy import daisy_server +from deploy.daisy_server import ( + DaisyServer +) + + +@pytest.fixture(scope="session") +def conf_file_dir(data_root): + return os.path.join(data_root, 'lab_conf') + + +daisy_server_info = { + 'name': 'daisy', + 'image': 'daisy.qcow2', + 'address': '10.20.0.2', + 'gateway': '10.20.0.1', + 'password': 'r00tme', + 'disk_size': 50 +} +adapter = 'ipmi' +scenario = 'os-odl-nofeature-ha' +deploy_file_name = 'final_deploy.yml' +net_file_name = 'network_baremetal.yml' +remote_dir = '/home/daisy' +bin_file_name = 'opnfv.bin' + + +def test_create_DaisyServer_instance(tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + assert (DaisyServerInst.name == daisy_server_info['name'] and + DaisyServerInst.address == daisy_server_info['address'] and + DaisyServerInst.password == daisy_server_info['password'] and + DaisyServerInst.remote_dir == remote_dir and + DaisyServerInst.bin_file == bin_file and + DaisyServerInst.adapter == adapter and + DaisyServerInst.scenario == scenario and + DaisyServerInst.deploy_file_name == deploy_file_name and + DaisyServerInst.net_file_name == net_file_name and + DaisyServerInst.ssh_client is None) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_exec_cmd') +def test_create_dir_DaisyServer(mock_ssh_exec_cmd, tmpdir): + remote_dir_test = '/home/daisy/test' + cmd = 'mkdir -p ' + remote_dir_test + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + DaisyServerInst.create_dir(remote_dir_test) + DaisyServerInst.ssh_exec_cmd.assert_called_once_with(cmd) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_exec_cmd') +def test_delete_dir_DaisyServer(mock_ssh_exec_cmd, tmpdir): + remote_dir_test = '/home/daisy/test' + cmd = 'if [[ -f {DIR} || -d {DIR} ]]; then rm -fr {DIR}; fi'.format(DIR=remote_dir_test) + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + DaisyServerInst.delete_dir(remote_dir_test) + DaisyServerInst.ssh_exec_cmd.assert_called_once_with(cmd) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'delete_dir') +@mock.patch.object(daisy_server.DaisyServer, 'scp_put') +@mock.patch.object(daisy_server.DaisyServer, 'create_dir') +@mock.patch('deploy.daisy_server.update_config') +def test_prepare_files_DaisyServer(mock_update_config, + mock_create_dir, + mock_scp_put, + mock_delete_dir, + tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + DaisyServerInst.prepare_files() + DaisyServerInst.delete_dir.assert_called_once_with(remote_dir) + DaisyServerInst.create_dir.assert_called_once_with('/home/daisy_install') + assert DaisyServerInst.scp_put.call_count == 3 + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +@mock.patch.object(daisy_server.DaisyServer, 'prepare_files') +def test_install_daisy_DaisyServer(mock_prepare_files, mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = '%s install' % os.path.join(remote_dir, 'opnfv.bin') + DaisyServerInst.install_daisy() + DaisyServerInst.ssh_run.assert_called_once_with(cmd) + DaisyServerInst.prepare_files.assert_called_once_with() + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_prepare_configurations_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = 'export PYTHONPATH={python_path}; python {script} -nw {net_file} -b {is_bare}'.format( + python_path=remote_dir, + script=os.path.join(remote_dir, 'deploy/prepare/execute.py'), + net_file=os.path.join(remote_dir, net_file_name), + is_bare=1 if adapter == 'ipmi' else 0) + DaisyServerInst.prepare_configurations() + DaisyServerInst.ssh_run.assert_called_once_with(cmd) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'scp_put') +@mock.patch.object(daisy_server.DaisyServer, 'prepare_configurations') +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_prepare_cluster_DaisyServer(mock_scp_put, + mock_prepare_configurations, + mock_ssh_run, + tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = "python {script} --dha {deploy_file} --network {net_file} --cluster \'yes\'".format( + script=os.path.join(remote_dir, 'deploy/tempest.py'), + deploy_file=os.path.join(remote_dir, deploy_file_name), + net_file=os.path.join(remote_dir, net_file_name)) + deploy_file = os.path.join(tmpdir.dirname, tmpdir.basename, deploy_file_name) + net_file = os.path.join(tmpdir.dirname, tmpdir.basename, net_file_name) + DaisyServerInst.prepare_cluster(deploy_file, net_file) + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=True) + DaisyServerInst.prepare_configurations.assert_called_once_with() + assert DaisyServerInst.scp_put.call_count == 2 + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'scp_put') +def test_copy_new_deploy_config_DaisyServer(mock_scp_put, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_scp_put.return_value = 0 + data = { + 'adapter': 'ipmi', + 'hosts': [ + { + 'name': 'controller01', + 'roles': ['CONTROLLER_LB'], + 'ipmi_ip': '192.168.1.11', + 'ipmi_user': 'testuser', + 'ipmi_pass': 'testpass' + } + ], + 'disks': { + 'daisy': 50 + }, + 'daisy_passwd': 'r00tme' + } + DaisyServerInst.copy_new_deploy_config(data) + assert DaisyServerInst.scp_put.call_count == 1 + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_prepare_host_and_pxe_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = "python {script} --dha {deploy_file} --network {net_file} --host \'yes\' --isbare {is_bare} --scenario {scenario}".format( + script=os.path.join(remote_dir, 'deploy/tempest.py'), + deploy_file=os.path.join(remote_dir, deploy_file_name), + net_file=os.path.join(remote_dir, net_file_name), + is_bare=1 if adapter == 'ipmi' else 0, + scenario=scenario) + DaisyServerInst.prepare_host_and_pxe() + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=True) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_install_virtual_nodes_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = "python {script} --dha {deploy_file} --network {net_file} --install \'yes\'".format( + script=os.path.join(remote_dir, 'deploy/tempest.py'), + deploy_file=os.path.join(remote_dir, deploy_file_name), + net_file=os.path.join(remote_dir, net_file_name)) + DaisyServerInst.install_virtual_nodes() + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=True) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_check_os_installation_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + nodes_num = 5 + cmd = '{script} -d {is_bare} -n {nodes_num}'.format( + script=os.path.join(remote_dir, 'deploy/check_os_progress.sh'), + is_bare=1 if adapter == 'ipmi' else 0, + nodes_num=nodes_num) + DaisyServerInst.check_os_installation(nodes_num) + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=True) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_check_openstack_installation_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + nodes_num = 5 + cmd = '{script} -n {nodes_num}'.format( + script=os.path.join(remote_dir, 'deploy/check_openstack_progress.sh'), + nodes_num=nodes_num) + DaisyServerInst.check_openstack_installation(nodes_num) + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=True) + tmpdir.remove() + + +@mock.patch.object(daisy_server.DaisyServer, 'ssh_run') +def test_post_deploy_DaisyServer(mock_ssh_run, tmpdir): + bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, bin_file_name) + adapter = 'libvirt' + DaisyServerInst = DaisyServer(daisy_server_info['name'], + daisy_server_info['address'], + daisy_server_info['password'], + remote_dir, + bin_file, + adapter, + scenario, + deploy_file_name, + net_file_name) + mock_ssh_run.return_value = 0 + cmd = 'export PYTHONPATH={python_path}; python {script} -nw {net_file}'.format( + python_path=remote_dir, + script=os.path.join(remote_dir, 'deploy/post/execute.py'), + net_file=os.path.join(remote_dir, net_file_name)) + DaisyServerInst.post_deploy() + DaisyServerInst.ssh_run.assert_called_once_with(cmd, check=False) + tmpdir.remove() diff --git a/tests/unit/test_environment.py b/tests/unit/test_environment.py new file mode 100644 index 00000000..5545fc58 --- /dev/null +++ b/tests/unit/test_environment.py @@ -0,0 +1,385 @@ +import os +import copy +import mock +import yaml +from deepdiff import DeepDiff + +from deploy.utils import WORKSPACE +from deploy import environment +from deploy.environment import ( + DaisyEnvironmentBase, + BareMetalEnvironment, + VirtualEnvironment, + BMDEPLOY_DAISY_SERVER_VM, + VMDEPLOY_DAISY_SERVER_NET, + VMDEPLOY_DAISY_SERVER_VM, +) + + +def get_conf_file_dir(): + return os.path.join(WORKSPACE, 'tests/data/lab_conf') + + +def get_conf_info_from_file(file_dir, conf_file_name): + conf_file_path = os.path.join(file_dir, conf_file_name) + with open(conf_file_path) as f: + conf_info = yaml.safe_load(f) + return conf_info + + +deploy_struct = get_conf_info_from_file(get_conf_file_dir(), 'deploy_baremetal.yml') +deploy_virtual_struct = get_conf_info_from_file(get_conf_file_dir(), 'deploy_virtual1.yml') +net_struct = get_conf_info_from_file(get_conf_file_dir(), 'network_baremetal.yml') +adapter = 'ipmi' +adapter_virtual = 'libvirt' +pxe_bridge = 'br7' +pxe_bridge_virtual = 'daisy1' +daisy_server_info = { + 'name': 'daisy', + 'image': 'daisy.qcow2', + 'address': '10.20.0.2', + 'gateway': '10.20.0.1', + 'password': 'r00tme', + 'disk_size': 50 +} +work_dir_name = 'workdir' +storage_dir_name = 'vms' +scenario = 'os-odl-nofeature-ha' + + +def test_create_DaisyEnvironmentBase_instance(tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + DaisyEnvBaseInst = DaisyEnvironmentBase( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + assert (DaisyEnvBaseInst.deploy_struct == deploy_struct and + DaisyEnvBaseInst.net_struct == net_struct and + DaisyEnvBaseInst.adapter == adapter and + DaisyEnvBaseInst.pxe_bridge == pxe_bridge and + DaisyEnvBaseInst.daisy_server_info == daisy_server and + DaisyEnvBaseInst.work_dir == work_dir and + DaisyEnvBaseInst.storage_dir == storage_dir and + DaisyEnvBaseInst.scenario == scenario) + tmpdir.remove() + + +def test_delete_daisy_server_DaisyEnvironmentBase(tmpdir, mocker): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + DaisyEnvBaseInst = DaisyEnvironmentBase( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + mocker.patch('deploy.environment.delete_vm_and_disk') + DaisyEnvBaseInst.delete_daisy_server() + environment.delete_vm_and_disk.assert_called_once_with('daisy') + tmpdir.remove() + + +def test_create_daisy_server_image_DaisyEnvironmentBase(tmpdir, monkeypatch): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + os.makedirs(work_dir, 0755) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + os.makedirs(storage_dir, 0755) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + DaisyEnvBaseInst = DaisyEnvironmentBase( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + + def create_server_image_sucess(cmd): + os.makedirs(os.path.join(work_dir, 'daisy')) + with open(os.path.join(work_dir, 'daisy', 'centos7.qcow2'), 'w') as f: + f.write('image-data') + return 0 + monkeypatch.setattr(environment, 'run_shell', create_server_image_sucess) + DaisyEnvBaseInst.create_daisy_server_image() + assert os.path.isfile(DaisyEnvBaseInst.daisy_server_info['image']) + tmpdir.remove() + + +def test_create_BareMetalEnvironment_instance(tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + BareMetalEnvironmentInst = BareMetalEnvironment( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + assert (BareMetalEnvironmentInst.deploy_struct == deploy_struct and + BareMetalEnvironmentInst.net_struct == net_struct and + BareMetalEnvironmentInst.adapter == adapter and + BareMetalEnvironmentInst.pxe_bridge == pxe_bridge and + BareMetalEnvironmentInst.daisy_server_info == daisy_server and + BareMetalEnvironmentInst.work_dir == work_dir and + BareMetalEnvironmentInst.storage_dir == storage_dir and + BareMetalEnvironmentInst.scenario == scenario) + tmpdir.remove() + + +@mock.patch.object(environment.DaisyEnvironmentBase, 'delete_daisy_server') +def test_delete_old_environment_BareMetalEnvironment(mock_delete_daisy_server, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_delete_daisy_server.return_value = None + BareMetalEnvironmentInst = BareMetalEnvironment( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + BareMetalEnvironmentInst.delete_old_environment() + BareMetalEnvironmentInst.delete_daisy_server.assert_called_once_with() + tmpdir.remove() + + +def test_create_daisy_server_vm_BareMetalEnvironment(mocker, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mocker.patch('deploy.environment.create_vm') + BareMetalEnvironmentInst = BareMetalEnvironment( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + BareMetalEnvironmentInst.create_daisy_server_vm() + environment.create_vm.assert_called_once_with(BMDEPLOY_DAISY_SERVER_VM, + name=daisy_server['name'], + disks=[daisy_server['image']]) + tmpdir.remove() + + +@mock.patch('deploy.environment.ipmi_reboot_node') +def test_reboot_nodes_BareMetalEnvironment(mock_ipmi_reboot_node, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_ipmi_reboot_node.return_value = True + BareMetalEnvironmentInst = BareMetalEnvironment( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + BareMetalEnvironmentInst.reboot_nodes() + assert environment.ipmi_reboot_node.call_count == 5 + tmpdir.remove() + + +@mock.patch.object(environment.DaisyEnvironmentBase, 'create_daisy_server_image') +@mock.patch.object(environment.BareMetalEnvironment, 'create_daisy_server_vm') +def test_create_daisy_server_BareMetalEnvironment(mock_create_daisy_server_vm, mock_create_daisy_server_image, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_create_daisy_server_vm.return_value = None + mock_create_daisy_server_image.return_value = None + BareMetalEnvironmentInst = BareMetalEnvironment( + deploy_struct, net_struct, adapter, pxe_bridge, + daisy_server, work_dir, storage_dir, scenario) + BareMetalEnvironmentInst.create_daisy_server() + BareMetalEnvironmentInst.create_daisy_server_image.assert_called_once_with() + BareMetalEnvironmentInst.create_daisy_server_vm.assert_called_once_with() + tmpdir.remove() + + +def test_create_VirtualEnvironment_instance(tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + assert (DeepDiff(VirtualEnvironmentInst.deploy_struct, deploy_virtual_struct, ignore_order=True) == {} and + VirtualEnvironmentInst.net_struct == net_struct and + VirtualEnvironmentInst.adapter == adapter_virtual and + VirtualEnvironmentInst.pxe_bridge == pxe_bridge_virtual and + VirtualEnvironmentInst.daisy_server_info == daisy_server and + VirtualEnvironmentInst.work_dir == work_dir and + VirtualEnvironmentInst.storage_dir == storage_dir and + VirtualEnvironmentInst.scenario == scenario and + VirtualEnvironmentInst._daisy_server_net is None and + VirtualEnvironmentInst._daisy_os_net is None and + VirtualEnvironmentInst._daisy_keepalived_net is None) + tmpdir.remove() + + +@mock.patch('deploy.environment.create_virtual_network') +def test_create_daisy_server_network_VirtualEnvironment(mock_create_virtual_network, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_create_virtual_network.return_value = pxe_bridge_virtual + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.create_daisy_server_network() + environment.create_virtual_network.assert_called_once_with(VMDEPLOY_DAISY_SERVER_NET) + assert VirtualEnvironmentInst._daisy_server_net == pxe_bridge_virtual + tmpdir.remove() + + +@mock.patch('deploy.environment.create_vm') +def test_create_daisy_server_vm_VirtualEnvironment(mock_create_vm, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_create_vm.return_value = True + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.create_daisy_server_vm() + environment.create_vm.assert_called_once_with(VMDEPLOY_DAISY_SERVER_VM, + name=daisy_server['name'], + disks=[daisy_server['image']]) + + +@mock.patch.object(environment.DaisyEnvironmentBase, 'create_daisy_server_image') +@mock.patch.object(environment.VirtualEnvironment, 'create_daisy_server_network') +@mock.patch.object(environment.VirtualEnvironment, 'create_daisy_server_vm') +def test_create_daisy_server_VirtualEnvironment(mock_create_daisy_server_vm, + mock_create_daisy_server_network, + mock_create_daisy_server_image, + tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.create_daisy_server() + VirtualEnvironmentInst.create_daisy_server_vm.assert_called_once_with() + VirtualEnvironmentInst.create_daisy_server_network.assert_called_once_with() + VirtualEnvironmentInst.create_daisy_server_image.assert_called_once_with() + tmpdir.remove() + + +@mock.patch('deploy.environment.create_vm') +@mock.patch('deploy.environment.create_virtual_disk') +def test_create_virtual_node_VirtualEnvironment(mock_create_virtual_disk, + mock_create_vm, + tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.create_virtual_node(deploy_virtual_struct['hosts'][0]) + environment.create_virtual_disk.call_count == 2 + name = deploy_virtual_struct['hosts'][0]['name'] + template = deploy_virtual_struct['hosts'][0]['template'] + files = [os.path.join(storage_dir, name + '.qcow2'), os.path.join(storage_dir, name + '_data.qcow2')] + environment.create_vm.assert_called_once_with(template, name, files) + tmpdir.remove() + + +@mock.patch('deploy.environment.create_virtual_network') +@mock.patch('deploy.environment.get_vm_mac_addresses') +@mock.patch.object(environment.VirtualEnvironment, 'create_virtual_node') +def test_create_nodes_VirtualEnvironment(mock_create_virtual_node, + mock_get_vm_mac_addresses, + mock_create_virtual_network, + tmpdir): + keepalived_net_name = 'daisy3' + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_create_virtual_network.return_value = keepalived_net_name + mock_get_vm_mac_addresses.return_value = '02:42:b6:90:7c:b2' + mock_create_virtual_node.return_value = 'test-domain' + + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.create_nodes() + assert (environment.create_virtual_network.call_count == 2 and + environment.get_vm_mac_addresses.call_count == 5 and + VirtualEnvironmentInst.create_virtual_node.call_count == 5) + environment.get_vm_mac_addresses.assert_called_with('test-domain') + assert VirtualEnvironmentInst._daisy_keepalived_net == keepalived_net_name + tmpdir.remove() + + +@mock.patch('deploy.environment.delete_vm_and_disk') +def test_delete_nodes_VirtualEnvironment(mock_delete_vm_and_disk, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.delete_nodes() + assert environment.delete_vm_and_disk.call_count == 5 + + +@mock.patch('deploy.environment.reboot_vm') +def test_reboot_nodes_VirtualEnvironment(mock_reboot_vm, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.reboot_nodes() + assert environment.reboot_vm.call_count == 5 + + +@mock.patch('deploy.environment.delete_virtual_network') +def test_delete_networks_VirtualEnvironment(mock_delete_virtual_network, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.delete_networks() + assert environment.delete_virtual_network.call_count == 3 + + +@mock.patch.object(environment.DaisyEnvironmentBase, 'delete_daisy_server') +@mock.patch.object(environment.VirtualEnvironment, 'delete_networks') +@mock.patch.object(environment.VirtualEnvironment, 'delete_nodes') +def test_delete_old_environment_VirtualEnvironment(mock_delete_daisy_server, + mock_delete_networks, + mock_delete_nodes, + tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst.delete_old_environment() + VirtualEnvironmentInst.delete_daisy_server.assert_called_once_with() + VirtualEnvironmentInst.delete_networks.assert_called_once_with() + VirtualEnvironmentInst.delete_nodes.assert_called_once_with() + tmpdir.remove() + + +@mock.patch('deploy.environment.commands.getstatusoutput') +def test_post_deploy_VirtualEnvironment(mock_getstatusoutput, tmpdir): + work_dir = os.path.join(tmpdir.dirname, tmpdir.basename, work_dir_name) + storage_dir = os.path.join(tmpdir.dirname, tmpdir.basename, storage_dir_name) + daisy_server = copy.deepcopy(daisy_server_info) + daisy_server['image'] = os.path.join(storage_dir, daisy_server['image']) + mock_getstatusoutput.return_value = (0, 'sucess') + VirtualEnvironmentInst = VirtualEnvironment( + deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual, + daisy_server, work_dir, storage_dir, scenario) + VirtualEnvironmentInst._post_deploy() + VirtualEnvironmentInst._daisy_server_net = 'daisy1' + VirtualEnvironmentInst._daisy_os_net = 'daisy2' + assert environment.commands.getstatusoutput.call_count == 4 diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index 22597dca..41a06f63 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -7,11 +7,14 @@ # http://www.apache.org/licenses/LICENSE-2.0 ############################################################################## import os - +import mock import pytest import mock +from deploy import utils from deploy.utils import ( + err_exit, + check_sudo_privilege, check_file_exists, make_file_executable, confirm_dir_exists, @@ -19,6 +22,20 @@ from deploy.utils import ( ) +def test_err_exit(): + message = 'test error msg!' + with pytest.raises(SystemExit): + err_exit(message) + + +@mock.patch('deploy.utils.err_exit') +@mock.patch('deploy.utils.os.getuid') +def test_check_sudo_privilege(mock_getuid, mock_err_exit): + mock_getuid.return_value = 1 + check_sudo_privilege() + utils.err_exit.assert_called_once_with('You need run this script with sudo privilege') + + @pytest.mark.parametrize('test_file_name', [ ('no_exist_file'), ('exist_file')]) |