def _test_update_migrated_volume(self, volume_status, rename_volume, rename_exception=False):
drv = nfs.NfsDriver(configuration=self.configuration)
fake_volume_id = "f51b5730-13b7-11e6-a238-fa163e67a298"
fake_new_volume_id = "12341234-13b7-11e6-a238-fa163e67a298"
fake_provider_source = "fake_provider_source"
fake_provider = "fake_provider"
base_dir = "/dir_base/"
volume_name_template = "volume-%s"
original_volume_name = volume_name_template % fake_volume_id
current_name = volume_name_template % fake_new_volume_id
original_volume_path = base_dir + original_volume_name
current_path = base_dir + current_name
volume = fake_volume.fake_volume_obj(
self.context, id=fake_volume_id, size=1, provider_location=fake_provider_source, _name_id=None
)
new_volume = fake_volume.fake_volume_obj(
self.context, id=fake_new_volume_id, size=1, provider_location=fake_provider, _name_id=None
)
with mock.patch.object(drv, "local_path") as local_path:
local_path.return_value = base_dir + current_name
if volume_status == "in-use":
update = drv.update_migrated_volume(self.context, volume, new_volume, volume_status)
self.assertEqual({"_name_id": fake_new_volume_id, "provider_location": fake_provider}, update)
elif rename_exception:
rename_volume.side_effect = OSError
update = drv.update_migrated_volume(self.context, volume, new_volume, volume_status)
rename_volume.assert_called_once_with(current_path, original_volume_path)
self.assertEqual({"_name_id": fake_new_volume_id, "provider_location": fake_provider}, update)
else:
update = drv.update_migrated_volume(self.context, volume, new_volume, volume_status)
rename_volume.assert_called_once_with(current_path, original_volume_path)
self.assertEqual({"_name_id": None, "provider_location": fake_provider}, update)
def test_do_clone_volume_success(self, m_exists, m_get_local_volume_path):
"""test _do_clone_volume() when filesnap over nfs is supported"""
drv = self.driver
volume = fake_volume.fake_volume_obj(self.context,
provider_location=self._loc)
snapshot = fake_volume.fake_volume_obj(self.context)
with mock.patch('cinder.privsep.path.symlink'):
m_exists.return_value = True
drv._do_clone_volume(volume, volume.name, snapshot)
def setUp(self):
"""Set up the test case environment.
Defines the mock HTTPS responses for the REST API calls.
"""
super(TestMisc, self).setUp()
self.domain_name_enc = urllib.parse.quote(self.DOMAIN_NAME)
self.pool_name_enc = urllib.parse.quote(self.POOL_NAME)
self.ctx = context.RequestContext('fake', 'fake', auth_token=True)
self.volume = fake_volume.fake_volume_obj(
self.ctx, **{'name': 'vol1', 'provider_id': fake.PROVIDER_ID}
)
self.new_volume = fake_volume.fake_volume_obj(
self.ctx, **{'name': 'vol2', 'provider_id': fake.PROVIDER2_ID}
)
self.HTTPS_MOCK_RESPONSES = {
self.RESPONSE_MODE.Valid: {
'types/Domain/instances/getByName::' +
self.domain_name_enc: '"{}"'.format(self.DOMAIN_NAME).encode(
'ascii',
'ignore'
),
'types/Pool/instances/getByName::{},{}'.format(
self.DOMAIN_NAME,
self.POOL_NAME
): '"{}"'.format(self.POOL_NAME).encode('ascii', 'ignore'),
'types/StoragePool/instances/action/querySelectedStatistics': {
'"{}"'.format(self.POOL_NAME): {
'capacityInUseInKb': 502,
'capacityLimitInKb': 1024,
},
},
'instances/Volume::{}/action/setVolumeName'.format(
self.volume['provider_id']):
self.new_volume['provider_id'],
'instances/Volume::{}/action/setVolumeName'.format(
self.new_volume['provider_id']):
self.volume['provider_id'],
},
self.RESPONSE_MODE.BadStatus: {
'types/Domain/instances/getByName::' +
self.domain_name_enc: self.BAD_STATUS_RESPONSE,
},
self.RESPONSE_MODE.Invalid: {
'types/Domain/instances/getByName::' +
self.domain_name_enc: None,
'instances/Volume::{}/action/setVolumeName'.format(
self.volume['provider_id']): mocks.MockHTTPSResponse(
{
'message': 'Invalid volume.',
'httpStatusCode': 400,
'errorCode': 0
}, 400),
},
}
def test_do_clone_volume_fail(self, m_exists, m_get_local_volume_path):
"""test _do_clone_volume() when filesnap over nfs is supported"""
drv = self.driver
volume = fake_volume.fake_volume_obj(self.context)
snapshot = fake_volume.fake_volume_obj(self.context)
with mock.patch.object(drv, '_execute'):
m_exists.return_value = False
self.assertRaises(exception.NfsException, drv._do_clone_volume,
volume, volume.name, snapshot)
def setUp(self):
"""Setup a test case environment.
Creates fake volume objects and sets up the required API responses.
"""
super(TestCreateClonedVolume, self).setUp()
ctx = context.RequestContext('fake', 'fake', auth_token=True)
self.src_volume = fake_volume.fake_volume_obj(
ctx, **{'provider_id': fake.PROVIDER_ID})
self.src_volume_name_2x_enc = urllib.parse.quote(
urllib.parse.quote(
self.driver._id_to_base64(self.src_volume.id)
)
)
self.new_volume_extras = {
'volumeIdList': ['cloned'],
'snapshotGroupId': 'cloned_snapshot'
}
self.new_volume = fake_volume.fake_volume_obj(
ctx, **self.new_volume_extras
)
self.new_volume_name_2x_enc = urllib.parse.quote(
urllib.parse.quote(
self.driver._id_to_base64(self.new_volume.id)
)
)
self.HTTPS_MOCK_RESPONSES = {
self.RESPONSE_MODE.Valid: {
'types/Volume/instances/getByName::' +
self.src_volume_name_2x_enc: self.src_volume.id,
'instances/System/action/snapshotVolumes': '{}'.format(
json.dumps(self.new_volume_extras)),
},
self.RESPONSE_MODE.BadStatus: {
'instances/System/action/snapshotVolumes':
self.BAD_STATUS_RESPONSE,
'types/Volume/instances/getByName::' +
self.src_volume['provider_id']: self.BAD_STATUS_RESPONSE,
},
self.RESPONSE_MODE.Invalid: {
'types/Volume/instances/getByName::' +
self.src_volume_name_2x_enc: None,
'instances/System/action/snapshotVolumes':
mocks.MockHTTPSResponse(
{
'errorCode': 400,
'message': 'Invalid Volume Snapshot Test'
}, 400
),
},
}
def setUp(self):
super(DSwareDriverTestCase, self).setUp()
self.driver = FakeDSWAREDriver()
self.context = context.get_admin_context()
self.volume = fake_volume.fake_volume_obj(context=self.context,
**test_volume)
self.scr_volume = fake_volume.fake_volume_obj(context=self.context,
**test_src_volume)
self.snapshot = fake_snapshot.fake_snapshot_obj(context=self.context,
**test_snapshot)
def setUp(self):
super(HNASNFSDriverTest, self).setUp()
self.context = context.get_admin_context()
self.volume = fake_volume.fake_volume_obj(self.context, **_VOLUME)
self.snapshot = self.instantiate_snapshot(_SNAPSHOT)
self.volume_type = fake_volume.fake_volume_type_obj(None, **{"name": "silver"})
self.clone = fake_volume.fake_volume_obj(
None,
**{
"id": fake.VOLUME2_ID,
"size": 128,
"host": "host1@hnas-nfs-backend#default",
"volume_type": "default",
"provider_location": "hnas",
}
)
# xml parsed from utils
self.parsed_xml = {
"username": "******",
"password": "******",
"hnas_cmd": "ssc",
"ssh_port": "22",
"services": {
"default": {
"hdp": "172.24.49.21:/fs-cinder",
"volume_type": "default",
"label": "svc_0",
"ctl": "1",
"export": {"fs": "fs-cinder", "path": "/export-cinder/volume"},
}
},
"cluster_admin_ip0": None,
"ssh_private_key": None,
"chap_enabled": "True",
"mgmt_ip0": "172.17.44.15",
"ssh_enabled": None,
}
self.configuration = mock.Mock(spec=conf.Configuration)
self.configuration.hds_hnas_nfs_config_file = "fake.xml"
self.mock_object(hnas_utils, "read_cinder_conf", mock.Mock(return_value=self.parsed_xml))
self.configuration = mock.Mock(spec=conf.Configuration)
self.configuration.max_over_subscription_ratio = 20.0
self.configuration.reserved_percentage = 0
self.configuration.hds_hnas_nfs_config_file = "fake_config.xml"
self.configuration.nfs_shares_config = "fake_nfs_share.xml"
self.configuration.num_shell_tries = 2
self.driver = nfs.HNASNFSDriver(configuration=self.configuration)
def test_create_volume_from_snapshot(self, m_do_clone_volume):
"""test create volume from snapshot"""
drv = self.driver
volume = fake_volume.fake_volume_obj(self.context)
snapshot = fake_volume.fake_volume_obj(self.context,
provider_location=self._loc)
volume.size = 10
snapshot.volume_size = 10
m_do_clone_volume(snapshot, snapshot.name,
volume).return_value = True
drv.create_volume_from_snapshot(volume, snapshot)
self.assertEqual(volume.provider_location, snapshot.provider_location)
def test_create_volume_from_snapshot_greater_size(self, m_local_path,
m_do_clone_volume):
"""test create volume from snapshot with greater volume size"""
drv = self.driver
volume = fake_volume.fake_volume_obj(self.context)
snapshot = fake_volume.fake_volume_obj(self.context,
provider_location=self._loc)
volume.size = 20
snapshot.volume_size = 10
m_do_clone_volume(snapshot, snapshot.name,
volume).return_value = True
m_local_path(volume).AndReturn(self.TEST_VOL_LOCAL_PATH)
with mock.patch.object(drv, '_execute'):
drv.create_volume_from_snapshot(volume, snapshot)
self.assertEqual(volume.provider_location, snapshot.provider_location)
def instantiate_snapshot(snap):
snap = snap.copy()
snap['volume'] = fake_volume.fake_volume_obj(
None, **snap['volume'])
snapshot = fake_snapshot.fake_snapshot_obj(
None, expected_attrs=['volume'], **snap)
return snapshot
def test_manage_existing_not_found(self):
volume = fake_volume.fake_volume_obj(self.context)
existing = {'source-name': self._provider_location + '/' +
volume.name}
with mock.patch('os.path.isfile', return_value=False):
self.assertRaises(exception.ManageExistingInvalidReference,
self._driver.manage_existing, volume, existing)
def test_get_volume_format_spec(self,
volume_meta_contains_fmt,
volume_type_contains_fmt):
self._smbfs_driver.configuration = copy.copy(self._FAKE_SMBFS_CONFIG)
fake_vol_meta_fmt = 'vhd'
fake_vol_type_fmt = 'vhdx'
volume_metadata = {}
volume_type_extra_specs = {}
if volume_meta_contains_fmt:
volume_metadata['volume_format'] = fake_vol_meta_fmt
elif volume_type_contains_fmt:
volume_type_extra_specs['volume_format'] = fake_vol_type_fmt
volume_type = fake_volume.fake_volume_type_obj(self.context)
volume = fake_volume.fake_volume_obj(self.context)
# Optional arguments are not set in _from_db_object,
# so have to set explicitly here
volume.volume_type = volume_type
volume.metadata = volume_metadata
# Same for extra_specs and VolumeType
volume_type.extra_specs = volume_type_extra_specs
resulted_fmt = self._smbfs_driver._get_volume_format_spec(volume)
if volume_meta_contains_fmt:
expected_fmt = fake_vol_meta_fmt
elif volume_type_contains_fmt:
expected_fmt = fake_vol_type_fmt
else:
expected_fmt = self._FAKE_SMBFS_CONFIG.smbfs_default_volume_format
self.assertEqual(expected_fmt, resulted_fmt)
def setUp(self):
super(VZStorageTestCase, self).setUp()
self._remotefsclient = mock.patch.object(remotefs,
'RemoteFsClient').start()
get_mount_point = mock.Mock(return_value=self._FAKE_MNT_POINT)
self._remotefsclient.get_mount_point = get_mount_point
cfg = copy.copy(self._FAKE_VZ_CONFIG)
self._vz_driver = vzstorage.VZStorageDriver(configuration=cfg)
self._vz_driver._local_volume_dir = mock.Mock(
return_value=self._FAKE_MNT_POINT)
self._vz_driver._execute = mock.Mock()
self._vz_driver.base = self._FAKE_MNT_BASE
self.context = context.get_admin_context()
vol_type = fake_volume.fake_volume_type_obj(self.context)
vol_type.extra_specs = {}
_FAKE_VOLUME = {'id': '4f711859-4928-4cb7-801a-a50c37ceaccc',
'size': 1,
'provider_location': self._FAKE_SHARE,
'name': self._FAKE_VOLUME_NAME,
'status': 'available'}
self.vol = fake_volume.fake_volume_obj(self.context,
volume_type_id=vol_type.id,
**_FAKE_VOLUME)
self.vol.volume_type = vol_type
_FAKE_SNAPSHOT = {'id': self._FAKE_SNAPSHOT_ID,
'status': 'available',
'volume_size': 1}
self.snap = fake_snapshot.fake_snapshot_obj(self.context,
**_FAKE_SNAPSHOT)
self.snap.volume = self.vol
def setUp(self):
"""Setup a test case environment.
Creates fake volume object and sets up the required API responses.
"""
super(TestExtendVolume, self).setUp()
ctx = context.RequestContext("fake", "fake", auth_token=True)
self.volume = fake_volume_obj(ctx, **{"id": fake.VOLUME_ID, "provider_id": fake.PROVIDER_ID})
self.volume_name_2x_enc = urllib.parse.quote(urllib.parse.quote(self.driver._id_to_base64(self.volume.id)))
self.HTTPS_MOCK_RESPONSES = {
self.RESPONSE_MODE.Valid: {
"types/Volume/instances/getByName::" + self.volume_name_2x_enc: '"{}"'.format(self.volume.id),
"instances/Volume::{}/action/setVolumeSize".format(self.volume.provider_id): mocks.MockHTTPSResponse(
{}, 200
),
},
self.RESPONSE_MODE.BadStatus: {
"types/Volume/instances/getByName::" + self.volume_name_2x_enc: self.BAD_STATUS_RESPONSE,
"types/Volume/instances/getByName::" + self.volume_name_2x_enc: self.BAD_STATUS_RESPONSE,
"instances/Volume::{}/action/setVolumeSize".format(self.volume.provider_id): self.BAD_STATUS_RESPONSE,
},
self.RESPONSE_MODE.Invalid: {
"types/Volume/instances/getByName::" + self.volume_name_2x_enc: None,
"instances/Volume::{}/action/setVolumeSize".format(self.volume.provider_id): mocks.MockHTTPSResponse(
{"errorCode": self.OLD_VOLUME_NOT_FOUND_ERROR, "message": "BadStatus Volume Test"}, 400
),
},
}
def test_snapshot_update(self, snapshot_get_by_id, volume_get_by_id,
snapshot_metadata_get, update_snapshot):
snapshot = {
'id': UUID,
'volume_id': fake.volume_id,
'status': 'available',
'volume_size': 100,
'display_name': 'Default name',
'display_description': 'Default description',
'expected_attrs': ['metadata'],
}
ctx = context.RequestContext(fake.user_id, fake.project_id, True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
fake_volume_obj = fake_volume.fake_volume_obj(ctx)
snapshot_get_by_id.return_value = snapshot_obj
volume_get_by_id.return_value = fake_volume_obj
updates = {"display_name": "Updated Test Name", }
body = {"snapshot": updates}
req = fakes.HTTPRequest.blank('/v1/snapshots/%s' % UUID)
res_dict = self.controller.update(req, UUID, body)
expected = {'snapshot': {
'id': UUID,
'volume_id': fake.volume_id,
'status': u'available',
'size': 100,
'created_at': None,
'display_name': u'Updated Test Name',
'display_description': u'Default description',
'metadata': {},
}}
self.assertEqual(expected, res_dict)
def _simple_volume(self, **kwargs):
updates = {'id': self._FAKE_VOLUME_ID,
'size': self._FAKE_VOLUME_SIZE,
'provider_location': self._FAKE_SHARE}
updates.update(kwargs)
ctxt = context.get_admin_context()
return fake_volume.fake_volume_obj(ctxt, **updates)
def fake_volume_get(*args, **kwargs):
ctx = context.RequestContext('non-admin', 'fake', False)
vol = {
'id': 'fake',
'project_id': PROJECT_ID,
}
return fake_volume.fake_volume_obj(ctx, **vol)
def test_cg_from_src_snapshot(self, get_all_for_cgsnapshot, req):
req.side_effect = xms_request
d = self.data
snapshot_obj = fake_snapshot.fake_snapshot_obj(d.context)
snapshot_obj.consistencygroup_id = d.group['id']
snapshot_obj.volume_id = d.test_volume['id']
get_all_for_cgsnapshot.return_value = [snapshot_obj]
self.driver.create_consistencygroup(d.context, d.group)
self.driver.create_volume(d.test_volume)
self.driver.create_cgsnapshot(d.context, d.cgsnapshot, [])
xms_data['volumes'][2]['ancestor-vol-id'] = (xms_data['volumes'][1]
['vol-id'])
snapset_name = self.driver._get_cgsnap_name(d.cgsnapshot)
snapset1 = {'vol-list': [xms_data['volumes'][2]['vol-id']],
'name': snapset_name,
'index': 1}
xms_data['snapshot-sets'] = {snapset_name: snapset1, 1: snapset1}
cg_obj = fake_cg.fake_consistencyobject_obj(d.context)
new_vol1 = fake_volume.fake_volume_obj(d.context)
snapshot1 = (fake_snapshot
.fake_snapshot_obj
(d.context, volume_id=d.test_volume['id']))
self.driver.create_consistencygroup_from_src(d.context, cg_obj,
[new_vol1],
d.cgsnapshot, [snapshot1])
def test_manage_existing_move_failure(self):
volume = fake_volume.fake_volume_obj(self.context)
existing = {'source-name': self._provider_location + '/source-volume'}
with mock.patch('os.path.isfile', return_value=True):
self.assertRaises(exception.VolumeDriverException,
self._driver.manage_existing,
volume, existing)
def test_create_volume_exception_puts_volume_in_error_state(
self, _mock_volume_update, _mock_message_create,
_mock_sched_create):
# Test NoValidHost exception behavior for create_volume.
# Puts the volume in 'error' state and eats the exception.
_mock_sched_create.side_effect = exception.NoValidHost(reason="")
volume = fake_volume.fake_volume_obj(self.context)
topic = 'fake_topic'
request_spec = {'volume_id': volume.id,
'volume': {'id': volume.id, '_name_id': None,
'metadata': {}, 'admin_metadata': {},
'glance_metadata': {}}}
request_spec_obj = objects.RequestSpec.from_primitives(request_spec)
self.manager.create_volume(self.context, topic, volume.id,
request_spec=request_spec,
filter_properties={},
volume=volume)
_mock_volume_update.assert_called_once_with(self.context,
volume.id,
{'status': 'error'})
_mock_sched_create.assert_called_once_with(self.context,
request_spec_obj, {})
_mock_message_create.assert_called_once_with(
self.context, defined_messages.UNABLE_TO_ALLOCATE,
self.context.project_id, resource_type='VOLUME',
resource_uuid=volume.id)
def test_snapshot_detail(self, get_all_snapshots, snapshot_get_by_id, volume_get_by_id, snapshot_metadata_get):
snapshot = {
"id": UUID,
"volume_id": 1,
"status": "available",
"volume_size": 100,
"display_name": "Default name",
"display_description": "Default description",
"expected_attrs": ["metadata"],
}
ctx = context.RequestContext("admin", "fake", True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
fake_volume_obj = fake_volume.fake_volume_obj(ctx)
snapshot_get_by_id.return_value = snapshot_obj
volume_get_by_id.return_value = fake_volume_obj
snapshots = objects.SnapshotList(objects=[snapshot_obj])
get_all_snapshots.return_value = snapshots
req = fakes.HTTPRequest.blank("/v2/snapshots/detail")
resp_dict = self.controller.detail(req)
self.assertIn("snapshots", resp_dict)
resp_snapshots = resp_dict["snapshots"]
self.assertEqual(1, len(resp_snapshots))
resp_snapshot = resp_snapshots.pop()
self.assertEqual(UUID, resp_snapshot["id"])
def fake_volume_get(*args, **kwargs):
ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, False)
vol = {
'id': fake.VOLUME_ID,
'project_id': PROJECT_ID,
}
return fake_volume.fake_volume_obj(ctx, **vol)
def test_create_volume_exception_puts_volume_in_error_state(
self, _mock_volume_update, _mock_message_create,
_mock_sched_create):
# Test NoValidBackend exception behavior for create_volume.
# Puts the volume in 'error' state and eats the exception.
_mock_sched_create.side_effect = exception.NoValidBackend(reason="")
volume = fake_volume.fake_volume_obj(self.context)
request_spec = {'volume_id': volume.id,
'volume': {'id': volume.id, '_name_id': None,
'metadata': {}, 'admin_metadata': {},
'glance_metadata': {}}}
request_spec_obj = objects.RequestSpec.from_primitives(request_spec)
self.manager.create_volume(self.context, volume,
request_spec=request_spec_obj,
filter_properties={})
_mock_volume_update.assert_called_once_with(self.context,
volume.id,
{'status': 'error'})
_mock_sched_create.assert_called_once_with(self.context,
request_spec_obj, {})
_mock_message_create.assert_called_once_with(
self.context, message_field.Action.SCHEDULE_ALLOCATE_VOLUME,
resource_uuid=volume.id,
exception=mock.ANY)
def test_get_all_for_volume(self, get_all_by_host):
fake_volume_obj = fake_volume.fake_volume_obj(self.context)
backups = objects.BackupList.get_all_by_host(self.context,
fake_volume_obj.id)
self.assertEqual(1, len(backups))
TestBackup._compare(self, fake_backup, backups[0])
def test_snapshot_detail(self, get_all_snapshots, snapshot_get_by_id,
volume_get_by_id, snapshot_metadata_get):
snapshot = {
'id': UUID,
'volume_id': fake.volume_id,
'status': 'available',
'volume_size': 100,
'display_name': 'Default name',
'display_description': 'Default description',
'expected_attrs': ['metadata']
}
ctx = context.RequestContext(fake.project_id, fake.user_id, True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
fake_volume_obj = fake_volume.fake_volume_obj(ctx)
snapshot_get_by_id.return_value = snapshot_obj
volume_get_by_id.return_value = fake_volume_obj
snapshots = objects.SnapshotList(objects=[snapshot_obj])
get_all_snapshots.return_value = snapshots
req = fakes.HTTPRequest.blank('/v2/snapshots/detail')
resp_dict = self.controller.detail(req)
self.assertIn('snapshots', resp_dict)
resp_snapshots = resp_dict['snapshots']
self.assertEqual(1, len(resp_snapshots))
self.assertIn('updated_at', resp_snapshots[0])
resp_snapshot = resp_snapshots.pop()
self.assertEqual(UUID, resp_snapshot['id'])
def test_extend_volume_no_valid_host(self, status, mock_create,
mock_rollback,
mock_extend, mock_consume,
mock_backend_passes):
volume = fake_volume.fake_volume_obj(self.context,
**{'size': 1,
'previous_status': status})
no_valid_backend = exception.NoValidBackend(reason='')
mock_backend_passes.side_effect = [no_valid_backend]
with mock.patch.object(self.manager,
'_set_volume_state_and_notify') as mock_notify:
self.manager.extend_volume(self.context, volume, 2,
'fake_reservation')
mock_notify.assert_called_once_with(
'extend_volume', {'volume_state': {'status': status,
'previous_status': None}},
self.context, no_valid_backend, None)
mock_rollback.assert_called_once_with(
self.context, 'fake_reservation', project_id=volume.project_id)
mock_consume.assert_not_called()
mock_extend.assert_not_called()
mock_create.assert_called_once_with(
self.context,
message_field.Action.EXTEND_VOLUME,
resource_uuid=volume.id,
exception=no_valid_backend)
def test_snapshot_show(self, max_ver, snapshot_get_by_id, volume_get_by_id,
snapshot_metadata_get):
snapshot = {
'id': UUID,
'volume_id': fake.VOLUME_ID,
'status': fields.SnapshotStatus.AVAILABLE,
'volume_size': 100,
'display_name': 'Default name',
'display_description': 'Default description',
'expected_attrs': ['metadata'],
'group_snapshot_id': None,
}
ctx = context.RequestContext(fake.PROJECT_ID, fake.USER_ID, True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
fake_volume_obj = fake_volume.fake_volume_obj(ctx)
snapshot_get_by_id.return_value = snapshot_obj
volume_get_by_id.return_value = fake_volume_obj
req = fakes.HTTPRequest.blank('/v3/snapshots/%s' % UUID)
req.api_version_request = api_version.APIVersionRequest(max_ver)
resp_dict = self.controller.show(req, UUID)
self.assertIn('snapshot', resp_dict)
self.assertEqual(UUID, resp_dict['snapshot']['id'])
self.assertIn('updated_at', resp_dict['snapshot'])
if max_ver == '3.14':
self.assertIn('group_snapshot_id', resp_dict['snapshot'])
elif max_ver == '3.13':
self.assertNotIn('group_snapshot_id', resp_dict['snapshot'])
def test_manage_existing(self):
volume = fake_volume.fake_volume_obj(self.context)
existing = {'source-name': self._provider_location + '/' +
volume.name}
with mock.patch('os.path.isfile', return_value=True):
self.assertEqual({'provider_location': self._provider_location},
self._driver.manage_existing(volume, existing))
def test_clone_image_failure(self):
volume = fake_volume.fake_volume_obj(self.context)
self.assertEqual(({'provider_location': None,
'bootable': False}, False),
self._driver.clone_image(
None, volume, 'image-name', FakeImage().__dict__,
None))
def setUp(self):
super(VolumeActionsTest, self).setUp()
self.context = context.RequestContext('fake', 'fake', is_admin=False)
self.UUID = uuid.uuid4()
self.controller = volume_actions.VolumeActionsController()
self.api_patchers = {}
for _meth in self._methods:
self.api_patchers[_meth] = mock.patch('cinder.volume.API.' + _meth)
self.api_patchers[_meth].start()
self.addCleanup(self.api_patchers[_meth].stop)
self.api_patchers[_meth].return_value = True
db_vol = {'id': 'fake', 'host': 'fake', 'status': 'available',
'size': 1, 'migration_status': None,
'volume_type_id': 'fake', 'project_id': 'project_id'}
vol = fake_volume.fake_volume_obj(self.context, **db_vol)
self.get_patcher = mock.patch('cinder.volume.API.get')
self.mock_volume_get = self.get_patcher.start()
self.addCleanup(self.get_patcher.stop)
self.mock_volume_get.return_value = vol
self.update_patcher = mock.patch('cinder.volume.API.update')
self.mock_volume_update = self.update_patcher.start()
self.addCleanup(self.update_patcher.stop)
self.mock_volume_update.return_value = vol
self.flags(rpc_backend='cinder.openstack.common.rpc.impl_fake')
def test_create_volume_from_snapshot(self):
snapshot = fake_snapshot.fake_snapshot_obj(self.context)
volume = fake_volume.fake_volume_obj(self.context)
self.assertEqual({'provider_location': self._provider_location},
self._driver.create_volume_from_snapshot(
volume, snapshot))
def test_create_volume_from_snapshot_failure(self):
snapshot = fake_snapshot.fake_snapshot_obj(self.context)
volume = fake_volume.fake_volume_obj(self.context)
self.assertRaises(exception.VolumeDriverException,
self._driver.create_volume_from_snapshot, volume,
snapshot)
def test_create_cloned_volume(self):
volume = fake_volume.fake_volume_obj(self.context)
self.assertEqual({'provider_location': self._provider_location},
self._driver.create_cloned_volume(volume, volume))
def test_is_replicated_no_type(self):
volume = fake_volume.fake_volume_obj(self.context,
volume_type_id=None,
volume_type=None)
self.assertFalse(bool(volume.is_replicated()))
def test_manage_existing(self):
volume = fake_volume.fake_volume_obj(self.context)
existing = {'source-name': self._provider_location + '/' + volume.name}
with mock.patch('os.path.isfile', return_value=True):
self.assertEqual({'provider_location': self._provider_location},
self._driver.manage_existing(volume, existing))
def test_create_cloned_volume_failure(self):
volume = fake_volume.fake_volume_obj(self.context)
self.assertRaises(exception.VolumeDriverException,
self._driver.create_cloned_volume, volume, volume)
def fake_volume_api_get(*args, **kwargs):
ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
db_volume = fake_db_volume_get()
return fake_volume.fake_volume_obj(ctx, **db_volume)
def test_manage_existing_invalid_ref(self):
existing = fake_volume.fake_volume_obj(self.context)
volume = fake_volume.fake_volume_obj(self.context)
self.assertRaises(exception.ManageExistingInvalidReference,
self._driver.manage_existing, volume, existing)
