def test__get_client(self, mock_client):
driver_info = seamicro._parse_driver_info(self.node)
args = {'username': driver_info['username'],
'password': driver_info['password'],
'auth_url': driver_info['api_endpoint']}
seamicro._get_client(**driver_info)
mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_node_vlan_id_no_input(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.vendor.set_node_vlan_id,
task, **{})
def test_set_boot_device_no_input(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.vendor.vendor_passthru, task,
**{'method': 'set_boot_device'})
def test_attach_volume_with_no_input_fail(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.vendor.vendor_passthru, task,
**{'method': 'attach_volume'})
def test__validate_fail(self, mock_get_volume):
info = seamicro._parse_driver_info(self.node)
volume_id = "0/p6-6/vol1"
volume = self.Volume()
volume.id = volume_id
mock_get_volume.return_value = volume
self.assertRaises(exception.InvalidParameterValue, seamicro._validate_volume, info, volume_id)
def test_set_boot_device_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "disk"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
task.driver.management.set_boot_device(task, boot_device)
mock_get_server.assert_called_once_with(info)
def test_set_boot_device_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "disk"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
task.driver.management.set_boot_device(task, boot_device)
mock_get_server.assert_called_once_with(info)
def test__create_volume_good(self, mock_get_client, mock_get_pools):
info = seamicro._parse_driver_info(self.node)
pools = [self.Pool(1), self.Pool(6), self.Pool(5)]
get_pools_patcher = mock.patch.object(mock_get_client, "volume.create")
get_pools_patcher.start()
mock_get_pools.return_value = pools
seamicro._create_volume(info, 2)
get_pools_patcher.stop()
def test_attach_volume_with_no_input_fail(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.vendor.
vendor_passthru, task, self.node,
**{'method': 'attach_volume'})
def test_set_boot_device_no_input(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.vendor.
vendor_passthru, task, self.node,
**{'method': 'set_boot_device'})
def test_set_boot_device_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "disk"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
kwargs = {"device": boot_device, "method": "set_boot_device"}
task.resources[0].driver.vendor.vendor_passthru(task, self.node, **kwargs)
mock_get_server.assert_called_once_with(info)
def test__validate_fail(self, mock_get_volume):
info = seamicro._parse_driver_info(self.node)
volume_id = "0/p6-6/vol1"
volume = self.Volume()
volume.id = volume_id
mock_get_volume.return_value = volume
self.assertRaises(exception.InvalidParameterValue,
seamicro._validate_volume, info, volume_id)
def test__create_volume_good(self, mock_get_client, mock_get_pools):
info = seamicro._parse_driver_info(self.node)
pools = [self.Pool(1), self.Pool(6), self.Pool(5)]
get_pools_patcher = mock.patch.object(mock_get_client, "volume.create")
get_pools_patcher.start()
mock_get_pools.return_value = pools
seamicro._create_volume(info, 2)
get_pools_patcher.stop()
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = obj_utils.get_test_node(self.context, driver="fake_seamicro", driver_info=INFO_DICT)
info = seamicro._parse_driver_info(node)
self.assertIsNotNone(info.get("api_endpoint"))
self.assertIsNotNone(info.get("username"))
self.assertIsNotNone(info.get("password"))
self.assertIsNotNone(info.get("server_id"))
self.assertIsNotNone(info.get("uuid"))
def test_attach_volume_with_volume_id_good(self, mock_validate_volume, mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = "0/ironic-p6-1/vol1"
mock_validate_volume.return_value = True
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
kwargs = {"volume_id": volume_id, "method": "attach_volume"}
task.resources[0].driver.vendor.vendor_passthru(task, self.node, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_set_power_state_off_good(self, mock_power_off):
info = seamicro._parse_driver_info(self.node)
mock_power_off.return_value = states.POWER_OFF
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
task.resources[0].driver.power.set_power_state(task, self.node, states.POWER_OFF)
mock_power_off.assert_called_once_with(self.node)
def test__get_client(self, mock_client):
driver_info = seamicro._parse_driver_info(self.node)
args = {
'username': driver_info['username'],
'password': driver_info['password'],
'auth_url': driver_info['api_endpoint']
}
seamicro._get_client(**driver_info)
mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_boot_device_invalid_device_fail(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "invalid_device"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.set_boot_device,
task, boot_device)
def test_set_boot_device_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "disk"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'device': boot_device, 'method': 'set_boot_device'}
task.driver.vendor.vendor_passthru(task, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_set_node_vlan_id_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
vlan_id = "12"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'}
task.driver.vendor.vendor_passthru(task, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_set_boot_device_invalid_device_fail(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "invalid_device"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.set_boot_device, task,
boot_device)
def test_reboot(self, mock_reboot):
info = seamicro._parse_driver_info(self.node)
mock_reboot.return_value = states.POWER_ON
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
task.resources[0].driver.power.reboot(task, self.node)
mock_reboot.assert_called_once_with(self.node)
def test_set_power_state_bad_state(self):
info = seamicro._parse_driver_info(self.node)
self.get_server_mock = self.get_server_patcher.start()
self.get_server_mock.return_value = self.Server()
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
self.assertRaises(
exception.IronicException, task.resources[0].driver.power.set_power_state, task, self.node, "BAD_PSTATE"
)
self.get_server_patcher.stop()
def test_set_power_state_on_good(self, mock_power_on):
info = seamicro._parse_driver_info(self.node)
mock_power_on.return_value = states.POWER_ON
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
task.driver.power.set_power_state(task, states.POWER_ON)
mock_power_on.assert_called_once_with(task.node)
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = db_utils.get_test_node(driver='fake_seamicro',
driver_info=INFO_DICT)
info = seamicro._parse_driver_info(node)
self.assertIsNotNone(info.get('api_endpoint'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('password'))
self.assertIsNotNone(info.get('server_id'))
self.assertIsNotNone(info.get('uuid'))
def test_set_boot_device_invalid_device_fail(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "invalid_device"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'device': boot_device, 'method': 'set_boot_device'}
self.assertRaises(exception.InvalidParameterValue,
task.driver.vendor.vendor_passthru, task,
**kwargs)
def test_attach_volume_with_no_input_fail(self):
info = seamicro._parse_driver_info(self.node)
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
self.assertRaises(
exception.InvalidParameterValue,
task.resources[0].driver.vendor.vendor_passthru,
task,
self.node,
**{"method": "attach_volume"}
)
def test__get_client_fail(self, mock_client):
driver_info = seamicro._parse_driver_info(self.node)
args = {'username': driver_info['username'],
'password': driver_info['password'],
'auth_url': driver_info['api_endpoint']}
mock_client.side_effect = seamicro_client_exception.UnsupportedVersion
self.assertRaises(exception.InvalidParameterValue,
seamicro._get_client,
**driver_info)
mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_set_node_vlan_id_good(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
vlan_id = "12"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'}
task.resources[0].driver.vendor.\
vendor_passthru(task, self.node, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_reboot(self, mock_reboot):
info = seamicro._parse_driver_info(self.node)
mock_reboot.return_value = states.POWER_ON
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
task.driver.power.reboot(task)
mock_reboot.assert_called_once_with(task.node)
def test_set_boot_device_invalid_device_fail(self, mock_get_server):
info = seamicro._parse_driver_info(self.node)
boot_device = "invalid_device"
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
kwargs = {'device': boot_device, 'method': 'set_boot_device'}
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.vendor.
vendor_passthru, task, self.node, **kwargs)
def test_set_power_state_off_good(self, mock_power_off):
info = seamicro._parse_driver_info(self.node)
mock_power_off.return_value = states.POWER_OFF
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
task.driver.power.set_power_state(task, states.POWER_OFF)
mock_power_off.assert_called_once_with(task.node)
def test_attach_volume_with_volume_id_good(self, mock_validate_volume,
mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = '0/ironic-p6-1/vol1'
mock_validate_volume.return_value = True
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'volume_id': volume_id, 'method': 'attach_volume'}
task.driver.vendor.vendor_passthru(task, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_set_power_state_bad_state(self):
info = seamicro._parse_driver_info(self.node)
self.get_server_mock = self.get_server_patcher.start()
self.get_server_mock.return_value = self.Server()
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.IronicException,
task.driver.power.set_power_state, task,
"BAD_PSTATE")
self.get_server_patcher.stop()
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = obj_utils.get_test_node(self.context,
driver='fake_seamicro',
driver_info=INFO_DICT)
info = seamicro._parse_driver_info(node)
self.assertEqual('http://1.2.3.4', info['api_endpoint'])
self.assertEqual('admin', info['username'])
self.assertEqual('fake', info['password'])
self.assertEqual('0/0', info['server_id'])
self.assertEqual('1be26c0b-03f2-4d2e-ae87-c02d7f33c123', info['uuid'])
def test__get_client_fail(self, mock_client):
driver_info = seamicro._parse_driver_info(self.node)
args = {
'username': driver_info['username'],
'password': driver_info['password'],
'auth_url': driver_info['api_endpoint']
}
mock_client.side_effect = seamicro_client_exception.UnsupportedVersion
self.assertRaises(exception.InvalidParameterValue,
seamicro._get_client, **driver_info)
mock_client.assert_called_once_with(driver_info['api_version'], **args)
def test_attach_volume_with_volume_id_good(self, mock_validate_volume,
mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = '0/ironic-p6-1/vol1'
mock_validate_volume.return_value = True
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'volume_id': volume_id, 'method': 'attach_volume'}
task.driver.vendor.vendor_passthru(task, **kwargs)
mock_get_server.assert_called_once_with(info)
def setUp(self):
super(SeaMicroPrivateMethodsTestCase, self).setUp()
n = {'driver': 'fake_seamicro', 'driver_info': INFO_DICT}
self.node = obj_utils.create_test_node(self.context, **n)
self.Server = Fake_Server
self.Volume = Fake_Volume
self.Pool = Fake_Pool
self.config(action_timeout=0, group='seamicro')
self.config(max_retry=2, group='seamicro')
self.info = seamicro._parse_driver_info(self.node)
def test_set_power_state_on_good(self, mock_power_on):
info = seamicro._parse_driver_info(self.node)
mock_power_on.return_value = states.POWER_ON
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
task.resources[0].driver.power.set_power_state(task,
self.node,
states.POWER_ON)
mock_power_on.assert_called_once_with(self.node)
def test_set_power_state_off_fail(self, mock_power_off):
info = seamicro._parse_driver_info(self.node)
mock_power_off.return_value = states.POWER_ON
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.PowerStateFailure,
task.driver.power.set_power_state,
task, states.POWER_OFF)
mock_power_off.assert_called_once_with(task.node)
def test_set_power_state_off_fail(self, mock_power_off):
info = seamicro._parse_driver_info(self.node)
mock_power_off.return_value = states.POWER_ON
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.PowerStateFailure,
task.driver.power.set_power_state, task,
states.POWER_OFF)
mock_power_off.assert_called_once_with(task.node)
def test_attach_volume_with_invalid_volume_id_fail(self, mock_get_volume,
mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = '0/p6-1/vol1'
mock_get_volume.return_value = self.Volume(volume_id)
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'volume_id': volume_id, 'method': 'attach_volume'}
self.assertRaises(exception.InvalidParameterValue,
task.driver.vendor.vendor_passthru, task,
**kwargs)
def setUp(self):
super(SeaMicroDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake_seamicro')
self.driver = driver_factory.get_driver('fake_seamicro')
self.node = obj_utils.create_test_node(self.context,
driver='fake_seamicro',
driver_info=INFO_DICT)
self.get_server_patcher = mock.patch.object(seamicro, '_get_server')
self.get_server_mock = None
self.Server = Fake_Server
self.Volume = Fake_Volume
self.info = seamicro._parse_driver_info(self.node)
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = obj_utils.get_test_node(
self.context,
driver='fake_seamicro',
driver_info=INFO_DICT)
info = seamicro._parse_driver_info(node)
self.assertEqual('http://1.2.3.4', info['api_endpoint'])
self.assertEqual('admin', info['username'])
self.assertEqual('fake', info['password'])
self.assertEqual('0/0', info['server_id'])
self.assertEqual('1be26c0b-03f2-4d2e-ae87-c02d7f33c123',
info['uuid'])
def test_attach_volume_with_invalid_volume_id_fail(self,
mock_get_volume,
mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = '0/p6-1/vol1'
mock_get_volume.return_value = self.Volume(volume_id)
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
kwargs = {'volume_id': volume_id, 'method': 'attach_volume'}
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.vendor.
vendor_passthru, task, **kwargs)
def setUp(self):
super(SeaMicroDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake_seamicro')
self.driver = driver_factory.get_driver('fake_seamicro')
self.node = obj_utils.create_test_node(self.context,
driver='fake_seamicro',
driver_info=INFO_DICT)
self.get_server_patcher = mock.patch.object(seamicro, '_get_server')
self.get_server_mock = None
self.Server = Fake_Server
self.Volume = Fake_Volume
self.info = seamicro._parse_driver_info(self.node)
def setUp(self):
super(SeaMicroPrivateMethodsTestCase, self).setUp()
n = {
'driver': 'fake_seamicro',
'driver_info': INFO_DICT
}
self.node = obj_utils.create_test_node(self.context, **n)
self.Server = Fake_Server
self.Volume = Fake_Volume
self.Pool = Fake_Pool
self.config(action_timeout=0, group='seamicro')
self.config(max_retry=2, group='seamicro')
self.info = seamicro._parse_driver_info(self.node)
def test_set_power_state_on_fail(self, mock_power_on):
info = seamicro._parse_driver_info(self.node)
mock_power_on.return_value = states.POWER_OFF
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
self.assertRaises(
exception.PowerStateFailure,
task.resources[0].driver.power.set_power_state,
task,
self.node,
states.POWER_ON,
)
mock_power_on.assert_called_once_with(self.node)
def test_attach_volume_with_volume_size_good(self, mock_create_volume,
mock_validate_volume,
mock_get_server):
info = seamicro._parse_driver_info(self.node)
volume_id = '0/ironic-p6-1/vol1'
volume_size = 2
mock_create_volume.return_value = volume_id
mock_validate_volume.return_value = True
mock_get_server.return_value = self.Server(active="true")
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
kwargs = {'volume_size': volume_size, 'method': "attach_volume"}
task.resources[0].driver.vendor.\
vendor_passthru(task, self.node, **kwargs)
mock_get_server.assert_called_once_with(info)
mock_create_volume.assert_called_once_with(info, volume_size)
def test_set_boot_device_fail(self, mock_get_server):
def fake_set_boot_order(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
boot_device = "pxe"
server = self.Server(active="true")
server.set_boot_order = fake_set_boot_order
mock_get_server.return_value = server
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.IronicException,
task.driver.management.set_boot_device,
task, boot_device)
mock_get_server.assert_called_once_with(info)
def test_set_boot_device_fail(self, mock_get_server):
def fake_set_boot_order(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
boot_device = "pxe"
server = self.Server(active="true")
server.set_boot_order = fake_set_boot_order
mock_get_server.return_value = server
with task_manager.acquire(self.context, [info["uuid"]], shared=False) as task:
kwargs = {"device": boot_device, "method": "set_boot_device"}
self.assertRaises(
exception.IronicException, task.resources[0].driver.vendor.vendor_passthru, task, self.node, **kwargs
)
mock_get_server.assert_called_once_with(info)
def test_set_boot_device_fail(self, mock_get_server):
def fake_set_boot_order(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
boot_device = "pxe"
server = self.Server(active="true")
server.set_boot_order = fake_set_boot_order
mock_get_server.return_value = server
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
self.assertRaises(exception.IronicException,
task.driver.management.set_boot_device, task,
boot_device)
mock_get_server.assert_called_once_with(info)
def test_set_boot_device_fail(self, mock_get_server):
def fake_set_boot_order(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
boot_device = "pxe"
server = self.Server(active="true")
server.set_boot_order = fake_set_boot_order
mock_get_server.return_value = server
with task_manager.acquire(self.context, [info['uuid']],
shared=False) as task:
kwargs = {'device': boot_device, 'method': 'set_boot_device'}
self.assertRaises(exception.IronicException,
task.resources[0].driver.vendor.
vendor_passthru, task, self.node, **kwargs)
mock_get_server.assert_called_once_with(info)
def test_set_node_vlan_id_fail(self, mock_get_server):
def fake_set_untagged_vlan(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
vlan_id = "12"
server = self.Server(active="true")
server.set_untagged_vlan = fake_set_untagged_vlan
mock_get_server.return_value = server
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'vlan_id': vlan_id, 'method': 'set_node_vlan_id'}
self.assertRaises(exception.IronicException,
task.driver.vendor.vendor_passthru, task,
**kwargs)
mock_get_server.assert_called_once_with(info)
def test_attach_volume_fail(self, mock_validate_volume, mock_get_server):
def fake_attach_volume(self, **kwargs):
raise seamicro_client_exception.ClientException(500)
info = seamicro._parse_driver_info(self.node)
volume_id = '0/p6-1/vol1'
mock_validate_volume.return_value = True
server = self.Server(active="true")
server.attach_volume = fake_attach_volume
mock_get_server.return_value = server
with task_manager.acquire(self.context, info['uuid'],
shared=False) as task:
kwargs = {'volume_id': volume_id, 'method': 'attach_volume'}
self.assertRaises(exception.IronicException,
task.driver.vendor.vendor_passthru, task,
**kwargs)
mock_get_server.assert_called_once_with(info)
def test__validate_good(self, mock_get_volume):
info = seamicro._parse_driver_info(self.node)
volume = self.Volume()
mock_get_volume.return_value = volume
valid = seamicro._validate_volume(info, volume.id)
self.assertEqual(valid, True)
def test__create_volume_fail(self, mock_get_pools):
info = seamicro._parse_driver_info(self.node)
mock_get_pools.return_value = None
self.assertRaises(exception.IronicException, seamicro._create_volume,
info, 2)
