Пример #1
0
    def get_service_clients(self):
        ironic_config = config.service_client_config(
            project_config.baremetal_group.name
        )
        baremetal_client = {
            'name': 'baremetal',
            'service_version': 'baremetal.v1',
            'module_path': 'ironic_tempest_plugin.services.baremetal.v1.'
                           'json.baremetal_client',
            'client_names': [
                'BaremetalClient',
            ],
        }
        baremetal_client.update(ironic_config)

        inspector_config = config.service_client_config(
            project_config.baremetal_introspection_group.name
        )
        inspector_client = {
            'name': 'introspection',
            'service_version': 'baremetal_introspection.v1',
            'module_path': 'ironic_tempest_plugin.services.'
                           'introspection_client',
            'client_names': [
                'BaremetalIntrospectionClient',
            ],
        }
        inspector_client.update(inspector_config)

        return [baremetal_client, inspector_client]
Пример #2
0
    def __init__(self, credentials, scope='project'):
        """Initialization of Manager class.

        Setup all services clients and make them available for tests cases.
        :param credentials: type Credentials or TestResources
        :param scope: default scope for tokens produced by the auth provider
        """
        _, identity_uri = get_auth_provider_class(credentials)
        super(Manager, self).__init__(
            credentials=credentials, identity_uri=identity_uri, scope=scope,
            region=CONF.identity.region)
        # TODO(andreaf) When clients are initialised without the right
        # parameters available, the calls below will trigger a KeyError.
        # We should catch that and raise a better error.
        self._set_compute_clients()
        self._set_identity_clients()
        self._set_volume_clients()
        self._set_object_storage_clients()
        self._set_image_clients()
        self._set_network_clients()
        self.placement_client = self.placement.PlacementClient()
        # TODO(andreaf) This is maintained for backward compatibility
        # with plugins, but it should removed eventually, since it was
        # never a stable interface and it's not useful anyways
        self.default_params = config.service_client_config()
Пример #3
0
 def resource_setup(cls):
     super(FWaaSClientMixin, cls).resource_setup()
     manager = cls.os_primary
     default_params = config.service_client_config()
     cls.firewalls_client = client.FirewallsClient(
         manager.auth_provider,
         CONF.network.catalog_type,
         CONF.network.region or CONF.identity.region,
         endpoint_type=CONF.network.endpoint_type,
         build_interval=CONF.network.build_interval,
         build_timeout=CONF.network.build_timeout,
         **default_params)
     cls.firewall_policies_client = client.FirewallPoliciesClient(
         manager.auth_provider,
         CONF.network.catalog_type,
         CONF.network.region or CONF.identity.region,
         endpoint_type=CONF.network.endpoint_type,
         build_interval=CONF.network.build_interval,
         build_timeout=CONF.network.build_timeout,
         **default_params)
     cls.firewall_rules_client = client.FirewallRulesClient(
         manager.auth_provider,
         CONF.network.catalog_type,
         CONF.network.region or CONF.identity.region,
         endpoint_type=CONF.network.endpoint_type,
         build_interval=CONF.network.build_interval,
         build_timeout=CONF.network.build_timeout,
         **default_params)
Пример #4
0
class Manager(clients.Manager):

    default_params = config.service_client_config()

    telemetry_params = {
        'service': CONF.telemetry.catalog_type,
        'region': CONF.identity.region,
        'endpoint_type': CONF.telemetry.endpoint_type,
    }
    telemetry_params.update(default_params)

    def __init__(self, credentials):
        # TODO(andreaf) Overriding Manager is a workaround. The "proper" way
        # would it to expose the ceilometer service client via the plugin
        # interface, use tempest.lib.clients and tempest master.
        # Then ceilometer service client would be loaded and configured
        # automatically into ServiceClients.
        # In any case we're about to declare clients.Manager a stable
        # interface for plugins and we won't change it, so this code won't
        # break.
        super(Manager, self).__init__(credentials=credentials)
        self.set_telemetry_client()

    def set_telemetry_client(self):
        self.telemetry_client = TelemetryClient(self.auth_provider,
                                                **self.telemetry_params)
Пример #5
0
 def setUp(self):
     super(TestPreProvisionedCredentials, self).setUp()
     self.useFixture(fake_config.ConfigFixture())
     self.patchobject(config, 'TempestConfigPrivate',
                      fake_config.FakePrivate)
     self.patch(self.token_client, side_effect=self.identity_response)
     self.useFixture(lockutils_fixtures.ExternalLockFixture())
     self.test_accounts = self._fake_accounts(cfg.CONF.identity.admin_role)
     self.accounts_mock = self.useFixture(fixtures.MockPatch(
         'tempest.lib.common.preprov_creds.read_accounts_yaml',
         return_value=self.test_accounts))
     self.useFixture(fixtures.MockPatch(
         'os.path.isfile', return_value=True))
     # NOTE(andreaf) Ensure config is loaded so service clients are
     # registered in the registry before tests
     config.service_client_config()
Пример #6
0
 def test_get_configured_admin_credentials_not_fill_valid(
         self, mock_get_credentials):
     cfg.CONF.set_default('auth_version', 'v2', 'identity')
     all_params = [
         ('admin_username', 'username', 'my_name'),
         ('admin_user_domain_name', 'user_domain_name', 'my_dname'),
         ('admin_password', 'password', 'secret'),
         ('admin_project_domain_name', 'project_domain_name', 'my_dname'),
         ('admin_project_name', 'project_name', 'my_pname'),
         ('admin_domain_name', 'domain_name', 'my_dname'),
         ('admin_system', 'system', None),
     ]
     expected_result = mock.Mock()
     expected_result.is_valid.return_value = True
     mock_get_credentials.return_value = expected_result
     for config_item, _, value in all_params:
         cfg.CONF.set_default(config_item, value, 'auth')
     # Build the expected params
     expected_params = dict([(field, value)
                             for _, field, value in all_params])
     expected_params.update(config.service_client_config())
     admin_creds = cf.get_configured_admin_credentials(
         fill_in=False, identity_version='v3')
     mock_get_credentials.assert_called_once_with(fill_in=False,
                                                  identity_version='v3',
                                                  **expected_params)
     self.assertEqual(expected_result, admin_creds)
     expected_result.is_valid.assert_called_once()
Пример #7
0
def get_credentials(fill_in=True, identity_version=None, **kwargs):
    """Get credentials from dict based on config

    Wrapper around auth.get_credentials to use the configured identity version
    if none is specified.

    :param fill_in: If True, a request to the Token API is submitted, and the
                    credential object is filled in with all names and IDs from
                    the token API response.
    :param identity_version: The identity version to talk to and the type of
                             credentials object to be created. 'v2' or 'v3'.
    :param kwargs: Attributes to be used to build the Credentials object.
    :returns: An object of a sub-type of `auth.Credentials`
    """
    params = dict(config.service_client_config(), **kwargs)
    identity_version = identity_version or CONF.identity.auth_version
    # In case of "v3" add the domain from config if not specified
    # To honour the "default_credentials_domain_name", if not domain
    # field is specified at all, add it the credential dict.
    if identity_version == 'v3':
        domain_fields = set(x for x in auth.KeystoneV3Credentials.ATTRIBUTES
                            if 'domain' in x)
        if not domain_fields.intersection(kwargs.keys()):
            domain_name = CONF.auth.default_credentials_domain_name
            # NOTE(andreaf) Setting domain_name implicitly sets user and
            # project domain names, if they are None
            params['domain_name'] = domain_name

        auth_url = CONF.identity.uri_v3
    else:
        auth_url = CONF.identity.uri
    return auth.get_credentials(auth_url,
                                fill_in=fill_in,
                                identity_version=identity_version,
                                **params)
Пример #8
0
    def _prepare_configuration(self):
        """Map values from CONF into Manager parameters

        This uses `config.service_client_config` for all services to collect
        most configuration items needed to init the clients.
        """
        # NOTE(andreaf) Configuration items will be passed in future patches
        # into ClientFactory objects, but for now we update all the
        # _set_*_client methods to consume them so we can verify that the
        # configuration collected is correct

        configuration = {}

        # Setup the parameters for all Tempest services.
        # NOTE(andreaf) Since client.py is an internal module of Tempest,
        # it doesn't have to consider plugin configuration.
        all_tempest_modules = (set(clients.tempest_modules()) |
                               clients._tempest_internal_modules())
        for service in all_tempest_modules:
            try:
                # NOTE(andreaf) Use the unversioned service name to fetch
                # the configuration since configuration is not versioned.
                service_for_config = service.split('.')[0]
                if service_for_config not in configuration:
                    configuration[service_for_config] = (
                        config.service_client_config(service_for_config))
            except lib_exc.UnknownServiceClient:
                LOG.warn(
                    'Could not load configuration for service %s' % service)

        return configuration
Пример #9
0
    def setup_clients(cls):
        super(BaseDatabaseTest, cls).setup_clients()
        default_params = config.service_client_config()

        # NOTE: Tempest uses timeout values of compute API if project specific
        # timeout values don't exist.
        default_params_with_timeout_values = {
            'build_interval': CONF.compute.build_interval,
            'build_timeout': CONF.compute.build_timeout
        }
        default_params_with_timeout_values.update(default_params)
        cls.database_flavors_client = flavors_client.FlavorsClient(
            cls.os_primary.auth_provider,
            CONF.database.catalog_type,
            CONF.identity.region,
            **default_params_with_timeout_values)
        cls.os_flavors_client = cls.os_primary.flavors_client
        cls.database_limits_client = limits_client.LimitsClient(
            cls.os_primary.auth_provider,
            CONF.database.catalog_type,
            CONF.identity.region,
            **default_params_with_timeout_values)
        cls.database_versions_client = versions_client.VersionsClient(
            cls.os_primary.auth_provider,
            CONF.database.catalog_type,
            CONF.identity.region,
            **default_params_with_timeout_values)
Пример #10
0
    def _prepare_configuration(self):
        """Map values from CONF into Manager parameters

        This uses `config.service_client_config` for all services to collect
        most configuration items needed to init the clients.
        """
        # NOTE(andreaf) Once all service clients in Tempest are migrated
        # to tempest.lib, their configuration will be picked up from the
        # registry, and this method will become redundant.

        configuration = {}

        # Setup the parameters for all Tempest services which are not in lib.
        # NOTE(andreaf) Since client.py is an internal module of Tempest,
        # it doesn't have to consider plugin configuration.
        for service in clients._tempest_internal_modules():
            try:
                # NOTE(andreaf) Use the unversioned service name to fetch
                # the configuration since configuration is not versioned.
                service_for_config = service.split('.')[0]
                if service_for_config not in configuration:
                    configuration[service_for_config] = (
                        config.service_client_config(service_for_config))
            except lib_exc.UnknownServiceClient:
                LOG.warn(
                    'Could not load configuration for service %s' % service)

        return configuration
Пример #11
0
    def __init__(self, credentials, scope='project'):
        """Initialization of Manager class.

        Setup all services clients and make them available for tests cases.
        :param credentials: type Credentials or TestResources
        :param scope: default scope for tokens produced by the auth provider
        """
        _, identity_uri = get_auth_provider_class(credentials)
        super(Manager, self).__init__(credentials=credentials,
                                      identity_uri=identity_uri,
                                      scope=scope,
                                      region=CONF.identity.region)
        # TODO(andreaf) When clients are initialised without the right
        # parameters available, the calls below will trigger a KeyError.
        # We should catch that and raise a better error.
        self._set_compute_clients()
        self._set_identity_clients()
        self._set_volume_clients()
        self._set_object_storage_clients()
        self._set_image_clients()
        self._set_network_clients()
        self._set_placement_clients()
        # TODO(andreaf) This is maintained for backward compatibility
        # with plugins, but it should removed eventually, since it was
        # never a stable interface and it's not useful anyways
        self.default_params = config.service_client_config()
Пример #12
0
 def get_service_clients(self):
     dns_config = config.service_client_config('dns')
     admin_params = {
         'name': 'dns_admin',
         'service_version': 'dns.admin',
         'module_path': 'designate_tempest_plugin.services.dns.admin',
         'client_names': ['QuotasClient']
     }
     v2_params = {
         'name':
         'dns_v2',
         'service_version':
         'dns.v2',
         'module_path':
         'designate_tempest_plugin.services.dns.v2',
         'client_names': [
             'BlacklistsClient', 'PoolClient', 'QuotasClient',
             'RecordsetClient', 'TldClient', 'TransferAcceptClient',
             'TransferRequestClient', 'TsigkeyClient', 'ZoneExportsClient',
             'ZoneImportsClient', 'ZonesClient'
         ]
     }
     admin_params.update(dns_config)
     v2_params.update(dns_config)
     return [admin_params, v2_params]
Пример #13
0
    def _prepare_configuration(self):
        """Map values from CONF into Manager parameters

        This uses `config.service_client_config` for all services to collect
        most configuration items needed to init the clients.
        """
        # NOTE(andreaf) Once all service clients in Tempest are migrated
        # to tempest.lib, their configuration will be picked up from the
        # registry, and this method will become redundant.

        configuration = {}

        # Setup the parameters for all Tempest services which are not in lib.
        # NOTE(andreaf) Since client.py is an internal module of Tempest,
        # it doesn't have to consider plugin configuration.
        for service in clients._tempest_internal_modules():
            try:
                # NOTE(andreaf) Use the unversioned service name to fetch
                # the configuration since configuration is not versioned.
                service_for_config = service.split(".")[0]
                if service_for_config not in configuration:
                    configuration[service_for_config] = config.service_client_config(service_for_config)
            except lib_exc.UnknownServiceClient:
                LOG.warn("Could not load configuration for service %s" % service)

        return configuration
Пример #14
0
def get_credentials(fill_in=True, identity_version=None, **kwargs):
    """Get credentials from dict based on config

    Wrapper around auth.get_credentials to use the configured identity version
    if none is specified.

    :param fill_in: If True, a request to the Token API is submitted, and the
                    credential object is filled in with all names and IDs from
                    the token API response.
    :param identity_version: The identity version to talk to and the type of
                             credentials object to be created. 'v2' or 'v3'.
    :param kwargs: Attributes to be used to build the Credentials object.
    :returns: An object of a sub-type of `auth.Credentials`
    """
    params = dict(config.service_client_config(), **kwargs)
    identity_version = identity_version or CONF.identity.auth_version
    # In case of "v3" add the domain from config if not specified
    # To honour the "default_credentials_domain_name", if not domain
    # field is specified at all, add it the credential dict.
    if identity_version == 'v3':
        domain_fields = set(x for x in auth.KeystoneV3Credentials.ATTRIBUTES
                            if 'domain' in x)
        if not domain_fields.intersection(kwargs.keys()):
            domain_name = CONF.auth.default_credentials_domain_name
            # NOTE(andreaf) Setting domain_name implicitly sets user and
            # project domain names, if they are None
            params['domain_name'] = domain_name

        auth_url = CONF.identity.uri_v3
    else:
        auth_url = CONF.identity.uri
    return auth.get_credentials(auth_url,
                                fill_in=fill_in,
                                identity_version=identity_version,
                                **params)
Пример #15
0
 def setUp(self):
     super(TestPreProvisionedCredentials, self).setUp()
     self.useFixture(fake_config.ConfigFixture())
     self.patchobject(config, 'TempestConfigPrivate',
                      fake_config.FakePrivate)
     self.patch(self.token_client, side_effect=self.identity_response)
     self.useFixture(lockutils_fixtures.ExternalLockFixture())
     self.test_accounts = self._fake_accounts(cfg.CONF.identity.admin_role)
     self.accounts_mock = self.useFixture(
         fixtures.MockPatch(
             'tempest.lib.common.preprov_creds.read_accounts_yaml',
             return_value=self.test_accounts))
     self.useFixture(fixtures.MockPatch('os.path.isfile',
                                        return_value=True))
     # NOTE(andreaf) Ensure config is loaded so service clients are
     # registered in the registry before tests
     config.service_client_config()
Пример #16
0
 def get_service_clients(self):
     service_config = config.service_client_config('database')
     service_params = {
         'name': 'database',
         'service_version': 'database',
         'module_path': 'trove_tempest_plugin.services.client',
         'client_names': ['TroveClient']
     }
     service_params.update(service_config)
     return [service_params]
Пример #17
0
def get_auth_provider(credentials, pre_auth=False, scope="project"):
    # kwargs for auth provider match the common ones used by service clients
    default_params = config.service_client_config()
    if credentials is None:
        raise exceptions.InvalidCredentials("Credentials must be specified")
    auth_provider_class, auth_url = get_auth_provider_class(credentials)
    _auth_provider = auth_provider_class(credentials, auth_url, scope=scope, **default_params)
    if pre_auth:
        _auth_provider.set_auth()
    return _auth_provider
Пример #18
0
 def get_service_clients(self):
     orchestration_config = config.service_client_config('heat_plugin')
     params = {
         'name': 'orchestration',
         'service_version': 'orchestration',
         'module_path': 'heat_integrationtests.services.orchestration',
         'client_names': ['OrchestrationClient']
     }
     params.update(orchestration_config)
     return [params]
Пример #19
0
 def get_service_clients(self):
     qinling_config = config.service_client_config('qinling')
     params = {
         'name': 'qinling',
         'service_version': 'qinling',
         'module_path': 'qinling_tempest_plugin.services.qinling_client',
         'client_names': ['QinlingClient'],
     }
     params.update(qinling_config)
     return [params]
Пример #20
0
 def test_service_client_config_no_service(self):
     params = config.service_client_config()
     for param_name in self.expected_common_params:
         self.assertIn(param_name, params)
     for param_name in self.expected_extra_params:
         self.assertNotIn(param_name, params)
     self.assertEqual(self.CONF.identity.disable_ssl_certificate_validation,
                      params['disable_ssl_certificate_validation'])
     self.assertEqual(self.CONF.identity.ca_certificates_file,
                      params['ca_certs'])
     self.assertEqual(self.CONF.debug.trace_requests,
                      params['trace_requests'])
Пример #21
0
 def test_service_client_config_no_service(self):
     params = config.service_client_config()
     for param_name in self.expected_common_params:
         self.assertIn(param_name, params)
     for param_name in self.expected_extra_params:
         self.assertNotIn(param_name, params)
     self.assertEqual(
         self.CONF.identity.disable_ssl_certificate_validation,
         params['disable_ssl_certificate_validation'])
     self.assertEqual(self.CONF.identity.ca_certificates_file,
                      params['ca_certs'])
     self.assertEqual(self.CONF.debug.trace_requests,
                      params['trace_requests'])
Пример #22
0
    def get_service_clients(self):
        data_processing_config = (
            config.service_client_config('data-processing'))

        params = {
            'name': 'data_processing',
            'service_version': 'data_processing.v1_1',
            'module_path':
            'sahara_tempest_plugin.services.data_processing.v1_1',
            'client_names': ['DataProcessingClient']
        }
        params.update(data_processing_config)
        return [params]
Пример #23
0
 def test_get_credentials_v2(self, mock_auth_get_credentials):
     expected_uri = 'V2_URI'
     expected_result = 'my_creds'
     mock_auth_get_credentials.return_value = expected_result
     cfg.CONF.set_default('uri', expected_uri, 'identity')
     params = {'foo': 'bar'}
     expected_params = params.copy()
     expected_params.update(config.service_client_config())
     result = cf.get_credentials(identity_version='v2', **params)
     self.assertEqual(expected_result, result)
     mock_auth_get_credentials.assert_called_once_with(
         expected_uri, fill_in=True, identity_version='v2',
         **expected_params)
Пример #24
0
def get_auth_provider(credentials, pre_auth=False, scope='project'):
    # kwargs for auth provider match the common ones used by service clients
    default_params = config.service_client_config()
    if credentials is None:
        raise lib_exc.InvalidCredentials('Credentials must be specified')
    auth_provider_class, auth_url = get_auth_provider_class(credentials)
    _auth_provider = auth_provider_class(credentials,
                                         auth_url,
                                         scope=scope,
                                         **default_params)
    if pre_auth:
        _auth_provider.set_auth()
    return _auth_provider
Пример #25
0
    def get_service_clients(self):
        octavia_config = config.service_client_config(
            project_config.octavia_group.name)

        params = {
            'name': 'load-balancer_v2',
            'service_version': 'load-balancer.v2',
            'module_path': 'octavia_tempest_plugin.services.load_balancer.v2',
            'client_names': ['LoadbalancerClient'],
        }
        params.update(octavia_config)

        return [params]
Пример #26
0
 def test_get_credentials_v2(self, mock_auth_get_credentials):
     expected_uri = 'V2_URI'
     expected_result = 'my_creds'
     mock_auth_get_credentials.return_value = expected_result
     cfg.CONF.set_default('uri', expected_uri, 'identity')
     params = {'foo': 'bar'}
     expected_params = params.copy()
     expected_params.update(config.service_client_config())
     result = cf.get_credentials(identity_version='v2', **params)
     self.assertEqual(expected_result, result)
     mock_auth_get_credentials.assert_called_once_with(
         expected_uri,
         fill_in=True,
         identity_version='v2',
         **expected_params)
Пример #27
0
    def _set_object_storage_clients(self):
        # NOTE(andreaf) Load configuration from config. Once object storage
        # is in lib, configuration will be pulled directly from the registry
        # and this will not be required anymore.
        params = config.service_client_config('object-storage')

        self.account_client = object_storage.AccountClient(self.auth_provider,
                                                           **params)
        self.bulk_client = object_storage.BulkMiddlewareClient(
            self.auth_provider, **params)
        self.capabilities_client = object_storage.CapabilitiesClient(
            self.auth_provider, **params)
        self.container_client = object_storage.ContainerClient(
            self.auth_provider, **params)
        self.object_client = object_storage.ObjectClient(self.auth_provider,
                                                         **params)
Пример #28
0
 def test_service_client_config_service_minimal(self):
     params = config.service_client_config(
         service_client_name='fake-service2')
     for param_name in self.expected_common_params:
         self.assertIn(param_name, params)
     for param_name in self.expected_extra_params:
         self.assertIn(param_name, params)
     self.assertEqual(self.CONF.fake_service2.catalog_type,
                      params['service'])
     self.assertEqual(self.CONF.fake_service2.endpoint_type,
                      params['endpoint_type'])
     self.assertEqual(self.CONF.identity.region, params['region'])
     self.assertEqual(self.CONF.compute.build_timeout,
                      params['build_timeout'])
     self.assertEqual(self.CONF.compute.build_interval,
                      params['build_interval'])
Пример #29
0
    def _set_object_storage_clients(self):
        # NOTE(andreaf) Load configuration from config. Once object storage
        # is in lib, configuration will be pulled directly from the registry
        # and this will not be required anymore.
        params = config.service_client_config('object-storage')

        self.account_client = object_storage.AccountClient(
            self.auth_provider, **params)
        self.bulk_client = object_storage.BulkMiddlewareClient(
            self.auth_provider, **params)
        self.capabilities_client = object_storage.CapabilitiesClient(
            self.auth_provider, **params)
        self.container_client = object_storage.ContainerClient(
            self.auth_provider, **params)
        self.object_client = object_storage.ObjectClient(
            self.auth_provider, **params)
Пример #30
0
def get_extension_client(os, service):
    params = config.service_client_config('object-storage')
    extensions_client = {
        'nova': os.compute.ExtensionsClient(),
        'neutron': os.network.ExtensionsClient(),
        'swift': object_storage.CapabilitiesClient(os.auth_provider, **params),
        # NOTE: Cinder v3 API is current and v2 and v1 are deprecated.
        # V3 extension API is the same as v2, so we reuse the v2 client
        # for v3 API also.
        'cinder': os.volume_v2.ExtensionsClient(),
    }

    if service not in extensions_client:
        print('No tempest extensions client for %s' % service)
        sys.exit(1)
    return extensions_client[service]
Пример #31
0
 def test_service_client_config_service_minimal(self):
     params = config.service_client_config(
         service_client_name='fake-service2')
     for param_name in self.expected_common_params:
         self.assertIn(param_name, params)
     for param_name in self.expected_extra_params:
         self.assertIn(param_name, params)
     self.assertEqual(self.CONF.fake_service2.catalog_type,
                      params['service'])
     self.assertEqual(self.CONF.fake_service2.endpoint_type,
                      params['endpoint_type'])
     self.assertEqual(self.CONF.identity.region, params['region'])
     self.assertEqual(self.CONF.compute.build_timeout,
                      params['build_timeout'])
     self.assertEqual(self.CONF.compute.build_interval,
                      params['build_interval'])
Пример #32
0
 def get_service_clients(self):
     dns_config = config.service_client_config('dns')
     admin_params = {
         'name': 'dns_admin',
         'service_version': 'dns.admin',
         'module_path': 'designate_tempest_plugin.services.dns.admin',
         'client_names': ['QuotasClient']
     }
     v2_params = {
         'name': 'dns_v2',
         'service_version': 'dns.v2',
         'module_path': 'designate_tempest_plugin.services.dns.v2',
         'client_names': dns_v2_services.__all__
     }
     admin_params.update(dns_config)
     v2_params.update(dns_config)
     return [admin_params, v2_params]
Пример #33
0
 def test_get_credentials_v3_domain(self, mock_auth_get_credentials):
     expected_uri = 'V3_URI'
     expected_result = 'my_creds'
     expected_domain = 'my_domain'
     mock_auth_get_credentials.return_value = expected_result
     cfg.CONF.set_default('uri_v3', expected_uri, 'identity')
     cfg.CONF.set_default('default_credentials_domain_name',
                          expected_domain, 'auth')
     params = {'foo': 'bar', 'user_domain_name': expected_domain}
     expected_params = params.copy()
     expected_params.update(config.service_client_config())
     result = cf.get_credentials(fill_in=False, identity_version='v3',
                                 **params)
     self.assertEqual(expected_result, result)
     mock_auth_get_credentials.assert_called_once_with(
         expected_uri, fill_in=False, identity_version='v3',
         **expected_params)
Пример #34
0
 def get_service_clients(self):
     shares_config = config.service_client_config('share')
     v1_params = {
         'name': 'share_v1',
         'service_version': 'share.v1',
         'module_path': 'manila_tempest_tests.services.share.json',
         'client_names': ['SharesClient'],
     }
     v2_params = {
         'name': 'share_v2',
         'service_version': 'share.v2',
         'module_path': 'manila_tempest_tests.services.share.v2',
         'client_names': ['SharesV2Client'],
     }
     v1_params.update(shares_config)
     v2_params.update(shares_config)
     return [v1_params, v2_params]
Пример #35
0
    def setup_clients(cls):
        super(BaseApplicationCatalogScenarioTest, cls).setup_clients()
        if not hasattr(cls, "os_primary"):
            creds = cls.get_configured_isolated_creds(type_of_creds='primary')
            cls.os_primary = clients.Manager(credentials=creds)
            cls.services_manager = services_manager(creds)

        cls.application_catalog_client = \
            cls.os_primary.application_catalog_client
        cls.artifacts_client = cls.os_primary.artifacts_client
        cls.servers_client = cls.services_manager.servers_client
        # NOTE(andreaf) The orchestration client is not initialised in Tempest
        # by default anymore.
        params = config.service_client_config('orchestration')
        cls.orchestration_client = orchestration.OrchestrationClient(
            cls.services_manager.auth_provider, **params)
        cls.images_client = cls.services_manager.image_client_v2
Пример #36
0
 def test_get_credentials_v3_system(self, mock_auth_get_credentials):
     expected_uri = 'V3_URI'
     expected_result = 'my_creds'
     mock_auth_get_credentials.return_value = expected_result
     cfg.CONF.set_default('uri_v3', expected_uri, 'identity')
     cfg.CONF.set_default('admin_system', 'all', 'auth')
     params = {'system': 'all'}
     expected_params = params.copy()
     expected_params.update(config.service_client_config())
     result = cf.get_credentials(fill_in=False,
                                 identity_version='v3',
                                 **params)
     self.assertEqual(expected_result, result)
     mock_auth_get_credentials.assert_called_once_with(
         expected_uri,
         fill_in=False,
         identity_version='v3',
         **expected_params)
Пример #37
0
 def test_get_configured_admin_credentials(self, mock_get_credentials):
     cfg.CONF.set_default('auth_version', 'v3', 'identity')
     all_params = [('admin_username', 'username', 'my_name'),
                   ('admin_password', 'password', 'secret'),
                   ('admin_project_name', 'project_name', 'my_pname'),
                   ('admin_domain_name', 'domain_name', 'my_dname')]
     expected_result = 'my_admin_credentials'
     mock_get_credentials.return_value = expected_result
     for config_item, _, value in all_params:
         cfg.CONF.set_default(config_item, value, 'auth')
     # Build the expected params
     expected_params = dict(
         [(field, value) for _, field, value in all_params])
     expected_params.update(config.service_client_config())
     admin_creds = cf.get_configured_admin_credentials()
     mock_get_credentials.assert_called_once_with(
         fill_in=True, identity_version='v3', **expected_params)
     self.assertEqual(expected_result, admin_creds)
Пример #38
0
    def get_service_clients(self):
        # Ignore the ArgsAlreadyParsed error: it means that
        # the same content is (still) defined in Tempest
        try:
            data_processing_config = (
                config.service_client_config('data-processing'))
        except cfg.ArgsAlreadyParsedError:
            # the service name must be returned with the other params
            data_processing_config = {'service': 'data-processing'}

        params = {
            'name': 'data_processing',
            'service_version': 'data_processing.v1_1',
            'module_path':
                'sahara_tempest_plugin.services.data_processing.v1_1',
            'client_names': ['DataProcessingClient']
        }
        params.update(data_processing_config)
        return [params]
Пример #39
0
def get_configured_admin_credentials(fill_in=True, identity_version=None):
    """Get admin credentials from the config file

    Read credentials from configuration, builds a Credentials object based on
    the specified or configured version

    :param fill_in: If True, a request to the Token API is submitted, and the
                    credential object is filled in with all names and IDs from
                    the token API response.
    :param identity_version: The identity version to talk to and the type of
                             credentials object to be created. 'v2' or 'v3'.
    :returns: An object of a sub-type of `auth.Credentials`
    """
    identity_version = identity_version or CONF.identity.auth_version

    if identity_version not in ('v2', 'v3'):
        raise exceptions.InvalidConfiguration('Unsupported auth version: %s' %
                                              identity_version)

    conf_attributes = ['username', 'password', 'project_name']

    if identity_version == 'v3':
        conf_attributes.append('domain_name')
        conf_attributes.append('user_domain_name')
        conf_attributes.append('project_domain_name')
        conf_attributes.append('system')
    # Read the parts of credentials from config
    params = config.service_client_config()
    for attr in conf_attributes:
        params[attr] = getattr(CONF.auth, 'admin_' + attr)
    # Build and validate credentials. We are reading configured credentials,
    # so validate them even if fill_in is False
    credentials = get_credentials(fill_in=fill_in,
                                  identity_version=identity_version,
                                  **params)
    if not fill_in:
        if not credentials.is_valid():
            msg = ("The admin credentials are incorrectly set in the config "
                   "file for identity version %s. Double check that all "
                   "required values are assigned.")
            raise exceptions.InvalidConfiguration(msg % identity_version)
    return credentials
Пример #40
0
 def test_get_credentials_v3_domain(self, mock_auth_get_credentials):
     expected_uri = 'V3_URI'
     expected_result = 'my_creds'
     expected_domain = 'my_domain'
     mock_auth_get_credentials.return_value = expected_result
     cfg.CONF.set_default('uri_v3', expected_uri, 'identity')
     cfg.CONF.set_default('default_credentials_domain_name',
                          expected_domain, 'auth')
     params = {'foo': 'bar', 'user_domain_name': expected_domain}
     expected_params = params.copy()
     expected_params.update(config.service_client_config())
     result = cf.get_credentials(fill_in=False,
                                 identity_version='v3',
                                 **params)
     self.assertEqual(expected_result, result)
     mock_auth_get_credentials.assert_called_once_with(
         expected_uri,
         fill_in=False,
         identity_version='v3',
         **expected_params)
Пример #41
0
 def get_service_clients(self):
     dns_config = config.service_client_config('dns')
     admin_params = {
         'name': 'dns_admin',
         'service_version': 'dns.admin',
         'module_path': 'designate_tempest_plugin.services.dns.admin',
         'client_names': ['QuotasClient']
     }
     v2_params = {
         'name': 'dns_v2',
         'service_version': 'dns.v2',
         'module_path': 'designate_tempest_plugin.services.dns.v2',
         'client_names': ['BlacklistsClient', 'PoolClient', 'QuotasClient',
                          'RecordsetClient', 'TldClient',
                          'TransferAcceptClient', 'TransferRequestClient',
                          'TsigkeyClient', 'ZoneExportsClient',
                          'ZoneImportsClient', 'ZonesClient']
     }
     admin_params.update(dns_config)
     v2_params.update(dns_config)
     return [admin_params, v2_params]
Пример #42
0
 def get_service_clients(self):
     gbp_config = config.service_client_config('gbp')
     v2_params = {
         'name':
         'gbp_v2',
         'service_version':
         'gbp.v2',
         'module_path':
         'gbp_tempest_plugin.services.gbp.v2',
         'client_names': [
             'PolicyActionClient', 'PolicyClassifierClient',
             'PolicyRuleClient', 'PolicyRuleSetClient', 'L3PolicyClient',
             'L2PolicyClient', 'AppPolicyGroupClient',
             'PolicyTargetGroupClient', 'PolicyTargetClient',
             'NetworkServicePolicyClient', 'ExternalPolicyClient',
             'ExternalSegmentClient', 'NATPoolClient',
             'ServiceChainSpecClient', 'ServiceProfileClient'
         ]
     }
     v2_params.update(gbp_config)
     return [v2_params]
Пример #43
0
def get_configured_admin_credentials(fill_in=True, identity_version=None):
    """Get admin credentials from the config file

    Read credentials from configuration, builds a Credentials object based on
    the specified or configured version

    :param fill_in: If True, a request to the Token API is submitted, and the
                    credential object is filled in with all names and IDs from
                    the token API response.
    :param identity_version: The identity version to talk to and the type of
                             credentials object to be created. 'v2' or 'v3'.
    :returns: An object of a sub-type of `auth.Credentials`
    """
    identity_version = identity_version or CONF.identity.auth_version

    if identity_version not in ('v2', 'v3'):
        raise exceptions.InvalidConfiguration(
            'Unsupported auth version: %s' % identity_version)

    conf_attributes = ['username', 'password',
                       'project_name']

    if identity_version == 'v3':
        conf_attributes.append('domain_name')
    # Read the parts of credentials from config
    params = config.service_client_config()
    for attr in conf_attributes:
        params[attr] = getattr(CONF.auth, 'admin_' + attr)
    # Build and validate credentials. We are reading configured credentials,
    # so validate them even if fill_in is False
    credentials = get_credentials(fill_in=fill_in,
                                  identity_version=identity_version, **params)
    if not fill_in:
        if not credentials.is_valid():
            msg = ("The admin credentials are incorrectly set in the config "
                   "file for identity version %s. Double check that all "
                   "required values are assigned.")
            raise exceptions.InvalidConfiguration(msg % identity_version)
    return credentials
Пример #44
0
class BaseSenlinTest(test.BaseTestCase):

    credentials = ['primary']

    default_params = config.service_client_config()

    # NOTE: Tempest uses timeout values of compute API if project specific
    # timeout values don't exist.
    default_params_with_timeout_values = {
        'build_interval': CONF.compute.build_interval,
        'build_timeout': CONF.compute.build_timeout
    }
    default_params_with_timeout_values.update(default_params)

    @classmethod
    def skip_checks(cls):
        super(BaseSenlinTest, cls).skip_checks()
        if not CONF.service_available.senlin:
            skip_msg = 'Senlin is disabled'
            raise cls.skipException(skip_msg)

    @classmethod
    def setup_clients(cls):
        super(BaseSenlinTest, cls).setup_clients()
Пример #45
0
 def test_service_client_config_service_unknown(self):
     unknown_service = 'unknown_service'
     with testtools.ExpectedException(exceptions.UnknownServiceClient,
                                      '.*' + unknown_service + '.*'):
         config.service_client_config(service_client_name=unknown_service)