def test_ibm_storage_block_device_api__destroy_volume_not_exist(self):
self.mock_client.list_volumes = MagicMock(return_value=[])
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
self.assertRaises(UnknownVolume, driver_obj.destroy_volume,
unicode(UUID(UUID1_STR)))
def test_ibm_storage_block_device_api__get_device_path(
self, ospathexist, multipathing_mock, check_output_mock):
multipathing_mock.return_value = True
ospathexist.return_value = True
check_output_mock.return_value = test_host_actions.MULTIPATH_OUTPUT2
blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode(test_host_actions.MULTIPATH_OUTPUT_WWN2),
size=int(GiB(16).to_Byte().value),
attached_to=u'fakehost',
dataset_id=UUID(UUID1_STR),
)
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
class VolInfoFake(object):
name = 'fake_volname'
driver_obj._get_volume_object = MagicMock(return_value=VolInfoFake())
driver_obj._get_blockdevicevolume_by_vol = MagicMock(
return_value=blockdevicevolume)
self.mock_client.backend_type = 'XIV'
self.mock_client.list_volumes = MagicMock(return_value=[FAKERList])
dpath = driver_obj.get_device_path(blockdevicevolume.blockdevice_id)
self.assertEqual(
dpath,
FilePath('{}/{}'.format(
PREFIX_DEVICE_PATH,
test_host_actions.WWN_PREFIX +
test_host_actions.MULTIPATH_OUTPUT_WWN2,
)))
def test_ibm_storage_block_device_api__get_blockdevicevolume_by_vol(
self, multipathing_mock):
multipathing_mock.return_value = True
vol_info = VolInfo('f_{}_{}'.format(UUID1_STR, UUID1_SLUG),
int(GiB(16).to_Byte().value),
1111,
UUID1_STR)
blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode(UUID1_STR),
size=int(GiB(16).to_Byte().value),
attached_to=u'fake_host',
dataset_id=UUID(UUID1_STR),
)
self.mock_client.get_vol_mapping = MagicMock(return_value='fake_host')
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID(FAKE_CLUSTER_ID), self.mock_client, DRIVER_BASIC_CONF)
driver_obj._is_cluster_volume = MagicMock(return_value=False)
with self.assertRaises(UnknownVolume):
driver_obj._get_blockdevicevolume_by_vol(vol_info)
driver_obj._is_cluster_volume = MagicMock(return_value=True)
self.assertEqual(blockdevicevolume,
driver_obj._get_blockdevicevolume_by_vol(vol_info))
def test_ibm_storage_block_device_api__create_volume(
self, multipathing_mock):
size = int(GiB(16).to_Byte().value)
multipathing_mock.return_value = True
mock_vol_obj = MagicMock
mock_vol_obj.id = 'vol-id-11111'
mock_vol_obj.size = size
mock_vol_obj.name = 'volfack'
mock_vol_obj.wwn = '11111111111'
self.mock_client.list_volumes = MagicMock(
return_value=[mock_vol_obj])
self.mock_client.create_volume = MagicMock
self.mock_client.handle_default_pool = MagicMock
self.mock_client.handle_default_profile = MagicMock(
return_value='fakepool')
self.mock_client.con_info = CONF_INFO_MOCK
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
bdv = driver_obj.create_volume(UUID(UUID1_STR), size)
expacted_blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode(mock_vol_obj.wwn),
size=size,
attached_to=None,
dataset_id=UUID(UUID1_STR),
)
self.assertEqual(bdv, expacted_blockdevicevolume)
def test_ibm_storage_block_device_api__is_cluster_volume(
self, check_output_mock):
check_output_mock.return_value = True
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
self.assertTrue(driver_obj._is_cluster_volume(VOL_NAME))
self.assertFalse(driver_obj._is_cluster_volume(
VOL_NAME_WITH_FAKE_CLUSTER_ID))
def test_init(self, check_output_mock):
check_output_mock.return_value = True
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
self.assertEqual(driver_obj._client, self.mock_client)
self.assertEqual(driver_obj._cluster_id, UUID1)
self.assertEqual(driver_obj._storage_resource,
DRIVER_BASIC_CONF[CONF_PARAM_DEFAULT_SERVICE])
self.assertEqual(driver_obj._instance_id, socket.gethostname())
self.assertEqual(driver_obj._cluster_id_slug, UUID1_SLUG)
self.assertEqual(driver_obj._is_multipathing, True)
conf = DRIVER_BASIC_CONF.copy()
conf[CONF_PARAM_HOSTNAME] = FAKE_HOSTNAME
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, conf)
self.assertEqual(driver_obj._instance_id, FAKE_HOSTNAME)
def test_ibm_storage_block_device_api___destroy_volume_exist(self):
self.mock_client.delete_volume = Mock()
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
expacted_blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode('999'),
size=10,
attached_to=None,
dataset_id=UUID(UUID1_STR),
)
driver_obj._get_volume = \
MagicMock(return_value=expacted_blockdevicevolume)
driver_obj.destroy_volume(unicode(UUID(UUID1_STR)))
def setUp(self):
self.mock_client = MagicMock()
self.mock_client.con_info = CONF_INFO_MOCK
self.mock_client.backend_type = messages.SCBE_STRING
self.mock_client.map_volume = MagicMock()
self.mock_client.unmap_volume = MagicMock()
self.driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
self.driver_obj._host_ops.rescan_scsi = MagicMock()
self.expacted_blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode('999'),
size=10,
attached_to=None,
dataset_id=UUID(UUID1_STR),
)
def test_ibm_storage_block_device_api__get_volume(
self, multipathing_mock):
multipathing_mock.return_value = True
fake_vol_list = [BDV1, BDV3]
self.mock_client.list_volumes = MagicMock(return_value=fake_vol_list)
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
driver_obj._get_blockdevicevolume_by_vol = MagicMock(return_value=BDV1)
self.assertTrue(driver_obj._get_volume(unicode(UUID1_STR)), BDV1)
driver_obj._get_blockdevicevolume_by_vol = MagicMock(return_value=BDV3)
self.assertTrue(driver_obj._get_volume(unicode(UUID3_STR)), BDV3)
self.mock_client.list_volumes = MagicMock(return_value=[])
self.assertRaises(UnknownVolume, driver_obj._get_volume,
unicode('fack-lockdevice-id'))
def test_ibm_storage_block_device_api__volume_exist(self,
multipathing_mock):
multipathing_mock.return_value = True
fake_vol_list = [BDV1, BDV3]
self.mock_client.list_volumes = MagicMock(return_value=fake_vol_list)
self.mock_client.con_info = CONF_INFO_MOCK
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
driver_obj._get_blockdevicevolume_by_vol = MagicMock(return_value=BDV1)
self.assertTrue(driver_obj._volume_exist(unicode(UUID1_STR)))
driver_obj._get_blockdevicevolume_by_vol = MagicMock(return_value=BDV1)
self.assertTrue(driver_obj._volume_exist(unicode(UUID3_STR)))
self.mock_client.list_volumes = MagicMock(return_value=[])
self.assertFalse(
driver_obj._volume_exist(unicode('fack-lockdevice-id')))
def setUp(self):
self.list_volumes_fake = [
VolInfo('f_{}_{}'.format(UUID1_STR, UUID1_SLUG),
WWN1_SIZE, '28d4e218f01647', WWN1),
VolInfo('f_{}_{}'.format(UUID3_STR, UUID1_SLUG),
WWN2_SIZE, '28d4e218f01647', WWN2),
# and one with different clusterid
VolInfo('f_{}_{}'.format(UUID3_STR, '666'),
WWN2_SIZE, '28d4e218f01647', WWN2),
]
self.get_vols_mapping_fake = {WWN1: HOST_ID, WWN2: HOST_ID}
self.get_hosts_fake = {HOST_ID: HOST, 99: 99, 98: 98}
self.expected_list_volumes = [
BlockDeviceVolume(
blockdevice_id=unicode(WWN1),
size=int(WWN1_SIZE),
attached_to=unicode(HOST),
dataset_id=UUID(UUID1_STR)
),
BlockDeviceVolume(
blockdevice_id=unicode(WWN2),
size=int(WWN2_SIZE),
attached_to=unicode(HOST),
dataset_id=UUID(UUID3_STR)
),
]
mock_client = MagicMock
mock_client.list_volumes = \
MagicMock(return_value=self.list_volumes_fake)
mock_client.get_vols_mapping = \
MagicMock(return_value=self.get_vols_mapping_fake)
mock_client.get_hosts = \
MagicMock(return_value=self.get_hosts_fake)
mock_client.backend_type = messages.SCBE_STRING
mock_client.con_info.debug_level = DEFAULT_DEBUG_LEVEL
mock_client.con_info.credential = dict(username='******')
with patch(IS_MULTIPATH_EXIST) as multipathing_mock:
multipathing_mock.return_value = True
self.driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, mock_client, DRIVER_BASIC_CONF)
def test_ibm_storage_block_device_api__get_device_path_not_found(
self, multipathing_mock, check_output_mock):
multipathing_mock.return_value = True
check_output_mock.return_value = test_host_actions.MULTIPATH_OUTPUT2
blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode(UUID1_STR),
size=int(GiB(16).to_Byte().value),
attached_to=u'fakehost',
dataset_id=UUID(UUID1_STR),
)
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
class VolInfoFake(object):
name = 'fake_volname'
driver_obj._get_volume_object = MagicMock(return_value=VolInfoFake())
driver_obj._get_blockdevicevolume_by_vol = MagicMock(
return_value=blockdevicevolume)
with self.assertRaises(UnattachedVolume):
driver_obj.get_device_path(blockdevicevolume.blockdevice_id)
def test_ibm_storage_block_device_api__get_device_path_not_attached_vol(
self, multipathing_mock):
multipathing_mock.return_value = True
blockdevicevolume = BlockDeviceVolume(
blockdevice_id=unicode(UUID1_STR),
size=int(GiB(16).to_Byte().value),
attached_to=None,
dataset_id=UUID(UUID1_STR),
)
self.mock_client.list_volumes = MagicMock(return_value=[FAKERList])
driver_obj = driver.IBMStorageBlockDeviceAPI(
UUID1, self.mock_client, DRIVER_BASIC_CONF)
class VolInfoFake(object):
name = 'fake_volname'
driver_obj._get_volume_object = MagicMock(return_value=VolInfoFake())
driver_obj._get_blockdevicevolume_by_vol = MagicMock(
return_value=blockdevicevolume)
with self.assertRaises(UnattachedVolume):
driver_obj.get_device_path(blockdevicevolume.blockdevice_id)
