openstack
/
python-novaclient
Code Issues Proposed changes

Clean up requests-mock usage 

In line with other clients testing we've found that having the
requests-mock fixture at self.requests can be misleading for new people
as it looks like you're calling requests itself.

Also make use of some of the new features of requests-mock like query
parsing, json handling, method names.

Change-Id: Id61b88c53478d49f91c3f880ed5b90d638051ba0
This commit is contained in:
Jamie Lennox 2016-10-04 18:10:06 +11:00
parent 749fee3346
commit e88afc046b
26 changed files with 416 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
novaclient/tests/unit/fixture_data/agents.py
View File

@ -32,9 +32,9 @@ class Fixture(base.Fixture):
} }
} }
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_agents, json=post_os_agents,
headers=self.json_headers) headers=self.json_headers)
put_os_agents_1 = { put_os_agents_1 = {
"agent": { "agent": {
@ -45,10 +45,10 @@ class Fixture(base.Fixture):
} }
} }
self.requests.register_uri('PUT', self.url(1), self.requests_mock.put(self.url(1),
json=put_os_agents_1, json=put_os_agents_1,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('DELETE', self.url(1), self.requests_mock.delete(self.url(1),
headers=self.json_headers, headers=self.json_headers,
status_code=202) status_code=202)

28
novaclient/tests/unit/fixture_data/aggregates.py
View File

@ -29,25 +29,25 @@ class Fixture(base.Fixture):
'availability_zone': 'nova1'}, 'availability_zone': 'nova1'},
]} ]}
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_aggregates, json=get_os_aggregates,
headers=self.json_headers) headers=self.json_headers)
get_aggregates_1 = {'aggregate': get_os_aggregates['aggregates'][0]} get_aggregates_1 = {'aggregate': get_os_aggregates['aggregates'][0]}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=get_aggregates_1, json=get_aggregates_1,
headers=self.json_headers) headers=self.json_headers)
for agg_id in (1, 2): for agg_id in (1, 2):
for method in ('GET', 'PUT'): for method in ('GET', 'PUT'):
self.requests.register_uri(method, self.url(agg_id), self.requests_mock.register_uri(method, self.url(agg_id),
json=get_aggregates_1, json=get_aggregates_1,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('POST', self.url(agg_id, 'action'), self.requests_mock.post(self.url(agg_id, 'action'),
json=get_aggregates_1, json=get_aggregates_1,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('DELETE', self.url(1), status_code=202, self.requests_mock.delete(self.url(1), status_code=202,
headers=self.json_headers) headers=self.json_headers)

12
novaclient/tests/unit/fixture_data/availability_zones.py
View File

@ -39,9 +39,9 @@ class V1(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_availability_zone, json=get_os_availability_zone,
headers=self.json_headers) headers=self.json_headers)
get_os_zone_detail = { get_os_zone_detail = {
self.zone_info_key: [ self.zone_info_key: [
@ -86,6 +86,6 @@ class V1(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url('detail'), self.requests_mock.get(self.url('detail'),
json=get_os_zone_detail, json=get_os_zone_detail,
headers=self.json_headers) headers=self.json_headers)

4
novaclient/tests/unit/fixture_data/base.py
View File

@ -24,9 +24,9 @@ class Fixture(fixtures.Fixture):
json_headers = {'Content-Type': 'application/json', json_headers = {'Content-Type': 'application/json',
'x-openstack-request-id': fakes.FAKE_REQUEST_ID} 'x-openstack-request-id': fakes.FAKE_REQUEST_ID}
def __init__(self, requests, compute_url=COMPUTE_URL): def __init__(self, requests_mock, compute_url=COMPUTE_URL):
super(Fixture, self).__init__() super(Fixture, self).__init__()
self.requests = requests self.requests_mock = requests_mock
self.compute_url = compute_url self.compute_url = compute_url
def url(self, *args, **kwargs): def url(self, *args, **kwargs):

12
novaclient/tests/unit/fixture_data/certs.py
View File

@ -40,9 +40,9 @@ class Fixture(base.Fixture):
'data': 'foo' 'data': 'foo'
} }
} }
self.requests.register_uri('GET', self.url('root'), self.requests_mock.get(self.url('root'),
json=get_os_certificate, json=get_os_certificate,
headers=self.json_headers) headers=self.json_headers)
post_os_certificates = { post_os_certificates = {
'certificate': { 'certificate': {
@ -50,6 +50,6 @@ class Fixture(base.Fixture):
'data': 'bar' 'data': 'bar'
} }
} }
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_certificates, json=post_os_certificates,
headers=self.json_headers) headers=self.json_headers)

16
novaclient/tests/unit/fixture_data/client.py
View File

@ -23,13 +23,13 @@ COMPUTE_URL = 'http://compute.host'
class V1(fixtures.Fixture): class V1(fixtures.Fixture):
def __init__(self, requests, def __init__(self, requests_mock,
compute_url=COMPUTE_URL, identity_url=IDENTITY_URL): compute_url=COMPUTE_URL, identity_url=IDENTITY_URL):
super(V1, self).__init__() super(V1, self).__init__()
self.identity_url = identity_url self.identity_url = identity_url
self.compute_url = compute_url self.compute_url = compute_url
self.client = None self.client = None
self.requests = requests self.requests_mock = requests_mock
self.token = fixture.V2Token() self.token = fixture.V2Token()
self.token.set_scope() self.token.set_scope()
@ -46,12 +46,12 @@ class V1(fixtures.Fixture):
auth_url = '%s/tokens' % self.identity_url auth_url = '%s/tokens' % self.identity_url
headers = {'X-Content-Type': 'application/json'} headers = {'X-Content-Type': 'application/json'}
self.requests.register_uri('POST', auth_url, self.requests_mock.post(auth_url,
json=self.token, json=self.token,
headers=headers) headers=headers)
self.requests.register_uri('GET', self.identity_url, self.requests_mock.get(self.identity_url,
json=self.discovery, json=self.discovery,
headers=headers) headers=headers)
self.client = self.new_client() self.client = self.new_client()
def new_client(self): def new_client(self):

20
novaclient/tests/unit/fixture_data/cloudpipe.py
View File

@ -21,17 +21,17 @@ class Fixture(base.Fixture):
super(Fixture, self).setUp() super(Fixture, self).setUp()
get_os_cloudpipe = {'cloudpipes': [{'project_id': 1}]} get_os_cloudpipe = {'cloudpipes': [{'project_id': 1}]}
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_cloudpipe, json=get_os_cloudpipe,
headers=self.json_headers) headers=self.json_headers)
instance_id = '9d5824aa-20e6-4b9f-b967-76a699fc51fd' instance_id = '9d5824aa-20e6-4b9f-b967-76a699fc51fd'
post_os_cloudpipe = {'instance_id': instance_id} post_os_cloudpipe = {'instance_id': instance_id}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_cloudpipe, json=post_os_cloudpipe,
headers=self.json_headers, headers=self.json_headers,
status_code=202) status_code=202)
self.requests.register_uri('PUT', self.url('configure-project'), self.requests_mock.put(self.url('configure-project'),
headers=self.json_headers, headers=self.json_headers,
status_code=202) status_code=202)

13
novaclient/tests/unit/fixture_data/fixedips.py
View File

@ -29,11 +29,10 @@ class Fixture(base.Fixture):
} }
} }
self.requests.register_uri('GET', self.url('192.168.1.1'), self.requests_mock.get(self.url('192.168.1.1'),
json=get_os_fixed_ips, json=get_os_fixed_ips,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('POST', self.requests_mock.post(self.url('192.168.1.1', 'action'),
self.url('192.168.1.1', 'action'), headers=self.json_headers,
headers=self.json_headers, status_code=202)
status_code=202)

118
novaclient/tests/unit/fixture_data/floatingips.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -27,28 +25,27 @@ class FloatingFixture(base.Fixture):
{'id': 2, 'fixed_ip': '10.0.0.2', 'ip': '11.0.0.2'}] {'id': 2, 'fixed_ip': '10.0.0.2', 'ip': '11.0.0.2'}]
get_os_floating_ips = {'floating_ips': floating_ips} get_os_floating_ips = {'floating_ips': floating_ips}
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_floating_ips, json=get_os_floating_ips,
headers=self.json_headers) headers=self.json_headers)
for ip in floating_ips: for ip in floating_ips:
get_os_floating_ip = {'floating_ip': ip} get_os_floating_ip = {'floating_ip': ip}
self.requests.register_uri('GET', self.url(ip['id']), self.requests_mock.get(self.url(ip['id']),
json=get_os_floating_ip, json=get_os_floating_ip,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('DELETE', self.url(ip['id']), self.requests_mock.delete(self.url(ip['id']),
headers=self.json_headers, headers=self.json_headers,
status_code=204) status_code=204)
def post_os_floating_ips(request, context): def post_os_floating_ips(request, context):
body = jsonutils.loads(request.body)
ip = floating_ips[0].copy() ip = floating_ips[0].copy()
ip['pool'] = body.get('pool') ip['pool'] = request.json().get('pool')
return {'floating_ip': ip} return {'floating_ip': ip}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_floating_ips, json=post_os_floating_ips,
headers=self.json_headers) headers=self.json_headers)
class DNSFixture(base.Fixture): class DNSFixture(base.Fixture):
@ -64,10 +61,10 @@ class DNSFixture(base.Fixture):
{'domain': 'example.com'} {'domain': 'example.com'}
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_floating_ip_dns, json=get_os_floating_ip_dns,
headers=self.json_headers, headers=self.json_headers,
status_code=205) status_code=205)
get_dns_testdomain_entries_testname = { get_dns_testdomain_entries_testname = {
'dns_entry': { 'dns_entry': {
@ -77,30 +74,29 @@ class DNSFixture(base.Fixture):
'domain': 'testdomain' 'domain': 'testdomain'
} }
} }
url = self.url('testdomain', 'entries', 'testname')
self.requests.register_uri('GET', url,
json=get_dns_testdomain_entries_testname,
headers=self.json_headers,
status_code=205)
self.requests.register_uri('DELETE', self.url('testdomain'), self.requests_mock.get(self.url('testdomain', 'entries', 'testname'),
headers=self.json_headers) json=get_dns_testdomain_entries_testname,
headers=self.json_headers,
status_code=205)
self.requests_mock.delete(self.url('testdomain'),
headers=self.json_headers)
url = self.url('testdomain', 'entries', 'testname') url = self.url('testdomain', 'entries', 'testname')
self.requests.register_uri('DELETE', url, headers=self.json_headers) self.requests_mock.delete(url, headers=self.json_headers)
def put_dns_testdomain_entries_testname(request, context): def put_dns_testdomain_entries_testname(request, context):
body = jsonutils.loads(request.body) fakes.assert_has_keys(request.json()['dns_entry'],
fakes.assert_has_keys(body['dns_entry'],
required=['ip', 'dns_type']) required=['ip', 'dns_type'])
context.status_code = 205 context.status_code = 205
return request.body return request.body
self.requests.register_uri('PUT', url, self.requests_mock.put(url,
text=put_dns_testdomain_entries_testname, text=put_dns_testdomain_entries_testname,
headers=self.json_headers) headers=self.json_headers)
url = self.url('testdomain', 'entries') url = self.url('testdomain', 'entries')
self.requests.register_uri('GET', url, status_code=404) self.requests_mock.get(url, status_code=404)
get_os_floating_ip_dns_testdomain = { get_os_floating_ip_dns_testdomain = {
'dns_entries': [ 'dns_entries': [
@ -122,13 +118,13 @@ class DNSFixture(base.Fixture):
}, },
] ]
} }
self.requests.register_uri('GET', url + '?ip=1.2.3.4', self.requests_mock.get(url + '?ip=1.2.3.4',
json=get_os_floating_ip_dns_testdomain, json=get_os_floating_ip_dns_testdomain,
status_code=205, status_code=205,
headers=self.json_headers) headers=self.json_headers)
def put_os_floating_ip_dns_testdomain(request, context): def put_os_floating_ip_dns_testdomain(request, context):
body = jsonutils.loads(request.body) body = request.json()
if body['domain_entry']['scope'] == 'private': if body['domain_entry']['scope'] == 'private':
fakes.assert_has_keys(body['domain_entry'], fakes.assert_has_keys(body['domain_entry'],
required=['availability_zone', 'scope']) required=['availability_zone', 'scope'])
@ -141,10 +137,10 @@ class DNSFixture(base.Fixture):
return request.body return request.body
self.requests.register_uri('PUT', self.url('testdomain'), self.requests_mock.put(self.url('testdomain'),
text=put_os_floating_ip_dns_testdomain, text=put_os_floating_ip_dns_testdomain,
status_code=205, status_code=205,
headers=self.json_headers) headers=self.json_headers)
class BulkFixture(base.Fixture): class BulkFixture(base.Fixture):
@ -160,25 +156,23 @@ class BulkFixture(base.Fixture):
{'id': 2, 'fixed_ip': '10.0.0.2', 'ip': '11.0.0.2'}, {'id': 2, 'fixed_ip': '10.0.0.2', 'ip': '11.0.0.2'},
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_floating_ips_bulk, json=get_os_floating_ips_bulk,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('GET', self.url('testHost'), self.requests_mock.get(self.url('testHost'),
json=get_os_floating_ips_bulk, json=get_os_floating_ips_bulk,
headers=self.json_headers) headers=self.json_headers)
def put_os_floating_ips_bulk_delete(request, context): def put_os_floating_ips_bulk_delete(request, context):
body = jsonutils.loads(request.body) ip_range = request.json().get('ip_range')
ip_range = body.get('ip_range')
return {'floating_ips_bulk_delete': ip_range} return {'floating_ips_bulk_delete': ip_range}
self.requests.register_uri('PUT', self.url('delete'), self.requests_mock.put(self.url('delete'),
json=put_os_floating_ips_bulk_delete, json=put_os_floating_ips_bulk_delete,
headers=self.json_headers) headers=self.json_headers)
def post_os_floating_ips_bulk(request, context): def post_os_floating_ips_bulk(request, context):
body = jsonutils.loads(request.body) params = request.json().get('floating_ips_bulk_create')
params = body.get('floating_ips_bulk_create')
pool = params.get('pool', 'defaultPool') pool = params.get('pool', 'defaultPool')
interface = params.get('interface', 'defaultInterface') interface = params.get('interface', 'defaultInterface')
return { return {
@ -189,9 +183,9 @@ class BulkFixture(base.Fixture):
} }
} }
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_floating_ips_bulk, json=post_os_floating_ips_bulk,
headers=self.json_headers) headers=self.json_headers)
class PoolsFixture(base.Fixture): class PoolsFixture(base.Fixture):
@ -207,6 +201,6 @@ class PoolsFixture(base.Fixture):
{'name': 'bar'} {'name': 'bar'}
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_floating_ip_pools, json=get_os_floating_ip_pools,
headers=self.json_headers) headers=self.json_headers)

12
novaclient/tests/unit/fixture_data/fping.py
View File

@ -27,9 +27,9 @@ class Fixture(base.Fixture):
"alive": True, "alive": True,
} }
} }
self.requests.register_uri('GET', self.url(1), self.requests_mock.get(self.url(1),
json=get_os_fping_1, json=get_os_fping_1,
headers=self.json_headers) headers=self.json_headers)
get_os_fping = { get_os_fping = {
'servers': [ 'servers': [
@ -41,6 +41,6 @@ class Fixture(base.Fixture):
}, },
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_fping, json=get_os_fping,
headers=self.json_headers) headers=self.json_headers)

73
novaclient/tests/unit/fixture_data/hosts.py
View File

@ -10,9 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from six.moves.urllib import parse
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -38,24 +35,22 @@ class BaseFixture(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url('host'), self.requests_mock.get(self.url('host'),
json=get_os_hosts_host, json=get_os_hosts_host,
headers=headers) headers=headers)
def get_os_hosts(request, context): def get_os_hosts(request, context):
host, query = parse.splitquery(request.url)
zone = 'nova1' zone = 'nova1'
service = None service = None
if query: if request.query:
qs = parse.parse_qs(query)
try: try:
zone = qs['zone'][0] zone = request.qs['zone'][0]
except Exception: except Exception:
pass pass
try: try:
service = qs['service'][0] service = request.qs['service'][0]
except Exception: except Exception:
pass pass
@ -74,51 +69,51 @@ class BaseFixture(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_hosts, json=get_os_hosts,
headers=headers) headers=headers)
get_os_hosts_sample_host = { get_os_hosts_sample_host = {
'host': [ 'host': [
{'resource': {'host': 'sample_host'}} {'resource': {'host': 'sample_host'}}
], ],
} }
self.requests.register_uri('GET', self.url('sample_host'), self.requests_mock.get(self.url('sample_host'),
json=get_os_hosts_sample_host, json=get_os_hosts_sample_host,
headers=headers) headers=headers)
self.requests.register_uri('PUT', self.url('sample_host', 1), self.requests_mock.put(self.url('sample_host', 1),
json=self.put_host_1(), json=self.put_host_1(),
headers=headers) headers=headers)
self.requests.register_uri('PUT', self.url('sample_host', 2), self.requests_mock.put(self.url('sample_host', 2),
json=self.put_host_2(), json=self.put_host_2(),
headers=headers) headers=headers)
self.requests.register_uri('PUT', self.url('sample_host', 3), self.requests_mock.put(self.url('sample_host', 3),
json=self.put_host_3(), json=self.put_host_3(),
headers=headers) headers=headers)
self.requests.register_uri('GET', self.url('sample_host', 'reboot'), self.requests_mock.get(self.url('sample_host', 'reboot'),
json=self.get_host_reboot(), json=self.get_host_reboot(),
headers=headers) headers=headers)
self.requests.register_uri('GET', self.url('sample_host', 'startup'), self.requests_mock.get(self.url('sample_host', 'startup'),
json=self.get_host_startup(), json=self.get_host_startup(),
headers=headers) headers=headers)
self.requests.register_uri('GET', self.url('sample_host', 'shutdown'), self.requests_mock.get(self.url('sample_host', 'shutdown'),
json=self.get_host_shutdown(), json=self.get_host_shutdown(),
headers=headers) headers=headers)
def put_os_hosts_sample_host(request, context): def put_os_hosts_sample_host(request, context):
result = {'host': 'dummy'} result = {'host': 'dummy'}
result.update(jsonutils.loads(request.body)) result.update(request.json())
return result return result
self.requests.register_uri('PUT', self.url('sample_host'), self.requests_mock.put(self.url('sample_host'),
json=put_os_hosts_sample_host, json=put_os_hosts_sample_host,
headers=headers) headers=headers)
class V1(BaseFixture): class V1(BaseFixture):

42
novaclient/tests/unit/fixture_data/hypervisors.py
View File

@ -29,9 +29,9 @@ class V1(base.Fixture):
self.headers = self.json_headers self.headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_hypervisors, json=get_os_hypervisors,
headers=self.headers) headers=self.headers)
get_os_hypervisors_detail = { get_os_hypervisors_detail = {
'hypervisors': [ 'hypervisors': [
@ -82,9 +82,9 @@ class V1(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url('detail'), self.requests_mock.get(self.url('detail'),
json=get_os_hypervisors_detail, json=get_os_hypervisors_detail,
headers=self.headers) headers=self.headers)
get_os_hypervisors_stats = { get_os_hypervisors_stats = {
'hypervisor_statistics': { 'hypervisor_statistics': {
@ -103,9 +103,9 @@ class V1(base.Fixture):
} }
} }
self.requests.register_uri('GET', self.url('statistics'), self.requests_mock.get(self.url('statistics'),
json=get_os_hypervisors_stats, json=get_os_hypervisors_stats,
headers=self.headers) headers=self.headers)
get_os_hypervisors_search = { get_os_hypervisors_search = {
'hypervisors': [ 'hypervisors': [
@ -114,9 +114,9 @@ class V1(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url('hyper', 'search'), self.requests_mock.get(self.url('hyper', 'search'),
json=get_os_hypervisors_search, json=get_os_hypervisors_search,
headers=self.headers) headers=self.headers)
get_hyper_server = { get_hyper_server = {
'hypervisors': [ 'hypervisors': [
@ -139,9 +139,9 @@ class V1(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url('hyper', 'servers'), self.requests_mock.get(self.url('hyper', 'servers'),
json=get_hyper_server, json=get_hyper_server,
headers=self.headers) headers=self.headers)
get_os_hypervisors_1234 = { get_os_hypervisors_1234 = {
'hypervisor': { 'hypervisor': {
@ -165,9 +165,9 @@ class V1(base.Fixture):
} }
} }
self.requests.register_uri('GET', self.url(1234), self.requests_mock.get(self.url(1234),
json=get_os_hypervisors_1234, json=get_os_hypervisors_1234,
headers=self.headers) headers=self.headers)
get_os_hypervisors_uptime = { get_os_hypervisors_uptime = {
'hypervisor': { 'hypervisor': {
@ -177,6 +177,6 @@ class V1(base.Fixture):
} }
} }
self.requests.register_uri('GET', self.url(1234, 'uptime'), self.requests_mock.get(self.url(1234, 'uptime'),
json=get_os_hypervisors_uptime, json=get_os_hypervisors_uptime,
headers=self.headers) headers=self.headers)

32
novaclient/tests/unit/fixture_data/images.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -32,9 +30,9 @@ class V1(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_images, json=get_images,
headers=headers) headers=headers)
image_1 = { image_1 = {
'id': 1, 'id': 1,
@ -59,27 +57,27 @@ class V1(base.Fixture):
"links": {}, "links": {},
} }
self.requests.register_uri('GET', self.url('detail'), self.requests_mock.get(self.url('detail'),
json={'images': [image_1, image_2]}, json={'images': [image_1, image_2]},
headers=headers) headers=headers)
self.requests.register_uri('GET', self.url(1), self.requests_mock.get(self.url(1),
json={'image': image_1}, json={'image': image_1},
headers=headers) headers=headers)
def post_images_1_metadata(request, context): def post_images_1_metadata(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['metadata'] assert list(body) == ['metadata']
fakes.assert_has_keys(body['metadata'], required=['test_key']) fakes.assert_has_keys(body['metadata'], required=['test_key'])
return {'metadata': image_1['metadata']} return {'metadata': image_1['metadata']}
self.requests.register_uri('POST', self.url(1, 'metadata'), self.requests_mock.post(self.url(1, 'metadata'),
json=post_images_1_metadata, json=post_images_1_metadata,
headers=headers) headers=headers)
for u in (1, '1/metadata/test_key'): for u in (1, '1/metadata/test_key'):
self.requests.register_uri('DELETE', self.url(u), status_code=204, self.requests_mock.delete(self.url(u), status_code=204,
headers=headers) headers=headers)
class V3(V1): class V3(V1):

27
novaclient/tests/unit/fixture_data/keypairs.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -26,23 +24,24 @@ class V1(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json={'keypairs': [keypair]}, json={'keypairs': [keypair]},
headers=headers) headers=headers)
self.requests.register_uri('GET', self.url('test'), self.requests_mock.get(self.url('test'),
json={'keypair': keypair}, json={'keypair': keypair},
headers=headers) headers=headers)
self.requests.register_uri('DELETE', self.url('test'), status_code=202, self.requests_mock.delete(self.url('test'),
headers=headers) status_code=202,
headers=headers)
def post_os_keypairs(request, context): def post_os_keypairs(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['keypair'] assert list(body) == ['keypair']
fakes.assert_has_keys(body['keypair'], required=['name']) fakes.assert_has_keys(body['keypair'], required=['name'])
return {'keypair': keypair} return {'keypair': keypair}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_keypairs, json=post_os_keypairs,
headers=headers) headers=headers)

6
novaclient/tests/unit/fixture_data/limits.py
View File

@ -75,6 +75,6 @@ class Fixture(base.Fixture):
} }
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_limits, json=get_limits,
headers=headers) headers=headers)

35
novaclient/tests/unit/fixture_data/networks.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -35,30 +33,29 @@ class Fixture(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_os_networks, json=get_os_networks,
headers=headers) headers=headers)
def post_os_networks(request, context): def post_os_networks(request, context):
body = jsonutils.loads(request.body) return {'network': request.json()}
return {'network': body}
self.requests.register_uri("POST", self.url(), self.requests_mock.post(self.url(),
json=post_os_networks, json=post_os_networks,
headers=headers) headers=headers)
get_os_networks_1 = {'network': {"label": "1", "cidr": "10.0.0.0/24"}} get_os_networks_1 = {'network': {"label": "1", "cidr": "10.0.0.0/24"}}
self.requests.register_uri('GET', self.url(1), self.requests_mock.get(self.url(1),
json=get_os_networks_1, json=get_os_networks_1,
headers=headers) headers=headers)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url('networkdelete'),
self.url('networkdelete'), status_code=202,
status_code=202, headers=headers)
headers=headers)
for u in ('add', 'networkdisassociate/action', 'networktest/action', for u in ('add', 'networkdisassociate/action', 'networktest/action',
'1/action', '2/action'): '1/action', '2/action'):
self.requests.register_uri('POST', self.url(u), status_code=202, self.requests_mock.post(self.url(u),
headers=headers) status_code=202,
headers=headers)

34
novaclient/tests/unit/fixture_data/quotas.py
View File

@ -27,28 +27,28 @@ class V1(base.Fixture):
for u in ('test', 'tenant-id', 'tenant-id/defaults', for u in ('test', 'tenant-id', 'tenant-id/defaults',
'%s/defaults' % uuid2, 'test/detail'): '%s/defaults' % uuid2, 'test/detail'):
self.requests.register_uri('GET', self.url(u), self.requests_mock.get(self.url(u),
json=test_json, json=test_json,
headers=self.headers)
self.requests.register_uri('PUT', self.url(uuid),
json={'quota_set': self.test_quota(uuid)},
headers=self.headers) headers=self.headers)
self.requests.register_uri('GET', self.url(uuid), self.requests_mock.put(self.url(uuid),
json={'quota_set': self.test_quota(uuid)}, json={'quota_set': self.test_quota(uuid)},
headers=self.headers) headers=self.headers)
self.requests.register_uri('PUT', self.url(uuid2), self.requests_mock.get(self.url(uuid),
json={'quota_set': self.test_quota(uuid2)}, json={'quota_set': self.test_quota(uuid)},
headers=self.headers) headers=self.headers)
self.requests.register_uri('GET', self.url(uuid2),
json={'quota_set': self.test_quota(uuid2)}, self.requests_mock.put(self.url(uuid2),
headers=self.headers) json={'quota_set': self.test_quota(uuid2)},
headers=self.headers)
self.requests_mock.get(self.url(uuid2),
json={'quota_set': self.test_quota(uuid2)},
headers=self.headers)
for u in ('test', uuid2): for u in ('test', uuid2):
self.requests.register_uri('DELETE', self.url(u), status_code=202, self.requests_mock.delete(self.url(u), status_code=202,
headers=self.headers) headers=self.headers)
def test_quota(self, tenant_id='test'): def test_quota(self, tenant_id='test'):
return { return {

23
novaclient/tests/unit/fixture_data/security_group_rules.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -35,16 +33,17 @@ class Fixture(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json={'security_group_rules': [rule]}, json={'security_group_rules': [rule]},
headers=headers) headers=headers)
for u in (1, 11, 12): for u in (1, 11, 12):
self.requests.register_uri('DELETE', self.url(u), status_code=202, self.requests_mock.delete(self.url(u),
headers=headers) status_code=202,
headers=headers)
def post_rules(request, context): def post_rules(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['security_group_rule'] assert list(body) == ['security_group_rule']
fakes.assert_has_keys(body['security_group_rule'], fakes.assert_has_keys(body['security_group_rule'],
required=['parent_group_id'], required=['parent_group_id'],
@ -53,7 +52,7 @@ class Fixture(base.Fixture):
return {'security_group_rule': rule} return {'security_group_rule': rule}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_rules, json=post_rules,
headers=headers, headers=headers,
status_code=202) status_code=202)

39
novaclient/tests/unit/fixture_data/security_groups.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -64,38 +62,39 @@ class Fixture(base.Fixture):
get_groups = {'security_groups': [security_group_1, security_group_2]} get_groups = {'security_groups': [security_group_1, security_group_2]}
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_groups, json=get_groups,
headers=headers) headers=headers)
get_group_1 = {'security_group': security_group_1} get_group_1 = {'security_group': security_group_1}
self.requests.register_uri('GET', self.url(1), self.requests_mock.get(self.url(1),
json=get_group_1, json=get_group_1,
headers=headers) headers=headers)
self.requests.register_uri('DELETE', self.url(1), status_code=202, self.requests_mock.delete(self.url(1),
headers=headers) status_code=202,
headers=headers)
def post_os_security_groups(request, context): def post_os_security_groups(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['security_group'] assert list(body) == ['security_group']
fakes.assert_has_keys(body['security_group'], fakes.assert_has_keys(body['security_group'],
required=['name', 'description']) required=['name', 'description'])
return {'security_group': security_group_1} return {'security_group': security_group_1}
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=post_os_security_groups, json=post_os_security_groups,
headers=headers, headers=headers,
status_code=202) status_code=202)
def put_os_security_groups_1(request, context): def put_os_security_groups_1(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['security_group'] assert list(body) == ['security_group']
fakes.assert_has_keys(body['security_group'], fakes.assert_has_keys(body['security_group'],
required=['name', 'description']) required=['name', 'description'])
return body return body
self.requests.register_uri('PUT', self.url(1), self.requests_mock.put(self.url(1),
json=put_os_security_groups_1, json=put_os_security_groups_1,
headers=headers, headers=headers,
status_code=205) status_code=205)

20
novaclient/tests/unit/fixture_data/server_groups.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
@ -54,16 +52,17 @@ class Fixture(base.Fixture):
headers = self.json_headers headers = self.json_headers
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json={'server_groups': server_groups}, json={'server_groups': server_groups},
headers=headers) headers=headers)
server = server_groups[0] server = server_groups[0]
server_j = jsonutils.dumps({'server_group': server})
def _register(method, *args): def _register(method, *args):
self.requests.register_uri(method, self.url(*args), text=server_j, self.requests_mock.register_uri(method,
headers=headers) self.url(*args),
json={'server_group': server},
headers=headers)
_register('POST') _register('POST')
_register('POST', server['id']) _register('POST', server['id'])
@ -71,5 +70,6 @@ class Fixture(base.Fixture):
_register('PUT', server['id']) _register('PUT', server['id'])
_register('POST', server['id'], '/action') _register('POST', server['id'], '/action')
self.requests.register_uri('DELETE', self.url(server['id']), self.requests_mock.delete(self.url(server['id']),
status_code=202, headers=headers) status_code=202,
headers=headers)

26
novaclient/tests/unit/fixture_data/server_migrations.py
View File

@ -22,9 +22,9 @@ class Fixture(base.Fixture):
def setUp(self): def setUp(self):
super(Fixture, self).setUp() super(Fixture, self).setUp()
url = self.url('1234', 'migrations', '1', 'action') url = self.url('1234', 'migrations', '1', 'action')
self.requests.register_uri('POST', url, self.requests_mock.post(url,
status_code=202, status_code=202,
headers=self.json_headers) headers=self.json_headers)
get_migrations = {'migrations': [ get_migrations = {'migrations': [
{ {
@ -47,10 +47,9 @@ class Fixture(base.Fixture):
}]} }]}
url = self.url('1234', 'migrations') url = self.url('1234', 'migrations')
self.requests.register_uri('GET', url, self.requests_mock.get(url,
status_code=200, json=get_migrations,
json=get_migrations, headers=self.json_headers)
headers=self.json_headers)
get_migration = {'migration': { get_migration = {'migration': {
"created_at": "2016-01-29T13:42:02.000000", "created_at": "2016-01-29T13:42:02.000000",
@ -72,11 +71,10 @@ class Fixture(base.Fixture):
}} }}
url = self.url('1234', 'migrations', '1') url = self.url('1234', 'migrations', '1')
self.requests.register_uri('GET', url, self.requests_mock.get(url,
status_code=200, json=get_migration,
json=get_migration, headers=self.json_headers)
headers=self.json_headers)
url = self.url('1234', 'migrations', '1') url = self.url('1234', 'migrations', '1')
self.requests.register_uri('DELETE', url, self.requests_mock.delete(url,
status_code=202, status_code=202,
headers=self.json_headers) headers=self.json_headers)

225
novaclient/tests/unit/fixture_data/servers.py
View File

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_serialization import jsonutils
from novaclient.tests.unit import fakes from novaclient.tests.unit import fakes
from novaclient.tests.unit.fixture_data import base from novaclient.tests.unit.fixture_data import base
from novaclient.tests.unit.v2 import fakes as v2_fakes from novaclient.tests.unit.v2 import fakes as v2_fakes
@ -31,9 +29,9 @@ class Base(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.url(), self.requests_mock.get(self.url(),
json=get_servers, json=get_servers,
headers=self.json_headers) headers=self.json_headers)
self.server_1234 = { self.server_1234 = {
"id": 1234, "id": 1234,
@ -155,17 +153,17 @@ class Base(base.Fixture):
servers = [self.server_1234, self.server_5678, self.server_9012] servers = [self.server_1234, self.server_5678, self.server_9012]
get_servers_detail = {"servers": servers} get_servers_detail = {"servers": servers}
self.requests.register_uri('GET', self.url('detail'), self.requests_mock.get(self.url('detail'),
json=get_servers_detail, json=get_servers_detail,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri( self.requests_mock.get(
'GET', self.url('detail', marker=self.server_1234["id"]), self.url('detail', marker=self.server_1234["id"]),
json={"servers": [self.server_1234, self.server_5678]}, json={"servers": [self.server_1234, self.server_5678]},
headers=self.json_headers, complete_qs=True) headers=self.json_headers, complete_qs=True)
self.requests.register_uri( self.requests_mock.get(
'GET', self.url('detail', marker=self.server_5678["id"]), self.url('detail', marker=self.server_5678["id"]),
json={"servers": []}, json={"servers": []},
headers=self.json_headers, complete_qs=True) headers=self.json_headers, complete_qs=True)
@ -175,39 +173,37 @@ class Base(base.Fixture):
self.server_1235['fault'] = {'message': 'something went wrong!'} self.server_1235['fault'] = {'message': 'something went wrong!'}
for s in servers + [self.server_1235]: for s in servers + [self.server_1235]:
self.requests.register_uri('GET', self.url(s['id']), self.requests_mock.get(self.url(s['id']),
json={'server': s}, json={'server': s},
headers=self.json_headers) headers=self.json_headers)
for s in (1234, 5678): for s in (1234, 5678):
self.requests.register_uri('DELETE', self.url(s), status_code=202, self.requests_mock.delete(self.url(s),
headers=self.json_headers) status_code=202,
headers=self.json_headers)
for k in ('test_key', 'key1', 'key2'): for k in ('test_key', 'key1', 'key2'):
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(1234, 'metadata', k),
self.url(1234, 'metadata', k), status_code=204,
status_code=204, headers=self.json_headers)
headers=self.json_headers)
metadata1 = {'metadata': {'test_key': 'test_value'}} metadata1 = {'metadata': {'test_key': 'test_value'}}
self.requests.register_uri('POST', self.url(1234, 'metadata'), self.requests_mock.post(self.url(1234, 'metadata'),
json=metadata1, json=metadata1,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('PUT', self.requests_mock.put(self.url(1234, 'metadata', 'test_key'),
self.url(1234, 'metadata', 'test_key'), json=metadata1,
json=metadata1, headers=self.json_headers)
headers=self.json_headers)
self.diagnostic = {'data': 'Fake diagnostics'} self.diagnostic = {'data': 'Fake diagnostics'}
metadata2 = {'metadata': {'key1': 'val1'}} metadata2 = {'metadata': {'key1': 'val1'}}
for u in ('uuid1', 'uuid2', 'uuid3', 'uuid4'): for u in ('uuid1', 'uuid2', 'uuid3', 'uuid4'):
self.requests.register_uri('POST', self.url(u, 'metadata'), self.requests_mock.post(self.url(u, 'metadata'),
json=metadata2, status_code=204) json=metadata2, status_code=204)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(u, 'metadata', 'key1'),
self.url(u, 'metadata', 'key1'), json=self.diagnostic,
json=self.diagnostic, headers=self.json_headers)
headers=self.json_headers)
get_security_groups = { get_security_groups = {
"security_groups": [{ "security_groups": [{
@ -218,22 +214,21 @@ class Base(base.Fixture):
'rules': []}] 'rules': []}]
} }
self.requests.register_uri('GET', self.requests_mock.get(self.url('1234', 'os-security-groups'),
self.url('1234', 'os-security-groups'), json=get_security_groups,
json=get_security_groups, headers=self.json_headers)
headers=self.json_headers)
self.requests.register_uri('POST', self.url(), self.requests_mock.post(self.url(),
json=self.post_servers, json=self.post_servers,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('POST', self.url('1234', 'remote-consoles'), self.requests_mock.post(self.url('1234', 'remote-consoles'),
json=self.post_servers_1234_remote_consoles, json=self.post_servers_1234_remote_consoles,
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('POST', self.url('1234', 'action'), self.requests_mock.post(self.url('1234', 'action'),
json=self.post_servers_1234_action, json=self.post_servers_1234_action,
headers=self.json_headers) headers=self.json_headers)
get_os_interface = { get_os_interface = {
"interfaceAttachments": [ "interfaceAttachments": [
@ -254,31 +249,29 @@ class Base(base.Fixture):
] ]
} }
self.requests.register_uri('GET', self.requests_mock.get(self.url('1234', 'os-interface'),
self.url('1234', 'os-interface'), json=get_os_interface,
json=get_os_interface, headers=self.json_headers)
headers=self.json_headers)
interface_data = {'interfaceAttachment': {}} interface_data = {'interfaceAttachment': {}}
self.requests.register_uri('POST', self.requests_mock.post(self.url('1234', 'os-interface'),
self.url('1234', 'os-interface'), json=interface_data,
json=interface_data, headers=self.json_headers)
headers=self.json_headers)
def put_servers_1234(request, context): def put_servers_1234(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['server'] assert list(body) == ['server']
fakes.assert_has_keys(body['server'], fakes.assert_has_keys(body['server'],
optional=['name', 'adminPass']) optional=['name', 'adminPass'])
return request.body return request.body
self.requests.register_uri('PUT', self.url(1234), self.requests_mock.put(self.url(1234),
text=put_servers_1234, text=put_servers_1234,
status_code=204, status_code=204,
headers=self.json_headers) headers=self.json_headers)
def post_os_volumes_boot(request, context): def post_os_volumes_boot(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert (set(body.keys()) <= assert (set(body.keys()) <=
set(['server', 'os:scheduler_hints'])) set(['server', 'os:scheduler_hints']))
@ -302,64 +295,56 @@ class Base(base.Fixture):
# NOTE(jamielennox): hack to make os_volumes mock go to the right place # NOTE(jamielennox): hack to make os_volumes mock go to the right place
base_url = self.base_url base_url = self.base_url
self.base_url = None self.base_url = None
self.requests.register_uri('POST', self.url('os-volumes_boot'), self.requests_mock.post(self.url('os-volumes_boot'),
json=post_os_volumes_boot, json=post_os_volumes_boot,
status_code=202, status_code=202,
headers=self.json_headers) headers=self.json_headers)
self.base_url = base_url self.base_url = base_url
# #
# Server password # Server password
# #
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(1234, 'os-server-password'),
self.url(1234, 'os-server-password'), status_code=202,
status_code=202, headers=self.json_headers)
headers=self.json_headers)
# #
# Server tags # Server tags
# #
self.requests.register_uri('GET', self.requests_mock.get(self.url(1234, 'tags'),
self.url(1234, 'tags'), json={'tags': ['tag1', 'tag2']},
json={'tags': ['tag1', 'tag2']}, headers=self.json_headers)
headers=self.json_headers)
self.requests.register_uri('GET', self.requests_mock.get(self.url(1234, 'tags', 'tag'),
self.url(1234, 'tags', 'tag'), status_code=204,
status_code=204, headers=self.json_headers)
headers=self.json_headers)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(1234, 'tags', 'tag'),
self.url(1234, 'tags', 'tag'), status_code=204,
status_code=204, headers=self.json_headers)
headers=self.json_headers)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(1234, 'tags'),
self.url(1234, 'tags'), status_code=204,
status_code=204, headers=self.json_headers)
headers=self.json_headers)
def put_server_tag(request, context): def put_server_tag(request, context):
body = jsonutils.loads(request.body) assert request.json() is None
assert body is None
context.status_code = 201 context.status_code = 201
return None return None
self.requests.register_uri('PUT', self.requests_mock.put(self.url(1234, 'tags', 'tag'),
self.url(1234, 'tags', 'tag'), json=put_server_tag,
json=put_server_tag, headers=self.json_headers)
headers=self.json_headers)
def put_server_tags(request, context): def put_server_tags(request, context):
body = jsonutils.loads(request.body) body = request.json()
assert list(body) == ['tags'] assert list(body) == ['tags']
return body return body
self.requests.register_uri('PUT', self.requests_mock.put(self.url(1234, 'tags'),
self.url(1234, 'tags'), json=put_server_tags,
json=put_server_tags, headers=self.json_headers)
headers=self.json_headers)
class V1(Base): class V1(Base):
@ -372,30 +357,27 @@ class V1(Base):
# #
add = self.server_1234['addresses'] add = self.server_1234['addresses']
self.requests.register_uri('GET', self.url(1234, 'ips'), self.requests_mock.get(self.url(1234, 'ips'),
json={'addresses': add}, json={'addresses': add},
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('GET', self.url(1234, 'ips', 'public'), self.requests_mock.get(self.url(1234, 'ips', 'public'),
json={'public': add['public']}, json={'public': add['public']},
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('GET', self.url(1234, 'ips', 'private'), self.requests_mock.get(self.url(1234, 'ips', 'private'),
json={'private': add['private']}, json={'private': add['private']},
headers=self.json_headers) headers=self.json_headers)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url(1234, 'ips', 'public', '1.2.3.4'),
self.url(1234, 'ips', 'public', '1.2.3.4'), status_code=202)
status_code=202)
self.requests.register_uri('GET', self.requests_mock.get(self.url('1234', 'diagnostics'),
self.url('1234', 'diagnostics'), json=self.diagnostic,
json=self.diagnostic, headers=self.json_headers)
headers=self.json_headers)
self.requests.register_uri('DELETE', self.requests_mock.delete(self.url('1234', 'os-interface', 'port-id'),
self.url('1234', 'os-interface', 'port-id'), headers=self.json_headers)
headers=self.json_headers)
# Testing with the following password and key # Testing with the following password and key
# #
@ -419,13 +401,12 @@ class V1(Base):
'/y5a6Z3/AoJZYGG7IH5WN88UROU3B9JZGFB2qtPLQTOvDMZLUhoPRIJeHiVSlo1N' '/y5a6Z3/AoJZYGG7IH5WN88UROU3B9JZGFB2qtPLQTOvDMZLUhoPRIJeHiVSlo1N'
'tI2/++UsXVg3ow6ItqCJGgdNuGG5JB+bslDHWPxROpesEIHdczk46HCpHQN8f1sk' 'tI2/++UsXVg3ow6ItqCJGgdNuGG5JB+bslDHWPxROpesEIHdczk46HCpHQN8f1sk'
'Hi/fmZZNQQqj1Ijq0caOIw=='} 'Hi/fmZZNQQqj1Ijq0caOIw=='}
self.requests.register_uri('GET', self.requests_mock.get(self.url(1234, 'os-server-password'),
self.url(1234, 'os-server-password'), json=get_server_password,
json=get_server_password, headers=self.json_headers)
headers=self.json_headers)
def post_servers(self, request, context): def post_servers(self, request, context):
body = jsonutils.loads(request.body) body = request.json()
context.status_code = 202 context.status_code = 202
assert (set(body.keys()) <= assert (set(body.keys()) <=
set(['server', 'os:scheduler_hints'])) set(['server', 'os:scheduler_hints']))
@ -444,7 +425,7 @@ class V1(Base):
def post_servers_1234_remote_consoles(self, request, context): def post_servers_1234_remote_consoles(self, request, context):
_body = '' _body = ''
body = jsonutils.loads(request.body) body = request.json()
context.status_code = 202 context.status_code = 202
assert len(body.keys()) == 1 assert len(body.keys()) == 1
assert 'remote_console' in body.keys() assert 'remote_console' in body.keys()
@ -458,7 +439,7 @@ class V1(Base):
def post_servers_1234_action(self, request, context): def post_servers_1234_action(self, request, context):
_body = '' _body = ''
body = jsonutils.loads(request.body) body = request.json()
context.status_code = 202 context.status_code = 202
assert len(body.keys()) == 1 assert len(body.keys()) == 1
action = list(body)[0] action = list(body)[0]

14
novaclient/tests/unit/utils.py
View File

@ -55,10 +55,6 @@ class TestCase(testtools.TestCase):
'verify': True, 'verify': True,
} }
@property
def requests(self):
return self.requests_mock
def setUp(self): def setUp(self):
super(TestCase, self).setUp() super(TestCase, self).setUp()
if (os.environ.get('OS_STDOUT_CAPTURE') == 'True' or if (os.environ.get('OS_STDOUT_CAPTURE') == 'True' or
@ -89,20 +85,20 @@ class FixturedTestCase(testscenarios.TestWithScenarios, TestCase):
self.cs = None self.cs = None
if self.client_fixture_class: if self.client_fixture_class:
fix = self.client_fixture_class(self.requests) fix = self.client_fixture_class(self.requests_mock)
self.client_fixture = self.useFixture(fix) self.client_fixture = self.useFixture(fix)
self.cs = self.client_fixture.client self.cs = self.client_fixture.client
if self.data_fixture_class: if self.data_fixture_class:
fix = self.data_fixture_class(self.requests) fix = self.data_fixture_class(self.requests_mock)
self.data_fixture = self.useFixture(fix) self.data_fixture = self.useFixture(fix)
def assert_called(self, method, path, body=None): def assert_called(self, method, path, body=None):
self.assertEqual(self.requests.last_request.method, method) self.assertEqual(self.requests_mock.last_request.method, method)
self.assertEqual(self.requests.last_request.path_url, path) self.assertEqual(self.requests_mock.last_request.path_url, path)
if body: if body:
req_data = self.requests.last_request.body req_data = self.requests_mock.last_request.body
if isinstance(req_data, six.binary_type): if isinstance(req_data, six.binary_type):
req_data = req_data.decode('utf-8') req_data = req_data.decode('utf-8')
if not isinstance(body, six.string_types): if not isinstance(body, six.string_types):

6
novaclient/tests/unit/v2/test_agents.py
View File

@ -53,9 +53,9 @@ class AgentsTest(utils.FixturedTestCase):
headers = {'Content-Type': 'application/json', headers = {'Content-Type': 'application/json',
'x-openstack-request-id': fakes.FAKE_REQUEST_ID} 'x-openstack-request-id': fakes.FAKE_REQUEST_ID}
self.requests.register_uri('GET', self.data_fixture.url(), self.requests_mock.get(self.data_fixture.url(),
json=get_os_agents, json=get_os_agents,
headers=headers) headers=headers)
def test_list_agents(self): def test_list_agents(self):
self.stub_hypervisors() self.stub_hypervisors()

5
novaclient/tests/unit/v2/test_hypervisors.py
View File

@ -194,8 +194,7 @@ class HypervisorsV233Test(HypervisorsTest):
self.cs.api_version = api_versions.APIVersion("2.33") self.cs.api_version = api_versions.APIVersion("2.33")
def test_use_limit_marker_params(self): def test_use_limit_marker_params(self):
params = {'limit': 10, 'marker': 'fake-marker'} params = {'limit': '10', 'marker': 'fake-marker'}
self.cs.hypervisors.list(**params) self.cs.hypervisors.list(**params)
for k, v in params.items(): for k, v in params.items():
self.assertIn('%s=%s' % (k, v), self.assertEqual([v], self.requests_mock.last_request.qs[k])
self.requests.last_request.path_url)

24
novaclient/tests/unit/v2/test_servers.py
View File

@ -17,7 +17,6 @@ import os
import tempfile import tempfile
import mock import mock
from oslo_serialization import jsonutils
import six import six
from novaclient import api_versions from novaclient import api_versions
@ -38,7 +37,7 @@ class ServersTest(utils.FixturedTestCase):
def setUp(self): def setUp(self):
super(ServersTest, self).setUp() super(ServersTest, self).setUp()
self.useFixture(floatingips.FloatingFixture(self.requests)) self.useFixture(floatingips.FloatingFixture(self.requests_mock))
if self.api_version: if self.api_version:
self.cs.api_version = api_versions.APIVersion(self.api_version) self.cs.api_version = api_versions.APIVersion(self.api_version)
@ -68,8 +67,8 @@ class ServersTest(utils.FixturedTestCase):
self.assertEqual(2, len(sl)) self.assertEqual(2, len(sl))
self.assertEqual(self.requests.request_history[-2].method, 'GET') self.assertEqual(self.requests_mock.request_history[-2].method, 'GET')
self.assertEqual(self.requests.request_history[-2].path_url, self.assertEqual(self.requests_mock.request_history[-2].path_url,
'/servers/detail?marker=1234') '/servers/detail?marker=1234')
self.assert_called('GET', '/servers/detail?marker=5678') self.assert_called('GET', '/servers/detail?marker=5678')
@ -320,7 +319,7 @@ class ServersTest(utils.FixturedTestCase):
self.assert_request_id(s, fakes.FAKE_REQUEST_ID_LIST) self.assert_request_id(s, fakes.FAKE_REQUEST_ID_LIST)
self.assert_called('POST', '/servers') self.assert_called('POST', '/servers')
self.assertIsInstance(s, servers.Server) self.assertIsInstance(s, servers.Server)
body = jsonutils.loads(self.requests.last_request.body) body = self.requests_mock.last_request.json()
self.assertEqual(test_password, body['server']['adminPass']) self.assertEqual(test_password, body['server']['adminPass'])
def test_create_server_userdata_bin(self): def test_create_server_userdata_bin(self):
@ -346,7 +345,7 @@ class ServersTest(utils.FixturedTestCase):
self.assert_called('POST', '/servers') self.assert_called('POST', '/servers')
self.assertIsInstance(s, servers.Server) self.assertIsInstance(s, servers.Server)
# verify userdata matches original # verify userdata matches original
body = jsonutils.loads(self.requests.last_request.body) body = self.requests_mock.last_request.json()
transferred_data = body['server']['user_data'] transferred_data = body['server']['user_data']
transferred_data = base64.b64decode(transferred_data) transferred_data = base64.b64decode(transferred_data)
self.assertEqual(original_data, transferred_data) self.assertEqual(original_data, transferred_data)
@ -364,8 +363,7 @@ class ServersTest(utils.FixturedTestCase):
self.assertIsInstance(s, servers.Server) self.assertIsInstance(s, servers.Server)
# verify disk config param was used in the request: # verify disk config param was used in the request:
body = jsonutils.loads(self.requests.last_request.body) server = self.requests_mock.last_request.json()['server']
server = body['server']
self.assertIn('OS-DCF:diskConfig', server) self.assertIn('OS-DCF:diskConfig', server)
self.assertEqual(disk_config, server['OS-DCF:diskConfig']) self.assertEqual(disk_config, server['OS-DCF:diskConfig'])
@ -471,9 +469,7 @@ class ServersTest(utils.FixturedTestCase):
self.assert_called('POST', '/servers/1234/action') self.assert_called('POST', '/servers/1234/action')
# verify disk config param was used in the request: # verify disk config param was used in the request:
body = jsonutils.loads(self.requests.last_request.body) d = self.requests_mock.last_request.json()[operation]
d = body[operation]
self.assertIn('OS-DCF:diskConfig', d) self.assertIn('OS-DCF:diskConfig', d)
self.assertEqual(disk_config, d['OS-DCF:diskConfig']) self.assertEqual(disk_config, d['OS-DCF:diskConfig'])
@ -488,8 +484,7 @@ class ServersTest(utils.FixturedTestCase):
ret = s.rebuild(image=1, preserve_ephemeral=True) ret = s.rebuild(image=1, preserve_ephemeral=True)
self.assert_request_id(ret, fakes.FAKE_REQUEST_ID_LIST) self.assert_request_id(ret, fakes.FAKE_REQUEST_ID_LIST)
self.assert_called('POST', '/servers/1234/action') self.assert_called('POST', '/servers/1234/action')
body = jsonutils.loads(self.requests.last_request.body) d = self.requests_mock.last_request.json()['rebuild']
d = body['rebuild']
self.assertIn('preserve_ephemeral', d) self.assertIn('preserve_ephemeral', d)
self.assertTrue(d['preserve_ephemeral']) self.assertTrue(d['preserve_ephemeral'])
@ -498,8 +493,7 @@ class ServersTest(utils.FixturedTestCase):
s = self.cs.servers.get(1234) s = self.cs.servers.get(1234)
ret = s.rebuild(image=1, name='new', meta={'foo': 'bar'}, files=files) ret = s.rebuild(image=1, name='new', meta={'foo': 'bar'}, files=files)
self.assert_request_id(ret, fakes.FAKE_REQUEST_ID_LIST) self.assert_request_id(ret, fakes.FAKE_REQUEST_ID_LIST)
body = jsonutils.loads(self.requests.last_request.body) d = self.requests_mock.last_request.json()['rebuild']
d = body['rebuild']
self.assertEqual('new', d['name']) self.assertEqual('new', d['name'])
self.assertEqual({'foo': 'bar'}, d['metadata']) self.assertEqual({'foo': 'bar'}, d['metadata'])
self.assertEqual('/etc/passwd', self.assertEqual('/etc/passwd',