Merge changes from topic 'unittest2'

* changes:
  Add more test function and case in test_utils.py
  Add more test cases in test_deploy.py

1 files changed, 260 insertions, 28 deletions

diff --git a/tests/unit/test_environment.py b/tests/unit/test_environment.py
index 250a80a9..dcd8b046 100644
--- a/tests/unit/test_environment.py
+++ b/tests/unit/test_environment.py
@@ -2,10 +2,13 @@ import os
 import copy
 import mock
 import yaml
+import pytest
 from deepdiff import DeepDiff
 
 from deploy.utils import WORKSPACE
 from deploy import environment
+from deploy import daisy_server
+from deploy.daisy_server import DaisyServer
 from deploy.environment import (
     DaisyEnvironmentBase,
     BareMetalEnvironment,
@@ -29,6 +32,7 @@ def get_conf_info_from_file(file_dir, conf_file_name):
 
 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')
+deploy_virtual2_struct = get_conf_info_from_file(get_conf_file_dir(), 'deploy_virtual2.yml')
 net_struct = get_conf_info_from_file(get_conf_file_dir(), 'network_baremetal.yml')
 adapter = 'ipmi'
 adapter_virtual = 'libvirt'
@@ -80,7 +84,18 @@ def test_delete_daisy_server_DaisyEnvironmentBase(tmpdir, mocker):
     tmpdir.remove()
 
 
-def test_create_daisy_server_image_DaisyEnvironmentBase(tmpdir, monkeypatch):
+@pytest.mark.parametrize('ret_run_shell, ret_access', [
+    (0, 1),
+    (1, 0)])
+@mock.patch('deploy.environment.os.access')
+@mock.patch('deploy.environment.os.remove')
+@mock.patch('deploy.environment.shutil.move')
+@mock.patch('deploy.environment.err_exit')
+@mock.patch('deploy.environment.run_shell')
+def test_create_daisy_server_image_DaisyEnvironmentBase(mock_run_shell, mock_err_exit,
+                                                        mock_move, mock_remove,
+                                                        mock_access, tmpdir,
+                                                        ret_run_shell, ret_access):
     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)
@@ -90,15 +105,40 @@ def test_create_daisy_server_image_DaisyEnvironmentBase(tmpdir, monkeypatch):
     DaisyEnvBaseInst = DaisyEnvironmentBase(
         deploy_struct, net_struct, adapter, pxe_bridge,
         daisy_server, work_dir, storage_dir, scenario)
+    mock_run_shell.return_value = ret_run_shell
+    mock_access.return_value = ret_access
+    mock_err_exit.return_value = 0
 
-    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'])
+    if ret_run_shell:
+        mock_err_exit.assert_called_once_with('Failed to create Daisy Server image')
+    else:
+        if ret_access:
+            mock_remove.assert_called_once_with(DaisyEnvBaseInst.daisy_server_info['image'])
+        else:
+            mock_move.assert_called_once()
+    tmpdir.remove()
+
+
+@mock.patch.object(daisy_server.DaisyServer, 'connect')
+@mock.patch.object(daisy_server.DaisyServer, 'install_daisy')
+def test_install_daisy_DaisyEnvironmentBase(mock_install_daisy, mock_connect, tmpdir):
+    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'])
+    remote_dir = '/home/daisy'
+    bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, 'opnfv.bin')
+    deploy_file_name = 'final_deploy.yml'
+    net_file_name = 'network_baremetal.yml'
+    DaisyEnvBaseInst = DaisyEnvironmentBase(
+        deploy_struct, net_struct, adapter, pxe_bridge,
+        daisy_server, work_dir, storage_dir, scenario)
+    DaisyEnvBaseInst.install_daisy(remote_dir, bin_file, deploy_file_name, net_file_name)
+    mock_install_daisy.assert_called_once_with()
+    mock_connect.assert_called_once_with()
     tmpdir.remove()
 
 
@@ -153,18 +193,36 @@ def test_create_daisy_server_vm_BareMetalEnvironment(mocker, tmpdir):
     tmpdir.remove()
 
 
+@pytest.mark.parametrize('deploy_struct_info', [
+    (deploy_struct)])
 @mock.patch('deploy.environment.ipmi_reboot_node')
-def test_reboot_nodes_BareMetalEnvironment(mock_ipmi_reboot_node, tmpdir):
+def test_reboot_nodes_BareMetalEnvironment(mock_ipmi_reboot_node,
+                                           deploy_struct_info, 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,
+        deploy_struct_info, net_struct, adapter, pxe_bridge,
         daisy_server, work_dir, storage_dir, scenario)
     BareMetalEnvironmentInst.reboot_nodes()
-    assert environment.ipmi_reboot_node.call_count == 5
+    assert mock_ipmi_reboot_node.call_count == 5
+    tmpdir.remove()
+
+
+@pytest.mark.parametrize('deploy_struct_info', [
+    (deploy_virtual_struct)])
+def test_reboot_nodes_err_BareMetalEnvironment(deploy_struct_info, 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_info, net_struct, adapter, pxe_bridge,
+        daisy_server, work_dir, storage_dir, scenario)
+    with pytest.raises(SystemExit):
+        BareMetalEnvironmentInst.reboot_nodes()
     tmpdir.remove()
 
 
@@ -186,6 +244,49 @@ def test_create_daisy_server_BareMetalEnvironment(mock_create_daisy_server_vm, m
     tmpdir.remove()
 
 
+@mock.patch.object(daisy_server.DaisyServer, 'prepare_cluster')
+@mock.patch.object(environment.BareMetalEnvironment, 'reboot_nodes')
+@mock.patch.object(daisy_server.DaisyServer, 'prepare_host_and_pxe')
+@mock.patch.object(daisy_server.DaisyServer, 'check_os_installation')
+@mock.patch.object(daisy_server.DaisyServer, 'check_openstack_installation')
+@mock.patch.object(daisy_server.DaisyServer, 'post_deploy')
+def test_deploy_BareMetalEnvironment(mock_post_deploy, mock_check_openstack_installation,
+                                     mock_check_os_installation, mock_prepare_host_and_pxe,
+                                     mock_reboot_nodes, mock_prepare_cluster,
+                                     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'])
+    deploy_file = os.path.join(get_conf_file_dir(), 'deploy_baremetal.yml')
+    net_file = os.path.join(get_conf_file_dir(), 'network_baremetal.yml')
+    remote_dir = '/home/daisy'
+    bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, 'opnfv.bin')
+    deploy_file_name = 'final_deploy.yml'
+    net_file_name = 'network_baremetal.yml'
+    BareMetalEnvironmentInst = BareMetalEnvironment(
+        deploy_struct, net_struct, adapter, pxe_bridge,
+        daisy_server, work_dir, storage_dir, scenario)
+    BareMetalEnvironmentInst.server = DaisyServer(
+        daisy_server['name'],
+        daisy_server['address'],
+        daisy_server['password'],
+        remote_dir,
+        bin_file,
+        adapter,
+        scenario,
+        deploy_file_name,
+        net_file_name)
+    BareMetalEnvironmentInst.deploy(deploy_file, net_file)
+    mock_prepare_cluster.assert_called_once_with(deploy_file, net_file)
+    mock_reboot_nodes.assert_called_once_with(boot_dev='pxe')
+    mock_prepare_host_and_pxe.assert_called_once_with()
+    mock_check_os_installation.assert_called_once_with(len(BareMetalEnvironmentInst.deploy_struct['hosts']))
+    mock_check_openstack_installation.assert_called_once_with(len(BareMetalEnvironmentInst.deploy_struct['hosts']))
+    mock_post_deploy.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)
@@ -208,19 +309,67 @@ def test_create_VirtualEnvironment_instance(tmpdir):
     tmpdir.remove()
 
 
+@mock.patch.object(environment.VirtualEnvironment, 'check_nodes_template')
+def test_check_configuration_VirtualEnvironment(mock_check_nodes_template, 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'])
+    VirtualEnvironment(
+        deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual,
+        daisy_server, work_dir, storage_dir, scenario)
+    mock_check_nodes_template.assert_called_once_with()
+    tmpdir.remove()
+
+
+deploy_virtual_invalid_struct = get_conf_info_from_file(get_conf_file_dir(), 'deploy_virtual_invalid_template.yml')
+
+
+@pytest.mark.parametrize('deploy_struct_info', [
+    (deploy_struct),
+    (deploy_virtual_struct),
+    (deploy_virtual_invalid_struct)])
+@mock.patch('deploy.environment.err_exit')
+def test_check_nodes_template_VirtualEnvironment(mock_err_exit, deploy_struct_info, 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_err_exit.return_value = 0
+    VirtualEnvironment(
+        deploy_struct_info, net_struct, adapter_virtual, pxe_bridge_virtual,
+        daisy_server, work_dir, storage_dir, scenario)
+    if deploy_struct_info == deploy_struct:
+        mock_err_exit.assert_not_called()
+    elif deploy_struct_info == deploy_virtual_struct:
+        mock_err_exit.assert_not_called()
+    elif deploy_struct_info == deploy_virtual_invalid_struct:
+        assert mock_err_exit.call_count == 5
+    tmpdir.remove()
+
+
+@pytest.mark.parametrize('net_name', [
+    (pxe_bridge_virtual)])
 @mock.patch('deploy.environment.create_virtual_network')
-def test_create_daisy_server_network_VirtualEnvironment(mock_create_virtual_network, tmpdir):
+@mock.patch('deploy.environment.err_exit')
+def test_create_daisy_server_network_VirtualEnvironment(mock_err_exit, mock_create_virtual_network,
+                                                        net_name, 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
+    mock_create_virtual_network.return_value = net_name
+    mock_err_exit.return_value = 0
     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
+    mock_create_virtual_network.assert_called_once_with(VMDEPLOY_DAISY_SERVER_NET)
+    if net_name == pxe_bridge_virtual:
+        mock_err_exit.assert_not_called()
+        assert VirtualEnvironmentInst._daisy_server_net == pxe_bridge_virtual
+    elif net_name == pxe_bridge:
+        mock_err_exit.assert_called_once()
     tmpdir.remove()
 
 
@@ -238,6 +387,7 @@ def test_create_daisy_server_vm_VirtualEnvironment(mock_create_vm, tmpdir):
     environment.create_vm.assert_called_once_with(VMDEPLOY_DAISY_SERVER_VM,
                                                   name=daisy_server['name'],
                                                   disks=[daisy_server['image']])
+    tmpdir.remove()
 
 
 @mock.patch.object(environment.DaisyEnvironmentBase, 'create_daisy_server_image')
@@ -261,23 +411,30 @@ def test_create_daisy_server_VirtualEnvironment(mock_create_daisy_server_vm,
     tmpdir.remove()
 
 
+@pytest.mark.parametrize('deploy_info_struct, node_num', [
+    (deploy_virtual_struct, 0),
+    (deploy_virtual_struct, 3),
+    (deploy_virtual2_struct, 0)])
 @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):
+def test_create_virtual_node_VirtualEnvironment(mock_create_virtual_disk, mock_create_vm,
+                                                deploy_info_struct, node_num, 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,
+        deploy_info_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')]
+    VirtualEnvironmentInst.create_virtual_node(deploy_info_struct['hosts'][node_num])
+    name = deploy_info_struct['hosts'][node_num]['name']
+    template = deploy_info_struct['hosts'][node_num]['template']
+    if deploy_info_struct == deploy_virtual_struct:
+        files = [os.path.join(storage_dir, name + '.qcow2'), os.path.join(storage_dir, name + '_data.qcow2')]
+        assert environment.create_virtual_disk.call_count == 2
+    elif deploy_info_struct == deploy_virtual2_struct:
+        files = [os.path.join(storage_dir, name + '.qcow2')]
+        assert environment.create_virtual_disk.call_count == 1
     environment.create_vm.assert_called_once_with(template, name, files)
     tmpdir.remove()
 
@@ -321,6 +478,7 @@ def test_delete_nodes_VirtualEnvironment(mock_delete_vm_and_disk, tmpdir):
         daisy_server, work_dir, storage_dir, scenario)
     VirtualEnvironmentInst.delete_nodes()
     assert environment.delete_vm_and_disk.call_count == 5
+    tmpdir.remove()
 
 
 @mock.patch('deploy.environment.reboot_vm')
@@ -334,19 +492,29 @@ def test_reboot_nodes_VirtualEnvironment(mock_reboot_vm, tmpdir):
         daisy_server, work_dir, storage_dir, scenario)
     VirtualEnvironmentInst.reboot_nodes()
     assert environment.reboot_vm.call_count == 5
+    tmpdir.remove()
 
 
+@pytest.mark.parametrize('isdir', [
+    (True),
+    (False)])
 @mock.patch('deploy.environment.delete_virtual_network')
-def test_delete_networks_VirtualEnvironment(mock_delete_virtual_network, tmpdir):
+@mock.patch('deploy.environment.os.path.isdir')
+def test_delete_networks_VirtualEnvironment(mock_isdir, mock_delete_virtual_network, isdir, 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_isdir.return_value = isdir
     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
+    if isdir is True:
+        assert mock_delete_virtual_network.call_count == 3
+    else:
+        mock_delete_virtual_network.assert_not_called()
+    tmpdir.remove()
 
 
 @mock.patch.object(environment.DaisyEnvironmentBase, 'delete_daisy_server')
@@ -370,13 +538,72 @@ def test_delete_old_environment_VirtualEnvironment(mock_delete_daisy_server,
     tmpdir.remove()
 
 
+@mock.patch.object(environment.DaisyServer, 'post_deploy')
+@mock.patch.object(environment.DaisyServer, 'check_openstack_installation')
+@mock.patch.object(environment.DaisyServer, 'check_os_installation')
+@mock.patch.object(environment.DaisyServer, 'install_virtual_nodes')
+@mock.patch.object(environment.DaisyServer, 'prepare_host_and_pxe')
+@mock.patch.object(environment.DaisyServer, 'copy_new_deploy_config')
+@mock.patch.object(environment.DaisyServer, 'prepare_cluster')
+@mock.patch.object(environment.VirtualEnvironment, '_post_deploy')
+@mock.patch.object(environment.VirtualEnvironment, 'reboot_nodes')
+@mock.patch.object(environment.VirtualEnvironment, 'create_nodes')
+def test_deploy_VirtualEnvironment(mock_create_nodes, mock_reboot_nodes,
+                                   mock__post_deploy, mock_prepare_cluster,
+                                   mock_copy_new_deploy_config, mock_prepare_host_and_pxe,
+                                   mock_install_virtual_nodes, mock_check_os_installation,
+                                   mock_check_openstack_installation, mock_post_deploy,
+                                   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'])
+    remote_dir = '/home/daisy'
+    bin_file = os.path.join(tmpdir.dirname, tmpdir.basename, 'opnfv.bin')
+    deploy_file_name = 'final_deploy.yml'
+    net_file_name = 'network_virtual1.yml'
+    deploy_file = os.path.join(get_conf_file_dir(), 'deploy_virtual1.yml')
+    net_file = os.path.join(get_conf_file_dir(), 'network_virtual1.yml')
+    VirtualEnvironmentInst = VirtualEnvironment(
+        deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual,
+        daisy_server, work_dir, storage_dir, scenario)
+    VirtualEnvironmentInst.server = DaisyServer(
+        daisy_server['name'],
+        daisy_server['address'],
+        daisy_server['password'],
+        remote_dir,
+        bin_file,
+        adapter,
+        scenario,
+        deploy_file_name,
+        net_file_name)
+    VirtualEnvironmentInst.deploy(deploy_file, net_file)
+    mock_create_nodes.assert_called_once()
+    assert mock_reboot_nodes.call_count == 2
+    mock__post_deploy.assert_called_once()
+    mock_prepare_cluster.assert_called_once()
+    mock_copy_new_deploy_config.assert_called_once()
+    mock_prepare_host_and_pxe.assert_called_once()
+    mock_install_virtual_nodes.assert_called_once()
+    mock_check_os_installation.assert_called_once()
+    mock_check_openstack_installation.assert_called_once()
+    mock_post_deploy.assert_called_once()
+    tmpdir.remove()
+
+
+@pytest.mark.parametrize('status', [
+    (True),
+    (False)])
 @mock.patch('deploy.environment.commands.getstatusoutput')
-def test_post_deploy_VirtualEnvironment(mock_getstatusoutput, tmpdir):
+@mock.patch('deploy.environment.LW')
+@mock.patch('deploy.environment.LI')
+def test__post_deploy_VirtualEnvironment(mock_LI, mock_LW,
+                                         mock_getstatusoutput, status, 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')
+    mock_getstatusoutput.return_value = (status, 'success')
     VirtualEnvironmentInst = VirtualEnvironment(
         deploy_virtual_struct, net_struct, adapter_virtual, pxe_bridge_virtual,
         daisy_server, work_dir, storage_dir, scenario)
@@ -384,3 +611,8 @@ def test_post_deploy_VirtualEnvironment(mock_getstatusoutput, tmpdir):
     VirtualEnvironmentInst._daisy_server_net = 'daisy1'
     VirtualEnvironmentInst._daisy_os_net = 'daisy2'
     assert environment.commands.getstatusoutput.call_count == 4
+    if status:
+        mock_LW.assert_called()
+    else:
+        mock_LI.assert_called()
+    tmpdir.remove()