openstack/openstacksdk
Code Issues Proposed changes

Convert use of .register_uri to .register_uris

Browse Source 
This patch converts all use of .register_uri to .register_uris for
the following files: test_caching, test_create_server, test_domains,
test_flavors, test_floating_ip_neutron, test_users.

Change-Id: I48d90465f22bfa27e9de552e135f42967a9e21fa
This commit is contained in:
Morgan Fainberg 2017-02-13 14:59:49 -08:00
parent ea83e73be0
commit 820885c1a1
7 changed files with 660 additions and 694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
shade/tests/unit/base.py
View File

@ -364,12 +364,14 @@ class RequestsMockTestCase(BaseTestCase):
method = to_mock.pop('method') method = to_mock.pop('method')
uri = to_mock.pop('uri') uri = to_mock.pop('uri')
key = '{method}:{uri}'.format(method=method, uri=uri) key = '{method}:{uri}'.format(method=method, uri=uri)
validate = to_mock.pop('validate', {})
headers = structures.CaseInsensitiveDict(to_mock.pop('headers', headers = structures.CaseInsensitiveDict(to_mock.pop('headers',
{})) {}))
validate = to_mock.pop('validate', {})
if 'content-type' not in headers: if 'content-type' not in headers:
headers[u'content-type'] = 'application/json' headers[u'content-type'] = 'application/json'
to_mock['headers'] = headers
self.calls += [ self.calls += [
dict( dict(
method=method, method=method,

81
shade/tests/unit/test_caching.py
View File

@ -116,24 +116,16 @@ class TestMemoryCache(base.RequestsMockTestCase):
second_response = {'projects': [p.json_response['project'] second_response = {'projects': [p.json_response['project']
for p in project_list]} for p in project_list]}
self.register_uri( mock_uri = self.get_mock_url(
'GET', service_type='identity', interface='admin', resource='projects',
self.get_mock_url( base_url_append='v3')
service_type='identity',
interface='admin', self.register_uris([
resource='projects', dict(method='GET', uri=mock_uri, status_code=200,
base_url_append='v3'), json=first_response),
status_code=200, dict(method='GET', uri=mock_uri, status_code=200,
json=first_response) json=second_response)])
self.register_uri(
'GET',
self.get_mock_url(
service_type='identity',
interface='admin',
resource='projects',
base_url_append='v3'),
status_code=200,
json=second_response)
self.assertEqual( self.assertEqual(
self.cloud._normalize_projects( self.cloud._normalize_projects(
meta.obj_list_to_dict(first_response['projects'])), meta.obj_list_to_dict(first_response['projects'])),
@ -161,22 +153,15 @@ class TestMemoryCache(base.RequestsMockTestCase):
second_response = {'tenants': [p.json_response['tenant'] second_response = {'tenants': [p.json_response['tenant']
for p in project_list]} for p in project_list]}
self.register_uri( mock_uri = self.get_mock_url(
'GET', service_type='identity', interface='admin', resource='tenants')
self.get_mock_url(
service_type='identity', self.register_uris([
interface='admin', dict(method='GET', uri=mock_uri, status_code=200,
resource='tenants'), json=first_response),
status_code=200, dict(method='GET', uri=mock_uri, status_code=200,
json=first_response) json=second_response)])
self.register_uri(
'GET',
self.get_mock_url(
service_type='identity',
interface='admin',
resource='tenants'),
status_code=200,
json=second_response)
self.assertEqual( self.assertEqual(
self.cloud._normalize_projects( self.cloud._normalize_projects(
meta.obj_list_to_dict(first_response['tenants'])), meta.obj_list_to_dict(first_response['tenants'])),
@ -410,20 +395,22 @@ class TestMemoryCache(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_list_flavors(self): def test_list_flavors(self):
self.register_uri( mock_uri = '{endpoint}/flavors/detail?is_public=None'.format(
'GET', '{endpoint}/flavors/detail?is_public=None'.format( endpoint=fakes.COMPUTE_ENDPOINT)
endpoint=fakes.COMPUTE_ENDPOINT),
json={'flavors': []})
self.register_uri( uris_to_mock = [
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET', uri=mock_uri, json={'flavors': []}),
endpoint=fakes.COMPUTE_ENDPOINT), dict(method='GET', uri=mock_uri,
json={'flavors': fakes.FAKE_FLAVOR_LIST}) json={'flavors': fakes.FAKE_FLAVOR_LIST})
for flavor in fakes.FAKE_FLAVOR_LIST: ]
self.register_uri( uris_to_mock.extend([
'GET', '{endpoint}/flavors/{id}/os-extra_specs'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']), uri='{endpoint}/flavors/{id}/os-extra_specs'.format(
json={'extra_specs': {}}) endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']),
json={'extra_specs': {}})
for flavor in fakes.FAKE_FLAVOR_LIST])
self.register_uris(uris_to_mock)
self.assertEqual([], self.cloud.list_flavors()) self.assertEqual([], self.cloud.list_flavors())

11
shade/tests/unit/test_create_server.py
View File

@ -313,10 +313,13 @@ class TestCreateServer(base.RequestsMockTestCase):
@mock.patch.object(OpenStackCloud, 'nova_client') @mock.patch.object(OpenStackCloud, 'nova_client')
def test_create_server_get_flavor_image( def test_create_server_get_flavor_image(
self, mock_nova, mock_image, mock_get_server_by_id): self, mock_nova, mock_image, mock_get_server_by_id):
self.register_uri(
'GET', '{endpoint}/flavors/detail?is_public=None'.format( self.register_uris([
endpoint=fakes.COMPUTE_ENDPOINT), dict(method='GET',
json={'flavors': fakes.FAKE_FLAVOR_LIST}) uri='{endpoint}/flavors/detail?is_public=None'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'flavors': fakes.FAKE_FLAVOR_LIST})])
self.cloud.create_server( self.cloud.create_server(
'server-name', 'image-id', 'vanilla', 'server-name', 'image-id', 'vanilla',
nics=[{'net-id': 'some-network'}]) nics=[{'net-id': 'some-network'}])

176
shade/tests/unit/test_domains.py
View File

@ -66,9 +66,9 @@ class TestDomains(base.RequestsMockTestCase):
def test_list_domains(self): def test_list_domains(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
self.register_uri( self.register_uris([
'GET', self.get_mock_url(), status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json={'domains': [domain_data.json_response['domain']]}) json={'domains': [domain_data.json_response['domain']]})])
domains = self.op_cloud.list_domains() domains = self.op_cloud.list_domains()
self.assertThat(len(domains), matchers.Equals(1)) self.assertThat(len(domains), matchers.Equals(1))
self.assertThat(domains[0].name, self.assertThat(domains[0].name,
@ -80,10 +80,11 @@ class TestDomains(base.RequestsMockTestCase):
def test_get_domain(self): def test_get_domain(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
self.register_uri( self.register_uris([
'GET', self.get_mock_url(append=[domain_data.domain_id]), dict(method='GET',
status_code=200, uri=self.get_mock_url(append=[domain_data.domain_id]),
json=domain_data.json_response) status_code=200,
json=domain_data.json_response)])
domain = self.op_cloud.get_domain(domain_id=domain_data.domain_id) domain = self.op_cloud.get_domain(domain_id=domain_data.domain_id)
self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id))
self.assertThat(domain.name, matchers.Equals(domain_data.domain_name)) self.assertThat(domain.name, matchers.Equals(domain_data.domain_name))
@ -92,12 +93,12 @@ class TestDomains(base.RequestsMockTestCase):
def test_get_domain_with_name_or_id(self): def test_get_domain_with_name_or_id(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
self.register_uri( response = {'domains': [domain_data.json_response['domain']]}
'GET', self.get_mock_url(), status_code=200, self.register_uris([
json={'domains': [domain_data.json_response['domain']]}) dict(method='GET', uri=self.get_mock_url(), status_code=200,
self.register_uri( json=response),
'GET', self.get_mock_url(), status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json={'domains': [domain_data.json_response['domain']]}) json=response)])
domain = self.op_cloud.get_domain(name_or_id=domain_data.domain_id) domain = self.op_cloud.get_domain(name_or_id=domain_data.domain_id)
domain_by_name = self.op_cloud.get_domain( domain_by_name = self.op_cloud.get_domain(
name_or_id=domain_data.domain_name) name_or_id=domain_data.domain_name)
@ -113,17 +114,14 @@ class TestDomains(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data(description=uuid.uuid4().hex, domain_data = self._get_domain_data(description=uuid.uuid4().hex,
enabled=True) enabled=True)
self.register_uri( self.register_uris([
'POST', dict(method='POST', uri=self.get_mock_url(), status_code=200,
self.get_mock_url(), json=domain_data.json_response,
status_code=200, validate=dict(json=domain_data.json_request)),
json=domain_data.json_response, dict(method='GET',
validate=dict(json=domain_data.json_request)) uri=self.get_mock_url(append=[domain_data.domain_id]),
self.register_uri( status_code=200,
'GET', json=domain_data.json_request)])
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=domain_data.json_response)
domain = self.op_cloud.create_domain( domain = self.op_cloud.create_domain(
domain_data.domain_name, domain_data.description) domain_data.domain_name, domain_data.description)
self.assertThat(domain.id, matchers.Equals(domain_data.domain_id)) self.assertThat(domain.id, matchers.Equals(domain_data.domain_id))
@ -138,10 +136,8 @@ class TestDomains(base.RequestsMockTestCase):
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Failed to create domain domain_name" "Failed to create domain domain_name"
): ):
self.register_uri( self.register_uris([
'POST', dict(method='POST', uri=self.get_mock_url(), status_code=409)])
self.get_mock_url(),
status_code=409)
self.op_cloud.create_domain('domain_name') self.op_cloud.create_domain('domain_name')
self.assert_calls() self.assert_calls()
@ -150,21 +146,13 @@ class TestDomains(base.RequestsMockTestCase):
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
new_resp = domain_data.json_response.copy() new_resp = domain_data.json_response.copy()
new_resp['domain']['enabled'] = False new_resp['domain']['enabled'] = False
self.register_uri( domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id])
'PATCH', self.register_uris([
self.get_mock_url(append=[domain_data.domain_id]), dict(method='PATCH', uri=domain_resource_uri, status_code=200,
status_code=200, json=new_resp, validate={'domain': {'enabled': False}}),
json=new_resp, dict(method='GET', uri=domain_resource_uri, status_code=200,
validate={'domain': {'enabled': False}}) json=new_resp),
self.register_uri( dict(method='DELETE', uri=domain_resource_uri, status_code=204)])
'GET',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=new_resp)
self.register_uri(
'DELETE',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=204)
self.op_cloud.delete_domain(domain_data.domain_id) self.op_cloud.delete_domain(domain_data.domain_id)
self.assert_calls() self.assert_calls()
@ -173,26 +161,16 @@ class TestDomains(base.RequestsMockTestCase):
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
new_resp = domain_data.json_response.copy() new_resp = domain_data.json_response.copy()
new_resp['domain']['enabled'] = False new_resp['domain']['enabled'] = False
self.register_uri(
'GET', domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id])
self.get_mock_url(), self.register_uris([
status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json={'domains': [domain_data.json_response['domain']]}) json={'domains': [domain_data.json_response['domain']]}),
self.register_uri( dict(method='PATCH', uri=domain_resource_uri, status_code=200,
'PATCH', json=new_resp, validate={'domain': {'enabled': False}}),
self.get_mock_url(append=[domain_data.domain_id]), dict(method='GET', uri=domain_resource_uri, status_code=200,
status_code=200, json=new_resp),
json=new_resp, dict(method='DELETE', uri=domain_resource_uri, status_code=204)])
validate={'domain': {'enabled': False}})
self.register_uri(
'GET',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=new_resp)
self.register_uri(
'DELETE',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=204)
self.op_cloud.delete_domain(name_or_id=domain_data.domain_id) self.op_cloud.delete_domain(name_or_id=domain_data.domain_id)
self.assert_calls() self.assert_calls()
@ -206,21 +184,13 @@ class TestDomains(base.RequestsMockTestCase):
domain_data = self._get_domain_data() domain_data = self._get_domain_data()
new_resp = domain_data.json_response.copy() new_resp = domain_data.json_response.copy()
new_resp['domain']['enabled'] = False new_resp['domain']['enabled'] = False
self.register_uri( domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id])
'PATCH', self.register_uris([
self.get_mock_url(append=[domain_data.domain_id]), dict(method='PATCH', uri=domain_resource_uri, status_code=200,
status_code=200, json=new_resp, validate={'domain': {'enabled': False}}),
json=new_resp, dict(method='GET', uri=domain_resource_uri, status_code=200,
validate={'domain': {'enabled': False}}) json=new_resp),
self.register_uri( dict(method='DELETE', uri=domain_resource_uri, status_code=404)])
'GET',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=new_resp)
self.register_uri(
'DELETE',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=404)
with testtools.ExpectedException( with testtools.ExpectedException(
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Failed to delete domain %s" % domain_data.domain_id "Failed to delete domain %s" % domain_data.domain_id
@ -232,17 +202,13 @@ class TestDomains(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data( domain_data = self._get_domain_data(
description=self.getUniqueString('domainDesc')) description=self.getUniqueString('domainDesc'))
self.register_uri( domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id])
'PATCH', self.register_uris([
self.get_mock_url(append=[domain_data.domain_id]), dict(method='PATCH', uri=domain_resource_uri, status_code=200,
status_code=200, json=domain_data.json_response,
json=domain_data.json_response, validate=dict(json=domain_data.json_request)),
validate=dict(json=domain_data.json_request)) dict(method='GET', uri=domain_resource_uri, status_code=200,
self.register_uri( json=domain_data.json_response)])
'GET',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=domain_data.json_response)
domain = self.op_cloud.update_domain( domain = self.op_cloud.update_domain(
domain_data.domain_id, domain_data.domain_id,
name=domain_data.domain_name, name=domain_data.domain_name,
@ -257,21 +223,15 @@ class TestDomains(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data( domain_data = self._get_domain_data(
description=self.getUniqueString('domainDesc')) description=self.getUniqueString('domainDesc'))
self.register_uri( domain_resource_uri = self.get_mock_url(append=[domain_data.domain_id])
'GET', self.register_uris([
self.get_mock_url(), status_code=200, dict(method='GET', uri=self.get_mock_url(), status_code=200,
json={'domains': [domain_data.json_response['domain']]}) json={'domains': [domain_data.json_response['domain']]}),
self.register_uri( dict(method='PATCH', uri=domain_resource_uri, status_code=200,
'PATCH', json=domain_data.json_response,
self.get_mock_url(append=[domain_data.domain_id]), validate=dict(json=domain_data.json_request)),
status_code=200, dict(method='GET', uri=domain_resource_uri, status_code=200,
json=domain_data.json_response, json=domain_data.json_response)])
validate=dict(json=domain_data.json_request))
self.register_uri(
'GET',
self.get_mock_url(append=[domain_data.domain_id]),
status_code=200,
json=domain_data.json_response)
domain = self.op_cloud.update_domain( domain = self.op_cloud.update_domain(
name_or_id=domain_data.domain_id, name_or_id=domain_data.domain_id,
name=domain_data.domain_name, name=domain_data.domain_name,
@ -286,10 +246,10 @@ class TestDomains(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
domain_data = self._get_domain_data( domain_data = self._get_domain_data(
description=self.getUniqueString('domainDesc')) description=self.getUniqueString('domainDesc'))
self.register_uri( self.register_uris([
'PATCH', dict(method='PATCH',
self.get_mock_url(append=[domain_data.domain_id]), uri=self.get_mock_url(append=[domain_data.domain_id]),
status_code=409) status_code=409)])
with testtools.ExpectedException( with testtools.ExpectedException(
shade.OpenStackCloudException, shade.OpenStackCloudException,
"Error in updating domain %s" % domain_data.domain_id "Error in updating domain %s" % domain_data.domain_id

252
shade/tests/unit/test_flavors.py
View File

@ -20,22 +20,23 @@ class TestFlavors(base.RequestsMockTestCase):
def test_create_flavor(self): def test_create_flavor(self):
self.register_uri( self.register_uris([
'POST', '{endpoint}/flavors'.format( dict(method='POST',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors'.format(
json={'flavor': fakes.FAKE_FLAVOR}, endpoint=fakes.COMPUTE_ENDPOINT),
validate=dict( json={'flavor': fakes.FAKE_FLAVOR},
json={'flavor': { validate=dict(
"name": "vanilla", json={
"ram": 65536, 'flavor': {
"vcpus": 24, "name": "vanilla",
"swap": 0, "ram": 65536,
"os-flavor-access:is_public": True, "vcpus": 24,
"rxtx_factor": 1.0, "swap": 0,
"OS-FLV-EXT-DATA:ephemeral": 0, "os-flavor-access:is_public": True,
"disk": 1600, "rxtx_factor": 1.0,
"id": None "OS-FLV-EXT-DATA:ephemeral": 0,
}})) "disk": 1600,
"id": None}}))])
self.op_cloud.create_flavor( self.op_cloud.create_flavor(
'vanilla', ram=65536, disk=1600, vcpus=24, 'vanilla', ram=65536, disk=1600, vcpus=24,
@ -43,49 +44,57 @@ class TestFlavors(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_delete_flavor(self): def test_delete_flavor(self):
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
self.register_uri( json={'flavors': fakes.FAKE_FLAVOR_LIST}),
'DELETE', '{endpoint}/flavors/{id}'.format( dict(method='DELETE',
endpoint=fakes.COMPUTE_ENDPOINT, id=fakes.FLAVOR_ID)) uri='{endpoint}/flavors/{id}'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=fakes.FLAVOR_ID))])
self.assertTrue(self.op_cloud.delete_flavor('vanilla')) self.assertTrue(self.op_cloud.delete_flavor('vanilla'))
self.assert_calls() self.assert_calls()
def test_delete_flavor_not_found(self): def test_delete_flavor_not_found(self):
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
json={'flavors': fakes.FAKE_FLAVOR_LIST})])
self.assertFalse(self.op_cloud.delete_flavor('invalid')) self.assertFalse(self.op_cloud.delete_flavor('invalid'))
self.assert_calls() self.assert_calls()
def test_delete_flavor_exception(self): def test_delete_flavor_exception(self):
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
self.register_uri( json={'flavors': fakes.FAKE_FLAVOR_LIST}),
'DELETE', '{endpoint}/flavors/{id}'.format( dict(method='DELETE',
endpoint=fakes.COMPUTE_ENDPOINT, id=fakes.FLAVOR_ID), uri='{endpoint}/flavors/{id}'.format(
status_code=503) endpoint=fakes.FAKE_FLAVOR_LIST, id=fakes.FLAVOR_ID),
status_code=503)])
self.assertRaises(shade.OpenStackCloudException, self.assertRaises(shade.OpenStackCloudException,
self.op_cloud.delete_flavor, 'vanilla') self.op_cloud.delete_flavor, 'vanilla')
def test_list_flavors(self): def test_list_flavors(self):
self.register_uri( uris_to_mock = [
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
for flavor in fakes.FAKE_FLAVOR_LIST: json={'flavors': fakes.FAKE_FLAVOR_LIST}),
self.register_uri( ]
'GET', '{endpoint}/flavors/{id}/os-extra_specs'.format( uris_to_mock.extend([
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']), dict(method='GET',
json={'extra_specs': {}}) uri='{endpoint}/flavors/{id}/os-extra_specs'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']),
json={'extra_specs': {}})
for flavor in fakes.FAKE_FLAVOR_LIST])
self.register_uris(uris_to_mock)
flavors = self.cloud.list_flavors() flavors = self.cloud.list_flavors()
@ -103,59 +112,65 @@ class TestFlavors(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_get_flavor_by_ram(self): def test_get_flavor_by_ram(self):
self.register_uri( uris_to_mock = [
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
for flavor in fakes.FAKE_FLAVOR_LIST: json={'flavors': fakes.FAKE_FLAVOR_LIST}),
self.register_uri( ]
'GET', '{endpoint}/flavors/{id}/os-extra_specs'.format( uris_to_mock.extend([
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']), dict(method='GET',
json={'extra_specs': {}}) uri='{endpoint}/flavors/{id}/os-extra_specs'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']),
json={'extra_specs': {}})
for flavor in fakes.FAKE_FLAVOR_LIST])
self.register_uris(uris_to_mock)
flavor = self.cloud.get_flavor_by_ram(ram=250) flavor = self.cloud.get_flavor_by_ram(ram=250)
self.assertEqual(fakes.STRAWBERRY_FLAVOR_ID, flavor['id']) self.assertEqual(fakes.STRAWBERRY_FLAVOR_ID, flavor['id'])
def test_get_flavor_by_ram_and_include(self): def test_get_flavor_by_ram_and_include(self):
self.register_uri( uris_to_mock = [
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': fakes.FAKE_FLAVOR_LIST}) endpoint=fakes.COMPUTE_ENDPOINT),
for flavor in fakes.FAKE_FLAVOR_LIST: json={'flavors': fakes.FAKE_FLAVOR_LIST}),
self.register_uri( ]
'GET', '{endpoint}/flavors/{id}/os-extra_specs'.format( uris_to_mock.extend([
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']), dict(method='GET',
json={'extra_specs': {}}) uri='{endpoint}/flavors/{id}/os-extra_specs'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=flavor['id']),
json={'extra_specs': {}})
for flavor in fakes.FAKE_FLAVOR_LIST])
self.register_uris(uris_to_mock)
flavor = self.cloud.get_flavor_by_ram(ram=150, include='strawberry') flavor = self.cloud.get_flavor_by_ram(ram=150, include='strawberry')
self.assertEqual(fakes.STRAWBERRY_FLAVOR_ID, flavor['id']) self.assertEqual(fakes.STRAWBERRY_FLAVOR_ID, flavor['id'])
def test_get_flavor_by_ram_not_found(self): def test_get_flavor_by_ram_not_found(self):
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/detail?is_public=None'.format(
json={'flavors': []}) endpoint=fakes.COMPUTE_ENDPOINT),
json={'flavors': []})])
self.assertRaises( self.assertRaises(
shade.OpenStackCloudException, shade.OpenStackCloudException,
self.cloud.get_flavor_by_ram, self.cloud.get_flavor_by_ram,
ram=100) ram=100)
def test_get_flavor_string_and_int(self): def test_get_flavor_string_and_int(self):
self.register_uri( flavor_list_uri = '{endpoint}/flavors/detail?is_public=None'.format(
'GET', '{endpoint}/flavors/detail?is_public=None'.format( endpoint=fakes.COMPUTE_ENDPOINT)
endpoint=fakes.COMPUTE_ENDPOINT), flavor_resource_uri = '{endpoint}/flavors/1/os-extra_specs'.format(
json={'flavors': [fakes.make_fake_flavor('1', 'vanilla')]}) endpoint=fakes.COMPUTE_ENDPOINT)
self.register_uri( flavor_list_json = {'flavors': [fakes.make_fake_flavor(
'GET', '{endpoint}/flavors/1/os-extra_specs'.format( '1', 'vanilla')]}
endpoint=fakes.COMPUTE_ENDPOINT), flavor_json = {'extra_specs': {}}
json={'extra_specs': {}})
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/detail?is_public=None'.format( dict(method='GET', uri=flavor_list_uri, json=flavor_list_json),
endpoint=fakes.COMPUTE_ENDPOINT), dict(method='GET', uri=flavor_resource_uri, json=flavor_json),
json={'flavors': [fakes.make_fake_flavor('1', 'vanilla')]}) dict(method='GET', uri=flavor_list_uri, json=flavor_list_json),
self.register_uri( dict(method='GET', uri=flavor_resource_uri, json=flavor_json)])
'GET', '{endpoint}/flavors/1/os-extra_specs'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'extra_specs': {}})
flavor1 = self.cloud.get_flavor('1') flavor1 = self.cloud.get_flavor('1')
self.assertEqual('1', flavor1['id']) self.assertEqual('1', flavor1['id'])
@ -164,65 +179,60 @@ class TestFlavors(base.RequestsMockTestCase):
def test_set_flavor_specs(self): def test_set_flavor_specs(self):
extra_specs = dict(key1='value1') extra_specs = dict(key1='value1')
self.register_uri( self.register_uris([
'POST', '{endpoint}/flavors/{id}/os-extra_specs'.format( dict(method='POST',
endpoint=fakes.COMPUTE_ENDPOINT, id=1), uri='{endpoint}/flavors/{id}/os-extra_specs'.format(
json=dict(extra_specs=extra_specs)) endpoint=fakes.COMPUTE_ENDPOINT, id=1),
json=dict(extra_specs=extra_specs))])
self.op_cloud.set_flavor_specs(1, extra_specs) self.op_cloud.set_flavor_specs(1, extra_specs)
self.assert_calls() self.assert_calls()
def test_unset_flavor_specs(self): def test_unset_flavor_specs(self):
keys = ['key1', 'key2'] keys = ['key1', 'key2']
for key in keys: self.register_uris([
self.register_uri( dict(method='DELETE',
'DELETE', uri='{endpoint}/flavors/{id}/os-extra_specs/{key}'.format(
'{endpoint}/flavors/{id}/os-extra_specs/{key}'.format( endpoint=fakes.COMPUTE_ENDPOINT, id=1, key=key))
endpoint=fakes.COMPUTE_ENDPOINT, id=1, key=key)) for key in keys])
self.op_cloud.unset_flavor_specs(1, keys) self.op_cloud.unset_flavor_specs(1, keys)
self.assert_calls() self.assert_calls()
def test_add_flavor_access(self): def test_add_flavor_access(self):
self.register_uri( self.register_uris([
'POST', '{endpoint}/flavors/{id}/action'.format( dict(method='POST',
endpoint=fakes.COMPUTE_ENDPOINT, id='flavor_id'), uri='{endpoint}/flavors/{id}/action'.format(
json={ endpoint=fakes.COMPUTE_ENDPOINT, id='flavor_id'),
'flavor_access': [{ json={
'flavor_id': 'flavor_id', 'flavor_access': [{
'tenant_id': 'tenant_id', 'flavor_id': 'flavor_id', 'tenant_id': 'tenant_id'}]},
}]}, validate=dict(
validate=dict( json={'addTenantAccess': {'tenant': 'tenant_id'}}))])
json={
'addTenantAccess': {
'tenant': 'tenant_id',
}}))
self.op_cloud.add_flavor_access('flavor_id', 'tenant_id') self.op_cloud.add_flavor_access('flavor_id', 'tenant_id')
self.assert_calls() self.assert_calls()
def test_remove_flavor_access(self): def test_remove_flavor_access(self):
self.register_uri( self.register_uris([
'POST', '{endpoint}/flavors/{id}/action'.format( dict(method='POST',
endpoint=fakes.COMPUTE_ENDPOINT, id='flavor_id'), uri='{endpoint}/flavors/{id}/action'.format(
json={'flavor_access': []}, endpoint=fakes.COMPUTE_ENDPOINT, id='flavor_id'),
validate=dict( json={'flavor_access': []},
json={ validate=dict(
'removeTenantAccess': { json={'removeTenantAccess': {'tenant': 'tenant_id'}}))])
'tenant': 'tenant_id',
}}))
self.op_cloud.remove_flavor_access('flavor_id', 'tenant_id') self.op_cloud.remove_flavor_access('flavor_id', 'tenant_id')
self.assert_calls() self.assert_calls()
def test_list_flavor_access(self): def test_list_flavor_access(self):
self.register_uri( self.register_uris([
'GET', '{endpoint}/flavors/vanilla/os-flavor-access'.format( dict(method='GET',
endpoint=fakes.COMPUTE_ENDPOINT), uri='{endpoint}/flavors/vanilla/os-flavor-access'.format(
json={ endpoint=fakes.COMPUTE_ENDPOINT),
'flavor_access': [{ json={
'flavor_id': 'vanilla', 'flavor_access': [
'tenant_id': 'tenant_id', {'flavor_id': 'vanilla', 'tenant_id': 'tenant_id'}]})
}]}) ])
self.op_cloud.list_flavor_access('vanilla') self.op_cloud.list_flavor_access('vanilla')
self.assert_calls() self.assert_calls()

590
shade/tests/unit/test_floating_ip_neutron.py
View File

@ -163,9 +163,10 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assertEqual('UNKNOWN', normalized[0]['status']) self.assertEqual('UNKNOWN', normalized[0]['status'])
def test_list_floating_ips(self): def test_list_floating_ips(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/floatingips.json', dict(method='GET',
json=self.mock_floating_ip_list_rep) uri='https://network.example.com/v2.0/floatingips.json',
json=self.mock_floating_ip_list_rep)])
floating_ips = self.cloud.list_floating_ips() floating_ips = self.cloud.list_floating_ips()
@ -177,19 +178,22 @@ class TestFloatingIP(base.RequestsMockTestCase):
def test_list_floating_ips_with_filters(self): def test_list_floating_ips_with_filters(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/floatingips.json?Foo=42', dict(method='GET',
json={'floatingips': []}) uri=('https://network.example.com/v2.0/floatingips.json?'
'Foo=42'),
json={'floatingips': []})])
self.cloud.list_floating_ips(filters={'Foo': 42}) self.cloud.list_floating_ips(filters={'Foo': 42})
self.assert_calls() self.assert_calls()
def test_search_floating_ips(self): def test_search_floating_ips(self):
self.register_uri( self.register_uris([
'GET', dict(method='GET',
'https://network.example.com/v2.0/floatingips.json?attached=False', uri=('https://network.example.com/v2.0/floatingips.json'
json=self.mock_floating_ip_list_rep) '?attached=False'),
json=self.mock_floating_ip_list_rep)])
floating_ips = self.cloud.search_floating_ips( floating_ips = self.cloud.search_floating_ips(
filters={'attached': False}) filters={'attached': False})
@ -200,9 +204,10 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_get_floating_ip(self): def test_get_floating_ip(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/floatingips.json', dict(method='GET',
json=self.mock_floating_ip_list_rep) uri='https://network.example.com/v2.0/floatingips.json',
json=self.mock_floating_ip_list_rep)])
floating_ip = self.cloud.get_floating_ip( floating_ip = self.cloud.get_floating_ip(
id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')
@ -221,9 +226,10 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_get_floating_ip_not_found(self): def test_get_floating_ip_not_found(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/floatingips.json', dict(method='GET',
json=self.mock_floating_ip_list_rep) uri='https://network.example.com/v2.0/floatingips.json',
json=self.mock_floating_ip_list_rep)])
floating_ip = self.cloud.get_floating_ip(id='non-existent') floating_ip = self.cloud.get_floating_ip(id='non-existent')
@ -231,14 +237,17 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_create_floating_ip(self): def test_create_floating_ip(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/networks.json', dict(method='GET',
json={'networks': [self.mock_get_network_rep]}) uri='https://network.example.com/v2.0/networks.json',
self.register_uri( json={'networks': [self.mock_get_network_rep]}),
'POST', 'https://network.example.com/v2.0/floatingips.json', dict(method='POST',
json=self.mock_floating_ip_new_rep, uri='https://network.example.com/v2.0/floatingips.json',
validate=dict( json=self.mock_floating_ip_new_rep,
json={'floatingip': {'floating_network_id': 'my-network-id'}})) validate=dict(
json={'floatingip': {
'floating_network_id': 'my-network-id'}}))
])
ip = self.cloud.create_floating_ip(network='my-network') ip = self.cloud.create_floating_ip(network='my-network')
self.assertEqual( self.assertEqual(
@ -247,17 +256,18 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_create_floating_ip_port_bad_response(self): def test_create_floating_ip_port_bad_response(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/networks.json', dict(method='GET',
json={'networks': [self.mock_get_network_rep]}) uri='https://network.example.com/v2.0/networks.json',
self.register_uri( json={'networks': [self.mock_get_network_rep]}),
'POST', 'https://network.example.com/v2.0/floatingips.json', dict(method='POST',
json=self.mock_floating_ip_new_rep, uri='https://network.example.com/v2.0/floatingips.json',
validate=dict( json=self.mock_floating_ip_new_rep,
json={'floatingip': { validate=dict(
'floating_network_id': 'my-network-id', json={'floatingip': {
'port_id': u'ce705c24-c1ef-408a-bda3-7bbd946164ab', 'floating_network_id': 'my-network-id',
}})) 'port_id': u'ce705c24-c1ef-408a-bda3-7bbd946164ab'}}))
])
# Fails because we requested a port and the returned FIP has no port # Fails because we requested a port and the returned FIP has no port
self.assertRaises( self.assertRaises(
@ -267,17 +277,18 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assert_calls() self.assert_calls()
def test_create_floating_ip_port(self): def test_create_floating_ip_port(self):
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/networks.json', dict(method='GET',
json={'networks': [self.mock_get_network_rep]}) uri='https://network.example.com/v2.0/networks.json',
self.register_uri( json={'networks': [self.mock_get_network_rep]}),
'POST', 'https://network.example.com/v2.0/floatingips.json', dict(method='POST',
json=self.mock_floating_ip_port_rep, uri='https://network.example.com/v2.0/floatingips.json',
validate=dict( json=self.mock_floating_ip_port_rep,
json={'floatingip': { validate=dict(
'floating_network_id': 'my-network-id', json={'floatingip': {
'port_id': u'ce705c24-c1ef-408a-bda3-7bbd946164ac', 'floating_network_id': 'my-network-id',
}})) 'port_id': u'ce705c24-c1ef-408a-bda3-7bbd946164ac'}}))
])
ip = self.cloud.create_floating_ip( ip = self.cloud.create_floating_ip(
network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ac') network='my-network', port='ce705c24-c1ef-408a-bda3-7bbd946164ac')
@ -287,51 +298,51 @@ class TestFloatingIP(base.RequestsMockTestCase):
ip['floating_ip_address']) ip['floating_ip_address'])
self.assert_calls() self.assert_calls()
def test__neutron_available_floating_ips(self): def test_neutron_available_floating_ips(self):
""" """
Test without specifying a network name. Test without specifying a network name.
""" """
self.register_uri( fips_mock_uri = 'https://network.example.com/v2.0/floatingips.json'
'GET', 'https://network.example.com/v2.0/networks.json', self.register_uris([
json={'networks': [self.mock_get_network_rep]}) dict(method='GET',
self.register_uri( uri='https://network.example.com/v2.0/networks.json',
'GET', 'https://network.example.com/v2.0/subnets.json', json={'networks': [self.mock_get_network_rep]}),
json={'subnets': []}) dict(method='GET',
self.register_uri( uri='https://network.example.com/v2.0/subnets.json',
'GET', 'https://network.example.com/v2.0/floatingips.json', json={'subnets': []}),
json={'floatingips': []}) dict(method='GET', uri=fips_mock_uri, json={'floatingips': []}),
self.register_uri( dict(method='POST', uri=fips_mock_uri,
'POST', 'https://network.example.com/v2.0/floatingips.json', json=self.mock_floating_ip_new_rep,
json=self.mock_floating_ip_new_rep, validate=dict(json={
validate=dict(json={ 'floatingip': {
'floatingip': { 'floating_network_id': self.mock_get_network_rep['id']
'floating_network_id': self.mock_get_network_rep['id'], }}))
}})) ])
# Test if first network is selected if no network is given # Test if first network is selected if no network is given
self.cloud._neutron_available_floating_ips() self.cloud._neutron_available_floating_ips()
self.assert_calls() self.assert_calls()
def test__neutron_available_floating_ips_network(self): def test_neutron_available_floating_ips_network(self):
""" """
Test with specifying a network name. Test with specifying a network name.
""" """
self.register_uri( fips_mock_uri = 'https://network.example.com/v2.0/floatingips.json'
'GET', 'https://network.example.com/v2.0/networks.json', self.register_uris([
json={'networks': [self.mock_get_network_rep]}) dict(method='GET',
self.register_uri( uri='https://network.example.com/v2.0/networks.json',
'GET', 'https://network.example.com/v2.0/subnets.json', json={'networks': [self.mock_get_network_rep]}),
json={'subnets': []}) dict(method='GET',
self.register_uri( uri='https://network.example.com/v2.0/subnets.json',
'GET', 'https://network.example.com/v2.0/floatingips.json', json={'subnets': []}),
json={'floatingips': []}) dict(method='GET', uri=fips_mock_uri, json={'floatingips': []}),
self.register_uri( dict(method='POST', uri=fips_mock_uri,
'POST', 'https://network.example.com/v2.0/floatingips.json', json=self.mock_floating_ip_new_rep,
json=self.mock_floating_ip_new_rep, validate=dict(json={
validate=dict(json={ 'floatingip': {
'floatingip': { 'floating_network_id': self.mock_get_network_rep['id']
'floating_network_id': self.mock_get_network_rep['id'], }}))
}})) ])
# Test if first network is selected if no network is given # Test if first network is selected if no network is given
self.cloud._neutron_available_floating_ips( self.cloud._neutron_available_floating_ips(
@ -339,16 +350,18 @@ class TestFloatingIP(base.RequestsMockTestCase):
) )
self.assert_calls() self.assert_calls()
def test__neutron_available_floating_ips_invalid_network(self): def test_neutron_available_floating_ips_invalid_network(self):
""" """
Test with an invalid network name. Test with an invalid network name.
""" """
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/networks.json', dict(method='GET',
json={'networks': [self.mock_get_network_rep]}) uri='https://network.example.com/v2.0/networks.json',
self.register_uri( json={'networks': [self.mock_get_network_rep]}),
'GET', 'https://network.example.com/v2.0/subnets.json', dict(method='GET',
json={'subnets': []}) uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': []})
])
self.assertRaises( self.assertRaises(
exc.OpenStackCloudException, exc.OpenStackCloudException,
@ -359,205 +372,202 @@ class TestFloatingIP(base.RequestsMockTestCase):
def test_auto_ip_pool_no_reuse(self): def test_auto_ip_pool_no_reuse(self):
# payloads taken from citycloud # payloads taken from citycloud
self.register_uri( self.register_uris([
'GET', 'https://network.example.com/v2.0/networks.json', dict(method='GET',
json={"networks": [{ uri='https://network.example.com/v2.0/networks.json',
"status": "ACTIVE", json={"networks": [{
"subnets": [ "status": "ACTIVE",
"df3e17fa-a4b2-47ae-9015-bc93eb076ba2", "subnets": [
"6b0c3dc9-b0b8-4d87-976a-7f2ebf13e7ec", "df3e17fa-a4b2-47ae-9015-bc93eb076ba2",
"fc541f48-fc7f-48c0-a063-18de6ee7bdd7"], "6b0c3dc9-b0b8-4d87-976a-7f2ebf13e7ec",
"availability_zone_hints": [], "fc541f48-fc7f-48c0-a063-18de6ee7bdd7"],
"availability_zones": ["nova"], "availability_zone_hints": [],
"name": "ext-net", "availability_zones": ["nova"],
"admin_state_up": True, "name": "ext-net",
"tenant_id": "a564613210ee43708b8a7fc6274ebd63", "admin_state_up": True,
"tags": [], "tenant_id": "a564613210ee43708b8a7fc6274ebd63",
"ipv6_address_scope": "9f03124f-89af-483a-b6fd-10f08079db4d", "tags": [],
"mtu": 0, "ipv6_address_scope": "9f03124f-89af-483a-b6fd-10f08079db4d", # noqa
"is_default": False, "mtu": 0,
"router:external": True, "is_default": False,
"ipv4_address_scope": None, "router:external": True,
"shared": False, "ipv4_address_scope": None,
"id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", "shared": False,
"description": None "id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf",
}, { "description": None
"status": "ACTIVE", }, {
"subnets": ["f0ad1df5-53ee-473f-b86b-3604ea5591e9"], "status": "ACTIVE",
"availability_zone_hints": [], "subnets": ["f0ad1df5-53ee-473f-b86b-3604ea5591e9"],
"availability_zones": ["nova"], "availability_zone_hints": [],
"name": "private", "availability_zones": ["nova"],
"admin_state_up": True, "name": "private",
"tenant_id": "65222a4d09ea4c68934fa1028c77f394", "admin_state_up": True,
"created_at": "2016-10-22T13:46:26", "tenant_id": "65222a4d09ea4c68934fa1028c77f394",
"tags": [], "created_at": "2016-10-22T13:46:26",
"updated_at": "2016-10-22T13:46:26", "tags": [],
"ipv6_address_scope": None, "updated_at": "2016-10-22T13:46:26",
"router:external": False, "ipv6_address_scope": None,
"ipv4_address_scope": None, "router:external": False,
"shared": False, "ipv4_address_scope": None,
"mtu": 1450, "shared": False,
"id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f", "mtu": 1450,
"description": "" "id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f",
}]}) "description": ""
self.register_uri( }]}),
'GET', dict(method='GET',
'https://network.example.com/v2.0/ports.json' uri='https://network.example.com/v2.0/ports.json'
'?device_id=f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7', '?device_id=f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7',
json={"ports": [{ json={"ports": [{
"status": "ACTIVE", "status": "ACTIVE",
"created_at": "2017-02-06T20:59:45", "created_at": "2017-02-06T20:59:45",
"description": "", "description": "",
"allowed_address_pairs": [], "allowed_address_pairs": [],
"admin_state_up": True, "admin_state_up": True,
"network_id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f", "network_id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f",
"dns_name": None, "dns_name": None,
"extra_dhcp_opts": [], "extra_dhcp_opts": [],
"mac_address": "fa:16:3e:e8:7f:03", "mac_address": "fa:16:3e:e8:7f:03",
"updated_at": "2017-02-06T20:59:49", "updated_at": "2017-02-06T20:59:49",
"name": "", "name": "",
"device_owner": "compute:None", "device_owner": "compute:None",
"tenant_id": "65222a4d09ea4c68934fa1028c77f394", "tenant_id": "65222a4d09ea4c68934fa1028c77f394",
"binding:vnic_type": "normal", "binding:vnic_type": "normal",
"fixed_ips": [{ "fixed_ips": [{
"subnet_id": "f0ad1df5-53ee-473f-b86b-3604ea5591e9", "subnet_id": "f0ad1df5-53ee-473f-b86b-3604ea5591e9",
"ip_address": "10.4.0.16"}], "ip_address": "10.4.0.16"}],
"id": "a767944e-057a-47d1-a669-824a21b8fb7b", "id": "a767944e-057a-47d1-a669-824a21b8fb7b",
"security_groups": ["9fb5ba44-5c46-4357-8e60-8b55526cab54"], "security_groups": [
"device_id": "f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7", "9fb5ba44-5c46-4357-8e60-8b55526cab54"],
}]}) "device_id": "f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7",
}]}),
self.register_uri( dict(method='POST',
'POST', uri='https://network.example.com/v2.0/floatingips.json',
'https://network.example.com/v2.0/floatingips.json', json={"floatingip": {
json={"floatingip": { "router_id": "9de9c787-8f89-4a53-8468-a5533d6d7fd1",
"router_id": "9de9c787-8f89-4a53-8468-a5533d6d7fd1", "status": "DOWN",
"status": "DOWN", "description": "",
"description": "", "dns_domain": "",
"dns_domain": "", "floating_network_id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", # noqa
"floating_network_id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", "fixed_ip_address": "10.4.0.16",
"fixed_ip_address": "10.4.0.16", "floating_ip_address": "89.40.216.153",
"floating_ip_address": "89.40.216.153", "port_id": "a767944e-057a-47d1-a669-824a21b8fb7b",
"port_id": "a767944e-057a-47d1-a669-824a21b8fb7b", "id": "e69179dc-a904-4c9a-a4c9-891e2ecb984c",
"id": "e69179dc-a904-4c9a-a4c9-891e2ecb984c", "dns_name": "",
"dns_name": "", "tenant_id": "65222a4d09ea4c68934fa1028c77f394"
"tenant_id": "65222a4d09ea4c68934fa1028c77f394" }},
}}, validate=dict(json={"floatingip": {
validate=dict(json={"floatingip": { "floating_network_id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", # noqa
"floating_network_id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", "fixed_ip_address": "10.4.0.16",
"fixed_ip_address": "10.4.0.16", "port_id": "a767944e-057a-47d1-a669-824a21b8fb7b",
"port_id": "a767944e-057a-47d1-a669-824a21b8fb7b", }})),
}})) dict(method='GET',
uri='{endpoint}/servers/detail'.format(
self.register_uri( endpoint=fakes.COMPUTE_ENDPOINT),
'GET', json={"servers": [{
'{endpoint}/servers/detail'.format( "status": "ACTIVE",
endpoint=fakes.COMPUTE_ENDPOINT), "updated": "2017-02-06T20:59:49Z",
json={"servers": [{ "addresses": {
"status": "ACTIVE", "private": [{
"updated": "2017-02-06T20:59:49Z", "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:e8:7f:03",
"addresses": { "version": 4,
"private": [{ "addr": "10.4.0.16",
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:e8:7f:03", "OS-EXT-IPS:type": "fixed"
"version": 4, }, {
"addr": "10.4.0.16", "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:e8:7f:03",
"OS-EXT-IPS:type": "fixed" "version": 4,
}, { "addr": "89.40.216.153",
"OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:e8:7f:03", "OS-EXT-IPS:type": "floating"
"version": 4, }]},
"addr": "89.40.216.153", "key_name": None,
"OS-EXT-IPS:type": "floating" "image": {"id": "95e4c449-8abf-486e-97d9-dc3f82417d2d"},
}]}, "OS-EXT-STS:task_state": None,
"key_name": None, "OS-EXT-STS:vm_state": "active",
"image": {"id": "95e4c449-8abf-486e-97d9-dc3f82417d2d"}, "OS-SRV-USG:launched_at": "2017-02-06T20:59:48.000000",
"OS-EXT-STS:task_state": None, "flavor": {"id": "2186bd79-a05e-4953-9dde-ddefb63c88d4"},
"OS-EXT-STS:vm_state": "active", "id": "f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7",
"OS-SRV-USG:launched_at": "2017-02-06T20:59:48.000000", "security_groups": [{"name": "default"}],
"flavor": {"id": "2186bd79-a05e-4953-9dde-ddefb63c88d4"}, "OS-SRV-USG:terminated_at": None,
"id": "f80e3ad0-e13e-41d4-8e9c-be79bccdb8f7", "OS-EXT-AZ:availability_zone": "nova",
"security_groups": [{"name": "default"}], "user_id": "c17534835f8f42bf98fc367e0bf35e09",
"OS-SRV-USG:terminated_at": None, "name": "testmt",
"OS-EXT-AZ:availability_zone": "nova", "created": "2017-02-06T20:59:44Z",
"user_id": "c17534835f8f42bf98fc367e0bf35e09", "tenant_id": "65222a4d09ea4c68934fa1028c77f394",
"name": "testmt", "OS-DCF:diskConfig": "MANUAL",
"created": "2017-02-06T20:59:44Z", "os-extended-volumes:volumes_attached": [],
"tenant_id": "65222a4d09ea4c68934fa1028c77f394", "accessIPv4": "",
"OS-DCF:diskConfig": "MANUAL", "accessIPv6": "",
"os-extended-volumes:volumes_attached": [], "progress": 0,
"accessIPv4": "", "OS-EXT-STS:power_state": 1,
"accessIPv6": "", "config_drive": "",
"progress": 0, "metadata": {}
"OS-EXT-STS:power_state": 1, }]}),
"config_drive": "", dict(method='GET',
"metadata": {} uri='https://network.example.com/v2.0/networks.json',
}]}) json={"networks": [{
"status": "ACTIVE",
self.register_uri( "subnets": [
'GET', 'https://network.example.com/v2.0/networks.json', "df3e17fa-a4b2-47ae-9015-bc93eb076ba2",
json={"networks": [{ "6b0c3dc9-b0b8-4d87-976a-7f2ebf13e7ec",
"status": "ACTIVE", "fc541f48-fc7f-48c0-a063-18de6ee7bdd7"],
"subnets": [ "availability_zone_hints": [],
"df3e17fa-a4b2-47ae-9015-bc93eb076ba2", "availability_zones": ["nova"],
"6b0c3dc9-b0b8-4d87-976a-7f2ebf13e7ec", "name": "ext-net",
"fc541f48-fc7f-48c0-a063-18de6ee7bdd7"], "admin_state_up": True,
"availability_zone_hints": [], "tenant_id": "a564613210ee43708b8a7fc6274ebd63",
"availability_zones": ["nova"], "tags": [],
"name": "ext-net", "ipv6_address_scope": "9f03124f-89af-483a-b6fd-10f08079db4d", # noqa
"admin_state_up": True, "mtu": 0,
"tenant_id": "a564613210ee43708b8a7fc6274ebd63", "is_default": False,
"tags": [], "router:external": True,
"ipv6_address_scope": "9f03124f-89af-483a-b6fd-10f08079db4d", "ipv4_address_scope": None,
"mtu": 0, "shared": False,
"is_default": False, "id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf",
"router:external": True, "description": None
"ipv4_address_scope": None, }, {
"shared": False, "status": "ACTIVE",
"id": "0232c17f-2096-49bc-b205-d3dcd9a30ebf", "subnets": ["f0ad1df5-53ee-473f-b86b-3604ea5591e9"],
"description": None "availability_zone_hints": [],
}, { "availability_zones": ["nova"],
"status": "ACTIVE", "name": "private",
"subnets": ["f0ad1df5-53ee-473f-b86b-3604ea5591e9"], "admin_state_up": True,
"availability_zone_hints": [], "tenant_id": "65222a4d09ea4c68934fa1028c77f394",
"availability_zones": ["nova"], "created_at": "2016-10-22T13:46:26",
"name": "private", "tags": [],
"admin_state_up": True, "updated_at": "2016-10-22T13:46:26",
"tenant_id": "65222a4d09ea4c68934fa1028c77f394", "ipv6_address_scope": None,
"created_at": "2016-10-22T13:46:26", "router:external": False,
"tags": [], "ipv4_address_scope": None,
"updated_at": "2016-10-22T13:46:26", "shared": False,
"ipv6_address_scope": None, "mtu": 1450,
"router:external": False, "id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f",
"ipv4_address_scope": None, "description": ""
"shared": False, }]}),
"mtu": 1450, dict(method='GET',
"id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f", uri='https://network.example.com/v2.0/subnets.json',
"description": "" json={"subnets": [{
}]}) "description": "",
self.register_uri( "enable_dhcp": True,
'GET', 'https://network.example.com/v2.0/subnets.json', "network_id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f",
json={"subnets": [{ "tenant_id": "65222a4d09ea4c68934fa1028c77f394",
"description": "", "created_at": "2016-10-22T13:46:26",
"enable_dhcp": True, "dns_nameservers": [
"network_id": "2c9adcb5-c123-4c5a-a2ba-1ad4c4e1481f", "89.36.90.101",
"tenant_id": "65222a4d09ea4c68934fa1028c77f394", "89.36.90.102"],
"created_at": "2016-10-22T13:46:26", "updated_at": "2016-10-22T13:46:26",
"dns_nameservers": [ "gateway_ip": "10.4.0.1",
"89.36.90.101", "ipv6_ra_mode": None,
"89.36.90.102"], "allocation_pools": [{
"updated_at": "2016-10-22T13:46:26", "start": "10.4.0.2",
"gateway_ip": "10.4.0.1", "end": "10.4.0.200"}],
"ipv6_ra_mode": None, "host_routes": [],
"allocation_pools": [{ "ip_version": 4,
"start": "10.4.0.2", "ipv6_address_mode": None,
"end": "10.4.0.200"}], "cidr": "10.4.0.0/24",
"host_routes": [], "id": "f0ad1df5-53ee-473f-b86b-3604ea5591e9",
"ip_version": 4, "subnetpool_id": None,
"ipv6_address_mode": None, "name": "private-subnet-ipv4",
"cidr": "10.4.0.0/24", }]})])
"id": "f0ad1df5-53ee-473f-b86b-3604ea5591e9",
"subnetpool_id": None,
"name": "private-subnet-ipv4",
}]})
self.cloud.add_ips_to_server( self.cloud.add_ips_to_server(
munch.Munch( munch.Munch(
@ -678,11 +688,11 @@ class TestFloatingIP(base.RequestsMockTestCase):
self.assertEqual(mock_get_floating_ip.call_count, 3) self.assertEqual(mock_get_floating_ip.call_count, 3)
def test_delete_floating_ip_not_found(self): def test_delete_floating_ip_not_found(self):
self.register_uri( self.register_uris([
'DELETE', dict(method='DELETE',
'https://network.example.com/v2.0/floatingips' uri=('https://network.example.com/v2.0/floatingips/'
'/a-wild-id-appears.json', 'a-wild-id-appears.json'),
status_code=404) status_code=404)])
ret = self.cloud.delete_floating_ip( ret = self.cloud.delete_floating_ip(
floating_ip_id='a-wild-id-appears') floating_ip_id='a-wild-id-appears')

240
shade/tests/unit/test_users.py
View File

@ -33,18 +33,17 @@ class TestUsers(base.RequestsMockTestCase):
user_data = self._get_user_data() user_data = self._get_user_data()
self.register_uri('POST', self.register_uris([
self._get_keystone_mock_url(resource='users', dict(method='POST',
v3=False), uri=self._get_keystone_mock_url(resource='users', v3=False),
status_code=204, status_code=200,
json=user_data.json_response, json=user_data.json_response,
validate=dict(json=user_data.json_request)) validate=user_data.json_request),
self.register_uri('GET', dict(method='GET',
self._get_keystone_mock_url( uri=self._get_keystone_mock_url(resource='users', v3=False,
resource='users', append=[user_data.user_id]),
append=[user_data.user_id], status_code=200, json=user_data.json_response)])
v3=False),
status_code=200, json=user_data.json_response)
user = self.op_cloud.create_user( user = self.op_cloud.create_user(
name=user_data.name, email=user_data.email, name=user_data.name, email=user_data.email,
password=user_data.password) password=user_data.password)
@ -59,17 +58,17 @@ class TestUsers(base.RequestsMockTestCase):
user_data = self._get_user_data( user_data = self._get_user_data(
domain_id=uuid.uuid4().hex, domain_id=uuid.uuid4().hex,
description=self.getUniqueString('description')) description=self.getUniqueString('description'))
self.register_uri(
'POST', self.register_uris([
self._get_keystone_mock_url(resource='users'), dict(method='POST',
status_code=204, uri=self._get_keystone_mock_url(resource='users'),
json=user_data.json_response, status_code=200, json=user_data.json_response,
validate=user_data.json_request) validate=user_data.json_request),
self.register_uri( dict(method='GET',
'GET', uri=self._get_keystone_mock_url(
self._get_keystone_mock_url(resource='users', resource='users', append=[user_data.user_id]),
append=[user_data.user_id]), status_code=200, json=user_data.json_response)])
status_code=200, json=user_data.json_response)
user = self.op_cloud.create_user( user = self.op_cloud.create_user(
name=user_data.name, email=user_data.email, name=user_data.name, email=user_data.email,
password=user_data.password, password=user_data.password,
@ -84,47 +83,40 @@ class TestUsers(base.RequestsMockTestCase):
def test_update_user_password_v2(self): def test_update_user_password_v2(self):
self.use_keystone_v2() self.use_keystone_v2()
user_data = self._get_user_data(email='test@example.com') user_data = self._get_user_data(email='test@example.com')
self.register_uri('GET', mock_user_resource_uri = self._get_keystone_mock_url(
self._get_keystone_mock_url(resource='users', resource='users', append=[user_data.user_id], v3=False)
v3=False), mock_users_uri = self._get_keystone_mock_url(
status_code=200, resource='users', v3=False)
json={'users': [user_data.json_response['user']]})
self.register_uri('GET', self.register_uris([
self._get_keystone_mock_url( # GET list to find user id
resource='users', # GET user info with user_id from list
v3=False, # PUT user with password update
append=[user_data.user_id]), # GET user info with id after update
json=user_data.json_response) # PUT empty update (password change is different than update)
self.register_uri( # but is always chained together [keystoneclient oddity]
'PUT', # GET user info after user update
self._get_keystone_mock_url( dict(method='GET', uri=mock_users_uri, status_code=200,
resource='users', v3=False, json={'users': [user_data.json_response['user']]}),
append=[user_data.user_id, 'OS-KSADM', 'password']), dict(method='GET', uri=mock_user_resource_uri, status_code=200,
status_code=204, json=user_data.json_response, json=user_data.json_response),
validate=dict(json={'user': {'password': user_data.password}})) dict(method='PUT',
self.register_uri('GET', uri=self._get_keystone_mock_url(
self._get_keystone_mock_url( resource='users', v3=False,
resource='users', v3=False, append=[user_data.user_id, 'OS-KSADM', 'password']),
append=[user_data.user_id]), status_code=200, json=user_data.json_response,
json=user_data.json_response) validate=dict(
# NOTE(notmorgan): when keystoneclient is dropped, the extra call is json={'user': {'password': user_data.password}})),
# not needed as it is a blank put. Keystoneclient has very limited dict(method='GET', uri=mock_user_resource_uri, status_code=200,
# logic and does odd things when updates inclue passwords in v2 json=user_data.json_response),
# keystone. dict(method='PUT', uri=mock_user_resource_uri, status_code=200,
self.register_uri( json=user_data.json_response,
'PUT', validate=dict(json={'user': {}})),
self._get_keystone_mock_url(resource='users', dict(method='GET', uri=mock_user_resource_uri, status_code=200,
append=[user_data.user_id], json=user_data.json_response)])
v3=False),
status_code=204, json=user_data.json_response,
validate=dict(json={'user': {}}))
self.register_uri('GET',
self._get_keystone_mock_url(
resource='users',
v3=False,
append=[user_data.user_id]),
json=user_data.json_response)
user = self.op_cloud.update_user( user = self.op_cloud.update_user(
user_data.user_id, password=user_data.password) user_data.user_id, password=user_data.password)
self.assertEqual(user_data.name, user.name) self.assertEqual(user_data.name, user.name)
@ -146,47 +138,48 @@ class TestUsers(base.RequestsMockTestCase):
def test_delete_user(self): def test_delete_user(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
user_data = self._get_user_data(domain_id=uuid.uuid4().hex) user_data = self._get_user_data(domain_id=uuid.uuid4().hex)
self.register_uri('GET', self._get_keystone_mock_url(resource='users'), user_resource_uri = self._get_keystone_mock_url(
status_code=200, resource='users', append=[user_data.user_id])
json={'users': [user_data.json_response['user']]})
self.register_uri('GET', self.register_uris([
self._get_keystone_mock_url( dict(method='GET',
resource='users', append=[user_data.user_id]), uri=self._get_keystone_mock_url(resource='users'),
status_code=200, json=user_data.json_response) status_code=200,
self.register_uri('DELETE', json={'users': [user_data.json_response['user']]}),
self._get_keystone_mock_url( dict(method='GET', uri=user_resource_uri, status_code=200,
resource='users', append=[user_data.user_id]), json=user_data.json_response),
status_code=204) dict(method='DELETE', uri=user_resource_uri, status_code=204)])
self.op_cloud.delete_user(user_data.name) self.op_cloud.delete_user(user_data.name)
self.assert_calls() self.assert_calls()
def test_delete_user_not_found(self): def test_delete_user_not_found(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
self.register_uri('GET', self.register_uris([
self._get_keystone_mock_url(resource='users'), dict(method='GET',
status_code=200, uri=self._get_keystone_mock_url(resource='users'),
json={'users': []}) status_code=200, json={'users': []})])
self.assertFalse(self.op_cloud.delete_user(self.getUniqueString())) self.assertFalse(self.op_cloud.delete_user(self.getUniqueString()))
def test_add_user_to_group(self): def test_add_user_to_group(self):
self._add_discovery_uri_call() self._add_discovery_uri_call()
user_data = self._get_user_data() user_data = self._get_user_data()
group_data = self._get_group_data() group_data = self._get_group_data()
self.register_uri('GET',
self._get_keystone_mock_url(resource='users'), self.register_uris([
status_code=200, dict(method='GET',
json={'users': [user_data.json_response['user']]}) uri=self._get_keystone_mock_url(resource='users'),
self.register_uri( status_code=200,
'GET', json={'users': [user_data.json_response['user']]}),
self._get_keystone_mock_url(resource='groups'), dict(method='GET',
status_code=200, uri=self._get_keystone_mock_url(resource='groups'),
json={'groups': [group_data.json_response['group']]}) status_code=200,
self.register_uri( json={'groups': [group_data.json_response['group']]}),
'PUT', dict(method='PUT',
self._get_keystone_mock_url( uri=self._get_keystone_mock_url(
resource='groups', resource='groups',
append=[group_data.group_id, 'users', user_data.user_id]), append=[group_data.group_id, 'users', user_data.user_id]),
status_code=200) status_code=200)])
self.op_cloud.add_user_to_group(user_data.user_id, group_data.group_id) self.op_cloud.add_user_to_group(user_data.user_id, group_data.group_id)
self.assert_calls() self.assert_calls()
@ -194,21 +187,22 @@ class TestUsers(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
user_data = self._get_user_data() user_data = self._get_user_data()
group_data = self._get_group_data() group_data = self._get_group_data()
self.register_uri('GET',
self._get_keystone_mock_url(resource='users'), self.register_uris([
status_code=200, dict(method='GET',
json={'users': [user_data.json_response['user']]}) uri=self._get_keystone_mock_url(resource='users'),
self.register_uri( status_code=200,
'GET', json={'users': [user_data.json_response['user']]}),
self._get_keystone_mock_url(resource='groups'), dict(method='GET',
status_code=200, uri=self._get_keystone_mock_url(resource='groups'),
json={'groups': [group_data.json_response['group']]}) status_code=200,
self.register_uri( json={'groups': [group_data.json_response['group']]}),
'HEAD', dict(method='HEAD',
self._get_keystone_mock_url( uri=self._get_keystone_mock_url(
resource='groups', resource='groups',
append=[group_data.group_id, 'users', user_data.user_id]), append=[group_data.group_id, 'users', user_data.user_id]),
status_code=204) status_code=204)])
self.assertTrue(self.op_cloud.is_user_in_group( self.assertTrue(self.op_cloud.is_user_in_group(
user_data.user_id, group_data.group_id)) user_data.user_id, group_data.group_id))
self.assert_calls() self.assert_calls()
@ -217,21 +211,21 @@ class TestUsers(base.RequestsMockTestCase):
self._add_discovery_uri_call() self._add_discovery_uri_call()
user_data = self._get_user_data() user_data = self._get_user_data()
group_data = self._get_group_data() group_data = self._get_group_data()
self.register_uri('GET',
self._get_keystone_mock_url(resource='users'), self.register_uris([
status_code=200, dict(method='GET',
json={'users': [user_data.json_response['user']]}) uri=self._get_keystone_mock_url(resource='users'),
self.register_uri( json={'users': [user_data.json_response['user']]}),
'GET', dict(method='GET',
self._get_keystone_mock_url(resource='groups'), uri=self._get_keystone_mock_url(resource='groups'),
status_code=200, status_code=200,
json={'groups': [group_data.json_response['group']]}) json={'groups': [group_data.json_response['group']]}),
self.register_uri( dict(method='DELETE',
'DELETE', uri=self._get_keystone_mock_url(
self._get_keystone_mock_url( resource='groups',
resource='groups', append=[group_data.group_id, 'users', user_data.user_id]),
append=[group_data.group_id, 'users', user_data.user_id]), status_code=204)])
status_code=204)
self.op_cloud.remove_user_from_group(user_data.user_id, self.op_cloud.remove_user_from_group(user_data.user_id,
group_data.group_id) group_data.group_id)
self.assert_calls() self.assert_calls()