openstack/ironic
Code Issues Proposed changes

Merge "Remove iterated form of side effects"

Browse Source
This commit is contained in:
Jenkins 2016-07-07 15:35:59 +00:00 committed by Gerrit Code Review
commit 22aba527fb
32 changed files with 150 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ironic/tests/unit/api/v1/test_drivers.py
View File

@ -259,9 +259,8 @@ class TestListDrivers(base.BaseApiTest):
self, disk_prop_mock):
driver._RAID_PROPERTIES = {}
self.register_fake_conductors()
disk_prop_mock.side_effect = iter(
[exception.UnsupportedDriverExtension(
extension='raid', driver='fake')])
disk_prop_mock.side_effect = exception.UnsupportedDriverExtension(
extension='raid', driver='fake')
path = '/drivers/%s/raid/logical_disk_properties' % self.d1
ret = self.get_json(path,
headers={api_base.Version.string: "1.12"},

11
ironic/tests/unit/api/v1/test_nodes.py
View File

@ -1981,8 +1981,7 @@ class TestPut(test_api_base.BaseApiTest):
node.target_provision_state = states.NOSTATE
node.reservation = 'fake-host'
node.save()
self.mock_dnd.side_effect = iter([exception.NodeLocked(node='',
host='')])
self.mock_dnd.side_effect = exception.NodeLocked(node='', host='')
ret = self.put_json('/nodes/%s/states/provision' % node.uuid,
{'target': states.ACTIVE},
expect_errors=True)
@ -2378,9 +2377,9 @@ class TestPut(test_api_base.BaseApiTest):
autospec=True)
def test_put_raid_iface_not_supported(self, set_raid_config_mock):
raid_config = {'logical_disks': [{'size_gb': 100, 'raid_level': 1}]}
set_raid_config_mock.side_effect = iter([
set_raid_config_mock.side_effect = (
exception.UnsupportedDriverExtension(extension='raid',
driver='fake')])
driver='fake'))
ret = self.put_json(
'/nodes/%s/states/raid' % self.node.uuid, raid_config,
headers={api_base.Version.string: "1.12"},
@ -2394,8 +2393,8 @@ class TestPut(test_api_base.BaseApiTest):
autospec=True)
def test_put_raid_invalid_parameter_value(self, set_raid_config_mock):
raid_config = {'logical_disks': [{'size_gb': 100, 'raid_level': 1}]}
set_raid_config_mock.side_effect = iter([
exception.InvalidParameterValue('foo')])
set_raid_config_mock.side_effect = exception.InvalidParameterValue(
'foo')
ret = self.put_json(
'/nodes/%s/states/raid' % self.node.uuid, raid_config,
headers={api_base.Version.string: "1.12"},

4
ironic/tests/unit/common/test_image_service.py
View File

@ -63,7 +63,7 @@ class HttpImageServiceTestCase(base.TestCase):
@mock.patch.object(requests, 'head', autospec=True)
def test_validate_href_error(self, head_mock):
head_mock.side_effect = iter([requests.ConnectionError()])
head_mock.side_effect = requests.ConnectionError()
self.assertRaises(exception.ImageRefValidationFailed,
self.service.validate_href, self.href)
head_mock.assert_called_once_with(self.href)
@ -116,7 +116,7 @@ class HttpImageServiceTestCase(base.TestCase):
@mock.patch.object(requests, 'get', autospec=True)
def test_download_fail_connerror(self, req_get_mock):
req_get_mock.side_effect = iter([requests.ConnectionError()])
req_get_mock.side_effect = requests.ConnectionError()
file_mock = mock.Mock(spec=file)
self.assertRaises(exception.ImageDownloadFailed,
self.service.download, self.href, file_mock)

23
ironic/tests/unit/common/test_images.py
View File

@ -269,8 +269,8 @@ class FsImageTestCase(base.TestCase):
'a3': 'sub_dir/b3'}
path_exists_mock.side_effect = path_exists_mock_func
dirname_mock.side_effect = iter(
['root_dir', 'root_dir', 'root_dir/sub_dir', 'root_dir/sub_dir'])
dirname_mock.side_effect = ['root_dir', 'root_dir', 'root_dir/sub_dir',
'root_dir/sub_dir']
images._create_root_fs('root_dir', files_info)
cp_mock.assert_any_call('a1', 'root_dir/b1')
cp_mock.assert_any_call('a2', 'root_dir/b2')
@ -425,8 +425,8 @@ class FsImageTestCase(base.TestCase):
('/tmpdir1/isolinux', [],
['efiboot.img', 'isolinux.bin',
'isolinux.cfg'])]
relpath_mock.side_effect = iter(
['EFI/ubuntu/grub.cfg', 'isolinux/efiboot.img'])
relpath_mock.side_effect = ['EFI/ubuntu/grub.cfg',
'isolinux/efiboot.img']
images._mount_deploy_iso('path/to/deployiso', 'tmpdir1')
mount_mock.assert_called_once_with('path/to/deployiso',
@ -443,7 +443,7 @@ class FsImageTestCase(base.TestCase):
walk_mock.return_value = [('/tmpdir1/EFI/ubuntu', [], ['grub.cfg']),
('/tmpdir1/isolinux', [],
['isolinux.bin', 'isolinux.cfg'])]
relpath_mock.side_effect = iter(['EFI/ubuntu/grub.cfg'])
relpath_mock.side_effect = 'EFI/ubuntu/grub.cfg'
self.assertRaises(exception.ImageCreationFailed,
images._mount_deploy_iso,
@ -464,7 +464,7 @@ class FsImageTestCase(base.TestCase):
('/tmpdir1/isolinux', '',
['efiboot.img', 'isolinux.bin',
'isolinux.cfg'])]
relpath_mock.side_effect = iter(['isolinux/efiboot.img'])
relpath_mock.side_effect = 'isolinux/efiboot.img'
self.assertRaises(exception.ImageCreationFailed,
images._mount_deploy_iso,
@ -503,7 +503,7 @@ class FsImageTestCase(base.TestCase):
cfg_file = 'tmpdir/isolinux/isolinux.cfg'
grubcfg = "grubcfg"
grub_file = 'tmpdir/relpath/to/grub.cfg'
gen_cfg_mock.side_effect = iter([cfg, grubcfg])
gen_cfg_mock.side_effect = cfg, grubcfg
params = ['a=b', 'c']
isolinux_options = {'kernel': '/vmlinuz',
@ -520,8 +520,7 @@ class FsImageTestCase(base.TestCase):
mock_file_handle.__enter__.return_value = 'tmpdir'
mock_file_handle1 = mock.MagicMock(spec=file)
mock_file_handle1.__enter__.return_value = 'mountdir'
tempdir_mock.side_effect = iter(
[mock_file_handle, mock_file_handle1])
tempdir_mock.side_effect = mock_file_handle, mock_file_handle1
mount_mock.return_value = (uefi_path_info,
e_img_rel_path, grub_rel_path)
@ -603,8 +602,7 @@ class FsImageTestCase(base.TestCase):
mock_file_handle.__enter__.return_value = 'tmpdir'
mock_file_handle1 = mock.MagicMock(spec=file)
mock_file_handle1.__enter__.return_value = 'mountdir'
tempdir_mock.side_effect = iter(
[mock_file_handle, mock_file_handle1])
tempdir_mock.side_effect = mock_file_handle, mock_file_handle1
create_root_fs_mock.side_effect = IOError
self.assertRaises(exception.ImageCreationFailed,
@ -648,8 +646,7 @@ class FsImageTestCase(base.TestCase):
mock_file_handle.__enter__.return_value = 'tmpdir'
mock_file_handle1 = mock.MagicMock(spec=file)
mock_file_handle1.__enter__.return_value = 'mountdir'
tempdir_mock.side_effect = iter(
[mock_file_handle, mock_file_handle1])
tempdir_mock.side_effect = mock_file_handle, mock_file_handle1
mount_mock.return_value = ({'a': 'a'}, 'b', 'c')
utils_mock.side_effect = processutils.ProcessExecutionError

11
ironic/tests/unit/conductor/test_manager.py
View File

@ -2270,7 +2270,7 @@ class DoNodeVerifyTestCase(mgr_utils.ServiceSetUpMixin,
last_error=None,
power_state=states.NOSTATE)
mock_validate.side_effect = iter([RuntimeError("boom")])
mock_validate.side_effect = RuntimeError("boom")
self._start_service()
with task_manager.acquire(
@ -2298,7 +2298,7 @@ class DoNodeVerifyTestCase(mgr_utils.ServiceSetUpMixin,
last_error=None,
power_state=states.NOSTATE)
mock_get_power_state.side_effect = iter([RuntimeError("boom")])
mock_get_power_state.side_effect = RuntimeError("boom")
self._start_service()
with task_manager.acquire(
@ -4676,8 +4676,8 @@ class ManagerCheckDeployingStatusTestCase(mgr_utils.ServiceSetUpMixin,
reservation='fake-conductor')
mock_mapped.return_value = True
mock_release.side_effect = iter([exception.NodeNotFound('not found'),
exception.NodeLocked('locked')])
mock_release.side_effect = [exception.NodeNotFound('not found'),
exception.NodeLocked('locked')]
self.service._check_deploying_status(self.context)
self.node.refresh()
@ -4693,8 +4693,7 @@ class ManagerCheckDeployingStatusTestCase(mgr_utils.ServiceSetUpMixin,
self, mock_release, mock_off_cond, mock_mapped, mock_fail_if):
mock_off_cond.return_value = ['fake-conductor']
mock_mapped.return_value = True
mock_release.side_effect = iter([
exception.NodeNotLocked('not locked')])
mock_release.side_effect = exception.NodeNotLocked('not locked')
self.service._check_deploying_status(self.context)
self.node.refresh()

3
ironic/tests/unit/drivers/modules/amt/test_management.py
View File

@ -152,8 +152,7 @@ class AMTManagementTestCase(db_base.DbTestCase):
def test_validate_fail(self, mock_drvinfo):
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
mock_drvinfo.side_effect = iter(
[exception.InvalidParameterValue('x')])
mock_drvinfo.side_effect = exception.InvalidParameterValue('x')
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.validate,
task)

19
ironic/tests/unit/drivers/modules/amt/test_power.py
View File

@ -128,7 +128,7 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
mock_ps, mock_enbd):
target_state = states.POWER_ON
boot_device = boot_devices.PXE
mock_ps.side_effect = iter([states.POWER_OFF, states.POWER_ON])
mock_ps.side_effect = [states.POWER_OFF, states.POWER_ON]
mock_enbd.return_value = None
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
@ -147,7 +147,7 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
def test__set_and_wait_power_on_without_boot_device(self, mock_sps,
mock_ps):
target_state = states.POWER_ON
mock_ps.side_effect = iter([states.POWER_OFF, states.POWER_ON])
mock_ps.side_effect = [states.POWER_OFF, states.POWER_ON]
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(states.POWER_ON,
@ -157,7 +157,7 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
boot_device = boot_devices.DISK
self.node.driver_internal_info['amt_boot_device'] = boot_device
mock_ps.side_effect = iter([states.POWER_OFF, states.POWER_ON])
mock_ps.side_effect = [states.POWER_OFF, states.POWER_ON]
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(states.POWER_ON,
@ -179,8 +179,8 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
def test__set_and_wait_exceed_iterations(self, mock_sps,
mock_ps):
target_state = states.POWER_ON
mock_ps.side_effect = iter([states.POWER_OFF, states.POWER_OFF,
states.POWER_OFF])
mock_ps.side_effect = [states.POWER_OFF, states.POWER_OFF,
states.POWER_OFF]
mock_sps.return_value = exception.AMTFailure('x')
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
@ -194,7 +194,7 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
autospec=True)
def test__set_and_wait_already_target_state(self, mock_ps):
target_state = states.POWER_ON
mock_ps.side_effect = iter([states.POWER_ON])
mock_ps.side_effect = [states.POWER_ON]
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(states.POWER_ON,
@ -207,7 +207,7 @@ class AMTPowerInteralMethodsTestCase(db_base.DbTestCase):
autospec=True)
def test__set_and_wait_power_off(self, mock_sps, mock_ps):
target_state = states.POWER_OFF
mock_ps.side_effect = iter([states.POWER_ON, states.POWER_OFF])
mock_ps.side_effect = [states.POWER_ON, states.POWER_OFF]
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(states.POWER_OFF,
@ -245,8 +245,7 @@ class AMTPowerTestCase(db_base.DbTestCase):
def test_validate_fail(self, mock_drvinfo):
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
mock_drvinfo.side_effect = iter(
[exception.InvalidParameterValue('x')])
mock_drvinfo.side_effect = exception.InvalidParameterValue('x')
self.assertRaises(exception.InvalidParameterValue,
task.driver.power.validate,
task)
@ -277,7 +276,7 @@ class AMTPowerTestCase(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
pstate = states.POWER_ON
mock_saw.side_effect = iter([exception.PowerStateFailure('x')])
mock_saw.side_effect = exception.PowerStateFailure('x')
self.assertRaises(exception.PowerStateFailure,
task.driver.power.set_power_state,
task, pstate)

5
ironic/tests/unit/drivers/modules/ilo/test_boot.py
View File

@ -100,9 +100,8 @@ class IloBootPrivateMethodsTestCase(db_base.DbTestCase):
@mock.patch.object(image_service.HttpImageService, 'validate_href',
spec_set=True, autospec=True)
def test__get_boot_iso_unsupported_url(self, validate_href_mock):
validate_href_mock.side_effect = iter(
[exception.ImageRefValidationFailed(
image_href='file://img.qcow2', reason='fail')])
validate_href_mock.side_effect = exception.ImageRefValidationFailed(
image_href='file://img.qcow2', reason='fail')
url = 'file://img.qcow2'
i_info = self.node.instance_info
i_info['ilo_boot_iso'] = url

5
ironic/tests/unit/drivers/modules/ilo/test_deploy.py
View File

@ -225,9 +225,8 @@ class IloDeployPrivateMethodsTestCase(db_base.DbTestCase):
mock_is_glance_image,
mock_validate_href):
deploy_iso = 'http://abc.org/image/qcow2'
mock_validate_href.side_effect = iter(
[exception.ImageRefValidationFailed(
image_href='http://abc.org/image/qcow2', reason='fail')])
mock_validate_href.side_effect = exception.ImageRefValidationFailed(
image_href='http://abc.org/image/qcow2', reason='fail')
mock_is_glance_image.return_value = False
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:

2
ironic/tests/unit/drivers/modules/ilo/test_power.py
View File

@ -191,7 +191,7 @@ class IloPowerTestCase(db_base.DbTestCase):
@mock.patch.object(ilo_common, 'parse_driver_info', spec_set=True,
autospec=True)
def test_validate_fail(self, mock_drvinfo):
side_effect = iter([exception.InvalidParameterValue("Invalid Input")])
side_effect = exception.InvalidParameterValue("Invalid Input")
mock_drvinfo.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

6
ironic/tests/unit/drivers/modules/irmc/test_boot.py
View File

@ -448,7 +448,7 @@ class IRMCDeployPrivateMethodsTestCase(db_base.DbTestCase):
mock_image_file_obj = mock.MagicMock()
mock_image_file_obj.name = 'image-tmp-file'
mock_image_file_handle.__enter__.return_value = mock_image_file_obj
tempfile_mock.side_effect = iter([mock_image_file_handle])
tempfile_mock.side_effect = [mock_image_file_handle]
deploy_args = {'arg1': 'val1', 'arg2': 'val2'}
CONF.irmc.remote_image_share_name = '/remote_image_share_root'
@ -476,11 +476,11 @@ class IRMCDeployPrivateMethodsTestCase(db_base.DbTestCase):
mock_image_file_obj = mock.MagicMock()
mock_image_file_obj.name = 'image-tmp-file'
mock_image_file_handle.__enter__.return_value = mock_image_file_obj
tempfile_mock.side_effect = iter([mock_image_file_handle])
tempfile_mock.side_effect = [mock_image_file_handle]
deploy_args = {'arg1': 'val1', 'arg2': 'val2'}
CONF.irmc.remote_image_share_name = '/remote_image_share_root'
copyfile_mock.side_effect = iter([IOError("fake error")])
copyfile_mock.side_effect = IOError("fake error")
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:

2
ironic/tests/unit/drivers/modules/irmc/test_management.py
View File

@ -70,7 +70,7 @@ class IRMCManagementTestCase(db_base.DbTestCase):
@mock.patch.object(irmc_common, 'parse_driver_info', spec_set=True,
autospec=True)
def test_validate_fail(self, mock_drvinfo):
side_effect = iter([exception.InvalidParameterValue("Invalid Input")])
side_effect = exception.InvalidParameterValue("Invalid Input")
mock_drvinfo.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

2
ironic/tests/unit/drivers/modules/irmc/test_power.py
View File

@ -132,7 +132,7 @@ class IRMCPowerTestCase(db_base.DbTestCase):
@mock.patch.object(irmc_common, 'parse_driver_info', spec_set=True,
autospec=True)
def test_validate_fail(self, mock_drvinfo):
side_effect = iter([exception.InvalidParameterValue("Invalid Input")])
side_effect = exception.InvalidParameterValue("Invalid Input")
mock_drvinfo.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

3
ironic/tests/unit/drivers/modules/msftocs/test_management.py
View File

@ -59,8 +59,7 @@ class MSFTOCSManagementTestCase(db_base.DbTestCase):
def test_validate_fail(self, mock_drvinfo):
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
mock_drvinfo.side_effect = iter(
[exception.InvalidParameterValue('x')])
mock_drvinfo.side_effect = exception.InvalidParameterValue('x')
self.assertRaises(exception.InvalidParameterValue,
task.driver.power.validate,
task)

2
ironic/tests/unit/drivers/modules/msftocs/test_msftocsclient.py
View File

@ -92,7 +92,7 @@ class MSFTOCSClientApiTestCase(base.TestCase):
@mock.patch.object(requests, 'get', autospec=True)
def test__exec_cmd_http_get_fail(self, mock_get):
fake_rel_url = 'fake_rel_url'
mock_get.side_effect = iter([requests_exceptions.ConnectionError('x')])
mock_get.side_effect = requests_exceptions.ConnectionError('x')
self.assertRaises(exception.MSFTOCSClientApiException,
self._client._exec_cmd,

3
ironic/tests/unit/drivers/modules/msftocs/test_power.py
View File

@ -58,8 +58,7 @@ class MSFTOCSPowerTestCase(db_base.DbTestCase):
def test_validate_fail(self, mock_drvinfo):
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
mock_drvinfo.side_effect = iter(
[exception.InvalidParameterValue('x')])
mock_drvinfo.side_effect = exception.InvalidParameterValue('x')
self.assertRaises(exception.InvalidParameterValue,
task.driver.power.validate,
task)

6
ironic/tests/unit/drivers/modules/oneview/test_vendor.py
View File

@ -111,7 +111,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
spec=types.FunctionType)
def test_reboot_and_finish_deploy_soft_poweroff_fails(
self, power_off_mock, node_power_action_mock):
power_off_mock.side_effect = iter([RuntimeError("boom")])
power_off_mock.side_effect = RuntimeError("boom")
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
@ -140,7 +140,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.side_effect = iter([RuntimeError("boom")])
get_power_state_mock.side_effect = RuntimeError("boom")
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(GET_POWER_STATE_RETRIES + 1,
@ -167,7 +167,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_ON
node_power_action_mock.side_effect = iter([RuntimeError("boom")])
node_power_action_mock.side_effect = RuntimeError("boom")
self.assertRaises(exception.InstanceDeployFailure,
self.passthru.reboot_and_finish_deploy,
task)

5
ironic/tests/unit/drivers/modules/test_agent.py
View File

@ -217,9 +217,8 @@ class TestAgentMethods(db_base.DbTestCase):
autospec=True)
def test_build_instance_info_for_deploy_nonsupported_image(
self, validate_href_mock):
validate_href_mock.side_effect = iter(
[exception.ImageRefValidationFailed(
image_href='file://img.qcow2', reason='fail')])
validate_href_mock.side_effect = exception.ImageRefValidationFailed(
image_href='file://img.qcow2', reason='fail')
i_info = self.node.instance_info
i_info['image_source'] = 'file://img.qcow2'
i_info['image_checksum'] = 'aa'

12
ironic/tests/unit/drivers/modules/test_agent_base_vendor.py
View File

@ -324,7 +324,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
kwargs = {
'agent_url': 'http://127.0.0.1:9999/bar'
}
done_mock.side_effect = iter([Exception('LlamaException')])
done_mock.side_effect = Exception('LlamaException')
with task_manager.acquire(
self.context, self.node['uuid'], shared=False) as task:
task.node.provision_state = states.DEPLOYWAIT
@ -617,7 +617,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
spec=types.FunctionType)
def test_reboot_and_finish_deploy_soft_poweroff_fails(
self, power_off_mock, node_power_action_mock):
power_off_mock.side_effect = iter([RuntimeError("boom")])
power_off_mock.side_effect = RuntimeError("boom")
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
@ -644,7 +644,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
get_power_state_mock.side_effect = iter([RuntimeError("boom")])
get_power_state_mock.side_effect = RuntimeError("boom")
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(7, get_power_state_mock.call_count)
@ -668,7 +668,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
get_power_state_mock.return_value = states.POWER_ON
node_power_action_mock.side_effect = iter([RuntimeError("boom")])
node_power_action_mock.side_effect = RuntimeError("boom")
self.assertRaises(exception.InstanceDeployFailure,
self.passthru.reboot_and_finish_deploy,
task)
@ -824,7 +824,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
self, install_bootloader_mock, try_set_boot_device_mock):
install_bootloader_mock.return_value = {
'command_status': 'SUCCESS', 'command_error': None}
try_set_boot_device_mock.side_effect = iter([RuntimeError('error')])
try_set_boot_device_mock.side_effect = RuntimeError('error')
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
@ -965,7 +965,7 @@ class TestBaseAgentVendor(db_base.DbTestCase):
@mock.patch.object(manager_utils, 'cleaning_error_handler', autospec=True)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
def test__cleaning_reboot_fail(self, mock_reboot, mock_handler):
mock_reboot.side_effect = iter([RuntimeError("broken")])
mock_reboot.side_effect = RuntimeError("broken")
with task_manager.acquire(self.context, self.node['uuid'],
shared=False) as task:

10
ironic/tests/unit/drivers/modules/test_console_utils.py
View File

@ -156,8 +156,7 @@ class ConsoleUtilsTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, '_get_console_pid', autospec=True)
def test__stop_console_nopid(self, mock_pid, mock_kill, mock_unlink):
pid_file = console_utils._get_console_pid_file(self.info['uuid'])
mock_pid.side_effect = iter(
[exception.NoConsolePid(pid_path="/tmp/blah")])
mock_pid.side_effect = exception.NoConsolePid(pid_path="/tmp/blah")
self.assertRaises(exception.NoConsolePid,
console_utils._stop_console,
@ -291,7 +290,7 @@ class ConsoleUtilsTestCase(db_base.DbTestCase):
mock_pid,
mock_popen):
# no existing PID file before starting
mock_stop.side_effect = iter([exception.NoConsolePid('/tmp/blah')])
mock_stop.side_effect = exception.NoConsolePid('/tmp/blah')
mock_popen.return_value.poll.return_value = 0
mock_pid.return_value = 12345
mock_pid_exists.return_value = True
@ -381,8 +380,7 @@ class ConsoleUtilsTestCase(db_base.DbTestCase):
def test_start_shellinabox_console_fail_nopiddir(self, mock_stop,
mock_dir_exists,
mock_popen):
mock_dir_exists.side_effect = iter(
[exception.ConsoleError(message='fail')])
mock_dir_exists.side_effect = exception.ConsoleError(message='fail')
mock_popen.return_value.poll.return_value = 0
self.assertRaises(exception.ConsoleError,
@ -404,7 +402,7 @@ class ConsoleUtilsTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, '_stop_console', autospec=True)
def test_stop_shellinabox_console_fail_nopid(self, mock_stop):
mock_stop.side_effect = iter([exception.NoConsolePid('/tmp/blah')])
mock_stop.side_effect = exception.NoConsolePid('/tmp/blah')
console_utils.stop_shellinabox_console(self.info['uuid'])

15
ironic/tests/unit/drivers/modules/test_deploy_utils.py
View File

@ -1334,7 +1334,7 @@ class OtherFunctionTestCase(db_base.DbTestCase):
mock_cache = mock.MagicMock(
spec_set=['master_dir'], master_dir='master_dir')
mock_clean_up_caches.side_effect = iter([exc])
mock_clean_up_caches.side_effect = [exc]
self.assertRaises(exception.InstanceDeployFailure,
utils.fetch_images,
None,
@ -1549,8 +1549,7 @@ class TrySetBootDeviceTestCase(db_base.DbTestCase):
self, node_set_boot_device_mock, log_mock):
self.node.properties = {'capabilities': 'boot_mode:uefi'}
self.node.save()
node_set_boot_device_mock.side_effect = iter(
[exception.IPMIFailure(cmd='a')])
node_set_boot_device_mock.side_effect = exception.IPMIFailure(cmd='a')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
utils.try_set_boot_device(task, boot_devices.DISK,
@ -1562,8 +1561,7 @@ class TrySetBootDeviceTestCase(db_base.DbTestCase):
@mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True)
def test_try_set_boot_device_ipmifailure_bios(
self, node_set_boot_device_mock):
node_set_boot_device_mock.side_effect = iter(
[exception.IPMIFailure(cmd='a')])
node_set_boot_device_mock.side_effect = exception.IPMIFailure(cmd='a')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
self.assertRaises(exception.IPMIFailure,
@ -1576,7 +1574,7 @@ class TrySetBootDeviceTestCase(db_base.DbTestCase):
def test_try_set_boot_device_some_other_exception(
self, node_set_boot_device_mock):
exc = exception.IloOperationError(operation="qwe", error="error")
node_set_boot_device_mock.side_effect = iter([exc])
node_set_boot_device_mock.side_effect = exc
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
self.assertRaises(exception.IloOperationError,
@ -1987,9 +1985,8 @@ class ValidateImagePropertiesTestCase(db_base.DbTestCase):
'ramdisk': 'file://initrd',
'root_gb': 100,
}
img_service_show_mock.side_effect = iter(
[exception.ImageRefValidationFailed(
image_href='http://ubuntu', reason='HTTPError')])
img_service_show_mock.side_effect = exception.ImageRefValidationFailed(
image_href='http://ubuntu', reason='HTTPError')
node = obj_utils.create_test_node(
self.context, driver='fake_pxe',
instance_info=instance_info,

2
ironic/tests/unit/drivers/modules/test_iboot.py
View File

@ -402,7 +402,7 @@ class IBootDriverTestCase(db_base.DbTestCase):
@mock.patch.object(iboot, '_parse_driver_info', autospec=True)
def test_validate_fails(self, parse_drv_info_mock):
side_effect = iter([exception.InvalidParameterValue("Bad input")])
side_effect = exception.InvalidParameterValue("Bad input")
parse_drv_info_mock.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

4
ironic/tests/unit/drivers/modules/test_inspector.py
View File

@ -229,8 +229,8 @@ class PeriodicTaskTestCase(BaseTestCase):
def test_node_locked(self, mock_check, mock_acquire):
iter_nodes_ret = [('1', 'd1'), ('2', 'd2')]
mock_acquire.side_effect = iter([exception.NodeLocked("boom")] *
len(iter_nodes_ret))
mock_acquire.side_effect = ([exception.NodeLocked("boom")] *
len(iter_nodes_ret))
mgr = mock.MagicMock(spec=['iter_nodes'])
mgr.iter_nodes.return_value = iter_nodes_ret
inspector.Inspector()._periodic_check_result(

6
ironic/tests/unit/drivers/modules/test_ipminative.py
View File

@ -510,8 +510,8 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'start_shellinabox_console',
autospec=True)
def test_start_console_fail(self, mock_exec):
mock_exec.side_effect = iter(
[exception.ConsoleSubprocessFailed(error='error')])
mock_exec.side_effect = exception.ConsoleSubprocessFailed(
error='error')
with task_manager.acquire(self.context,
self.node.uuid) as task:
@ -534,7 +534,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'stop_shellinabox_console',
autospec=True)
def test_stop_console_fail(self, mock_stop):
mock_stop.side_effect = iter([exception.ConsoleError()])
mock_stop.side_effect = exception.ConsoleError()
with task_manager.acquire(self.context,
self.node.uuid) as task:

78
ironic/tests/unit/drivers/modules/test_ipmitool.py
View File

@ -78,8 +78,7 @@ class IPMIToolCheckInitTestCase(base.TestCase):
def test_power_init_calls_raises_1(self, mock_check_dir, mock_support):
mock_support.return_value = True
ipmi.TMP_DIR_CHECKED = None
mock_check_dir.side_effect = iter(
[exception.PathNotFound(dir="foo_dir")])
mock_check_dir.side_effect = exception.PathNotFound(dir="foo_dir")
self.assertRaises(exception.PathNotFound, ipmi.IPMIPower)
@mock.patch.object(ipmi, '_is_option_supported', autospec=True)
@ -87,8 +86,8 @@ class IPMIToolCheckInitTestCase(base.TestCase):
def test_power_init_calls_raises_2(self, mock_check_dir, mock_support):
mock_support.return_value = True
ipmi.TMP_DIR_CHECKED = None
mock_check_dir.side_effect = iter(
[exception.DirectoryNotWritable(dir="foo_dir")])
mock_check_dir.side_effect = exception.DirectoryNotWritable(
dir="foo_dir")
self.assertRaises(exception.DirectoryNotWritable, ipmi.IPMIPower)
@mock.patch.object(ipmi, '_is_option_supported', autospec=True)
@ -96,8 +95,8 @@ class IPMIToolCheckInitTestCase(base.TestCase):
def test_power_init_calls_raises_3(self, mock_check_dir, mock_support):
mock_support.return_value = True
ipmi.TMP_DIR_CHECKED = None
mock_check_dir.side_effect = iter([exception.InsufficientDiskSpace(
path="foo_dir", required=1, actual=0)])
mock_check_dir.side_effect = exception.InsufficientDiskSpace(
path="foo_dir", required=1, actual=0)
self.assertRaises(exception.InsufficientDiskSpace, ipmi.IPMIPower)
@mock.patch.object(ipmi, '_is_option_supported', autospec=True)
@ -189,8 +188,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_timing_fail(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter(
[subprocess.CalledProcessError(1, 'ipmitool')])
mock_chkcall.side_effect = subprocess.CalledProcessError(1, 'ipmitool')
mock_support.return_value = None
expected = [mock.call('timing'),
mock.call('timing', False)]
@ -200,7 +198,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_timing_no_ipmitool(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter([OSError()])
mock_chkcall.side_effect = OSError()
mock_support.return_value = None
expected = [mock.call('timing')]
@ -219,8 +217,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_single_bridge_fail(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter(
[subprocess.CalledProcessError(1, 'ipmitool')])
mock_chkcall.side_effect = subprocess.CalledProcessError(1, 'ipmitool')
mock_support.return_value = None
expected = [mock.call('single_bridge'),
mock.call('single_bridge', False)]
@ -231,7 +228,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
def test_check_single_bridge_no_ipmitool(self, mock_chkcall,
mock_support):
mock_chkcall.side_effect = iter([OSError()])
mock_chkcall.side_effect = OSError()
mock_support.return_value = None
expected = [mock.call('single_bridge')]
@ -251,8 +248,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_dual_bridge_fail(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter(
[subprocess.CalledProcessError(1, 'ipmitool')])
mock_chkcall.side_effect = subprocess.CalledProcessError(1, 'ipmitool')
mock_support.return_value = None
expected = [mock.call('dual_bridge'),
mock.call('dual_bridge', False)]
@ -262,7 +258,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_dual_bridge_no_ipmitool(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter([OSError()])
mock_chkcall.side_effect = OSError()
mock_support.return_value = None
expected = [mock.call('dual_bridge')]
@ -286,8 +282,8 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
def test_check_all_options_fail(self, mock_chkcall, mock_support):
options = ['timing', 'single_bridge', 'dual_bridge']
mock_chkcall.side_effect = iter(
[subprocess.CalledProcessError(1, 'ipmitool')] * len(options))
mock_chkcall.side_effect = [subprocess.CalledProcessError(
1, 'ipmitool')] * len(options)
mock_support.return_value = None
expected = [
mock.call('timing'), mock.call('timing', False),
@ -301,7 +297,7 @@ class IPMIToolCheckOptionSupportedTestCase(base.TestCase):
self.assertEqual(expected, mock_support.call_args_list)
def test_check_all_options_no_ipmitool(self, mock_chkcall, mock_support):
mock_chkcall.side_effect = iter([OSError()])
mock_chkcall.side_effect = OSError()
mock_support.return_value = None
# exception is raised once ipmitool was not found for an command
expected = [mock.call('timing')]
@ -705,7 +701,7 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
expected = [mock.call('timing'),
mock.call('timing')]
mock_support.return_value = False
mock_exec.side_effect = iter([(None, None), (None, None)])
mock_exec.side_effect = [(None, None), (None, None)]
ipmi._exec_ipmitool(self.info, 'A B C')
mock_exec.assert_called_with(*args[0])
@ -742,7 +738,7 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
expected = [mock.call('timing'),
mock.call('timing')]
mock_support.return_value = False
mock_exec.side_effect = iter([(None, None), (None, None)])
mock_exec.side_effect = [(None, None), (None, None)]
ipmi._exec_ipmitool(self.info, 'A B C')
mock_exec.assert_called_with(*args[0])
@ -781,7 +777,7 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
expected = [mock.call('timing'),
mock.call('timing')]
mock_support.return_value = False
mock_exec.side_effect = iter([(None, None), (None, None)])
mock_exec.side_effect = [(None, None), (None, None)]
ipmi._exec_ipmitool(self.info, 'A B C')
mock_exec.assert_called_with(*args[0])
@ -1045,12 +1041,12 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
ipmi.LAST_CMD_TIME = {}
mock_support.return_value = False
mock_exec.side_effect = iter([
mock_exec.side_effect = [
processutils.ProcessExecutionError(
stderr="insufficient resources for session"
),
(None, None)
])
]
# Directly set the configuration values such that
# the logic will cause _exec_ipmitool to retry twice.
@ -1070,9 +1066,9 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
ipmi.LAST_CMD_TIME = {}
mock_support.return_value = False
mock_exec.side_effect = iter([processutils.ProcessExecutionError(
mock_exec.side_effect = [processutils.ProcessExecutionError(
stderr="insufficient resources for session"
)])
)]
# Directly set the configuration values such that
# the logic will cause _exec_ipmitool to timeout.
@ -1096,14 +1092,14 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
# Return a retryable error, then an error that cannot
# be retried thus resulting in a single retry
# attempt by _exec_ipmitool.
mock_exec.side_effect = iter([
mock_exec.side_effect = [
processutils.ProcessExecutionError(
stderr="insufficient resources for session"
),
processutils.ProcessExecutionError(
stderr="Unknown"
),
])
]
# Directly set the configuration values such that
# the logic will cause _exec_ipmitool to retry up
@ -1196,8 +1192,7 @@ class IPMIToolPrivateMethodTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
def test__power_status_exception(self, mock_exec, mock_sleep):
mock_exec.side_effect = iter(
[processutils.ProcessExecutionError("error")])
mock_exec.side_effect = processutils.ProcessExecutionError("error")
self.assertRaises(exception.IPMIFailure,
ipmi._power_status,
self.info)
@ -1281,8 +1276,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
def test_get_power_state_exception(self, mock_exec):
mock_exec.side_effect = iter(
[processutils.ProcessExecutionError("error")])
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,
@ -1371,8 +1365,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
def test_send_raw_bytes_fail(self, mock_exec):
mock_exec.side_effect = iter(
[exception.PasswordFileFailedToCreate('error')])
mock_exec.side_effect = exception.PasswordFileFailedToCreate('error')
with task_manager.acquire(self.context,
self.node['uuid']) as task:
@ -1404,7 +1397,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
def test__bmc_reset_fail(self, mock_exec):
mock_exec.side_effect = iter([processutils.ProcessExecutionError()])
mock_exec.side_effect = processutils.ProcessExecutionError()
with task_manager.acquire(self.context,
self.node['uuid']) as task:
@ -1452,7 +1445,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_parse_driver_info', autospec=True)
def test_vendor_passthru_validate__parse_driver_info_fail(self, info_mock):
info_mock.side_effect = iter([exception.InvalidParameterValue("bad")])
info_mock.side_effect = exception.InvalidParameterValue("bad")
with task_manager.acquire(self.context, self.node['uuid']) as task:
self.assertRaises(exception.InvalidParameterValue,
self.driver.vendor.validate,
@ -1577,8 +1570,8 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'start_shellinabox_console',
autospec=True)
def test_start_console_fail(self, mock_exec):
mock_exec.side_effect = iter(
[exception.ConsoleSubprocessFailed(error='error')])
mock_exec.side_effect = exception.ConsoleSubprocessFailed(
error='error')
with task_manager.acquire(self.context,
self.node['uuid']) as task:
@ -1589,7 +1582,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'start_shellinabox_console',
autospec=True)
def test_start_console_fail_nodir(self, mock_exec):
mock_exec.side_effect = iter([exception.ConsoleError()])
mock_exec.side_effect = exception.ConsoleError()
with task_manager.acquire(self.context,
self.node.uuid) as task:
@ -1632,7 +1625,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'stop_shellinabox_console',
autospec=True)
def test_stop_console_fail(self, mock_stop):
mock_stop.side_effect = iter([exception.ConsoleError()])
mock_stop.side_effect = exception.ConsoleError()
with task_manager.acquire(self.context,
self.node.uuid) as task:
@ -1712,7 +1705,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
def test_management_interface_set_boot_device_exec_failed(self, mock_exec):
mock_exec.side_effect = iter([processutils.ProcessExecutionError()])
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,
@ -1725,7 +1718,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
class FakeException(Exception):
pass
mock_exec.side_effect = iter([FakeException('boom')])
mock_exec.side_effect = FakeException('boom')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(FakeException,
self.driver.management.set_boot_device,
@ -1778,8 +1771,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
@mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
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 = iter(
[processutils.ProcessExecutionError()])
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")

4
ironic/tests/unit/drivers/modules/test_iscsi_deploy.py
View File

@ -165,8 +165,8 @@ class IscsiDeployMethodsTestCase(db_base.DbTestCase):
def test_continue_deploy_fail(self, deploy_mock, power_mock,
mock_image_cache, mock_disk_layout):
kwargs = {'address': '123456', 'iqn': 'aaa-bbb'}
deploy_mock.side_effect = iter([
exception.InstanceDeployFailure("test deploy error")])
deploy_mock.side_effect = exception.InstanceDeployFailure(
"test deploy error")
self.node.provision_state = states.DEPLOYWAIT
self.node.target_provision_state = states.ACTIVE
self.node.save()

4
ironic/tests/unit/drivers/modules/test_pxe.py
View File

@ -626,7 +626,7 @@ class PXEBootTestCase(db_base.DbTestCase):
@mock.patch.object(base_image_service.BaseImageService, '_show',
autospec=True)
def test_validate_fail_glance_image_doesnt_exists(self, mock_glance):
mock_glance.side_effect = iter([exception.ImageNotFound('not found')])
mock_glance.side_effect = exception.ImageNotFound('not found')
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertRaises(exception.InvalidParameterValue,
@ -638,7 +638,7 @@ class PXEBootTestCase(db_base.DbTestCase):
exceptions = (exception.GlanceConnectionFailed('connection fail'),
exception.ImageNotAuthorized('not authorized'),
exception.Invalid('invalid'))
mock_glance.side_effect = iter(exceptions)
mock_glance.side_effect = exceptions
for exc in exceptions:
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

12
ironic/tests/unit/drivers/modules/test_seamicro.py
View File

@ -331,7 +331,7 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
@mock.patch.object(seamicro, '_parse_driver_info', autospec=True)
def test_power_interface_validate_fails(self, parse_drv_info_mock):
side_effect = iter([exception.InvalidParameterValue("Bad input")])
side_effect = exception.InvalidParameterValue("Bad input")
parse_drv_info_mock.side_effect = side_effect
with task_manager.acquire(self.context, self.node['uuid'],
shared=True) as task:
@ -415,7 +415,7 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
@mock.patch.object(seamicro, '_parse_driver_info', autospec=True)
def test_vendor_passthru_validate_parse_driver_info_fail(self, mock_info):
mock_info.side_effect = iter([exception.InvalidParameterValue("bad")])
mock_info.side_effect = exception.InvalidParameterValue("bad")
with task_manager.acquire(self.context, self.node['uuid'],
shared=True) as task:
method = list(task.driver.vendor.vendor_routes)[0]
@ -630,8 +630,8 @@ class SeaMicroDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'start_shellinabox_console',
autospec=True)
def test_start_console_fail(self, mock_exec):
mock_exec.side_effect = iter(
[exception.ConsoleSubprocessFailed(error='error')])
mock_exec.side_effect = exception.ConsoleSubprocessFailed(
error='error')
with task_manager.acquire(self.context,
self.node.uuid) as task:
@ -652,7 +652,7 @@ class SeaMicroDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'stop_shellinabox_console',
autospec=True)
def test_stop_console_fail(self, mock_stop):
mock_stop.side_effect = iter([exception.ConsoleError()])
mock_stop.side_effect = exception.ConsoleError()
with task_manager.acquire(self.context,
self.node.uuid) as task:
@ -665,7 +665,7 @@ class SeaMicroDriverTestCase(db_base.DbTestCase):
@mock.patch.object(console_utils, 'start_shellinabox_console',
autospec=True)
def test_start_console_fail_nodir(self, mock_exec):
mock_exec.side_effect = iter([exception.ConsoleError()])
mock_exec.side_effect = exception.ConsoleError()
with task_manager.acquire(self.context,
self.node.uuid) as task:

50
ironic/tests/unit/drivers/modules/test_ssh.py
View File

@ -209,8 +209,7 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
@mock.patch.object(utils, 'ssh_connect', autospec=True)
def test__get_connection_exception(self, ssh_connect_mock):
ssh_connect_mock.side_effect = iter(
[exception.SSHConnectFailed(host='fake')])
ssh_connect_mock.side_effect = exception.SSHConnectFailed(host='fake')
self.assertRaises(exception.SSHConnectFailed,
ssh._get_connection,
self.node)
@ -325,8 +324,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'],
info['cmd_set']['get_node_macs'])
cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName')
exec_ssh_mock.side_effect = iter([('NodeName', ''),
('52:54:00:cf:2d:31', '')])
exec_ssh_mock.side_effect = [('NodeName', ''),
('52:54:00:cf:2d:31', '')]
expected = [mock.call(self.sshclient, ssh_cmd),
mock.call(self.sshclient, cmd_to_exec)]
@ -341,8 +340,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
self.config(group='ssh', get_vm_name_retry_interval=0)
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "22:22:22:22:22:22"]
exec_ssh_mock.side_effect = iter([('NodeName', ''),
('52:54:00:cf:2d:31', '')] * 2)
exec_ssh_mock.side_effect = ([('NodeName', ''),
('52:54:00:cf:2d:31', '')] * 2)
ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'],
info['cmd_set']['list_all'])
@ -364,10 +363,10 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
self.config(group='ssh', get_vm_name_retry_interval=0)
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "22:22:22:22:22:22"]
exec_ssh_mock.side_effect = iter([('NodeName', ''),
('', ''),
('NodeName', ''),
('11:11:11:11:11:11', '')])
exec_ssh_mock.side_effect = [('NodeName', ''),
('', ''),
('NodeName', ''),
('11:11:11:11:11:11', '')]
ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'],
info['cmd_set']['list_all'])
@ -395,8 +394,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
info['cmd_set']['get_node_macs'])
cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName')
exec_ssh_mock.side_effect = iter(
[('NodeName', ''), processutils.ProcessExecutionError])
exec_ssh_mock.side_effect = [('NodeName', ''),
processutils.ProcessExecutionError]
expected = [mock.call(self.sshclient, ssh_cmd),
mock.call(self.sshclient, cmd_to_exec)]
@ -414,8 +413,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
get_power_status_mock.side_effect = iter([states.POWER_OFF,
states.POWER_ON])
get_power_status_mock.side_effect = [states.POWER_OFF,
states.POWER_ON]
get_hosts_name_mock.return_value = "NodeName"
expected = [mock.call(self.sshclient, info),
mock.call(self.sshclient, info)]
@ -437,8 +436,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
exec_ssh_mock):
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
get_power_status_mock.side_effect = iter([states.POWER_OFF,
states.POWER_OFF])
get_power_status_mock.side_effect = ([states.POWER_OFF,
states.POWER_OFF])
get_hosts_name_mock.return_value = "NodeName"
expected = [mock.call(self.sshclient, info),
mock.call(self.sshclient, info)]
@ -462,8 +461,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
exec_ssh_mock.side_effect = processutils.ProcessExecutionError
get_power_status_mock.side_effect = iter([states.POWER_OFF,
states.POWER_ON])
get_power_status_mock.side_effect = ([states.POWER_OFF,
states.POWER_ON])
get_hosts_name_mock.return_value = "NodeName"
cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'],
@ -485,8 +484,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
get_power_status_mock, exec_ssh_mock):
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
get_power_status_mock.side_effect = iter([states.POWER_ON,
states.POWER_OFF])
get_power_status_mock.side_effect = [states.POWER_ON,
states.POWER_OFF]
get_hosts_name_mock.return_value = "NodeName"
expected = [mock.call(self.sshclient, info),
mock.call(self.sshclient, info)]
@ -508,8 +507,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
get_power_status_mock, exec_ssh_mock):
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
get_power_status_mock.side_effect = iter([states.POWER_ON,
states.POWER_ON])
get_power_status_mock.side_effect = [states.POWER_ON,
states.POWER_ON]
get_hosts_name_mock.return_value = "NodeName"
expected = [mock.call(self.sshclient, info),
mock.call(self.sshclient, info)]
@ -532,8 +531,8 @@ class SSHPrivateMethodsTestCase(db_base.DbTestCase):
info = ssh._parse_driver_info(self.node)
info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"]
exec_ssh_mock.side_effect = processutils.ProcessExecutionError
get_power_status_mock.side_effect = iter([states.POWER_ON,
states.POWER_OFF])
get_power_status_mock.side_effect = [states.POWER_ON,
states.POWER_OFF]
get_hosts_name_mock.return_value = "NodeName"
cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'],
@ -562,8 +561,7 @@ class SSHDriverTestCase(db_base.DbTestCase):
@mock.patch.object(utils, 'ssh_connect', autospec=True)
def test__validate_info_ssh_connect_failed(self, ssh_connect_mock):
ssh_connect_mock.side_effect = iter(
[exception.SSHConnectFailed(host='fake')])
ssh_connect_mock.side_effect = exception.SSHConnectFailed(host='fake')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,

2
ironic/tests/unit/drivers/modules/ucs/test_power.py
View File

@ -65,7 +65,7 @@ class UcsPowerTestCase(db_base.DbTestCase):
@mock.patch.object(ucs_helper, 'parse_driver_info',
spec_set=True, autospec=True)
def test_validate_fail(self, mock_parse_driver_info):
side_effect = iter([exception.InvalidParameterValue('Invalid Input')])
side_effect = exception.InvalidParameterValue('Invalid Input')
mock_parse_driver_info.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:

8
ironic/tests/unit/drivers/test_irmc.py
View File

@ -61,8 +61,8 @@ class IRMCVirtualMediaIscsiTestCase(testtools.TestCase):
@mock.patch.object(irmc.boot.IRMCVirtualMediaBoot, '__init__',
spec_set=True, autospec=True)
def test___init___share_fs_not_mounted_exception(self, __init___mock):
__init___mock.side_effect = iter(
[exception.IRMCSharedFileSystemNotMounted(share='/share')])
__init___mock.side_effect = exception.IRMCSharedFileSystemNotMounted(
share='/share')
self.assertRaises(exception.IRMCSharedFileSystemNotMounted,
irmc.IRMCVirtualMediaIscsiDriver)
@ -104,8 +104,8 @@ class IRMCVirtualMediaAgentTestCase(testtools.TestCase):
@mock.patch.object(irmc.boot.IRMCVirtualMediaBoot, '__init__',
spec_set=True, autospec=True)
def test___init___share_fs_not_mounted_exception(self, __init___mock):
__init___mock.side_effect = iter([
exception.IRMCSharedFileSystemNotMounted(share='/share')])
__init___mock.side_effect = exception.IRMCSharedFileSystemNotMounted(
share='/share')
self.assertRaises(exception.IRMCSharedFileSystemNotMounted,
irmc.IRMCVirtualMediaAgentDriver)

6
ironic/tests/unit/objects/test_node.py
View File

@ -127,8 +127,7 @@ class TestNodeObject(base.DbTestCase):
with mock.patch.object(self.dbapi, 'reserve_node',
autospec=True) as mock_reserve:
node_id = 'non-existent'
mock_reserve.side_effect = iter(
[exception.NodeNotFound(node=node_id)])
mock_reserve.side_effect = exception.NodeNotFound(node=node_id)
self.assertRaises(exception.NodeNotFound,
objects.Node.reserve, self.context, 'fake-tag',
node_id)
@ -145,8 +144,7 @@ class TestNodeObject(base.DbTestCase):
with mock.patch.object(self.dbapi, 'release_node',
autospec=True) as mock_release:
node_id = 'non-existent'
mock_release.side_effect = iter(
[exception.NodeNotFound(node=node_id)])
mock_release.side_effect = exception.NodeNotFound(node=node_id)
self.assertRaises(exception.NodeNotFound,
objects.Node.release, self.context,
'fake-tag', node_id)