def test__exec_ipmitool_exception(self, mock_exec, mock_pwf,
mock_timing_support, mock_sleep):
pw_file_handle = tempfile.NamedTemporaryFile()
pw_file = pw_file_handle.name
file_handle = open(pw_file, "w")
args = [
'ipmitool',
'-I',
'lanplus',
'-H',
self.info['address'],
'-L',
self.info['priv_level'],
'-U',
self.info['username'],
'-f',
file_handle,
'A',
'B',
'C',
]
mock_timing_support.return_value = False
mock_pwf.return_value = file_handle
mock_exec.side_effect = processutils.ProcessExecutionError("x")
self.assertRaises(processutils.ProcessExecutionError,
ipmi._exec_ipmitool, self.info, 'A B C')
mock_pwf.assert_called_once_with(self.info['password'])
mock_exec.assert_called_once_with(*args)
def test__exec_ipmitool_exception(self):
pw_file_handle = tempfile.NamedTemporaryFile()
pw_file = pw_file_handle.name
file_handle = open(pw_file, "w")
args = [
'ipmitool',
'-I',
'lanplus',
'-H',
self.info['address'],
'-L',
self.info['priv_level'],
'-U',
self.info['username'],
'-f',
file_handle,
'A',
'B',
'C',
]
with mock.patch.object(ipmi, '_make_password_file',
autospec=True) as mock_pwf:
mock_pwf.return_value = file_handle
with mock.patch.object(utils, 'execute',
autospec=True) as mock_exec:
mock_exec.side_effect = processutils.ProcessExecutionError("x")
self.assertRaises(processutils.ProcessExecutionError,
ipmi._exec_ipmitool, self.info, 'A B C')
mock_pwf.assert_called_once_with(self.info['password'])
mock_exec.assert_called_once_with(*args, attempts=3)
def test_stop_shellinabox_console_fail_nokill(self, mock_stop):
mock_stop.side_effect = processutils.ProcessExecutionError()
self.assertRaises(exception.ConsoleError,
console_utils.stop_shellinabox_console,
self.info['uuid'])
mock_stop.assert_called_once_with(self.info['uuid'])
def test_check_timing_fail(self, mock_exc, mock_timing):
mock_exc.side_effect = processutils.ProcessExecutionError()
mock_timing.return_value = None
expected = [mock.call(), mock.call(False)]
ipmi.check_timing_support()
self.assertTrue(mock_exc.called)
self.assertEqual(expected, mock_timing.call_args_list)
def test__power_status_exception(self):
with mock.patch.object(
ipmi,
'_exec_ipmitool',
side_effect=processutils.ProcessExecutionError("error"),
autospec=True) as mock_exec:
self.assertRaises(exception.IPMIFailure, ipmi._power_status,
self.info)
mock_exec.assert_called_once_with(self.info, "power status")
def test__stop_console_nokill(self, mock_pid, mock_execute, mock_unlink):
pid_file = console_utils._get_console_pid_file(self.info['uuid'])
mock_pid.return_value = '12345'
mock_execute.side_effect = processutils.ProcessExecutionError()
self.assertRaises(processutils.ProcessExecutionError,
console_utils._stop_console,
self.info['uuid'])
mock_pid.assert_called_once_with(self.info['uuid'])
mock_execute.assert_called_once_with('kill', mock_pid.return_value,
check_exit_code=[0, 99])
mock_unlink.assert_called_once_with(pid_file)
def test_management_interface_get_boot_device_fail(self, mock_exec):
with task_manager.acquire(self.context, self.node.uuid) as task:
mock_exec.side_effect = processutils.ProcessExecutionError()
self.assertRaises(exception.IPMIFailure,
task.driver.management.get_boot_device, task)
mock_exec.assert_called_with(mock.ANY, "chassis bootparam get 5")
def test_management_interface_set_boot_device_exec_failed(self, mock_exec):
mock_exec.side_effect = processutils.ProcessExecutionError()
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.IPMIFailure,
self.driver.management.set_boot_device, task,
boot_devices.PXE)
def test_get_power_state_exception(self, mock_exec):
mock_exec.side_effect = processutils.ProcessExecutionError("error")
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.IPMIFailure,
self.driver.power.get_power_state, task)
mock_exec.assert_called_once_with(self.info, "power status")
def test__power_status_exception(self, mock_exec, mock_sleep):
mock_exec.side_effect = processutils.ProcessExecutionError("error")
self.assertRaises(exception.IPMIFailure, ipmi._power_status, self.info)
mock_exec.assert_called_once_with(self.info, "power status")
class MkfsTestCase(base.TestCase):
@mock.patch.object(utils, 'execute')
def test_mkfs(self, execute_mock):
utils.mkfs('ext4', '/my/block/dev')
utils.mkfs('msdos', '/my/msdos/block/dev')
utils.mkfs('swap', '/my/swap/block/dev')
expected = [
mock.call('mkfs',
'-t',
'ext4',
'-F',
'/my/block/dev',
run_as_root=True,
use_standard_locale=True),
mock.call('mkfs',
'-t',
'msdos',
'/my/msdos/block/dev',
run_as_root=True,
use_standard_locale=True),
mock.call('mkswap',
'/my/swap/block/dev',
run_as_root=True,
use_standard_locale=True)
]
self.assertEqual(expected, execute_mock.call_args_list)
@mock.patch.object(utils, 'execute')
def test_mkfs_with_label(self, execute_mock):
utils.mkfs('ext4', '/my/block/dev', 'ext4-vol')
utils.mkfs('msdos', '/my/msdos/block/dev', 'msdos-vol')
utils.mkfs('swap', '/my/swap/block/dev', 'swap-vol')
expected = [
mock.call('mkfs',
'-t',
'ext4',
'-F',
'-L',
'ext4-vol',
'/my/block/dev',
run_as_root=True,
use_standard_locale=True),
mock.call('mkfs',
'-t',
'msdos',
'-n',
'msdos-vol',
'/my/msdos/block/dev',
run_as_root=True,
use_standard_locale=True),
mock.call('mkswap',
'-L',
'swap-vol',
'/my/swap/block/dev',
run_as_root=True,
use_standard_locale=True)
]
self.assertEqual(expected, execute_mock.call_args_list)
@mock.patch.object(utils,
'execute',
side_effect=processutils.ProcessExecutionError(
stderr=os.strerror(errno.ENOENT)))
def test_mkfs_with_unsupported_fs(self, execute_mock):
self.assertRaises(exception.FileSystemNotSupported, utils.mkfs, 'foo',
'/my/block/dev')
@mock.patch.object(
utils,
'execute',
side_effect=processutils.ProcessExecutionError(stderr='fake'))
def test_mkfs_with_unexpected_error(self, execute_mock):
self.assertRaises(processutils.ProcessExecutionError, utils.mkfs,
'ext4', '/my/block/dev', 'ext4-vol')
class MkfsTestCase(base.TestCase):
@mock.patch.object(os.environ, 'copy')
@mock.patch.object(utils, 'execute')
def test_mkfs(self, execute_mock, mock_env):
lang_env_variable = {'LC_ALL': 'C'}
mock_env.return_value = lang_env_variable
utils.mkfs('ext4', '/my/block/dev')
utils.mkfs('msdos', '/my/msdos/block/dev')
utils.mkfs('swap', '/my/swap/block/dev')
expected = [
mock.call('mkfs',
'-t',
'ext4',
'-F',
'/my/block/dev',
run_as_root=True,
env_variables=lang_env_variable),
mock.call('mkfs',
'-t',
'msdos',
'/my/msdos/block/dev',
run_as_root=True,
env_variables=lang_env_variable),
mock.call('mkswap',
'/my/swap/block/dev',
run_as_root=True,
env_variables=lang_env_variable)
]
self.assertEqual(expected, execute_mock.call_args_list)
@mock.patch.object(os.environ, 'copy')
@mock.patch.object(utils, 'execute')
def test_mkfs_with_label(self, execute_mock, mock_env):
lang_env_variable = {'LC_ALL': 'C'}
mock_env.return_value = lang_env_variable
utils.mkfs('ext4', '/my/block/dev', 'ext4-vol')
utils.mkfs('msdos', '/my/msdos/block/dev', 'msdos-vol')
utils.mkfs('swap', '/my/swap/block/dev', 'swap-vol')
expected = [
mock.call('mkfs',
'-t',
'ext4',
'-F',
'-L',
'ext4-vol',
'/my/block/dev',
run_as_root=True,
env_variables=lang_env_variable),
mock.call('mkfs',
'-t',
'msdos',
'-n',
'msdos-vol',
'/my/msdos/block/dev',
run_as_root=True,
env_variables=lang_env_variable),
mock.call('mkswap',
'-L',
'swap-vol',
'/my/swap/block/dev',
run_as_root=True,
env_variables=lang_env_variable)
]
self.assertEqual(expected, execute_mock.call_args_list)
@mock.patch.object(utils,
'execute',
side_effect=processutils.ProcessExecutionError(
stderr=os.strerror(errno.ENOENT)))
def test_mkfs_with_unsupported_fs(self, execute_mock):
self.assertRaises(exception.FileSystemNotSupported, utils.mkfs, 'foo',
'/my/block/dev')
@mock.patch.object(
utils,
'execute',
side_effect=processutils.ProcessExecutionError(stderr='fake'))
def test_mkfs_with_unexpected_error(self, execute_mock):
self.assertRaises(processutils.ProcessExecutionError, utils.mkfs,
'ext4', '/my/block/dev', 'ext4-vol')