def test_version_data_override_version_url(self):
# if the request url is versioned already, just return it.
self.requests_mock.get(
V3_URL,
status_code=200,
json={
'version': fixture.V3Discovery('http://override/identity/v3')
})
disc = discover.Discover(self.session, V3_URL)
version_data = disc.version_data()
for v in version_data:
self.assertEqual(v['version'], (3, 0))
self.assertEqual(v['status'], discover.Status.CURRENT)
self.assertEqual(v['raw_status'], 'stable')
self.assertEqual(v['url'], V3_URL)
# if the request url is not versioned, just add version info to it.(
# do not changed the url's netloc or path)
self.requests_mock.get(
BASE_URL,
status_code=200,
json={
'version': fixture.V3Discovery('http://override/identity/v3')
})
disc = discover.Discover(self.session, BASE_URL)
version_data = disc.version_data()
for v in version_data:
self.assertEqual(v['version'], (3, 0))
self.assertEqual(v['status'], discover.Status.CURRENT)
self.assertEqual(v['raw_status'], 'stable')
self.assertEqual(v['url'], V3_URL)
def _discover_auth_versions(self, session, auth_url):
# discover the API versions the server is supporting based on the
# given URL
v2_auth_url = None
v3_auth_url = None
try:
ks_discover = discover.Discover(session=session, url=auth_url)
v2_auth_url = ks_discover.url_for('2.0')
v3_auth_url = ks_discover.url_for('3.0')
except exceptions.DiscoveryFailure:
# Discovery response mismatch. Raise the error
raise
except Exception:
# Some public clouds throw some other exception or doesn't support
# discovery. In that case try to determine version from auth_url
# API version from the original URL
url_parts = urlparse.urlparse(auth_url)
(scheme, netloc, path, params, query, fragment) = url_parts
path = path.lower()
if path.startswith('/v3'):
v3_auth_url = auth_url
elif path.startswith('/v2'):
v2_auth_url = auth_url
else:
raise exc.CommandError('Unable to determine the Keystone'
' version to authenticate with '
'using the given auth_url.')
return (v2_auth_url, v3_auth_url)
def get_trusted_client(conf, trust_id):
# Ideally we would use load_session_from_conf_options, but we can't do that
# *and* specify a trust, so let's create the object manually.
if conf[CFG_GROUP].auth_type == "password-aodh-legacy":
auth_url = conf[CFG_GROUP].os_auth_url
try:
auth_url_noneversion = auth_url.replace('/v2.0', '/')
discover = ka_discover.Discover(auth_url=auth_url_noneversion)
v3_auth_url = discover.url_for('3.0')
if v3_auth_url:
auth_url = v3_auth_url
else:
auth_url = auth_url
except Exception:
auth_url = auth_url.replace('/v2.0', '/v3')
auth_plugin = password.Password(username=conf[CFG_GROUP].os_username,
password=conf[CFG_GROUP].os_password,
auth_url=auth_url,
user_domain_id='default',
trust_id=trust_id)
else:
auth_plugin = password.Password(
username=conf[CFG_GROUP].username,
password=conf[CFG_GROUP].password,
auth_url=conf[CFG_GROUP].auth_url,
user_domain_id=conf[CFG_GROUP].user_domain_id,
trust_id=trust_id)
sess = session.Session(auth=auth_plugin)
return ks_client_v3.Client(session=sess)
def test_version_data_basics(self):
examples = {
'keystone': V3_VERSION_LIST,
'cinder': CINDER_EXAMPLES,
'glance': GLANCE_EXAMPLES
}
for path, data in examples.items():
url = "%s%s" % (BASE_URL, path)
mock = self.requests_mock.get(url, status_code=300, json=data)
disc = discover.Discover(self.session, url)
raw_data = disc.raw_version_data()
clean_data = disc.version_data()
for v in raw_data:
for n in ('id', 'status', 'links'):
msg = '%s missing from %s version data' % (n, path)
self.assertThat(
v, matchers.Annotate(msg, matchers.Contains(n)))
for v in clean_data:
for n in ('version', 'url', 'raw_status'):
msg = '%s missing from %s version data' % (n, path)
self.assertThat(
v, matchers.Annotate(msg, matchers.Contains(n)))
self.assertTrue(mock.called_once)
def test_version_data_legacy_ironic_microversions(self):
"""Validate detection of legacy Ironic microversion ranges."""
ironic_url = 'https://bare-metal.example.com/v1/'
self.requests_mock.get(ironic_url,
status_code=200,
json={
'id': 'v1',
'links': [{
"href": ironic_url,
"rel": "self"
}]
},
headers={
'X-OpenStack-Ironic-API-Minimum-Version':
'1.3',
'X-OpenStack-Ironic-API-Maximum-Version':
'1.21',
})
self.assertEqual([
{
'collection': None,
'version': (1, 0),
'url': ironic_url,
'status': discover.Status.CURRENT,
'raw_status': discover.Status.CURRENT,
'min_microversion': (1, 3),
'max_microversion': (1, 21),
'next_min_version': None,
'not_before': None,
},
],
discover.Discover(self.session,
ironic_url).version_data())
def test_allow_deprecated(self):
status = 'deprecated'
version_list = [{
'id': 'v3.0',
'links': [{
'href': V3_URL,
'rel': 'self'
}],
'media-types': V3_MEDIA_TYPES,
'status': status,
'updated': UPDATED
}]
self.requests_mock.get(BASE_URL, json={'versions': version_list})
disc = discover.Discover(self.session, BASE_URL)
# deprecated is allowed by default
versions = disc.version_data(allow_deprecated=False)
self.assertEqual(0, len(versions))
versions = disc.version_data(allow_deprecated=True)
self.assertEqual(1, len(versions))
self.assertEqual(status, versions[0]['raw_status'])
self.assertEqual(V3_URL, versions[0]['url'])
self.assertEqual((3, 0), versions[0]['version'])
def test_ignoring_invalid_links(self):
version_list = [{'id': 'v3.0',
'links': [{'href': V3_URL, 'rel': 'self'}],
'media-types': V3_MEDIA_TYPES,
'status': 'stable',
'updated': UPDATED},
{'id': 'v3.1',
'media-types': V3_MEDIA_TYPES,
'status': 'stable',
'updated': UPDATED},
{'media-types': V3_MEDIA_TYPES,
'status': 'stable',
'updated': UPDATED,
'links': [{'href': V3_URL, 'rel': 'self'}],
}]
self.requests_mock.get(BASE_URL, json={'versions': version_list})
disc = discover.Discover(self.session, BASE_URL)
# raw_version_data will return all choices, even invalid ones
versions = disc.raw_version_data()
self.assertEqual(3, len(versions))
# only the version with both id and links will be actually returned
versions = disc.version_data()
self.assertEqual(1, len(versions))
def _discover_auth_versions(session, auth_url):
# discover the API versions the server is supporting based on the
# given URL
v2_auth_url = None
v3_auth_url = None
try:
ks_discover = discover.Discover(session=session, url=auth_url)
v2_auth_url = ks_discover.url_for('2.0')
v3_auth_url = ks_discover.url_for('3.0')
except ka_exc.DiscoveryFailure:
raise
except exceptions.ClientException:
# Identity service may not support discovery. In that case,
# try to determine version from auth_url
url_parts = urlparse.urlparse(auth_url)
(scheme, netloc, path, params, query, fragment) = url_parts
path = path.lower()
if path.startswith('/v3'):
v3_auth_url = auth_url
elif path.startswith('/v2'):
v2_auth_url = auth_url
else:
raise exc.CommandError('Unable to determine the Keystone '
'version to authenticate with '
'using the given auth_url.')
return v2_auth_url, v3_auth_url
def _discover_auth_versions(self, session, auth_url):
# discover the API versions the server is supporting base on the
# given URL
v2_auth_url = None
v3_auth_url = None
try:
ks_discover = discover.Discover(session=session, url=auth_url)
v2_auth_url = ks_discover.url_for('2.0')
v3_auth_url = ks_discover.url_for('3.0')
except ks_exc.ClientException as e:
# Identity service may not support discover API version.
# Lets trying to figure out the API version from the original URL.
url_parts = urlparse.urlparse(auth_url)
(scheme, netloc, path, params, query, fragment) = url_parts
path = path.lower()
if path.startswith('/v3'):
v3_auth_url = auth_url
elif path.startswith('/v2'):
v2_auth_url = auth_url
else:
# not enough information to determine the auth version
msg = ('Unable to determine the Keystone version '
'to authenticate with using the given '
'auth_url. Identity service may not support API '
'version discovery. Please provide a versioned '
'auth_url instead. error=%s') % (e)
raise exc.CommandError(msg)
return (v2_auth_url, v3_auth_url)
def get_versions(auth_url):
from keystoneauth1 import discover
from keystoneauth1 import session
temp_session = session.Session(
verify=(self.credential.https_cacert or
not self.credential.https_insecure),
timeout=CONF.openstack_client_http_timeout)
data = discover.Discover(temp_session, auth_url).version_data()
return dict([(v["version"][0], v["url"]) for v in data])
def test_version_data_unknown(self):
discovery_fixture = fixture.V3Discovery(V3_URL)
discovery_fixture.status = 'hungry'
discovery_doc = _create_single_version(discovery_fixture)
self.requests_mock.get(V3_URL, status_code=200, json=discovery_doc)
disc = discover.Discover(self.session, V3_URL)
clean_data = disc.version_data(allow_unknown=True)
self.assertEqual(discover.Status.UNKNOWN, clean_data[0]['status'])
def get_session(self, version=None):
key = "keystone_session_and_plugin_%s" % version
if key not in self.cache:
from keystoneauth1 import discover
from keystoneauth1 import identity
from keystoneauth1 import session
version = self.choose_version(version)
auth_url = self.credential.auth_url
if version is not None:
auth_url = self._remove_url_version()
password_args = {
"auth_url": auth_url,
"username": self.credential.username,
"password": self.credential.password,
"tenant_name": self.credential.tenant_name
}
if version is None:
# NOTE(rvasilets): If version not specified than we discover
# available version with the smallest number. To be able to
# discover versions we need session
temp_session = session.Session(
verify=(self.credential.https_cacert
or not self.credential.https_insecure),
cert=self.credential.https_cert,
timeout=CONF.openstack_client_http_timeout)
version = str(
discover.Discover(
temp_session,
password_args["auth_url"]).version_data()[0]["version"]
[0])
temp_session.session.close()
if "v2.0" not in password_args["auth_url"] and version != "2":
password_args.update({
"user_domain_name":
self.credential.user_domain_name,
"domain_name":
self.credential.domain_name,
"project_domain_name":
self.credential.project_domain_name
})
identity_plugin = identity.Password(**password_args)
sess = session.Session(
auth=identity_plugin,
verify=(self.credential.https_cacert
or not self.credential.https_insecure),
cert=self.credential.https_cert,
timeout=CONF.openstack_client_http_timeout)
self.cache[key] = (sess, identity_plugin)
return self.cache[key]
def test_data_for_url(self):
mock = self.requests_mock.get(V3_URL,
status_code=200,
json=V3_VERSION_ENTRY)
disc = discover.Discover(self.session, V3_URL)
for url in (V3_URL, V3_URL + '/'):
data = disc.versioned_data_for(url=url)
self.assertEqual(data['version'], (3, 0))
self.assertEqual(data['raw_status'], 'stable')
self.assertEqual(data['url'], V3_URL)
self.assertTrue(mock.called_once)
def get_endpoint(self, session, interface=None, version=None, **kwargs):
"""Return an endpoint for the client.
There are no required keyword arguments to ``get_endpoint`` as a plugin
implementation should use best effort with the information available to
determine the endpoint.
:param session: The session object that the auth_plugin belongs to.
:type session: keystoneauth1.session.Session
:param version: The version number required for this endpoint.
:type version: tuple or str
:param str interface: what visibility the endpoint should have.
:returns: The base URL that will be used to talk to the required
service or None if not available.
:rtype: string
"""
if interface == plugin.AUTH_INTERFACE:
return self._identity_uri
if not version:
# NOTE(jamielennox): This plugin can only be used within auth_token
# and auth_token will always provide version= with requests.
return None
if not self._discover:
self._discover = discover.Discover(session,
url=self._identity_uri,
authenticated=False)
if not self._discover.url_for(version):
# NOTE(jamielennox): The requested version is not supported by the
# identity server.
return None
# NOTE(jamielennox): for backwards compatibility here we don't
# actually use the URL from discovery we hack it up instead. :(
# NOTE(blk-u): Normalizing the version is a workaround for bug 1450272.
# This can be removed once that's fixed. Also fix the docstring for the
# version parameter to be just "tuple".
version = discover.normalize_version_number(version)
if discover.version_match((2, 0), version):
return '%s/v2.0' % self._identity_uri
elif discover.version_match((3, 0), version):
return '%s/v3' % self._identity_uri
# NOTE(jamielennox): This plugin will only get called from auth_token
# middleware. The middleware should never request a version that the
# plugin doesn't know how to handle.
msg = _('Invalid version asked for in auth_token plugin')
raise NotImplementedError(msg)
def test_data_for_no_version(self):
mock = self.requests_mock.get(V3_URL,
status_code=200,
json=V3_VERSION_ENTRY)
disc = discover.Discover(self.session, V3_URL)
data = disc.versioned_data_for()
self.assertEqual(data['version'], (3, 0))
self.assertEqual(data['raw_status'], 'stable')
self.assertEqual(data['url'], V3_URL)
self.assertRaises(TypeError, disc.data_for, version=None)
self.assertTrue(mock.called_once)
def test_ok(versions_in, versions_out):
setup_mock(versions_in)
# Ensure the output contains the expected microversions
self.assertEqual([
dict(
{
'collection': None,
'version': (2, 2),
'url': V3_URL,
'raw_status': 'CURRENT',
}, **versions_out)
],
discover.Discover(self.session,
V3_URL).version_data())
def get_auth_uri(v3=True):
# Look for the keystone auth_uri in the configuration. First we
# check the [clients_keystone] section, and if it is not set we
# look in [keystone_authtoken]
if cfg.CONF.clients_keystone.auth_uri:
session = ks_session.Session(**config.get_ssl_options('keystone'))
discover = ks_discover.Discover(session=session,
url=cfg.CONF.clients_keystone.auth_uri)
return discover.url_for('3.0')
else:
# Import auth_token to have keystone_authtoken settings setup.
importutils.import_module('keystonemiddleware.auth_token')
auth_uri = cfg.CONF.keystone_authtoken.www_authenticate_uri
return auth_uri.replace('v2.0', 'v3') if auth_uri and v3 else auth_uri
def get_discovery(self, session, url, authenticated=None):
"""Return the discovery object for a URL.
Check the session and the plugin cache to see if we have already
performed discovery on the URL and if so return it, otherwise create
a new discovery object, cache it and return it.
This function is expected to be used by subclasses and should not
be needed by users.
:param session: A session object to discover with.
:type session: keystonauth.session.Session
:param str url: The url to lookup.
:param bool authenticated: Include a token in the discovery call.
(optional) Defaults to None (use a token
if a plugin is installed).
:raises keystonauth.exceptions.DiscoveryFailure: if for some reason
the lookup fails.
:raises keystonauth.exceptions.HttpError: An error from an invalid
HTTP response.
:returns: A discovery object with the results of looking up that URL.
"""
# NOTE(jamielennox): we want to cache endpoints on the session as well
# so that they maintain sharing between auth plugins. Create a cache on
# the session if it doesn't exist already.
try:
session_endpoint_cache = session._identity_endpoint_cache
except AttributeError:
session_endpoint_cache = session._identity_endpoint_cache = {}
# NOTE(jamielennox): There is a cache located on both the session
# object and the auth plugin object so that they can be shared and the
# cache is still usable
for cache in (self._endpoint_cache, session_endpoint_cache):
disc = cache.get(url)
if disc:
break
else:
disc = discover.Discover(session, url,
authenticated=authenticated)
self._endpoint_cache[url] = disc
session_endpoint_cache[url] = disc
return disc
def test_allow_unknown(self):
status = 'abcdef'
version_list = fixture.DiscoveryList(BASE_URL,
v2=False,
v3_status=status)
self.requests_mock.get(BASE_URL, json=version_list)
disc = discover.Discover(self.session, BASE_URL)
versions = disc.version_data()
self.assertEqual(0, len(versions))
versions = disc.version_data(allow_unknown=True)
self.assertEqual(1, len(versions))
self.assertEqual(status, versions[0]['raw_status'])
self.assertEqual(V3_URL, versions[0]['url'])
self.assertEqual((3, 0), versions[0]['version'])
def _get_session(self, auth_url=None, version=None):
from keystoneauth1 import discover
from keystoneauth1 import session
from keystoneclient.auth import identity
password_args = {
"auth_url": auth_url or self.credential.auth_url,
"username": self.credential.username,
"password": self.credential.password,
"tenant_name": self.credential.tenant_name
}
version = OSClient.get("keystone")(self.credential, self.api_info,
self.cache).choose_version(version)
if version is None:
# NOTE(rvasilets): If version not specified than we discover
# available version with the smallest number. To be able to
# discover versions we need session
temp_session = session.Session(
verify=(self.credential.cacert
or not self.credential.insecure),
timeout=CONF.openstack_client_http_timeout)
version = str(
discover.Discover(
temp_session,
password_args["auth_url"]).version_data()[0]["version"][0])
if "v2.0" not in password_args["auth_url"] and (version != "2"):
password_args.update({
"user_domain_name":
self.credential.user_domain_name,
"domain_name":
self.credential.domain_name,
"project_domain_name":
self.credential.project_domain_name,
})
identity_plugin = identity.Password(**password_args)
sess = session.Session(auth=identity_plugin,
verify=(self.credential.cacert
or not self.credential.insecure),
timeout=CONF.openstack_client_http_timeout)
return sess, identity_plugin
def test_version_data_individual(self):
mock = self.requests_mock.get(V3_URL,
status_code=200,
json=V3_VERSION_ENTRY)
disc = discover.Discover(self.session, V3_URL)
raw_data = disc.raw_version_data()
clean_data = disc.version_data()
for v in raw_data:
self.assertEqual(v['id'], 'v3.0')
self.assertEqual(v['status'], 'stable')
self.assertIn('media-types', v)
self.assertIn('links', v)
for v in clean_data:
self.assertEqual(v['version'], (3, 0))
self.assertEqual(v['raw_status'], 'stable')
self.assertEqual(v['url'], V3_URL)
self.assertTrue(mock.called_once)
def Client(self):
sess = None
keystone = None
version = self.conf.os_identity_api_version
# switch on keystoneauth1
if self.conf.use_keystoneauth1:
globals()['v2'] = authv2
globals()['v3'] = authv3
globals()['session'] = auth_session
if self.conf.keystoneauth1.use_loading:
if self.conf.debug:
plugin_loaders = loading.get_available_plugin_loaders()
avail_plugins = loading.get_available_plugin_names()
logger.debug('Available plugin loaders: %s' %
sorted(plugin_loaders.iteritems()))
logger.debug('Available plugins: %s' %
sorted(avail_plugins))
loader = loading.get_plugin_loader('password')
self.logger.debug('loader: %s' % loader)
auth_args = self._get_auth_args()
auth = loader.load_from_options(**auth_args)
# Discover with session
if self.conf.keystoneauth1.use_discovery:
if self.conf.null_session_discovery:
# gem from ceilometerclient.client...
s = session.Session()
else:
s = session.Session(auth=auth)
url = self.os_service_endpoint
discover = kauth_discover.Discover(session=s, url=url)
self.logger.debug('discover: %s' % discover)
self.logger.debug('discovered version data: %s' %
discover.version_data())
disc_auth_url = discover.url_for(version)
self.logger.debug('discovered urls: %s' % disc_auth_url)
# Re-init auth args and auth...
# Not doing this generates interesting error using Identity v3: (remove and attempt v2 for magic!!)
# keystoneauth1.exceptions.http.Forbidden: You are not authorized to perform the requested action: identity:list_projects
auth_kwargs = self._get_auth_args(auth_url=disc_auth_url,
version=version)
auth = loader.load_from_options(**auth_kwargs)
else:
raise Exception('Non-discovery approach not implemented.')
else:
auth = self._get_password_auth()
if not self.conf.keystoneauth1.use_sessions:
raise Exception('Non-session approach not supported.')
sess = session.Session(auth=auth)
keystone = keystoneclient.client.Client(version, session=sess)
else:
# Using deprecated keystoneclient mechanisms
# TODO: try generic passwords -- not possible w/o keystoneauth1
auth = self._get_password_auth()
if self.conf.keystoneclient.use_sessions:
# TODO: use discovery
if self.conf.keystoneclient.use_discovery:
# ^^^ seems not possible without versioned urls?
auth_args = self._get_auth_args()
# TODO: could i use keystoneauth1 loading here...?
auth = self._get_password_auth(**auth_args)
sess = legacy_session.Session(auth=auth)
# /home/kmidzi/projects/rdtibcc-679/local/lib/python2.7/site-packages/keystoneclient/session.py:17
# what is implication of import keystoneauth1? advent?
try:
url = self.os_service_endpoint
discover = ks_discover.Discover(session=sess, url=url)
self.logger.debug('discover: %s' % discover)
self.logger.debug('discovered version data: %s' %
discover.version_data())
disc_auth_url = discover.url_for(version)
self.logger.debug('discovered urls: %s' %
disc_auth_url)
except Exception as e:
raise (Exception('Could not discover: %s' % e.message))
else:
sess = keystoneclient.session.Session(auth=auth)
# keystoneclient.exceptions.DiscoveryFailure: Not enough information to determine URL. Provide either auth_url or endpoint
keystone = keystoneclient.client.Client(version, session=sess)
else:
raise Exception('Non-session approach not implemented.')
self._sess = sess
self.logger.info('Auth object: %s' % auth)
self.logger.info('Session object: %s' % sess)
return keystone
def test_glance_version_data(self):
mock = self.requests_mock.get(BASE_URL,
status_code=200,
json=GLANCE_EXAMPLES)
disc = discover.Discover(self.session, BASE_URL)
raw_data = disc.raw_version_data()
clean_data = disc.version_data()
self.assertEqual(5, len(raw_data))
for v in raw_data:
if v['id'] in ('v2.2', 'v1.1'):
self.assertEqual(v['status'], 'CURRENT')
elif v['id'] in ('v2.1', 'v2.0', 'v1.0'):
self.assertEqual(v['status'], 'SUPPORTED')
else:
self.fail("Invalid version found")
v1_url = '%sv1/' % BASE_URL
v2_url = '%sv2/' % BASE_URL
self.assertEqual(clean_data, [
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (1, 0),
'url': v1_url,
'raw_status': 'SUPPORTED',
},
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (1, 1),
'url': v1_url,
'raw_status': 'CURRENT',
},
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (2, 0),
'url': v2_url,
'raw_status': 'SUPPORTED',
},
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (2, 1),
'url': v2_url,
'raw_status': 'SUPPORTED',
},
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (2, 2),
'url': v2_url,
'raw_status': 'CURRENT',
},
])
for ver in (2, 2.1, 2.2):
for version in (disc.data_for(ver),
disc.versioned_data_for(
min_version=ver,
max_version=(2, discover.LATEST))):
self.assertEqual((2, 2), version['version'])
self.assertEqual('CURRENT', version['raw_status'])
self.assertEqual(v2_url, version['url'])
self.assertEqual(v2_url, disc.url_for(ver))
for ver in (1, 1.1):
for version in (disc.data_for(ver),
disc.versioned_data_for(
min_version=ver,
max_version=(1, discover.LATEST))):
self.assertEqual((1, 1), version['version'])
self.assertEqual('CURRENT', version['raw_status'])
self.assertEqual(v1_url, version['url'])
self.assertEqual(v1_url, disc.url_for(ver))
self.assertIsNone(disc.url_for('v3'))
self.assertIsNone(
disc.versioned_url_for(min_version='v3', max_version='v3.latest'))
self.assertIsNone(disc.url_for('v2.3'))
self.assertIsNone(
disc.versioned_url_for(min_version='v2.3',
max_version='v2.latest'))
self.assertTrue(mock.called_once)
def test_cinder_version_data(self):
mock = self.requests_mock.get(BASE_URL,
status_code=300,
json=CINDER_EXAMPLES)
disc = discover.Discover(self.session, BASE_URL)
raw_data = disc.raw_version_data()
clean_data = disc.version_data()
self.assertEqual(3, len(raw_data))
for v in raw_data:
self.assertEqual(v['status'], 'CURRENT')
if v['id'] == 'v1.0':
self.assertEqual(v['updated'], '2012-01-04T11:33:21Z')
elif v['id'] == 'v2.0':
self.assertEqual(v['updated'], '2012-11-21T11:33:21Z')
elif v['id'] == 'v3.0':
self.assertEqual(v['updated'], '2012-11-21T11:33:21Z')
else:
self.fail("Invalid version found")
v1_url = "%sv1/" % BASE_URL
v2_url = "%sv2/" % BASE_URL
v3_url = "%sv3/" % BASE_URL
self.assertEqual(clean_data, [
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (1, 0),
'url': v1_url,
'raw_status': 'CURRENT',
},
{
'collection': None,
'max_microversion': None,
'min_microversion': None,
'next_min_version': None,
'not_before': None,
'version': (2, 0),
'url': v2_url,
'raw_status': 'CURRENT',
},
{
'collection': BASE_URL,
'max_microversion': (3, 27),
'min_microversion': (3, 0),
'next_min_version': (3, 4),
'not_before': u'2019-12-31',
'version': (3, 0),
'url': v3_url,
'raw_status': 'CURRENT',
},
])
for version in (disc.data_for('v2.0'),
disc.versioned_data_for(min_version='v2.0',
max_version='v2.latest')):
self.assertEqual((2, 0), version['version'])
self.assertEqual('CURRENT', version['raw_status'])
self.assertEqual(v2_url, version['url'])
for version in (disc.data_for(1),
disc.versioned_data_for(
min_version=(1, ),
max_version=(1, discover.LATEST))):
self.assertEqual((1, 0), version['version'])
self.assertEqual('CURRENT', version['raw_status'])
self.assertEqual(v1_url, version['url'])
self.assertIsNone(disc.url_for('v4'))
self.assertIsNone(
disc.versioned_url_for(min_version='v4', max_version='v4.latest'))
self.assertEqual(v3_url, disc.url_for('v3'))
self.assertEqual(
v3_url,
disc.versioned_url_for(min_version='v3', max_version='v3.latest'))
self.assertEqual(v2_url, disc.url_for('v2'))
self.assertEqual(
v2_url,
disc.versioned_url_for(min_version='v2', max_version='v2.latest'))
self.assertEqual(v1_url, disc.url_for('v1'))
self.assertEqual(
v1_url,
disc.versioned_url_for(min_version='v1', max_version='v1.latest'))
self.assertTrue(mock.called_once)
def test_keystone_version_data(self):
mock = self.requests_mock.get(BASE_URL,
status_code=300,
json=V3_VERSION_LIST)
disc = discover.Discover(self.session, BASE_URL)
raw_data = disc.raw_version_data()
clean_data = disc.version_data()
self.assertEqual(2, len(raw_data))
self.assertEqual(2, len(clean_data))
for v in raw_data:
self.assertIn(v['id'], ('v2.0', 'v3.0'))
self.assertEqual(v['updated'], UPDATED)
self.assertEqual(v['status'], 'stable')
if v['id'] == 'v3.0':
self.assertEqual(v['media-types'], V3_MEDIA_TYPES)
for v in clean_data:
self.assertIn(v['version'], ((2, 0), (3, 0)))
self.assertEqual(v['raw_status'], 'stable')
valid_v3_versions = (disc.data_for('v3.0'), disc.data_for('3.latest'),
disc.data_for('latest'),
disc.versioned_data_for(min_version='v3.0',
max_version='v3.latest'),
disc.versioned_data_for(min_version='3'),
disc.versioned_data_for(min_version='3.latest'),
disc.versioned_data_for(min_version='latest'),
disc.versioned_data_for(min_version='3.latest',
max_version='latest'),
disc.versioned_data_for(min_version='latest',
max_version='latest'),
disc.versioned_data_for(min_version=2),
disc.versioned_data_for(min_version='2.latest'))
for version in valid_v3_versions:
self.assertEqual((3, 0), version['version'])
self.assertEqual('stable', version['raw_status'])
self.assertEqual(V3_URL, version['url'])
valid_v2_versions = (disc.data_for(2), disc.data_for('2.latest'),
disc.versioned_data_for(
min_version=2,
max_version=(2, discover.LATEST)),
disc.versioned_data_for(min_version='2.latest',
max_version='2.latest'))
for version in valid_v2_versions:
self.assertEqual((2, 0), version['version'])
self.assertEqual('stable', version['raw_status'])
self.assertEqual(V2_URL, version['url'])
self.assertIsNone(disc.url_for('v4'))
self.assertIsNone(
disc.versioned_url_for(min_version='v4', max_version='v4.latest'))
self.assertEqual(V3_URL, disc.url_for('v3'))
self.assertEqual(
V3_URL,
disc.versioned_url_for(min_version='v3', max_version='v3.latest'))
self.assertEqual(V2_URL, disc.url_for('v2'))
self.assertEqual(
V2_URL,
disc.versioned_url_for(min_version='v2', max_version='v2.latest'))
self.assertTrue(mock.called_once)
def test_exc(versions_in):
setup_mock(versions_in)
# Ensure TypeError is raised
self.assertRaises(
TypeError,
discover.Discover(self.session, V3_URL).version_data)
