desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'GET /policies/{policy_id}'
| def test_get_policy(self):
| r = self.get(('/policies/%(policy_id)s' % {'policy_id': self.policy_id}))
self.assertValidPolicyResponse(r, self.policy)
|
'PATCH /policies/{policy_id}'
| def test_update_policy(self):
| policy = self.new_policy_ref()
policy['id'] = self.policy_id
r = self.patch(('/policies/%(policy_id)s' % {'policy_id': self.policy_id}), body={'policy': policy})
self.assertValidPolicyResponse(r, policy)
|
'DELETE /policies/{policy_id}'
| def test_delete_policy(self):
| self.delete(('/policies/%(policy_id)s' % {'policy_id': self.policy_id}))
|
'Parses two XML documents from strings and compares the results.
This provides easy-to-read failures from nose.'
| def assertEqualXML(self, a, b):
| parser = etree.XMLParser(remove_blank_text=True)
def canonical_xml(s):
s = s.strip()
fp = StringIO.StringIO()
dom = etree.fromstring(s, parser)
dom.getroottree().write_c14n(fp)
s = fp.getvalue()
dom = etree.fromstring(s, parser)
return etree.tostring(dom, ... |
'Ignores the passed in args.'
| def __init__(self, *args, **kwargs):
| self.cache = {}
|
'Retrieves the value for a key or None.'
| def get(self, key):
| self.check_key(key)
obj = self.cache.get(key)
now = utils.unixtime(timeutils.utcnow())
if (obj and ((obj[1] == 0) or (obj[1] > now))):
return obj[0]
|
'Sets the value for a key.'
| def set(self, key, value, time=0):
| self.check_key(key)
self.cache[key] = (value, time)
return True
|
'Test for getting roles for user on a domain.
Test Plan:
- Create a domain, with 2 users
- Check no roles yet exit
- Give user1 two roles on the domain, user2 one role
- Get roles on user1 and the domain - maybe sure we only
get back the 2 roles on user1
- Delete both roles from user1
- Check we get no roles back for u... | def test_get_roles_for_user_and_domain(self):
| new_domain = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
self.identity_api.create_domain(new_domain['id'], new_domain)
new_user1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex, 'password': uuid.uuid4().hex, 'enabled': True, 'domain_id': new_domain['id']}
self.identity_api.create_user(new_use... |
'Test errors raised when getting roles for user on a domain.
Test Plan:
- Check non-existing user gives UserNotFound
- Check non-existing domain gives DomainNotFound'
| def test_get_roles_for_user_and_domain_404(self):
| new_domain = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
self.identity_api.create_domain(new_domain['id'], new_domain)
new_user1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex, 'password': uuid.uuid4().hex, 'enabled': True, 'domain_id': new_domain['id']}
self.identity_api.create_user(new_use... |
'Regression test for building the tree names'
| def test_build_tree(self):
| user_api = identity.backends.ldap.UserApi(CONF)
self.assertTrue(user_api)
self.assertEquals(user_api.tree_dn, ('ou=Users,%s' % CONF.ldap.suffix))
|
'Don\'t bind in case the user and password are blank'
| def test_user_api_get_connection_no_user_password(self):
| self.config([test.etcdir('keystone.conf.sample'), test.testsdir('test_overrides.conf')])
CONF.ldap.url = 'fake://memory'
user_api = identity.backends.ldap.UserApi(CONF)
self.stubs.Set(fakeldap, 'FakeLdap', self.mox.CreateMock(fakeldap.FakeLdap))
conn = self.mox.CreateMockAnything()
conn = fakeld... |
'Tests /v2.0/tokens and /v2.0/tokens/ normalized URLs match.'
| def test_trailing_slash_normalization(self):
| req1 = webob.Request.blank('/v2.0/tokens')
req2 = webob.Request.blank('/v2.0/tokens/')
self.middleware(req1.environ, self.start_fake_response)
self.middleware(req2.environ, self.start_fake_response)
self.assertEqual(req1.path_url, req2.path_url)
self.assertEqual(req1.path_url, 'http://localhost/... |
'Tests empty path is rewritten to root.'
| def test_rewrite_empty_path(self):
| req = webob.Request.blank('')
self.middleware(req.environ, self.start_fake_response)
self.assertEqual(req.path_url, 'http://localhost/')
|
'Make sure both public and admin API work with 1-way SSL.'
| def test_1way_ssl_ok(self):
| self.public_server = self.serveapp('keystone', name='main', cert=CERT, key=KEY, ca=CA)
self.admin_server = self.serveapp('keystone', name='admin', cert=CERT, key=KEY, ca=CA)
conn = httplib.HTTPSConnection('127.0.0.1', CONF.admin_port)
conn.request('GET', '/')
resp = conn.getresponse()
self.asser... |
'Make sure both public and admin API work with 2-way SSL. Requires
client certificate.'
| def test_2way_ssl_ok(self):
| self.public_server = self.serveapp('keystone', name='main', cert=CERT, key=KEY, ca=CA, cert_required=True)
self.admin_server = self.serveapp('keystone', name='admin', cert=CERT, key=KEY, ca=CA, cert_required=True)
conn = httplib.HTTPSConnection('127.0.0.1', CONF.admin_port, CLIENT, CLIENT)
conn.request(... |
'Make sure both public and admin API work with 1-way ipv6 & SSL.'
| def test_1way_ssl_with_ipv6_ok(self):
| self.skip_if_no_ipv6()
self.public_server = self.serveapp('keystone', name='main', cert=CERT, key=KEY, ca=CA, host='::1', port=0)
self.admin_server = self.serveapp('keystone', name='admin', cert=CERT, key=KEY, ca=CA, host='::1', port=0)
conn = httplib.HTTPSConnection('::1', CONF.admin_port)
conn.req... |
'Make sure both public and admin API work with 2-way ipv6 & SSL.
Requires client certificate.'
| def test_2way_ssl_with_ipv6_ok(self):
| self.skip_if_no_ipv6()
self.public_server = self.serveapp('keystone', name='main', cert=CERT, key=KEY, ca=CA, cert_required=True, host='::1', port=0)
self.admin_server = self.serveapp('keystone', name='admin', cert=CERT, key=KEY, ca=CA, cert_required=True, host='::1', port=0)
conn = httplib.HTTPSConnect... |
'Expect to fail when client does not present proper certificate.'
| def test_2way_ssl_fail(self):
| self.public_server = self.serveapp('keystone', name='main', cert=CERT, key=KEY, ca=CA, cert_required=True)
self.admin_server = self.serveapp('keystone', name='admin', cert=CERT, key=KEY, ca=CA, cert_required=True)
conn = httplib.HTTPSConnection('127.0.0.1', CONF.admin_port)
try:
conn.request('GE... |
'Asserts that a given method raises 501 Not Implemented.
Provides each argument with a value of None, ignoring optional
arguments.'
| def assertMethodNotImplemented(self, f):
| args = inspect.getargspec(f).args
args.remove('self')
kwargs = dict(zip(args, ([None] * len(args))))
with self.assertRaises(exception.NotImplemented):
f(**kwargs)
|
'Public methods on an interface class should not be implemented.'
| def assertInterfaceNotImplemented(self, interface):
| for name in dir(interface):
method = getattr(interface, name)
if ((name[0] != '_') and callable(method)):
self.assertMethodNotImplemented(method)
|
'POST /domains'
| def test_create_domain(self):
| ref = self.new_domain_ref()
r = self.post('/domains', body={'domain': ref})
return self.assertValidDomainResponse(r, ref)
|
'GET /domains'
| def test_list_domains(self):
| r = self.get('/domains')
self.assertValidDomainListResponse(r, ref=self.domain)
|
'GET /domains (xml data)'
| def test_list_domains_xml(self):
| r = self.get('/domains', content_type='xml')
self.assertValidDomainListResponse(r, ref=self.domain)
|
'GET /domains/{domain_id}'
| def test_get_domain(self):
| r = self.get(('/domains/%(domain_id)s' % {'domain_id': self.domain_id}))
self.assertValidDomainResponse(r, self.domain)
|
'PATCH /domains/{domain_id}'
| def test_update_domain(self):
| ref = self.new_domain_ref()
del ref['id']
r = self.patch(('/domains/%(domain_id)s' % {'domain_id': self.domain_id}), body={'domain': ref})
self.assertValidDomainResponse(r, ref)
|
'PATCH /domains/{domain_id} (set enabled=False)'
| def test_disable_domain(self):
| self.domain2 = self.new_domain_ref()
self.identity_api.create_domain(self.domain2['id'], self.domain2)
self.project2 = self.new_project_ref(domain_id=self.domain2['id'])
self.identity_api.create_project(self.project2['id'], self.project2)
self.user2 = self.new_user_ref(domain_id=self.domain2['id'], ... |
'DELETE /domains/{domain_id}...(when domain enabled)'
| def test_delete_enabled_domain_fails(self):
| self.delete(('/domains/%(domain_id)s' % {'domain_id': self.domain['id']}), expected_status=exception.ForbiddenAction.code)
|
'DELETE /domains/{domain_id}
The sample data set up already has a user, group, project
and credential that is part of self.domain. Since the user
we will authenticate with is in this domain, we create a
another set of entities in a second domain. Deleting this
second domain should delete all these new entities. In add... | def test_delete_domain(self):
| self.domain2 = self.new_domain_ref()
self.identity_api.create_domain(self.domain2['id'], self.domain2)
self.project2 = self.new_project_ref(domain_id=self.domain2['id'])
self.identity_api.create_project(self.project2['id'], self.project2)
self.user2 = self.new_user_ref(domain_id=self.domain2['id'], ... |
'GET /projects'
| def test_list_projects(self):
| r = self.get('/projects')
self.assertValidProjectListResponse(r, ref=self.project)
|
'GET /projects (xml data)'
| def test_list_projects_xml(self):
| r = self.get('/projects', content_type='xml')
self.assertValidProjectListResponse(r, ref=self.project)
|
'POST /projects'
| def test_create_project(self):
| ref = self.new_project_ref(domain_id=self.domain_id)
r = self.post('/projects', body={'project': ref})
self.assertValidProjectResponse(r, ref)
|
'GET /projects/{project_id}'
| def test_get_project(self):
| r = self.get(('/projects/%(project_id)s' % {'project_id': self.project_id}))
self.assertValidProjectResponse(r, self.project)
|
'PATCH /projects/{project_id}'
| def test_update_project(self):
| ref = self.new_project_ref(domain_id=self.domain_id)
del ref['id']
r = self.patch(('/projects/%(project_id)s' % {'project_id': self.project_id}), body={'project': ref})
self.assertValidProjectResponse(r, ref)
|
'DELETE /projects/{project_id}
As well as making sure the delete succeeds, we ensure
that any credentials that reference this projects are
also deleted, while other credentials are unaffected.'
| def test_delete_project(self):
| r = self.identity_api.get_credential(self.credential['id'])
self.assertDictEqual(r, self.credential)
self.project2 = self.new_project_ref(domain_id=self.domain['id'])
self.identity_api.create_project(self.project2['id'], self.project2)
self.credential2 = self.new_credential_ref(user_id=self.user['id... |
'POST /users'
| def test_create_user(self):
| ref = self.new_user_ref(domain_id=self.domain_id)
r = self.post('/users', body={'user': ref})
return self.assertValidUserResponse(r, ref)
|
'GET /users'
| def test_list_users(self):
| r = self.get('/users')
self.assertValidUserListResponse(r, ref=self.user)
|
'GET /users (xml data)'
| def test_list_users_xml(self):
| r = self.get('/users', content_type='xml')
self.assertValidUserListResponse(r, ref=self.user)
|
'GET /users/{user_id}'
| def test_get_user(self):
| r = self.get(('/users/%(user_id)s' % {'user_id': self.user['id']}))
self.assertValidUserResponse(r, self.user)
|
'PUT /groups/{group_id}/users/{user_id}'
| def test_add_user_to_group(self):
| self.put(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
|
'HEAD /groups/{group_id}/users/{user_id}'
| def test_check_user_in_group(self):
| self.put(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
self.head(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
|
'GET /groups/{group_id}/users'
| def test_list_users_in_group(self):
| r = self.put(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
r = self.get(('/groups/%(group_id)s/users' % {'group_id': self.group_id}))
self.assertValidUserListResponse(r, ref=self.user)
self.assertIn(('/groups/%(group_id)s/users' % {'group_id': self... |
'DELETE /groups/{group_id}/users/{user_id}'
| def test_remove_user_from_group(self):
| self.put(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
self.delete(('/groups/%(group_id)s/users/%(user_id)s' % {'group_id': self.group_id, 'user_id': self.user['id']}))
|
'PATCH /users/{user_id}'
| def test_update_user(self):
| user = self.new_user_ref(domain_id=self.domain_id)
del user['id']
r = self.patch(('/users/%(user_id)s' % {'user_id': self.user['id']}), body={'user': user})
self.assertValidUserResponse(r, user)
|
'DELETE /users/{user_id}
As well as making sure the delete succeeds, we ensure
that any credentials that reference this user are
also deleted, while other credentials are unaffected.
In addition, no tokens should remain valid for this user.'
| def test_delete_user(self):
| r = self.identity_api.get_credential(self.credential['id'])
self.assertDictEqual(r, self.credential)
self.user2 = self.new_user_ref(domain_id=self.domain['id'], project_id=self.project['id'])
self.identity_api.create_user(self.user2['id'], self.user2)
self.credential2 = self.new_credential_ref(user_... |
'POST /groups'
| def test_create_group(self):
| ref = self.new_group_ref(domain_id=self.domain_id)
r = self.post('/groups', body={'group': ref})
return self.assertValidGroupResponse(r, ref)
|
'GET /groups'
| def test_list_groups(self):
| r = self.get('/groups')
self.assertValidGroupListResponse(r, ref=self.group)
|
'GET /groups (xml data)'
| def test_list_groups_xml(self):
| r = self.get('/groups', content_type='xml')
self.assertValidGroupListResponse(r, ref=self.group)
|
'GET /groups/{group_id}'
| def test_get_group(self):
| r = self.get(('/groups/%(group_id)s' % {'group_id': self.group_id}))
self.assertValidGroupResponse(r, self.group)
|
'PATCH /groups/{group_id}'
| def test_update_group(self):
| group = self.new_group_ref(domain_id=self.domain_id)
del group['id']
r = self.patch(('/groups/%(group_id)s' % {'group_id': self.group_id}), body={'group': group})
self.assertValidGroupResponse(r, group)
|
'DELETE /groups/{group_id}'
| def test_delete_group(self):
| self.delete(('/groups/%(group_id)s' % {'group_id': self.group_id}))
|
'GET /credentials'
| def test_list_credentials(self):
| r = self.get('/credentials')
self.assertValidCredentialListResponse(r, ref=self.credential)
|
'GET /credentials (xml data)'
| def test_list_credentials_xml(self):
| r = self.get('/credentials', content_type='xml')
self.assertValidCredentialListResponse(r, ref=self.credential)
|
'POST /credentials'
| def test_create_credential(self):
| ref = self.new_credential_ref(user_id=self.user['id'])
r = self.post('/credentials', body={'credential': ref})
self.assertValidCredentialResponse(r, ref)
|
'GET /credentials/{credential_id}'
| def test_get_credential(self):
| r = self.get(('/credentials/%(credential_id)s' % {'credential_id': self.credential_id}))
self.assertValidCredentialResponse(r, self.credential)
|
'PATCH /credentials/{credential_id}'
| def test_update_credential(self):
| ref = self.new_credential_ref(user_id=self.user['id'], project_id=self.project_id)
del ref['id']
r = self.patch(('/credentials/%(credential_id)s' % {'credential_id': self.credential_id}), body={'credential': ref})
self.assertValidCredentialResponse(r, ref)
|
'DELETE /credentials/{credential_id}'
| def test_delete_credential(self):
| self.delete(('/credentials/%(credential_id)s' % {'credential_id': self.credential_id}))
|
'POST /roles'
| def test_create_role(self):
| ref = self.new_role_ref()
r = self.post('/roles', body={'role': ref})
return self.assertValidRoleResponse(r, ref)
|
'GET /roles'
| def test_list_roles(self):
| r = self.get('/roles')
self.assertValidRoleListResponse(r, ref=self.role)
|
'GET /roles (xml data)'
| def test_list_roles_xml(self):
| r = self.get('/roles', content_type='xml')
self.assertValidRoleListResponse(r, ref=self.role)
|
'GET /roles/{role_id}'
| def test_get_role(self):
| r = self.get(('/roles/%(role_id)s' % {'role_id': self.role_id}))
self.assertValidRoleResponse(r, self.role)
|
'PATCH /roles/{role_id}'
| def test_update_role(self):
| ref = self.new_role_ref()
del ref['id']
r = self.patch(('/roles/%(role_id)s' % {'role_id': self.role_id}), body={'role': ref})
self.assertValidRoleResponse(r, ref)
|
'DELETE /roles/{role_id}'
| def test_delete_role(self):
| self.delete(('/roles/%(role_id)s' % {'role_id': self.role_id}))
|
'POST /services'
| def test_create_service(self):
| ref = self.new_service_ref()
r = self.post('/services', body={'service': ref})
return self.assertValidServiceResponse(r, ref)
|
'GET /services'
| def test_list_services(self):
| r = self.get('/services')
self.assertValidServiceListResponse(r, ref=self.service)
|
'GET /services (xml data)'
| def test_list_services_xml(self):
| r = self.get('/services', content_type='xml')
self.assertValidServiceListResponse(r, ref=self.service)
|
'GET /services/{service_id}'
| def test_get_service(self):
| r = self.get(('/services/%(service_id)s' % {'service_id': self.service_id}))
self.assertValidServiceResponse(r, self.service)
|
'PATCH /services/{service_id}'
| def test_update_service(self):
| service = self.new_service_ref()
del service['id']
r = self.patch(('/services/%(service_id)s' % {'service_id': self.service_id}), body={'service': service})
self.assertValidServiceResponse(r, service)
|
'DELETE /services/{service_id}'
| def test_delete_service(self):
| self.delete(('/services/%(service_id)s' % {'service_id': self.service_id}))
|
'GET /endpoints'
| def test_list_endpoints(self):
| r = self.get('/endpoints')
self.assertValidEndpointListResponse(r, ref=self.endpoint)
|
'GET /endpoints (xml data)'
| def test_list_endpoints_xml(self):
| r = self.get('/endpoints', content_type='xml')
self.assertValidEndpointListResponse(r, ref=self.endpoint)
|
'POST /endpoints'
| def test_create_endpoint(self):
| ref = self.new_endpoint_ref(service_id=self.service_id)
r = self.post('/endpoints', body={'endpoint': ref})
self.assertValidEndpointResponse(r, ref)
|
'POST /endpoints'
| def test_create_endpoint_400(self):
| ref = self.new_endpoint_ref(service_id=self.service_id)
ref['region'] = ('0' * 256)
self.post('/endpoints', body={'endpoint': ref}, expected_status=400)
|
'GET /endpoints/{endpoint_id}'
| def test_get_endpoint(self):
| r = self.get(('/endpoints/%(endpoint_id)s' % {'endpoint_id': self.endpoint_id}))
self.assertValidEndpointResponse(r, self.endpoint)
|
'PATCH /endpoints/{endpoint_id}'
| def test_update_endpoint(self):
| ref = self.new_endpoint_ref(service_id=self.service_id)
del ref['id']
r = self.patch(('/endpoints/%(endpoint_id)s' % {'endpoint_id': self.endpoint_id}), body={'endpoint': ref})
self.assertValidEndpointResponse(r, ref)
|
'DELETE /endpoints/{endpoint_id}'
| def test_delete_endpoint(self):
| self.delete(('/endpoints/%(endpoint_id)s' % {'endpoint_id': self.endpoint_id}))
|
'This tests for backwards-compatibility with an essex/folsom bug.
Non-indexed attributes were returned in an \'extra\' attribute, instead
of on the entity itself; for consistency and backwards compatibility,
those attributes should be included twice.
This behavior is specific to the SQL driver.'
| def test_update_project_returns_extra(self):
| tenant_id = uuid.uuid4().hex
arbitrary_key = uuid.uuid4().hex
arbitrary_value = uuid.uuid4().hex
tenant = {'id': tenant_id, 'name': uuid.uuid4().hex, 'domain_id': DEFAULT_DOMAIN_ID, arbitrary_key: arbitrary_value}
ref = self.identity_man.create_project({}, tenant_id, tenant)
self.assertEqual(arb... |
'This tests for backwards-compatibility with an essex/folsom bug.
Non-indexed attributes were returned in an \'extra\' attribute, instead
of on the entity itself; for consistency and backwards compatibility,
those attributes should be included twice.
This behavior is specific to the SQL driver.'
| def test_update_user_returns_extra(self):
| user_id = uuid.uuid4().hex
arbitrary_key = uuid.uuid4().hex
arbitrary_value = uuid.uuid4().hex
user = {'id': user_id, 'name': uuid.uuid4().hex, 'domain_id': DEFAULT_DOMAIN_ID, 'password': uuid.uuid4().hex, arbitrary_key: arbitrary_value}
ref = self.identity_man.create_user({}, user_id, user)
sel... |
'Use the doc string as the error message by default.'
| def __init__(self, message=None, **kwargs):
| try:
message = self._build_message(message, **kwargs)
except KeyError as e:
if _FATAL_EXCEPTION_FORMAT_ERRORS:
raise e
else:
LOG.warning('missing exception kwargs (programmer error)')
message = self.__doc__
super(Error, self).__init__(m... |
'Builds and returns an exception message.
:raises: KeyError given insufficient kwargs'
| def _build_message(self, message, **kwargs):
| return (message or (self.__doc__ % kwargs))
|
'Cleans up line breaks and indentation from doc strings.'
| def __str__(self):
| string = super(Error, self).__str__()
string = re.sub('[ \n]+', ' ', string)
string = string.strip()
return string
|
'Only returns detailed messages in debug mode.'
| def _build_message(self, message, **kwargs):
| if CONF.debug:
return (message or (self.__doc__ % kwargs))
else:
return (self.__doc__ % kwargs)
|
'Ensure ImportError for the specified module.'
| def disable_module(self, module):
| self._cleared_modules.update(self.clear_module(module))
class NoModule(object, ):
def find_module(self, fullname, path):
if ((fullname == module) or fullname.startswith((module + '.'))):
raise ImportError
finder = NoModule()
self._finders.append(finder)
sys.meta_p... |
'Create shortcut references to each driver for data manipulation.'
| def load_backends(self):
| for (name, manager) in initialize_drivers().iteritems():
setattr(self, name, manager.driver)
|
'Hacky basic and naive fixture loading based on a python module.
Expects that the various APIs into the various services are already
defined on `self`.'
| def load_fixtures(self, fixtures):
| if hasattr(self, 'identity_api'):
for domain in fixtures.DOMAINS:
try:
rv = self.identity_api.create_domain(domain['id'], domain)
except (exception.Conflict, exception.NotImplemented):
pass
setattr(self, ('domain_%s' % domain['id']), domain... |
'Asserts that two datetimes are nearly equal within a small delta.
:param delta: Maximum allowable time delta, defined in seconds.'
| def assertCloseEnoughForGovernmentWork(self, a, b, delta=3):
| self.assertAlmostEqual(a, b, delta=datetime.timedelta(seconds=delta))
|
'Returns a dictionary populated by decoding the given xml string.'
| def __call__(self, xml_str):
| dom = etree.fromstring(xml_str.strip(), PARSER)
return self.walk_element(dom, True)
|
'Returns a tag name.
The tag name may contain the namespace prefix or not, which can
be determined by specifying the parameter namespace.'
| @staticmethod
def _tag_name(tag, namespace):
| m = re.search('[^}]+$', tag)
tag_name = m.string[m.start():]
if (not namespace):
return tag_name
bracket = re.search('[^{]+$', tag)
ns = m.string[bracket.start():(m.start() - 1)]
prefix = None
for xmlns in XMLNS_LIST:
if (xmlns['value'] == ns):
prefix = xmlns.get(... |
'Populates a dictionary by walking an etree element.'
| def walk_element(self, element, namespace=False):
| values = {}
for (k, v) in element.attrib.iteritems():
if (k in ['enabled']):
if (v in ['true']):
v = True
elif (v in ['false']):
v = False
values[k] = v
text = None
if (element.text is not None):
text = element.text.strip()
... |
'Returns an xml etree populated by the given dictionary.
Optionally, namespace the etree by specifying an ``xmlns``.'
| def __call__(self, d, xmlns=None):
| links = None
for key in d.keys():
if ('_links' in key):
d.pop(key)
if ('links' == key):
if links:
raise Exception('Multiple links found')
links = d.pop(key)
assert (len(d.keys()) == 1), ('Cannot encode more than one roo... |
'Populates an element with a key & list value.'
| def _populate_list(self, element, k, v):
| container = element
if (k == 'media-types'):
container = element.find('media-types')
if (container is None):
container = etree.Element(k)
element.append(container)
name = k[:(-1)]
elif ((k == 'serviceCatalog') or (k == 'catalog')):
container = etree.El... |
'Populates an element with a key & dictionary value.'
| def _populate_dict(self, element, k, v):
| if (k == 'links'):
self._populate_links(element, v)
else:
child = etree.Element(k)
self.populate_element(child, v)
element.append(child)
|
'Populates an element with a key & boolean value.'
| def _populate_bool(self, element, k, v):
| element.set(k, unicode(v).lower())
|
'Populates an element with a key & string value.'
| def _populate_str(self, element, k, v):
| if (k in ['description']):
child = etree.Element(k)
child.text = unicode(v)
element.append(child)
else:
element.set(k, unicode(v))
|
'Populates an element with a key & numeric value.'
| def _populate_number(self, element, k, v):
| self._populate_str(element, k, v)
|
'Populates an etree with the given value.'
| def populate_element(self, element, value):
| if isinstance(value, list):
self._populate_sequence(element, value)
elif isinstance(value, dict):
self._populate_tree(element, value)
elif isinstance(value, basestring):
element.text = unicode(value)
|
'Populates an etree with a sequence of elements, given a list.'
| def _populate_sequence(self, element, l):
| name = element.tag
if (element.tag[(-1)] == 's'):
name = element.tag[:(-1)]
if (name == 'policie'):
name = 'policy'
for item in l:
child = etree.Element(name)
self.populate_element(child, item)
element.append(child)
|
'Populates an etree with attributes & elements, given a dict.'
| def _populate_tree(self, element, d):
| for (k, v) in d.iteritems():
if isinstance(v, dict):
self._populate_dict(element, k, v)
elif isinstance(v, list):
self._populate_list(element, k, v)
elif isinstance(v, bool):
self._populate_bool(element, k, v)
elif isinstance(v, basestring):
... |
':param data: Underlying data object
:param limit: maximum number of bytes the reader should allow'
| def __init__(self, data, limit):
| self.data = data
self.limit = limit
self.bytes_read = 0
|
'Deletes an item, returning True on success, False otherwise.'
| def delete(self, key):
| try:
del self[key]
except KeyError:
raise exception.NotFound(target=key)
|
'Forward calls to the underlying driver.'
| def __getattr__(self, name):
| f = getattr(self.driver, name)
@functools.wraps(f)
def _wrapper(context, *args, **kw):
return f(*args, **kw)
setattr(self, name, _wrapper)
return _wrapper
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.