def _create_delete_access_rule(self, share_id, access_type, access_to, microversion=None): self.skip_if_microversion_not_supported(microversion) if access_type not in self.access_types: raise self.skipException( "'%(access_type)s' access rules is disabled for protocol " "'%(protocol)s'." % {"access_type": access_type, "protocol": self.protocol}) access = self.user_client.access_allow( share_id, access_type, access_to, self.access_level, microversion=microversion) self.assertEqual(share_id, access.get('share_id')) self.assertEqual(access_type, access.get('access_type')) self.assertEqual(access_to.replace('\\\\', '\\'), access.get('access_to')) self.assertEqual(self.access_level, access.get('access_level')) if (api_versions.APIVersion(microversion) >= api_versions.APIVersion("2.33")): self.assertIn('access_key', access) self.assertIn('created_at', access) self.assertIn('updated_at', access) elif (api_versions.APIVersion(microversion) >= api_versions.APIVersion("2.21")): self.assertIn('access_key', access) else: self.assertNotIn('access_key', access) self.user_client.wait_for_access_rule_status(share_id, access['id']) self.user_client.access_deny(share_id, access['id']) self.user_client.wait_for_access_rule_deletion(share_id, access['id']) self.assertRaises(tempest_lib_exc.NotFound, self.user_client.get_access, share_id, access['id'])
def get_types(self, **kw): req_version = self.default_headers['X-Openstack-Manila-Api-Version'] if not isinstance(req_version, api_versions.APIVersion): req_version = api_versions.APIVersion(req_version) response_body = { 'share_types': [{ 'id': 1, 'name': 'test-type-1', 'extra_specs': { 'test1': 'test1' }, 'required_extra_specs': { 'test': 'test' } }, { 'id': 2, 'name': 'test-type-2', 'extra_specs': { 'test1': 'test1' }, 'required_extra_specs': { 'test': 'test' } }] } if req_version >= api_versions.APIVersion('2.46'): response_body['share_types'][0]['is_default'] = False response_body['share_types'][1]['is_default'] = False return 200, {}, response_body
def test_get_string(self): v1_string = "3.23" v1 = api_versions.APIVersion(v1_string) self.assertEqual(v1_string, v1.get_string()) self.assertRaises(ValueError, api_versions.APIVersion().get_string)
def test_create_with_default_values(self, microversion, dhss): manager = self._get_share_types_manager(microversion) if (api_versions.APIVersion(microversion) > api_versions.APIVersion("2.6")): is_public_keyname = "share_type_access:is_public" else: is_public_keyname = "os-share-type-access:is_public" expected_body = { "share_type": { "name": 'test-type-3', is_public_keyname: True, "extra_specs": { "driver_handles_share_servers": dhss, "snapshot_support": True, } } } with mock.patch.object(manager, '_create', mock.Mock(return_value="fake")): result = manager.create('test-type-3', dhss) manager._create.assert_called_once_with( "/types", expected_body, "share_type") self.assertEqual("fake", result)
def test_requested_version_is_less_than_server_max(self): self._mock_returned_server_version('2.17', '2.14') max_version = api_versions.APIVersion('2.15') manilaclient.API_MAX_VERSION = max_version manilaclient.API_MIN_VERSION = api_versions.APIVersion('2.12') version = api_versions.discover_version(self.fake_client, max_version) self.assertEqual(api_versions.APIVersion('2.15'), version)
def test_pre_microversion_server(self): self.fake_client.services.server_api_version.return_value = [] manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5") discovered_version = api_versions.discover_version( self.fake_client, manilaclient.API_MAX_VERSION) self.assertEqual("1.0", discovered_version.get_string()) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_requested_version_is_downgraded(self): server_end_version = '2.7' self._mock_returned_server_version(server_end_version, '2.0') max_version = api_versions.APIVersion("2.8") manilaclient.API_MAX_VERSION = max_version manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5") version = api_versions.discover_version(self.fake_client, max_version) self.assertEqual(api_versions.APIVersion(server_end_version), version)
def test_requested_version_is_too_old(self): self._mock_returned_server_version('2.5', '2.0') manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5") self.assertRaisesRegex(exceptions.UnsupportedVersion, ".*range is '2.0' to '2.5'.*", api_versions.discover_version, self.fake_client, api_versions.APIVersion("1.0"))
def test_update_share_type_quotas_positive(self, microversion): if not utils.is_microversion_supported(microversion): msg = "Microversion '%s' not supported." % microversion raise self.skipException(msg) # Get project quotas cmd = 'quota-show --tenant-id %s ' % self.project_id quotas_raw = self.admin_client.manila(cmd, microversion=microversion) p_quotas = output_parser.details(quotas_raw) # Define share type quotas st_custom_quotas = { 'shares': _get_share_type_quota_values(p_quotas['shares']), 'snapshots': _get_share_type_quota_values(p_quotas['snapshots']), 'gigabytes': _get_share_type_quota_values(p_quotas['gigabytes']), 'snapshot_gigabytes': _get_share_type_quota_values( p_quotas['snapshot_gigabytes']), } supports_share_replica_quotas = ( api_versions.APIVersion(microversion) >= api_versions.APIVersion( REPLICA_QUOTAS_MICROVERSION)) if supports_share_replica_quotas: st_custom_quotas['share_replicas'] = _get_share_type_quota_values( p_quotas['share_replicas'] ) st_custom_quotas['replica_gigabytes'] = ( _get_share_type_quota_values(p_quotas['replica_gigabytes'])) replica_params = (' --share-replicas %s ' '--replica-gigabytes %s') % ( st_custom_quotas['share_replicas'], st_custom_quotas['replica_gigabytes']) # Update quotas for share type cmd = ('quota-update %s --share-type %s ' '--shares %s --gigabytes %s --snapshots %s ' '--snapshot-gigabytes %s') % ( self.project_id, self.st_id, st_custom_quotas['shares'], st_custom_quotas['gigabytes'], st_custom_quotas['snapshots'], st_custom_quotas['snapshot_gigabytes']) if supports_share_replica_quotas: cmd += replica_params self.admin_client.manila(cmd, microversion=microversion) # Verify share type quotas self._verify_current_st_quotas_equal_to(st_custom_quotas, microversion) # Reset share type quotas cmd = 'quota-delete --tenant-id %s --share-type %s' % ( self.project_id, self.st_id) self.admin_client.manila(cmd, microversion=microversion) # Verify share type quotas after reset self._verify_current_st_quotas_equal_to(p_quotas, microversion)
def test_server_is_too_old(self): self._mock_returned_server_version('2.2', '2.0') manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.10") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.9") self.assertRaises(exceptions.UnsupportedVersion, api_versions.discover_version, self.fake_client, api_versions.APIVersion("2.10")) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_and_client_max_are_same(self): self._mock_returned_server_version('2.5', '2.0') manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5") discovered_version = api_versions.discover_version( self.fake_client, manilaclient.API_MAX_VERSION) self.assertEqual("2.5", discovered_version.get_string()) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_requested_version_in_range(self): self._mock_returned_server_version('2.7', '2.4') manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.11") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1") discovered_version = api_versions.discover_version( self.fake_client, api_versions.APIVersion('2.7')) self.assertEqual('2.7', discovered_version.get_string()) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_is_too_new(self): self._mock_returned_server_version('2.7', '2.4') manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.3") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1") self.assertRaisesRegex(exceptions.UnsupportedVersion, ".*range is '2.4' to '2.7'.*", api_versions.discover_version, self.fake_client, api_versions.APIVersion("2.3")) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_without_microversion(self): self._mock_returned_server_version(None, None) manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.11") manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1") discovered_version = api_versions.discover_version( self.fake_client, api_versions.APIVersion('2.7')) self.assertEqual(api_versions.DEPRECATED_VERSION, discovered_version.get_string()) self.assertTrue(self.fake_client.services.server_api_version.called)
def test_force_delete_share_snapshot(self, microversion, snapshot): manager = self._get_manager(microversion) if (api_versions.APIVersion(microversion) > api_versions.APIVersion("2.6")): action_name = "force_delete" else: action_name = "os-force_delete" with mock.patch.object(manager, "_action", mock.Mock()): manager.force_delete(snapshot) manager._action.assert_called_once_with(action_name, "1234")
def take_action(self, parsed_args): share_client = self.app.client_manager.share kwargs = {'name': parsed_args.name} try: kwargs['spec_driver_handles_share_servers'] = ( strutils.bool_from_string( parsed_args.spec_driver_handles_share_servers, strict=True)) except ValueError as e: msg = ("Argument spec_driver_handles_share_servers " "argument is not valid: %s" % str(e)) raise exceptions.CommandError(msg) if parsed_args.description: if share_client.api_version.matches( api_versions.APIVersion("2.41"), api_versions.APIVersion()): kwargs['description'] = parsed_args.description else: raise exceptions.CommandError( "Adding description to share type " "is only available with API microversion >= 2.41") if parsed_args.public: kwargs['is_public'] = strutils.bool_from_string(parsed_args.public, default=True) extra_specs = {} if parsed_args.extra_specs: for item in parsed_args.extra_specs: (key, value) = item.split('=', 1) if key == 'driver_handles_share_servers': msg = ("'driver_handles_share_servers' " "is already set via positional argument.") raise exceptions.CommandError(msg) else: extra_specs = utils.extract_extra_specs( extra_specs, [item]) for key in constants.BOOL_SPECS: value = getattr(parsed_args, key) if value: extra_specs = utils.extract_extra_specs( extra_specs, [key + '=' + value]) kwargs['extra_specs'] = extra_specs share_type = share_client.share_types.create(**kwargs) formatted_type = format_share_type(share_type) return (ATTRIBUTES, oscutils.get_dict_properties(formatted_type._info, ATTRIBUTES))
def take_action(self, parsed_args): share_client = self.app.client_manager.share kwargs = { 'service_host': parsed_args.service_host, 'protocol': parsed_args.protocol, 'export_path': parsed_args.export_path, 'name': parsed_args.name, 'description': parsed_args.description } share_type = None if parsed_args.share_type: share_type = apiutils.find_resource(share_client.share_types, parsed_args.share_type).id kwargs['share_type'] = share_type driver_options = None if parsed_args.driver_options: driver_options = utils.extract_properties( parsed_args.driver_options) kwargs['driver_options'] = driver_options if parsed_args.public: if share_client.api_version >= api_versions.APIVersion("2.8"): kwargs['public'] = True else: raise exceptions.CommandError( 'Setting share visibility while adopting a share is ' 'available only for API microversion >= 2.8') if parsed_args.share_server_id: if share_client.api_version >= api_versions.APIVersion("2.49"): kwargs['share_server_id'] = parsed_args.share_server_id else: raise exceptions.CommandError( 'Selecting a share server ID is available only for ' 'API microversion >= 2.49') share = share_client.shares.manage(**kwargs) if parsed_args.wait: if not oscutils.wait_for_status( status_f=share_client.shares.get, res_id=share.id, success_status=['available'], error_status=['manage_error', 'error']): LOG.error(_("ERROR: Share is in error state.")) share = apiutils.find_resource(share_client.shares, share.id) share._info.pop('links', None) return self.dict2columns(share._info)
def test_valid_instance_state(self, microversion, instance, state): manager = self._get_manager(microversion) if (api_versions.APIVersion(microversion) > api_versions.APIVersion("2.6")): action_name = "reset_status" else: action_name = "os-reset_status" with mock.patch.object(manager, "_action", mock.Mock()): manager.reset_state(instance, state) manager._action.assert_called_once_with( action_name, instance, {"status": state})
def take_action(self, parsed_args): share_client = self.app.client_manager.share share = apiutils.find_resource(share_client.shares, parsed_args.share) if share_client.api_version >= api_versions.APIVersion("2.45"): search_opts = {} if parsed_args.properties: search_opts = { 'metadata': utils.extract_properties(parsed_args.properties) } access_list = share_client.share_access_rules.access_list( share, search_opts) elif parsed_args.properties: raise exceptions.CommandError( "Filtering access rules by properties is supported only " "with API microversion 2.45 and beyond.") else: access_list = share.access_list() list_of_keys = [ 'id', 'access_type', 'access_to', 'access_level', 'state' ] if share_client.api_version >= api_versions.APIVersion("2.21"): list_of_keys.append('access_key') if share_client.api_version >= api_versions.APIVersion("2.33"): list_of_keys.append('created_at') list_of_keys.append('updated_at') if parsed_args.columns: columns = parsed_args.columns.split(',') for column in columns: if column not in list_of_keys: msg = ("No column named '%s'. Possible columns are: " "'id', 'access_type', 'access_to', " "'access_level', 'state', " "'access_key'(API microversion 2.21 and beyond), " "'created_at'(API microversion 2.33 and beyond), " "'updated_at'(API microversion 2.33 and beyond)." % column) raise exceptions.CommandError(msg) else: columns = list_of_keys values = (oscutils.get_item_properties(a, columns) for a in access_list) return (columns, values)
def test_manage_share(self, microversion, resource_path, is_public=False, share_server_id=None): service_host = "fake_service_host" protocol = "fake_protocol" export_path = "fake_export_path" driver_options = "fake_driver_options" share_type = "fake_share_type" name = "foo_name" description = "bar_description" expected_body = { "service_host": service_host, "share_type": share_type, "protocol": protocol, "export_path": export_path, "driver_options": driver_options, "name": name, "description": description, "share_server_id": share_server_id, } version = api_versions.APIVersion(microversion) if version >= api_versions.APIVersion('2.8'): expected_body["is_public"] = is_public mock_microversion = mock.Mock(api_version=version) manager = shares.ShareManager(api=mock_microversion) with mock.patch.object(manager, "_create", mock.Mock(return_value="fake")): if version < api_versions.APIVersion('2.8'): result = manager.manage(service_host, protocol, export_path, driver_options, share_type, name, description) elif (api_versions.APIVersion('2.8') <= version < api_versions.APIVersion('2.49')): result = manager.manage(service_host, protocol, export_path, driver_options, share_type, name, description, is_public) else: result = manager.manage(service_host, protocol, export_path, driver_options, share_type, name, description, is_public, share_server_id) self.assertEqual(manager._create.return_value, result) manager._create.assert_called_once_with(resource_path, {"share": expected_body}, "share")
def _convert_to_api_version(version): """Convert version to an APIVersion object unless it already is one.""" if hasattr(version, 'get_major_version'): api_version = version else: if version in ('1', '1.0'): api_version = api_versions.APIVersion( api_versions.DEPRECATED_VERSION) elif version == '2': api_version = api_versions.APIVersion(api_versions.MIN_VERSION) else: api_version = api_versions.APIVersion(version) return api_version
def test_end_version_is_none(self, mock_versioned_method, mock_name): func_name = 'foo' mock_name.return_value = func_name mock_versioned_method.side_effect = self._side_effect_of_vers_method @api_versions.wraps('2.2') def foo(*args, **kwargs): pass foo(self._get_obj_with_vers('2.4')) mock_versioned_method.assert_called_once_with( func_name, api_versions.APIVersion('2.2'), api_versions.APIVersion(api_versions.MAX_VERSION), mock.ANY)
def test_reset_snapshot_state(self, microversion, snapshot): manager = self._get_manager(microversion) state = 'available' if (api_versions.APIVersion(microversion) > api_versions.APIVersion("2.6")): action_name = "reset_status" else: action_name = "os-reset_status" with mock.patch.object(manager, "_action", mock.Mock()): manager.reset_state(snapshot, state) manager._action.assert_called_once_with(action_name, snapshot, {"status": state})
def test_create(self, microversion): api_version = api_versions.APIVersion(microversion) values = self.values.copy() if (api_version >= api_versions.APIVersion("2.26")): del (values['nova_net_id']) body_expected = {share_networks.RESOURCE_NAME: values} manager = share_networks.ShareNetworkManager( fakes.FakeClient(api_version=api_version)) with mock.patch.object(manager, '_create', fakes.fake_create): result = manager.create(**values) self.assertEqual(result['url'], share_networks.RESOURCES_PATH) self.assertEqual(result['resp_key'], share_networks.RESOURCE_NAME) self.assertEqual(body_expected, result['body'])
def test_update_share_network(self, microversion, share_nw): api_version = api_versions.APIVersion(microversion) values = self.values.copy() if (api_version >= api_versions.APIVersion("2.26")): del (values['nova_net_id']) body_expected = {share_networks.RESOURCE_NAME: values} manager = share_networks.ShareNetworkManager( fakes.FakeClient(api_version=api_version)) with mock.patch.object(manager, '_update', fakes.fake_update): result = manager.update(share_nw, **values) id = share_nw.id if hasattr(share_nw, 'id') else share_nw self.assertEqual(result['url'], share_networks.RESOURCE_PATH % id) self.assertEqual(result['resp_key'], share_networks.RESOURCE_NAME) self.assertEqual(result['body'], body_expected)
def test_tenant_quotas_get(self, microversion): tenant_id = 'test' manager = self._get_manager(microversion) resource_path = self._get_resource_path(microversion) version = api_versions.APIVersion(microversion) if version >= api_versions.APIVersion('2.25'): expected_url = "%s/test/detail" % resource_path else: expected_url = ("%s/test" % resource_path) with mock.patch.object(manager, '_get', mock.Mock(return_value='fake_get')): manager.get(tenant_id, detail=True) manager._get.assert_called_once_with(expected_url, "quota_set")
def test_start_and_end_version_are_presented(self, mock_versioned_method, mock_name): func_name = "foo" mock_name.return_value = func_name mock_versioned_method.side_effect = self._side_effect_of_vers_method @api_versions.wraps("2.2", "2.6") def foo(*args, **kwargs): pass foo(self._get_obj_with_vers("2.4")) mock_versioned_method.assert_called_once_with( func_name, api_versions.APIVersion("2.2"), api_versions.APIVersion("2.6"), mock.ANY)
def test_api_version_doesnt_match(self, mock_versioned_method, mock_name): func_name = "foo" mock_name.return_value = func_name mock_versioned_method.side_effect = self._side_effect_of_vers_method @api_versions.wraps("2.2", "2.6") def foo(*args, **kwargs): pass self.assertRaises(exceptions.UnsupportedVersion, foo, self._get_obj_with_vers("2.1")) mock_versioned_method.assert_called_once_with( func_name, api_versions.APIVersion("2.2"), api_versions.APIVersion("2.6"), mock.ANY)
def _get_manager(self, microversion): version = api_versions.APIVersion(microversion) mock_microversion = mock.Mock(api_version=version) return ( share_instance_export_locations.ShareInstanceExportLocationManager( api=mock_microversion) )
def get_share_group_types(self, **kw): share_group_types = { 'share_group_types': [ { 'id': 1, 'name': 'test-group-type-1', 'group_specs': { 'key1': 'value1', }, 'share_types': [ 'type1', 'type2', ], 'is_public': True, }, { 'id': 2, 'name': 'test-type-2', 'group_specs': { 'key2': 'value2', }, 'share_types': [ 'type3', 'type4', ], 'is_public': False, }, ], } req_version = self.default_headers['X-Openstack-Manila-Api-Version'] if req_version >= api_versions.APIVersion('2.46'): share_group_types['share_group_types'][0]['is_default'] = False share_group_types['share_group_types'][1]['is_default'] = False return 200, {}, share_group_types