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_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)