diff options
Diffstat (limited to 'nova/tests/api/openstack/compute')
14 files changed, 3570 insertions, 367 deletions
diff --git a/nova/tests/api/openstack/compute/contrib/test_availability_zone.py b/nova/tests/api/openstack/compute/contrib/test_availability_zone.py index 2ccb9fa31..0b63960ce 100644 --- a/nova/tests/api/openstack/compute/contrib/test_availability_zone.py +++ b/nova/tests/api/openstack/compute/contrib/test_availability_zone.py @@ -76,6 +76,7 @@ def fake_set_availability_zones(context, services): class AvailabilityZoneApiTest(test.TestCase): def setUp(self): super(AvailabilityZoneApiTest, self).setUp() + availability_zones._reset_cache() self.stubs.Set(db, 'service_get_all', fake_service_get_all) self.stubs.Set(availability_zones, 'set_availability_zones', fake_set_availability_zones) diff --git a/nova/tests/api/openstack/compute/contrib/test_extended_availability_zone.py b/nova/tests/api/openstack/compute/contrib/test_extended_availability_zone.py index 814c0fff4..59d60acf2 100644 --- a/nova/tests/api/openstack/compute/contrib/test_extended_availability_zone.py +++ b/nova/tests/api/openstack/compute/contrib/test_extended_availability_zone.py @@ -19,6 +19,7 @@ import webob from nova.api.openstack.compute.contrib import extended_availability_zone from nova import availability_zones from nova import compute +from nova.compute import vm_states from nova import exception from nova.openstack.common import jsonutils from nova import test @@ -29,14 +30,31 @@ UUID2 = '00000000-0000-0000-0000-000000000002' UUID3 = '00000000-0000-0000-0000-000000000003' +def fake_compute_get_az(*args, **kwargs): + inst = fakes.stub_instance(1, uuid=UUID3, host="get-host", + vm_state=vm_states.ACTIVE, + availability_zone='fakeaz') + return inst + + +def fake_compute_get_empty(*args, **kwargs): + inst = fakes.stub_instance(1, uuid=UUID3, host="", + vm_state=vm_states.ACTIVE, + availability_zone='fakeaz') + return inst + + def fake_compute_get(*args, **kwargs): - inst = fakes.stub_instance(1, uuid=UUID3, host="get-host") + inst = fakes.stub_instance(1, uuid=UUID3, host="get-host", + vm_state=vm_states.ACTIVE) return inst def fake_compute_get_all(*args, **kwargs): - inst1 = fakes.stub_instance(1, uuid=UUID1, host="all-host") - inst2 = fakes.stub_instance(2, uuid=UUID2, host="all-host") + inst1 = fakes.stub_instance(1, uuid=UUID1, host="all-host", + vm_state=vm_states.ACTIVE) + inst2 = fakes.stub_instance(2, uuid=UUID2, host="all-host", + vm_state=vm_states.ACTIVE) return [inst1, inst2] @@ -44,12 +62,17 @@ def fake_get_host_availability_zone(context, host): return host +def fake_get_no_host_availability_zone(context, host): + return None + + class ExtendedServerAttributesTest(test.TestCase): content_type = 'application/json' prefix = 'OS-EXT-AZ:' def setUp(self): super(ExtendedServerAttributesTest, self).setUp() + availability_zones._reset_cache() fakes.stub_out_nw_api(self.stubs) self.stubs.Set(compute.api.API, 'get', fake_compute_get) self.stubs.Set(compute.api.API, 'get_all', fake_compute_get_all) @@ -77,6 +100,28 @@ class ExtendedServerAttributesTest(test.TestCase): self.assertEqual(server.get('%savailability_zone' % self.prefix), az) + def test_show_no_host_az(self): + self.stubs.Set(compute.api.API, 'get', fake_compute_get_az) + self.stubs.Set(availability_zones, 'get_host_availability_zone', + fake_get_no_host_availability_zone) + + url = '/v2/fake/servers/%s' % UUID3 + res = self._make_request(url) + + self.assertEqual(res.status_int, 200) + self.assertServerAttributes(self._get_server(res.body), 'fakeaz') + + def test_show_empty_host_az(self): + self.stubs.Set(compute.api.API, 'get', fake_compute_get_empty) + self.stubs.Set(availability_zones, 'get_host_availability_zone', + fake_get_no_host_availability_zone) + + url = '/v2/fake/servers/%s' % UUID3 + res = self._make_request(url) + + self.assertEqual(res.status_int, 200) + self.assertServerAttributes(self._get_server(res.body), 'fakeaz') + def test_show(self): url = '/v2/fake/servers/%s' % UUID3 res = self._make_request(url) diff --git a/nova/tests/api/openstack/compute/contrib/test_security_groups.py b/nova/tests/api/openstack/compute/contrib/test_security_groups.py index f1433bd0a..ac3e8885d 100644 --- a/nova/tests/api/openstack/compute/contrib/test_security_groups.py +++ b/nova/tests/api/openstack/compute/contrib/test_security_groups.py @@ -716,7 +716,7 @@ class TestSecurityGroupRules(test.TestCase): db1 = security_group_db(self.sg1) db2 = security_group_db(self.sg2) - def return_security_group(context, group_id): + def return_security_group(context, group_id, columns_to_join=None): if group_id == db1['id']: return db1 if group_id == db2['id']: diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_cells.py b/nova/tests/api/openstack/compute/plugins/v3/test_cells.py new file mode 100644 index 000000000..f369c06e3 --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_cells.py @@ -0,0 +1,469 @@ +# Copyright 2011-2012 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import copy + +from lxml import etree +from webob import exc + +from nova.api.openstack.compute.plugins.v3 import cells as cells_ext +from nova.api.openstack import extensions +from nova.api.openstack import xmlutil +from nova.cells import rpcapi as cells_rpcapi +from nova import context +from nova import db +from nova import exception +from nova.openstack.common import timeutils +from nova import test +from nova.tests.api.openstack import fakes +from nova.tests import utils + + +FAKE_CELLS = [ + dict(id=1, name='cell1', username='bob', is_parent=True, + weight_scale=1.0, weight_offset=0.0, + rpc_host='r1.example.org', password='xxxx'), + dict(id=2, name='cell2', username='alice', is_parent=False, + weight_scale=1.0, weight_offset=0.0, + rpc_host='r2.example.org', password='qwerty')] + + +FAKE_CAPABILITIES = [ + {'cap1': '0,1', 'cap2': '2,3'}, + {'cap3': '4,5', 'cap4': '5,6'}] + + +def fake_db_cell_get(context, cell_name): + for cell in FAKE_CELLS: + if cell_name == cell['name']: + return cell + else: + raise exception.CellNotFound(cell_name=cell_name) + + +def fake_db_cell_create(context, values): + cell = dict(id=1) + cell.update(values) + return cell + + +def fake_db_cell_update(context, cell_id, values): + cell = fake_db_cell_get(context, cell_id) + cell.update(values) + return cell + + +def fake_cells_api_get_all_cell_info(*args): + cells = copy.deepcopy(FAKE_CELLS) + del cells[0]['password'] + del cells[1]['password'] + for i, cell in enumerate(cells): + cell['capabilities'] = FAKE_CAPABILITIES[i] + return cells + + +def fake_db_cell_get_all(context): + return FAKE_CELLS + + +class CellsTest(test.TestCase): + def setUp(self): + super(CellsTest, self).setUp() + self.stubs.Set(db, 'cell_get', fake_db_cell_get) + self.stubs.Set(db, 'cell_get_all', fake_db_cell_get_all) + self.stubs.Set(db, 'cell_update', fake_db_cell_update) + self.stubs.Set(db, 'cell_create', fake_db_cell_create) + self.stubs.Set(cells_rpcapi.CellsAPI, 'get_cell_info_for_neighbors', + fake_cells_api_get_all_cell_info) + + self.controller = cells_ext.CellsController() + self.context = context.get_admin_context() + + def _get_request(self, resource): + return fakes.HTTPRequestV3.blank('/' + resource) + + def test_index(self): + req = self._get_request("cells") + res_dict = self.controller.index(req) + + self.assertEqual(len(res_dict['cells']), 2) + for i, cell in enumerate(res_dict['cells']): + self.assertEqual(cell['name'], FAKE_CELLS[i]['name']) + self.assertNotIn('capabilitiles', cell) + self.assertNotIn('password', cell) + + def test_detail(self): + req = self._get_request("cells/detail") + res_dict = self.controller.detail(req) + + self.assertEqual(len(res_dict['cells']), 2) + for i, cell in enumerate(res_dict['cells']): + self.assertEqual(cell['name'], FAKE_CELLS[i]['name']) + self.assertEqual(cell['capabilities'], FAKE_CAPABILITIES[i]) + self.assertNotIn('password', cell) + + def test_show_bogus_cell_raises(self): + req = self._get_request("cells/bogus") + self.assertRaises(exc.HTTPNotFound, self.controller.show, req, 'bogus') + + def test_get_cell_by_name(self): + req = self._get_request("cells/cell1") + res_dict = self.controller.show(req, 'cell1') + cell = res_dict['cell'] + + self.assertEqual(cell['name'], 'cell1') + self.assertEqual(cell['rpc_host'], 'r1.example.org') + self.assertNotIn('password', cell) + + def test_cell_delete(self): + call_info = {'delete_called': 0} + + def fake_db_cell_delete(context, cell_name): + self.assertEqual(cell_name, 'cell999') + call_info['delete_called'] += 1 + + self.stubs.Set(db, 'cell_delete', fake_db_cell_delete) + + req = self._get_request("cells/cell999") + self.controller.delete(req, 'cell999') + self.assertEqual(call_info['delete_called'], 1) + + def test_delete_bogus_cell_raises(self): + req = self._get_request("cells/cell999") + req.environ['nova.context'] = self.context + self.assertRaises(exc.HTTPNotFound, self.controller.delete, req, + 'cell999') + + def test_cell_create_parent(self): + body = {'cell': {'name': 'meow', + 'username': 'fred', + 'password': 'fubar', + 'rpc_host': 'r3.example.org', + 'type': 'parent', + # Also test this is ignored/stripped + 'is_parent': False}} + + req = self._get_request("cells") + res_dict = self.controller.create(req, body) + cell = res_dict['cell'] + + self.assertEqual(cell['name'], 'meow') + self.assertEqual(cell['username'], 'fred') + self.assertEqual(cell['rpc_host'], 'r3.example.org') + self.assertEqual(cell['type'], 'parent') + self.assertNotIn('password', cell) + self.assertNotIn('is_parent', cell) + + def test_cell_create_child(self): + body = {'cell': {'name': 'meow', + 'username': 'fred', + 'password': 'fubar', + 'rpc_host': 'r3.example.org', + 'type': 'child'}} + + req = self._get_request("cells") + res_dict = self.controller.create(req, body) + cell = res_dict['cell'] + + self.assertEqual(cell['name'], 'meow') + self.assertEqual(cell['username'], 'fred') + self.assertEqual(cell['rpc_host'], 'r3.example.org') + self.assertEqual(cell['type'], 'child') + self.assertNotIn('password', cell) + self.assertNotIn('is_parent', cell) + + def test_cell_create_no_name_raises(self): + body = {'cell': {'username': 'moocow', + 'password': 'secret', + 'rpc_host': 'r3.example.org', + 'type': 'parent'}} + + req = self._get_request("cells") + self.assertRaises(exc.HTTPBadRequest, + self.controller.create, req, body) + + def test_cell_create_name_empty_string_raises(self): + body = {'cell': {'name': '', + 'username': 'fred', + 'password': 'secret', + 'rpc_host': 'r3.example.org', + 'type': 'parent'}} + + req = self._get_request("cells") + self.assertRaises(exc.HTTPBadRequest, + self.controller.create, req, body) + + def test_cell_create_name_with_bang_raises(self): + body = {'cell': {'name': 'moo!cow', + 'username': 'fred', + 'password': 'secret', + 'rpc_host': 'r3.example.org', + 'type': 'parent'}} + + req = self._get_request("cells") + self.assertRaises(exc.HTTPBadRequest, + self.controller.create, req, body) + + def test_cell_create_name_with_dot_raises(self): + body = {'cell': {'name': 'moo.cow', + 'username': 'fred', + 'password': 'secret', + 'rpc_host': 'r3.example.org', + 'type': 'parent'}} + + req = self._get_request("cells") + self.assertRaises(exc.HTTPBadRequest, + self.controller.create, req, body) + + def test_cell_create_name_with_invalid_type_raises(self): + body = {'cell': {'name': 'moocow', + 'username': 'fred', + 'password': 'secret', + 'rpc_host': 'r3.example.org', + 'type': 'invalid'}} + + req = self._get_request("cells") + self.assertRaises(exc.HTTPBadRequest, + self.controller.create, req, body) + + def test_cell_update(self): + body = {'cell': {'username': 'zeb', + 'password': 'sneaky'}} + + req = self._get_request("cells/cell1") + res_dict = self.controller.update(req, 'cell1', body) + cell = res_dict['cell'] + + self.assertEqual(cell['name'], 'cell1') + self.assertEqual(cell['rpc_host'], FAKE_CELLS[0]['rpc_host']) + self.assertEqual(cell['username'], 'zeb') + self.assertNotIn('password', cell) + + def test_cell_update_empty_name_raises(self): + body = {'cell': {'name': '', + 'username': 'zeb', + 'password': 'sneaky'}} + + req = self._get_request("cells/cell1") + self.assertRaises(exc.HTTPBadRequest, + self.controller.update, req, 'cell1', body) + + def test_cell_update_invalid_type_raises(self): + body = {'cell': {'username': 'zeb', + 'type': 'invalid', + 'password': 'sneaky'}} + + req = self._get_request("cells/cell1") + self.assertRaises(exc.HTTPBadRequest, + self.controller.update, req, 'cell1', body) + + def test_cell_info(self): + caps = ['cap1=a;b', 'cap2=c;d'] + self.flags(name='darksecret', capabilities=caps, group='cells') + + req = self._get_request("cells/info") + res_dict = self.controller.info(req) + cell = res_dict['cell'] + cell_caps = cell['capabilities'] + + self.assertEqual(cell['name'], 'darksecret') + self.assertEqual(cell_caps['cap1'], 'a;b') + self.assertEqual(cell_caps['cap2'], 'c;d') + + def test_show_capacities(self): + self.mox.StubOutWithMock(self.controller.cells_rpcapi, + 'get_capacities') + response = {"ram_free": + {"units_by_mb": {"8192": 0, "512": 13, + "4096": 1, "2048": 3, "16384": 0}, + "total_mb": 7680}, + "disk_free": + {"units_by_mb": {"81920": 11, "20480": 46, + "40960": 23, "163840": 5, "0": 0}, + "total_mb": 1052672} + } + self.controller.cells_rpcapi.\ + get_capacities(self.context, cell_name=None).AndReturn(response) + self.mox.ReplayAll() + req = self._get_request("cells/capacities") + req.environ["nova.context"] = self.context + res_dict = self.controller.capacities(req) + self.assertEqual(response, res_dict['cell']['capacities']) + + def test_show_capacity_fails_with_non_admin_context(self): + rules = {"compute_extension:cells": "is_admin:true"} + self.policy.set_rules(rules) + + self.mox.ReplayAll() + req = self._get_request("cells/capacities") + req.environ["nova.context"] = self.context + req.environ["nova.context"].is_admin = False + self.assertRaises(exception.PolicyNotAuthorized, + self.controller.capacities, req) + + def test_show_capacities_for_invalid_cell(self): + self.mox.StubOutWithMock(self.controller.cells_rpcapi, + 'get_capacities') + self.controller.cells_rpcapi. \ + get_capacities(self.context, cell_name="invalid_cell").AndRaise( + exception.CellNotFound(cell_name="invalid_cell")) + self.mox.ReplayAll() + req = self._get_request("cells/invalid_cell/capacities") + req.environ["nova.context"] = self.context + self.assertRaises(exc.HTTPNotFound, + self.controller.capacities, req, "invalid_cell") + + def test_show_capacities_for_cell(self): + self.mox.StubOutWithMock(self.controller.cells_rpcapi, + 'get_capacities') + response = {"ram_free": + {"units_by_mb": {"8192": 0, "512": 13, + "4096": 1, "2048": 3, "16384": 0}, + "total_mb": 7680}, + "disk_free": + {"units_by_mb": {"81920": 11, "20480": 46, + "40960": 23, "163840": 5, "0": 0}, + "total_mb": 1052672} + } + self.controller.cells_rpcapi.\ + get_capacities(self.context, cell_name='cell_name').\ + AndReturn(response) + self.mox.ReplayAll() + req = self._get_request("cells/capacities") + req.environ["nova.context"] = self.context + res_dict = self.controller.capacities(req, 'cell_name') + self.assertEqual(response, res_dict['cell']['capacities']) + + def test_sync_instances(self): + call_info = {} + + def sync_instances(self, context, **kwargs): + call_info['project_id'] = kwargs.get('project_id') + call_info['updated_since'] = kwargs.get('updated_since') + + self.stubs.Set(cells_rpcapi.CellsAPI, 'sync_instances', sync_instances) + + req = self._get_request("cells/sync_instances") + body = {} + self.controller.sync_instances(req, body=body) + self.assertEqual(call_info['project_id'], None) + self.assertEqual(call_info['updated_since'], None) + + body = {'project_id': 'test-project'} + self.controller.sync_instances(req, body=body) + self.assertEqual(call_info['project_id'], 'test-project') + self.assertEqual(call_info['updated_since'], None) + + expected = timeutils.utcnow().isoformat() + if not expected.endswith("+00:00"): + expected += "+00:00" + + body = {'updated_since': expected} + self.controller.sync_instances(req, body=body) + self.assertEqual(call_info['project_id'], None) + self.assertEqual(call_info['updated_since'], expected) + + body = {'updated_since': 'skjdfkjsdkf'} + self.assertRaises(exc.HTTPBadRequest, + self.controller.sync_instances, req, body=body) + + body = {'foo': 'meow'} + self.assertRaises(exc.HTTPBadRequest, + self.controller.sync_instances, req, body=body) + + +class TestCellsXMLSerializer(test.TestCase): + def test_multiple_cells(self): + fixture = {'cells': fake_cells_api_get_all_cell_info()} + + serializer = cells_ext.CellsTemplate() + output = serializer.serialize(fixture) + res_tree = etree.XML(output) + + self.assertEqual(res_tree.tag, '{%s}cells' % xmlutil.XMLNS_V10) + self.assertEqual(len(res_tree), 2) + self.assertEqual(res_tree[0].tag, '{%s}cell' % xmlutil.XMLNS_V10) + self.assertEqual(res_tree[1].tag, '{%s}cell' % xmlutil.XMLNS_V10) + + def test_single_cell_with_caps(self): + cell = {'id': 1, + 'name': 'darksecret', + 'username': 'meow', + 'capabilities': {'cap1': 'a;b', + 'cap2': 'c;d'}} + fixture = {'cell': cell} + + serializer = cells_ext.CellTemplate() + output = serializer.serialize(fixture) + res_tree = etree.XML(output) + + self.assertEqual(res_tree.tag, '{%s}cell' % xmlutil.XMLNS_V10) + self.assertEqual(res_tree.get('name'), 'darksecret') + self.assertEqual(res_tree.get('username'), 'meow') + self.assertEqual(res_tree.get('password'), None) + self.assertEqual(len(res_tree), 1) + + child = res_tree[0] + self.assertEqual(child.tag, + '{%s}capabilities' % xmlutil.XMLNS_V10) + for elem in child: + self.assertIn(elem.tag, ('{%s}cap1' % xmlutil.XMLNS_V10, + '{%s}cap2' % xmlutil.XMLNS_V10)) + if elem.tag == '{%s}cap1' % xmlutil.XMLNS_V10: + self.assertEqual(elem.text, 'a;b') + elif elem.tag == '{%s}cap2' % xmlutil.XMLNS_V10: + self.assertEqual(elem.text, 'c;d') + + def test_single_cell_without_caps(self): + cell = {'id': 1, + 'username': 'woof', + 'name': 'darksecret'} + fixture = {'cell': cell} + + serializer = cells_ext.CellTemplate() + output = serializer.serialize(fixture) + res_tree = etree.XML(output) + + self.assertEqual(res_tree.tag, '{%s}cell' % xmlutil.XMLNS_V10) + self.assertEqual(res_tree.get('name'), 'darksecret') + self.assertEqual(res_tree.get('username'), 'woof') + self.assertEqual(res_tree.get('password'), None) + self.assertEqual(len(res_tree), 0) + + +class TestCellsXMLDeserializer(test.TestCase): + def test_cell_deserializer(self): + caps_dict = {'cap1': 'a;b', + 'cap2': 'c;d'} + caps_xml = ("<capabilities><cap1>a;b</cap1>" + "<cap2>c;d</cap2></capabilities>") + expected = {'cell': {'name': 'testcell1', + 'type': 'child', + 'rpc_host': 'localhost', + 'capabilities': caps_dict}} + intext = ("<?xml version='1.0' encoding='UTF-8'?>\n" + "<cell><name>testcell1</name><type>child</type>" + "<rpc_host>localhost</rpc_host>" + "%s</cell>") % caps_xml + deserializer = cells_ext.CellDeserializer() + result = deserializer.deserialize(intext) + self.assertEqual(dict(body=expected), result) + + def test_with_corrupt_xml(self): + deserializer = cells_ext.CellDeserializer() + self.assertRaises( + exception.MalformedRequestBody, + deserializer.deserialize, + utils.killer_xml_body()) diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_flavor_access.py b/nova/tests/api/openstack/compute/plugins/v3/test_flavor_access.py new file mode 100644 index 000000000..7d9ec93df --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_flavor_access.py @@ -0,0 +1,308 @@ +# Copyright 2012 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import datetime + +from lxml import etree +from webob import exc + +from nova.api.openstack.compute.plugins.v3 import flavor_access +from nova.api.openstack.compute import flavors as flavors_api +from nova.compute import flavors +from nova import context +from nova import exception +from nova import test +from nova.tests.api.openstack import fakes + + +def generate_flavor(flavorid, ispublic): + return { + 'id': flavorid, + 'flavorid': str(flavorid), + 'root_gb': 1, + 'ephemeral_gb': 1, + 'name': u'test', + 'deleted': False, + 'created_at': datetime.datetime(2012, 1, 1, 1, 1, 1, 1), + 'updated_at': None, + 'memory_mb': 512, + 'vcpus': 1, + 'swap': 512, + 'rxtx_factor': 1.0, + 'extra_specs': {}, + 'deleted_at': None, + 'vcpu_weight': None, + 'is_public': bool(ispublic) + } + + +INSTANCE_TYPES = { + '0': generate_flavor(0, True), + '1': generate_flavor(1, True), + '2': generate_flavor(2, False), + '3': generate_flavor(3, False)} + + +ACCESS_LIST = [{'flavor_id': '2', 'project_id': 'proj2'}, + {'flavor_id': '2', 'project_id': 'proj3'}, + {'flavor_id': '3', 'project_id': 'proj3'}] + + +def fake_get_flavor_access_by_flavor_id(flavorid): + res = [] + for access in ACCESS_LIST: + if access['flavor_id'] == flavorid: + res.append(access) + return res + + +def fake_get_flavor_by_flavor_id(flavorid): + return INSTANCE_TYPES[flavorid] + + +def _has_flavor_access(flavorid, projectid): + for access in ACCESS_LIST: + if access['flavor_id'] == flavorid and \ + access['project_id'] == projectid: + return True + return False + + +def fake_get_all_flavors(context, inactive=0, filters=None): + if filters == None or filters['is_public'] == None: + return INSTANCE_TYPES + + res = {} + for k, v in INSTANCE_TYPES.iteritems(): + if filters['is_public'] and _has_flavor_access(k, context.project_id): + res.update({k: v}) + continue + if v['is_public'] == filters['is_public']: + res.update({k: v}) + + return res + + +class FakeRequest(object): + environ = {"nova.context": context.get_admin_context()} + + def get_db_flavor(self, flavor_id): + return INSTANCE_TYPES[flavor_id] + + +class FakeResponse(object): + obj = {'flavor': {'id': '0'}, + 'flavors': [ + {'id': '0'}, + {'id': '2'}] + } + + def attach(self, **kwargs): + pass + + +class FlavorAccessTest(test.TestCase): + def setUp(self): + super(FlavorAccessTest, self).setUp() + self.flavor_controller = flavors_api.Controller() + self.flavor_access_controller = flavor_access.FlavorAccessController() + self.flavor_action_controller = flavor_access.FlavorActionController() + self.req = FakeRequest() + self.context = self.req.environ['nova.context'] + self.stubs.Set(flavors, 'get_flavor_by_flavor_id', + fake_get_flavor_by_flavor_id) + self.stubs.Set(flavors, 'get_all_flavors', fake_get_all_flavors) + self.stubs.Set(flavors, 'get_flavor_access_by_flavor_id', + fake_get_flavor_access_by_flavor_id) + + def _verify_flavor_list(self, result, expected): + # result already sorted by flavor_id + self.assertEqual(len(result), len(expected)) + + for d1, d2 in zip(result, expected): + self.assertEqual(d1['id'], d2['id']) + + def test_list_flavor_access_public(self): + # query os-flavor-access on public flavor should return 404 + req = fakes.HTTPRequest.blank('/v3/fake/flavors/os-flavor-access', + use_admin_context=True) + self.assertRaises(exc.HTTPNotFound, + self.flavor_access_controller.index, + self.req, '1') + + def test_list_flavor_access_private(self): + expected = {'flavor_access': [ + {'flavor_id': '2', 'tenant_id': 'proj2'}, + {'flavor_id': '2', 'tenant_id': 'proj3'}]} + result = self.flavor_access_controller.index(self.req, '2') + self.assertEqual(result, expected) + + def test_list_flavor_with_admin_default_proj1(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors', + use_admin_context=True) + req.environ['nova.context'].project_id = 'proj1' + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_admin_default_proj2(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}, {'id': '2'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors', + use_admin_context=True) + req.environ['nova.context'].project_id = 'proj2' + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_admin_ispublic_true(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=true', + use_admin_context=True) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_admin_ispublic_false(self): + expected = {'flavors': [{'id': '2'}, {'id': '3'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=false', + use_admin_context=True) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_admin_ispublic_false_proj2(self): + expected = {'flavors': [{'id': '2'}, {'id': '3'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=false', + use_admin_context=True) + req.environ['nova.context'].project_id = 'proj2' + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_admin_ispublic_none(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}, {'id': '2'}, + {'id': '3'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=none', + use_admin_context=True) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_no_admin_default(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors', + use_admin_context=False) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_no_admin_ispublic_true(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=true', + use_admin_context=False) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_no_admin_ispublic_false(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=false', + use_admin_context=False) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_list_flavor_with_no_admin_ispublic_none(self): + expected = {'flavors': [{'id': '0'}, {'id': '1'}]} + req = fakes.HTTPRequest.blank('/v3/fake/flavors?is_public=none', + use_admin_context=False) + result = self.flavor_controller.index(req) + self._verify_flavor_list(result['flavors'], expected['flavors']) + + def test_show(self): + resp = FakeResponse() + self.flavor_action_controller.show(self.req, resp, '0') + self.assertEqual({'id': '0', 'os-flavor-access:is_public': True}, + resp.obj['flavor']) + self.flavor_action_controller.show(self.req, resp, '2') + self.assertEqual({'id': '0', 'os-flavor-access:is_public': False}, + resp.obj['flavor']) + + def test_detail(self): + resp = FakeResponse() + self.flavor_action_controller.detail(self.req, resp) + self.assertEqual([{'id': '0', 'os-flavor-access:is_public': True}, + {'id': '2', 'os-flavor-access:is_public': False}], + resp.obj['flavors']) + + def test_create(self): + resp = FakeResponse() + self.flavor_action_controller.create(self.req, {}, resp) + self.assertEqual({'id': '0', 'os-flavor-access:is_public': True}, + resp.obj['flavor']) + + def test_add_tenant_access(self): + def stub_add_flavor_access(flavorid, projectid, ctxt=None): + self.assertEqual('3', flavorid, "flavorid") + self.assertEqual("proj2", projectid, "projectid") + self.stubs.Set(flavors, 'add_flavor_access', + stub_add_flavor_access) + expected = {'flavor_access': + [{'flavor_id': '3', 'tenant_id': 'proj3'}]} + body = {'addTenantAccess': {'tenant': 'proj2'}} + req = fakes.HTTPRequest.blank('/v3/fake/flavors/2/action', + use_admin_context=True) + result = self.flavor_action_controller.\ + _addTenantAccess(req, '3', body) + self.assertEqual(result, expected) + + def test_add_tenant_access_with_already_added_access(self): + def stub_add_flavor_access(flavorid, projectid, ctxt=None): + raise exception.FlavorAccessExists(flavor_id=flavorid, + project_id=projectid) + self.stubs.Set(flavors, 'add_flavor_access', + stub_add_flavor_access) + body = {'addTenantAccess': {'tenant': 'proj2'}} + req = fakes.HTTPRequest.blank('/v3/fake/flavors/2/action', + use_admin_context=True) + self.assertRaises(exc.HTTPConflict, + self.flavor_action_controller._addTenantAccess, + self.req, '3', body) + + def test_remove_tenant_access_with_bad_access(self): + def stub_remove_flavor_access(flavorid, projectid, ctxt=None): + raise exception.FlavorAccessNotFound(flavor_id=flavorid, + project_id=projectid) + self.stubs.Set(flavors, 'remove_flavor_access', + stub_remove_flavor_access) + body = {'removeTenantAccess': {'tenant': 'proj2'}} + req = fakes.HTTPRequest.blank('/v3/fake/flavors/2/action', + use_admin_context=True) + self.assertRaises(exc.HTTPNotFound, + self.flavor_action_controller._removeTenantAccess, + self.req, '3', body) + + +class FlavorAccessSerializerTest(test.TestCase): + def test_serializer_empty(self): + serializer = flavor_access.FlavorAccessTemplate() + text = serializer.serialize(dict(flavor_access=[])) + tree = etree.fromstring(text) + self.assertEqual(len(tree), 0) + + def test_serializer(self): + expected = ("<?xml version='1.0' encoding='UTF-8'?>\n" + '<flavor_access>' + '<access tenant_id="proj2" flavor_id="2"/>' + '<access tenant_id="proj3" flavor_id="2"/>' + '</flavor_access>') + access_list = [{'flavor_id': '2', 'tenant_id': 'proj2'}, + {'flavor_id': '2', 'tenant_id': 'proj3'}] + + serializer = flavor_access.FlavorAccessTemplate() + text = serializer.serialize(dict(flavor_access=access_list)) + self.assertEqual(text, expected) diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_flavor_disabled.py b/nova/tests/api/openstack/compute/plugins/v3/test_flavor_disabled.py new file mode 100644 index 000000000..5ff7f4035 --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_flavor_disabled.py @@ -0,0 +1,101 @@ +# Copyright 2012 Nebula, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from lxml import etree +import webob + +from nova.api.openstack.compute.plugins.v3 import flavor_disabled +from nova.compute import flavors +from nova.openstack.common import jsonutils +from nova import test +from nova.tests.api.openstack import fakes + +FAKE_FLAVORS = { + 'flavor 1': { + "flavorid": '1', + "name": 'flavor 1', + "memory_mb": '256', + "root_gb": '10', + "disabled": False, + }, + 'flavor 2': { + "flavorid": '2', + "name": 'flavor 2', + "memory_mb": '512', + "root_gb": '20', + "disabled": True, + }, +} + + +def fake_flavor_get_by_flavor_id(flavorid): + return FAKE_FLAVORS['flavor %s' % flavorid] + + +def fake_flavor_get_all(*args, **kwargs): + return FAKE_FLAVORS + + +class FlavorDisabledTest(test.TestCase): + content_type = 'application/json' + prefix = '%s:' % flavor_disabled.FlavorDisabled.alias + + def setUp(self): + super(FlavorDisabledTest, self).setUp() + fakes.stub_out_nw_api(self.stubs) + self.stubs.Set(flavors, "get_all_flavors", + fake_flavor_get_all) + self.stubs.Set(flavors, + "get_flavor_by_flavor_id", + fake_flavor_get_by_flavor_id) + + def _make_request(self, url): + req = webob.Request.blank(url) + req.headers['Accept'] = self.content_type + app = fakes.wsgi_app_v3(init_only=('servers', 'flavors', + 'os-flavor-disabled')) + return req.get_response(app) + + def _get_flavor(self, body): + return jsonutils.loads(body).get('flavor') + + def _get_flavors(self, body): + return jsonutils.loads(body).get('flavors') + + def assertFlavorDisabled(self, flavor, disabled): + self.assertEqual(str(flavor.get('%sdisabled' % self.prefix)), disabled) + + def test_show(self): + res = self._make_request('/v3/flavors/1') + self.assertEqual(res.status_int, 200, res.body) + self.assertFlavorDisabled(self._get_flavor(res.body), 'False') + + def test_detail(self): + res = self._make_request('/v3/flavors/detail') + + self.assertEqual(res.status_int, 200, res.body) + flavors = self._get_flavors(res.body) + self.assertFlavorDisabled(flavors[0], 'False') + self.assertFlavorDisabled(flavors[1], 'True') + + +class FlavorDisabledXmlTest(FlavorDisabledTest): + content_type = 'application/xml' + prefix = '{%s}' % flavor_disabled.FlavorDisabled.namespace + + def _get_flavor(self, body): + return etree.XML(body) + + def _get_flavors(self, body): + return etree.XML(body).getchildren() diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_flavors.py b/nova/tests/api/openstack/compute/plugins/v3/test_flavors.py new file mode 100644 index 000000000..d204af11f --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_flavors.py @@ -0,0 +1,696 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2012 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from lxml import etree +import webob + +import urlparse + +from nova.api.openstack.compute.plugins.v3 import flavors +from nova.api.openstack import xmlutil +import nova.compute.flavors +from nova import context +from nova import db +from nova import exception +from nova import test +from nova.tests.api.openstack import fakes +from nova.tests import matchers + +NS = "{http://docs.openstack.org/compute/api/v1.1}" +ATOMNS = "{http://www.w3.org/2005/Atom}" + + +FAKE_FLAVORS = { + 'flavor 1': { + "flavorid": '1', + "name": 'flavor 1', + "memory_mb": '256', + "root_gb": '10', + }, + 'flavor 2': { + "flavorid": '2', + "name": 'flavor 2', + "memory_mb": '512', + "root_gb": '20', + }, +} + + +def fake_flavor_get_by_flavor_id(flavorid): + return FAKE_FLAVORS['flavor %s' % flavorid] + + +def fake_flavor_get_all(inactive=False, filters=None): + def reject_min(db_attr, filter_attr): + return (filter_attr in filters and + int(flavor[db_attr]) < int(filters[filter_attr])) + + filters = filters or {} + output = {} + for (flavor_name, flavor) in FAKE_FLAVORS.items(): + if reject_min('memory_mb', 'min_memory_mb'): + continue + elif reject_min('root_gb', 'min_root_gb'): + continue + + output[flavor_name] = flavor + + return output + + +def empty_flavor_get_all(inactive=False, filters=None): + return {} + + +def return_flavor_not_found(flavor_id): + raise exception.InstanceTypeNotFound(instance_type_id=flavor_id) + + +class FlavorsTest(test.TestCase): + def setUp(self): + super(FlavorsTest, self).setUp() + self.flags(osapi_compute_extension=[]) + fakes.stub_out_networking(self.stubs) + fakes.stub_out_rate_limiting(self.stubs) + self.stubs.Set(nova.compute.flavors, "get_all_flavors", + fake_flavor_get_all) + self.stubs.Set(nova.compute.flavors, + "get_flavor_by_flavor_id", + fake_flavor_get_by_flavor_id) + + self.controller = flavors.FlavorsController() + + def test_get_flavor_by_invalid_id(self): + self.stubs.Set(nova.compute.flavors, + "get_flavor_by_flavor_id", + return_flavor_not_found) + req = fakes.HTTPRequestV3.blank('/flavors/asdf') + self.assertRaises(webob.exc.HTTPNotFound, + self.controller.show, req, 'asdf') + + def test_get_flavor_by_id(self): + req = fakes.HTTPRequestV3.blank('/flavors/1') + flavor = self.controller.show(req, '1') + expected = { + "flavor": { + "id": "1", + "name": "flavor 1", + "ram": "256", + "disk": "10", + "vcpus": "", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/1", + }, + ], + }, + } + self.assertEqual(flavor, expected) + + def test_get_flavor_with_custom_link_prefix(self): + self.flags(osapi_compute_link_prefix='http://zoo.com:42', + osapi_glance_link_prefix='http://circus.com:34') + req = fakes.HTTPRequestV3.blank('/flavors/1') + flavor = self.controller.show(req, '1') + expected = { + "flavor": { + "id": "1", + "name": "flavor 1", + "ram": "256", + "disk": "10", + "vcpus": "", + "links": [ + { + "rel": "self", + "href": "http://zoo.com:42/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://zoo.com:42/flavors/1", + }, + ], + }, + } + self.assertEqual(flavor, expected) + + def test_get_flavor_list(self): + req = fakes.HTTPRequestV3.blank('/flavors') + flavor = self.controller.index(req) + expected = { + "flavors": [ + { + "id": "1", + "name": "flavor 1", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/1", + }, + ], + }, + { + "id": "2", + "name": "flavor 2", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + } + self.assertEqual(flavor, expected) + + def test_get_flavor_list_with_marker(self): + self.maxDiff = None + req = fakes.HTTPRequestV3.blank('/flavors?limit=1&marker=1') + flavor = self.controller.index(req) + expected = { + "flavors": [ + { + "id": "2", + "name": "flavor 2", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + 'flavors_links': [ + {'href': 'http://localhost/v3/flavors?limit=1&marker=2', + 'rel': 'next'} + ] + } + self.assertThat(flavor, matchers.DictMatches(expected)) + + def test_get_flavor_detail_with_limit(self): + req = fakes.HTTPRequestV3.blank('/flavors/detail?limit=1') + response = self.controller.index(req) + response_list = response["flavors"] + response_links = response["flavors_links"] + + expected_flavors = [ + { + "id": "1", + "name": "flavor 1", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/1", + }, + ], + }, + ] + self.assertEqual(response_list, expected_flavors) + self.assertEqual(response_links[0]['rel'], 'next') + + href_parts = urlparse.urlparse(response_links[0]['href']) + self.assertEqual('/v3/flavors', href_parts.path) + params = urlparse.parse_qs(href_parts.query) + self.assertThat({'limit': ['1'], 'marker': ['1']}, + matchers.DictMatches(params)) + + def test_get_flavor_with_limit(self): + req = fakes.HTTPRequestV3.blank('/flavors?limit=2') + response = self.controller.index(req) + response_list = response["flavors"] + response_links = response["flavors_links"] + + expected_flavors = [ + { + "id": "1", + "name": "flavor 1", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/1", + }, + ], + }, + { + "id": "2", + "name": "flavor 2", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + } + ] + self.assertEqual(response_list, expected_flavors) + self.assertEqual(response_links[0]['rel'], 'next') + + href_parts = urlparse.urlparse(response_links[0]['href']) + self.assertEqual('/v3/flavors', href_parts.path) + params = urlparse.parse_qs(href_parts.query) + self.assertThat({'limit': ['2'], 'marker': ['2']}, + matchers.DictMatches(params)) + + def test_get_flavor_list_detail(self): + req = fakes.HTTPRequestV3.blank('/flavors/detail') + flavor = self.controller.detail(req) + expected = { + "flavors": [ + { + "id": "1", + "name": "flavor 1", + "ram": "256", + "disk": "10", + "vcpus": "", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/1", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/1", + }, + ], + }, + { + "id": "2", + "name": "flavor 2", + "ram": "512", + "disk": "20", + "vcpus": "", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + } + self.assertEqual(flavor, expected) + + def test_get_empty_flavor_list(self): + self.stubs.Set(nova.compute.flavors, "get_all_flavors", + empty_flavor_get_all) + + req = fakes.HTTPRequestV3.blank('/flavors') + flavors = self.controller.index(req) + expected = {'flavors': []} + self.assertEqual(flavors, expected) + + def test_get_flavor_list_filter_min_ram(self): + # Flavor lists may be filtered by minRam. + req = fakes.HTTPRequestV3.blank('/flavors?minRam=512') + flavor = self.controller.index(req) + expected = { + "flavors": [ + { + "id": "2", + "name": "flavor 2", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + } + self.assertEqual(flavor, expected) + + def test_get_flavor_list_filter_invalid_min_ram(self): + # Ensure you cannot list flavors with invalid minRam param. + req = fakes.HTTPRequestV3.blank('/flavors?minRam=NaN') + self.assertRaises(webob.exc.HTTPBadRequest, + self.controller.index, req) + + def test_get_flavor_list_filter_min_disk(self): + # Flavor lists may be filtered by minDisk. + req = fakes.HTTPRequestV3.blank('/flavors?minDisk=20') + flavor = self.controller.index(req) + expected = { + "flavors": [ + { + "id": "2", + "name": "flavor 2", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + } + self.assertEqual(flavor, expected) + + def test_get_flavor_list_filter_invalid_min_disk(self): + # Ensure you cannot list flavors with invalid minDisk param. + req = fakes.HTTPRequestV3.blank('/flavors?minDisk=NaN') + self.assertRaises(webob.exc.HTTPBadRequest, + self.controller.index, req) + + def test_get_flavor_list_detail_min_ram_and_min_disk(self): + """Tests that filtering work on flavor details and that minRam and + minDisk filters can be combined + """ + req = fakes.HTTPRequestV3.blank('/flavors/detail' + '?minRam=256&minDisk=20') + flavor = self.controller.detail(req) + expected = { + "flavors": [ + { + "id": "2", + "name": "flavor 2", + "ram": "512", + "disk": "20", + "vcpus": "", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/2", + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/2", + }, + ], + }, + ], + } + self.assertEqual(flavor, expected) + + +class FlavorsXMLSerializationTest(test.TestCase): + def _create_flavor(self): + id = 0 + while True: + id += 1 + yield { + "id": str(id), + "name": "asdf", + "ram": "256", + "disk": "10", + "vcpus": "", + "swap": "512", + "links": [ + { + "rel": "self", + "href": "http://localhost/v3/flavors/%s" % id, + }, + { + "rel": "bookmark", + "href": "http://localhost/flavors/%s" % id, + }, + ], + } + + def setUp(self): + super(FlavorsXMLSerializationTest, self).setUp() + self.flavors = self._create_flavor() + + def test_xml_declaration(self): + serializer = flavors.FlavorTemplate() + fixture = {'flavor': next(self.flavors)} + output = serializer.serialize(fixture) + has_dec = output.startswith("<?xml version='1.0' encoding='UTF-8'?>") + self.assertTrue(has_dec) + + def test_show(self): + serializer = flavors.FlavorTemplate() + + fixture = {'flavor': next(self.flavors)} + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'flavor', version='v3') + flavor_dict = fixture['flavor'] + + for key in ['name', 'id', 'ram', 'disk']: + self.assertEqual(root.get(key), str(flavor_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(flavor_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_show_handles_integers(self): + serializer = flavors.FlavorTemplate() + + fixture = {'flavor': next(self.flavors)} + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'flavor', version='v3') + flavor_dict = fixture['flavor'] + + for key in ['name', 'id', 'ram', 'disk']: + self.assertEqual(root.get(key), str(flavor_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(flavor_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_detail(self): + serializer = flavors.FlavorsTemplate() + + fixture = { + "flavors": [ + next(self.flavors), + next(self.flavors), + ], + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'flavors', version='v3') + flavor_elems = root.findall('{0}flavor'.format(NS)) + self.assertEqual(len(flavor_elems), 2) + for i, flavor_elem in enumerate(flavor_elems): + flavor_dict = fixture['flavors'][i] + + for key in ['name', 'id', 'ram', 'disk']: + self.assertEqual(flavor_elem.get(key), str(flavor_dict[key])) + + link_nodes = flavor_elem.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(flavor_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_index(self): + serializer = flavors.MinimalFlavorsTemplate() + + fixture = { + "flavors": [ + next(self.flavors), + next(self.flavors), + ], + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'flavors_index') + flavor_elems = root.findall('{0}flavor'.format(NS)) + self.assertEqual(len(flavor_elems), 2) + for i, flavor_elem in enumerate(flavor_elems): + flavor_dict = fixture['flavors'][i] + + for key in ['name', 'id']: + self.assertEqual(flavor_elem.get(key), str(flavor_dict[key])) + + link_nodes = flavor_elem.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(flavor_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_index_empty(self): + serializer = flavors.MinimalFlavorsTemplate() + + fixture = { + "flavors": [], + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'flavors_index') + flavor_elems = root.findall('{0}flavor'.format(NS)) + self.assertEqual(len(flavor_elems), 0) + + +class DisabledFlavorsWithRealDBTest(test.TestCase): + """ + Tests that disabled flavors should not be shown nor listed. + """ + def setUp(self): + super(DisabledFlavorsWithRealDBTest, self).setUp() + self.controller = flavors.FlavorsController() + + # Add a new disabled type to the list of flavors + self.req = fakes.HTTPRequestV3.blank('/flavors') + self.context = self.req.environ['nova.context'] + self.admin_context = context.get_admin_context() + + self.disabled_type = self._create_disabled_instance_type() + self.inst_types = db.api.instance_type_get_all(self.admin_context) + + def tearDown(self): + db.api.instance_type_destroy(self.admin_context, + self.disabled_type['name']) + + super(DisabledFlavorsWithRealDBTest, self).tearDown() + + def _create_disabled_instance_type(self): + inst_types = db.api.instance_type_get_all(self.admin_context) + + inst_type = inst_types[0] + + del inst_type['id'] + inst_type['name'] += '.disabled' + inst_type['flavorid'] = unicode(max( + [int(flavor['flavorid']) for flavor in inst_types]) + 1) + inst_type['disabled'] = True + + disabled_type = db.api.instance_type_create(self.admin_context, + inst_type) + + return disabled_type + + def test_index_should_not_list_disabled_flavors_to_user(self): + self.context.is_admin = False + + flavor_list = self.controller.index(self.req)['flavors'] + api_flavorids = set(f['id'] for f in flavor_list) + + db_flavorids = set(i['flavorid'] for i in self.inst_types) + disabled_flavorid = str(self.disabled_type['flavorid']) + + self.assert_(disabled_flavorid in db_flavorids) + self.assertEqual(db_flavorids - set([disabled_flavorid]), + api_flavorids) + + def test_index_should_list_disabled_flavors_to_admin(self): + self.context.is_admin = True + + flavor_list = self.controller.index(self.req)['flavors'] + api_flavorids = set(f['id'] for f in flavor_list) + + db_flavorids = set(i['flavorid'] for i in self.inst_types) + disabled_flavorid = str(self.disabled_type['flavorid']) + + self.assert_(disabled_flavorid in db_flavorids) + self.assertEqual(db_flavorids, api_flavorids) + + def test_show_should_include_disabled_flavor_for_user(self): + """ + Counterintuitively we should show disabled flavors to all users and not + just admins. The reason is that, when a user performs a server-show + request, we want to be able to display the pretty flavor name ('512 MB + Instance') and not just the flavor-id even if the flavor id has been + marked disabled. + """ + self.context.is_admin = False + + flavor = self.controller.show( + self.req, self.disabled_type['flavorid'])['flavor'] + + self.assertEqual(flavor['name'], self.disabled_type['name']) + + def test_show_should_include_disabled_flavor_for_admin(self): + self.context.is_admin = True + + flavor = self.controller.show( + self.req, self.disabled_type['flavorid'])['flavor'] + + self.assertEqual(flavor['name'], self.disabled_type['name']) + + +class ParseIsPublicTest(test.TestCase): + def setUp(self): + super(ParseIsPublicTest, self).setUp() + self.controller = flavors.FlavorsController() + + def assertPublic(self, expected, is_public): + self.assertIs(expected, self.controller._parse_is_public(is_public), + '%s did not return %s' % (is_public, expected)) + + def test_None(self): + self.assertPublic(True, None) + + def test_truthy(self): + self.assertPublic(True, True) + self.assertPublic(True, 't') + self.assertPublic(True, 'true') + self.assertPublic(True, 'yes') + self.assertPublic(True, '1') + + def test_falsey(self): + self.assertPublic(False, False) + self.assertPublic(False, 'f') + self.assertPublic(False, 'false') + self.assertPublic(False, 'no') + self.assertPublic(False, '0') + + def test_string_none(self): + self.assertPublic(None, 'none') + + def test_other(self): + self.assertRaises( + webob.exc.HTTPBadRequest, self.assertPublic, None, 'other') diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_images.py b/nova/tests/api/openstack/compute/plugins/v3/test_images.py new file mode 100644 index 000000000..712e3c8a5 --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_images.py @@ -0,0 +1,1336 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2010 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Tests of the new image services, both as a service layer, +and as a WSGI layer +""" + +import urlparse + +from lxml import etree +import webob + +from nova.api.openstack.compute.plugins.v3 import images +from nova.api.openstack.compute.views import images as images_view +from nova.api.openstack import xmlutil +from nova import exception +from nova.image import glance +from nova import test +from nova.tests.api.openstack import fakes +from nova.tests import matchers + +NS = "{http://docs.openstack.org/compute/api/v1.1}" +ATOMNS = "{http://www.w3.org/2005/Atom}" +NOW_API_FORMAT = "2010-10-11T10:30:22Z" + + +class ImagesControllerTest(test.TestCase): + """ + Test of the OpenStack API /images application controller w/Glance. + """ + + def setUp(self): + """Run before each test.""" + super(ImagesControllerTest, self).setUp() + fakes.stub_out_networking(self.stubs) + fakes.stub_out_rate_limiting(self.stubs) + fakes.stub_out_key_pair_funcs(self.stubs) + fakes.stub_out_compute_api_snapshot(self.stubs) + fakes.stub_out_compute_api_backup(self.stubs) + fakes.stub_out_glance(self.stubs) + + self.controller = images.ImagesController() + + def test_get_image(self): + fake_req = fakes.HTTPRequestV3.blank('/os-images/123') + actual_image = self.controller.show(fake_req, '124') + + href = "http://localhost/v3/images/124" + bookmark = "http://localhost/images/124" + alternate = "%s/fake/images/124" % glance.generate_glance_url() + server_uuid = "aa640691-d1a7-4a67-9d3c-d35ee6b3cc74" + server_href = "http://localhost/v3/servers/" + server_uuid + server_bookmark = "http://localhost/servers/" + server_uuid + + expected_image = { + "image": { + "id": "124", + "name": "queued snapshot", + "updated": NOW_API_FORMAT, + "created": NOW_API_FORMAT, + "status": "SAVING", + "progress": 25, + "minDisk": 0, + "minRam": 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "metadata": { + "instance_uuid": server_uuid, + "user_id": "fake", + }, + "links": [{ + "rel": "self", + "href": href, + }, + { + "rel": "bookmark", + "href": bookmark, + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate + }], + }, + } + + self.assertThat(actual_image, matchers.DictMatches(expected_image)) + + def test_get_image_with_custom_prefix(self): + self.flags(osapi_compute_link_prefix='https://zoo.com:42', + osapi_glance_link_prefix='http://circus.com:34') + fake_req = fakes.HTTPRequestV3.blank('/v3/os-images/124') + actual_image = self.controller.show(fake_req, '124') + href = "https://zoo.com:42/v3/images/124" + bookmark = "https://zoo.com:42/images/124" + alternate = "http://circus.com:34/fake/images/124" + server_uuid = "aa640691-d1a7-4a67-9d3c-d35ee6b3cc74" + server_href = "https://zoo.com:42/v3/servers/" + server_uuid + server_bookmark = "https://zoo.com:42/servers/" + server_uuid + + expected_image = { + "image": { + "id": "124", + "name": "queued snapshot", + "updated": NOW_API_FORMAT, + "created": NOW_API_FORMAT, + "status": "SAVING", + "progress": 25, + "minDisk": 0, + "minRam": 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "metadata": { + "instance_uuid": server_uuid, + "user_id": "fake", + }, + "links": [{ + "rel": "self", + "href": href, + }, + { + "rel": "bookmark", + "href": bookmark, + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate + }], + }, + } + self.assertThat(actual_image, matchers.DictMatches(expected_image)) + + def test_get_image_404(self): + fake_req = fakes.HTTPRequestV3.blank('/os-images/unknown') + self.assertRaises(webob.exc.HTTPNotFound, + self.controller.show, fake_req, 'unknown') + + def test_get_image_details(self): + request = fakes.HTTPRequestV3.blank('/os-images/detail') + response = self.controller.detail(request) + response_list = response["images"] + + server_uuid = "aa640691-d1a7-4a67-9d3c-d35ee6b3cc74" + server_href = "http://localhost/v3/servers/" + server_uuid + server_bookmark = "http://localhost/servers/" + server_uuid + alternate = "%s/fake/images/%s" + + expected = [{ + 'id': '123', + 'name': 'public image', + 'metadata': {'key1': 'value1'}, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'ACTIVE', + 'progress': 100, + 'minDisk': 10, + 'minRam': 128, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/123", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/123", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate % (glance.generate_glance_url(), 123), + }], + }, + { + 'id': '124', + 'name': 'queued snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'SAVING', + 'progress': 25, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/124", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/124", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate % (glance.generate_glance_url(), 124), + }], + }, + { + 'id': '125', + 'name': 'saving snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'SAVING', + 'progress': 50, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/125", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/125", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/125" % glance.generate_glance_url() + }], + }, + { + 'id': '126', + 'name': 'active snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'ACTIVE', + 'progress': 100, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/126", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/126", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/126" % glance.generate_glance_url() + }], + }, + { + 'id': '127', + 'name': 'killed snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'ERROR', + 'progress': 0, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/127", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/127", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/127" % glance.generate_glance_url() + }], + }, + { + 'id': '128', + 'name': 'deleted snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'DELETED', + 'progress': 0, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/128", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/128", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/128" % glance.generate_glance_url() + }], + }, + { + 'id': '129', + 'name': 'pending_delete snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'DELETED', + 'progress': 0, + 'minDisk': 0, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/129", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/129", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/129" % glance.generate_glance_url() + }], + }, + { + 'id': '130', + 'name': None, + 'metadata': {}, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'ACTIVE', + 'progress': 100, + 'minDisk': 0, + 'minRam': 0, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/130", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/130", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": "%s/fake/images/130" % glance.generate_glance_url() + }], + }, + ] + + self.assertThat(expected, matchers.DictListMatches(response_list)) + + def test_get_image_details_with_limit(self): + request = fakes.HTTPRequestV3.blank('/os-images/detail?limit=2') + response = self.controller.detail(request) + response_list = response["images"] + response_links = response["images_links"] + + server_uuid = "aa640691-d1a7-4a67-9d3c-d35ee6b3cc74" + server_href = "http://localhost/v3/servers/" + server_uuid + server_bookmark = "http://localhost/servers/" + server_uuid + alternate = "%s/fake/images/%s" + + expected = [{ + 'id': '123', + 'name': 'public image', + 'metadata': {'key1': 'value1'}, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'ACTIVE', + 'minDisk': 10, + 'progress': 100, + 'minRam': 128, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/123", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/123", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate % (glance.generate_glance_url(), 123), + }], + }, + { + 'id': '124', + 'name': 'queued snapshot', + 'metadata': { + u'instance_uuid': server_uuid, + u'user_id': u'fake', + }, + 'updated': NOW_API_FORMAT, + 'created': NOW_API_FORMAT, + 'status': 'SAVING', + 'minDisk': 0, + 'progress': 25, + 'minRam': 0, + 'server': { + 'id': server_uuid, + "links": [{ + "rel": "self", + "href": server_href, + }, + { + "rel": "bookmark", + "href": server_bookmark, + }], + }, + "links": [{ + "rel": "self", + "href": "http://localhost/v3/images/124", + }, + { + "rel": "bookmark", + "href": "http://localhost/images/124", + }, + { + "rel": "alternate", + "type": "application/vnd.openstack.image", + "href": alternate % (glance.generate_glance_url(), 124), + }], + }] + + self.assertThat(expected, matchers.DictListMatches(response_list)) + + href_parts = urlparse.urlparse(response_links[0]['href']) + self.assertEqual('/v3/images', href_parts.path) + params = urlparse.parse_qs(href_parts.query) + + self.assertThat({'limit': ['2'], 'marker': ['124']}, + matchers.DictMatches(params)) + + def test_image_detail_filter_with_name(self): + image_service = self.mox.CreateMockAnything() + filters = {'name': 'testname'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail' + '?name=testname') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_with_status(self): + image_service = self.mox.CreateMockAnything() + filters = {'status': 'active'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail' + '?status=ACTIVE') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_with_property(self): + image_service = self.mox.CreateMockAnything() + filters = {'property-test': '3'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail' + '?property-test=3') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_server_href(self): + image_service = self.mox.CreateMockAnything() + uuid = 'fa95aaf5-ab3b-4cd8-88c0-2be7dd051aaf' + ref = 'http://localhost:8774/servers/' + uuid + url = '/v3/os-images/detail?server=' + ref + filters = {'property-instance_uuid': uuid} + request = fakes.HTTPRequestV3.blank(url) + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_server_uuid(self): + image_service = self.mox.CreateMockAnything() + uuid = 'fa95aaf5-ab3b-4cd8-88c0-2be7dd051aaf' + url = '/v2/fake/images/detail?server=' + uuid + filters = {'property-instance_uuid': uuid} + request = fakes.HTTPRequestV3.blank(url) + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_changes_since(self): + image_service = self.mox.CreateMockAnything() + filters = {'changes-since': '2011-01-24T17:08Z'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail' + '?changes-since=2011-01-24T17:08Z') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_with_type(self): + image_service = self.mox.CreateMockAnything() + filters = {'property-image_type': 'BASE'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail?type=BASE') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_filter_not_supported(self): + image_service = self.mox.CreateMockAnything() + filters = {'status': 'active'} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail?status=' + 'ACTIVE&UNSUPPORTEDFILTER=testname') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_no_filters(self): + image_service = self.mox.CreateMockAnything() + filters = {} + request = fakes.HTTPRequestV3.blank('/v3/os-images/detail') + context = request.environ['nova.context'] + image_service.detail(context, filters=filters).AndReturn([]) + self.mox.ReplayAll() + controller = images.ImagesController(image_service=image_service) + controller.detail(request) + + def test_image_detail_invalid_marker(self): + class InvalidImageService(object): + + def detail(self, *args, **kwargs): + raise exception.Invalid('meow') + + request = fakes.HTTPRequestV3.blank('/v3/os-images?marker=invalid') + controller = images.ImagesController(image_service=InvalidImageService()) + self.assertRaises(webob.exc.HTTPBadRequest, controller.detail, request) + + def test_generate_alternate_link(self): + view = images_view.ViewBuilder() + request = fakes.HTTPRequestV3.blank('/v3/os-images/1') + generated_url = view._get_alternate_link(request, 1) + actual_url = "%s/fake/images/1" % glance.generate_glance_url() + self.assertEqual(generated_url, actual_url) + + def test_delete_image(self): + request = fakes.HTTPRequestV3.blank('/v3/os-images/124') + request.method = 'DELETE' + response = self.controller.delete(request, '124') + self.assertEqual(response.status_int, 204) + + def test_delete_deleted_image(self): + """If you try to delete a deleted image, you get back 403 Forbidden.""" + + deleted_image_id = 128 + # see nova.tests.api.openstack.fakes:_make_image_fixtures + + request = fakes.HTTPRequestV3.blank( + '/v3/os-images/%s' % deleted_image_id) + request.method = 'DELETE' + self.assertRaises(webob.exc.HTTPForbidden, self.controller.delete, + request, '%s' % deleted_image_id) + + def test_delete_image_not_found(self): + request = fakes.HTTPRequestV3.blank('/v3/os-images/300') + request.method = 'DELETE' + self.assertRaises(webob.exc.HTTPNotFound, + self.controller.delete, request, '300') + + +class ImageXMLSerializationTest(test.TestCase): + + TIMESTAMP = "2010-10-11T10:30:22Z" + SERVER_UUID = 'aa640691-d1a7-4a67-9d3c-d35ee6b3cc74' + SERVER_HREF = 'http://localhost/v3/servers/' + SERVER_UUID + SERVER_BOOKMARK = 'http://localhost/servers/' + SERVER_UUID + IMAGE_HREF = 'http://localhost/v3/os-images/%s' + IMAGE_NEXT = 'http://localhost/v3/os-images?limit=%s&marker=%s' + IMAGE_BOOKMARK = 'http://localhost/os-images/%s' + + def test_xml_declaration(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'progress': 80, + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + has_dec = output.startswith("<?xml version='1.0' encoding='UTF-8'?>") + self.assertTrue(has_dec) + + def test_show(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'progress': 80, + 'minRam': 10, + 'minDisk': 100, + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status', 'progress']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + metadata_root = root.find('{0}metadata'.format(NS)) + metadata_elems = metadata_root.findall('{0}meta'.format(NS)) + self.assertEqual(len(metadata_elems), 1) + for i, metadata_elem in enumerate(metadata_elems): + (meta_key, meta_value) = image_dict['metadata'].items()[i] + self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) + self.assertEqual(str(metadata_elem.text).strip(), str(meta_value)) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root.get('id'), image_dict['server']['id']) + link_nodes = server_root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['server']['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_show_zero_metadata(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'metadata': {}, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + meta_nodes = root.findall('{0}meta'.format(ATOMNS)) + self.assertEqual(len(meta_nodes), 0) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root.get('id'), image_dict['server']['id']) + link_nodes = server_root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['server']['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_show_image_no_metadata_key(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + meta_nodes = root.findall('{0}meta'.format(ATOMNS)) + self.assertEqual(len(meta_nodes), 0) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root.get('id'), image_dict['server']['id']) + link_nodes = server_root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['server']['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_show_no_server(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + metadata_root = root.find('{0}metadata'.format(NS)) + metadata_elems = metadata_root.findall('{0}meta'.format(NS)) + self.assertEqual(len(metadata_elems), 1) + for i, metadata_elem in enumerate(metadata_elems): + (meta_key, meta_value) = image_dict['metadata'].items()[i] + self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) + self.assertEqual(str(metadata_elem.text).strip(), str(meta_value)) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root, None) + + def test_show_with_min_ram(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'progress': 80, + 'minRam': 256, + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status', 'progress', + 'minRam']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + metadata_root = root.find('{0}metadata'.format(NS)) + metadata_elems = metadata_root.findall('{0}meta'.format(NS)) + self.assertEqual(len(metadata_elems), 1) + for i, metadata_elem in enumerate(metadata_elems): + (meta_key, meta_value) = image_dict['metadata'].items()[i] + self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) + self.assertEqual(str(metadata_elem.text).strip(), str(meta_value)) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root.get('id'), image_dict['server']['id']) + link_nodes = server_root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['server']['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_show_with_min_disk(self): + serializer = images.ImageTemplate() + + fixture = { + 'image': { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'progress': 80, + 'minDisk': 5, + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'image') + image_dict = fixture['image'] + + for key in ['name', 'id', 'updated', 'created', 'status', 'progress', + 'minDisk']: + self.assertEqual(root.get(key), str(image_dict[key])) + + link_nodes = root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + metadata_root = root.find('{0}metadata'.format(NS)) + metadata_elems = metadata_root.findall('{0}meta'.format(NS)) + self.assertEqual(len(metadata_elems), 1) + for i, metadata_elem in enumerate(metadata_elems): + (meta_key, meta_value) = image_dict['metadata'].items()[i] + self.assertEqual(str(metadata_elem.get('key')), str(meta_key)) + self.assertEqual(str(metadata_elem.text).strip(), str(meta_value)) + + server_root = root.find('{0}server'.format(NS)) + self.assertEqual(server_root.get('id'), image_dict['server']['id']) + link_nodes = server_root.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['server']['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_index(self): + serializer = images.MinimalImagesTemplate() + + fixture = { + 'images': [ + { + 'id': 1, + 'name': 'Image1', + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + { + 'id': 2, + 'name': 'Image2', + 'links': [ + { + 'href': self.IMAGE_HREF % 2, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 2, + 'rel': 'bookmark', + }, + ], + }, + ] + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'images_index') + image_elems = root.findall('{0}image'.format(NS)) + self.assertEqual(len(image_elems), 2) + for i, image_elem in enumerate(image_elems): + image_dict = fixture['images'][i] + + for key in ['name', 'id']: + self.assertEqual(image_elem.get(key), str(image_dict[key])) + + link_nodes = image_elem.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + def test_index_with_links(self): + serializer = images.MinimalImagesTemplate() + + fixture = { + 'images': [ + { + 'id': 1, + 'name': 'Image1', + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + { + 'id': 2, + 'name': 'Image2', + 'links': [ + { + 'href': self.IMAGE_HREF % 2, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 2, + 'rel': 'bookmark', + }, + ], + }, + ], + 'images_links': [ + { + 'rel': 'next', + 'href': self.IMAGE_NEXT % (2, 2), + } + ], + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'images_index') + image_elems = root.findall('{0}image'.format(NS)) + self.assertEqual(len(image_elems), 2) + for i, image_elem in enumerate(image_elems): + image_dict = fixture['images'][i] + + for key in ['name', 'id']: + self.assertEqual(image_elem.get(key), str(image_dict[key])) + + link_nodes = image_elem.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) + + # Check images_links + images_links = root.findall('{0}link'.format(ATOMNS)) + for i, link in enumerate(fixture['images_links']): + for key, value in link.items(): + self.assertEqual(images_links[i].get(key), value) + + def test_index_zero_images(self): + serializer = images.MinimalImagesTemplate() + + fixtures = { + 'images': [], + } + + output = serializer.serialize(fixtures) + root = etree.XML(output) + xmlutil.validate_schema(root, 'images_index') + image_elems = root.findall('{0}image'.format(NS)) + self.assertEqual(len(image_elems), 0) + + def test_detail(self): + serializer = images.ImagesTemplate() + + fixture = { + 'images': [ + { + 'id': 1, + 'name': 'Image1', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'ACTIVE', + 'server': { + 'id': self.SERVER_UUID, + 'links': [ + { + 'href': self.SERVER_HREF, + 'rel': 'self', + }, + { + 'href': self.SERVER_BOOKMARK, + 'rel': 'bookmark', + }, + ], + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 1, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 1, + 'rel': 'bookmark', + }, + ], + }, + { + 'id': '2', + 'name': 'Image2', + 'created': self.TIMESTAMP, + 'updated': self.TIMESTAMP, + 'status': 'SAVING', + 'progress': 80, + 'metadata': { + 'key1': 'value1', + }, + 'links': [ + { + 'href': self.IMAGE_HREF % 2, + 'rel': 'self', + }, + { + 'href': self.IMAGE_BOOKMARK % 2, + 'rel': 'bookmark', + }, + ], + }, + ] + } + + output = serializer.serialize(fixture) + root = etree.XML(output) + xmlutil.validate_schema(root, 'images') + image_elems = root.findall('{0}image'.format(NS)) + self.assertEqual(len(image_elems), 2) + for i, image_elem in enumerate(image_elems): + image_dict = fixture['images'][i] + + for key in ['name', 'id', 'updated', 'created', 'status']: + self.assertEqual(image_elem.get(key), str(image_dict[key])) + + link_nodes = image_elem.findall('{0}link'.format(ATOMNS)) + self.assertEqual(len(link_nodes), 2) + for i, link in enumerate(image_dict['links']): + for key, value in link.items(): + self.assertEqual(link_nodes[i].get(key), value) diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_quota_classes.py b/nova/tests/api/openstack/compute/plugins/v3/test_quota_classes.py new file mode 100644 index 000000000..c4f79118e --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_quota_classes.py @@ -0,0 +1,188 @@ +# Copyright 2012 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from lxml import etree +import webob + +from nova.api.openstack.compute.contrib import quota_classes +from nova.api.openstack import wsgi +from nova import test +from nova.tests.api.openstack import fakes + + +def quota_set(class_name): + return {'quota_class_set': {'id': class_name, 'metadata_items': 128, + 'ram': 51200, 'floating_ips': 10, + 'fixed_ips': -1, 'instances': 10, + 'injected_files': 5, 'cores': 20, + 'injected_file_content_bytes': 10240, + 'security_groups': 10, + 'security_group_rules': 20, 'key_pairs': 100, + 'injected_file_path_bytes': 255}} + + +class QuotaClassSetsTest(test.TestCase): + + def setUp(self): + super(QuotaClassSetsTest, self).setUp() + self.controller = quota_classes.QuotaClassSetsController() + + def test_format_quota_set(self): + raw_quota_set = { + 'instances': 10, + 'cores': 20, + 'ram': 51200, + 'floating_ips': 10, + 'fixed_ips': -1, + 'metadata_items': 128, + 'injected_files': 5, + 'injected_file_path_bytes': 255, + 'injected_file_content_bytes': 10240, + 'security_groups': 10, + 'security_group_rules': 20, + 'key_pairs': 100, + } + + quota_set = self.controller._format_quota_set('test_class', + raw_quota_set) + qs = quota_set['quota_class_set'] + + self.assertEqual(qs['id'], 'test_class') + self.assertEqual(qs['instances'], 10) + self.assertEqual(qs['cores'], 20) + self.assertEqual(qs['ram'], 51200) + self.assertEqual(qs['floating_ips'], 10) + self.assertEqual(qs['fixed_ips'], -1) + self.assertEqual(qs['metadata_items'], 128) + self.assertEqual(qs['injected_files'], 5) + self.assertEqual(qs['injected_file_path_bytes'], 255) + self.assertEqual(qs['injected_file_content_bytes'], 10240) + self.assertEqual(qs['security_groups'], 10) + self.assertEqual(qs['security_group_rules'], 20) + self.assertEqual(qs['key_pairs'], 100) + + def test_quotas_show_as_admin(self): + req = fakes.HTTPRequest.blank( + '/v2/fake4/os-quota-class-sets/test_class', + use_admin_context=True) + res_dict = self.controller.show(req, 'test_class') + + self.assertEqual(res_dict, quota_set('test_class')) + + def test_quotas_show_as_unauthorized_user(self): + req = fakes.HTTPRequest.blank( + '/v2/fake4/os-quota-class-sets/test_class') + self.assertRaises(webob.exc.HTTPForbidden, self.controller.show, + req, 'test_class') + + def test_quotas_update_as_admin(self): + body = {'quota_class_set': {'instances': 50, 'cores': 50, + 'ram': 51200, 'floating_ips': 10, + 'fixed_ips': -1, 'metadata_items': 128, + 'injected_files': 5, + 'injected_file_content_bytes': 10240, + 'injected_file_path_bytes': 255, + 'security_groups': 10, + 'security_group_rules': 20, + 'key_pairs': 100}} + + req = fakes.HTTPRequest.blank( + '/v2/fake4/os-quota-class-sets/test_class', + use_admin_context=True) + res_dict = self.controller.update(req, 'test_class', body) + + self.assertEqual(res_dict, body) + + def test_quotas_update_as_user(self): + body = {'quota_class_set': {'instances': 50, 'cores': 50, + 'ram': 51200, 'floating_ips': 10, + 'fixed_ips': -1, 'metadata_items': 128, + 'injected_files': 5, + 'injected_file_content_bytes': 10240, + 'security_groups': 10, + 'security_group_rules': 20, + 'key_pairs': 100, + }} + + req = fakes.HTTPRequest.blank( + '/v2/fake4/os-quota-class-sets/test_class') + self.assertRaises(webob.exc.HTTPForbidden, self.controller.update, + req, 'test_class', body) + + +class QuotaTemplateXMLSerializerTest(test.TestCase): + def setUp(self): + super(QuotaTemplateXMLSerializerTest, self).setUp() + self.serializer = quota_classes.QuotaClassTemplate() + self.deserializer = wsgi.XMLDeserializer() + + def test_serializer(self): + exemplar = dict(quota_class_set=dict( + id='test_class', + metadata_items=10, + injected_file_path_bytes=255, + injected_file_content_bytes=20, + ram=50, + floating_ips=60, + fixed_ips=-1, + instances=70, + injected_files=80, + security_groups=10, + security_group_rules=20, + key_pairs=100, + cores=90)) + text = self.serializer.serialize(exemplar) + + tree = etree.fromstring(text) + + self.assertEqual('quota_class_set', tree.tag) + self.assertEqual('test_class', tree.get('id')) + self.assertEqual(len(exemplar['quota_class_set']) - 1, len(tree)) + for child in tree: + self.assertTrue(child.tag in exemplar['quota_class_set']) + self.assertEqual(int(child.text), + exemplar['quota_class_set'][child.tag]) + + def test_deserializer(self): + exemplar = dict(quota_class_set=dict( + metadata_items='10', + injected_file_content_bytes='20', + ram='50', + floating_ips='60', + fixed_ips='-1', + instances='70', + injected_files='80', + security_groups='10', + security_group_rules='20', + key_pairs='100', + cores='90')) + intext = ("<?xml version='1.0' encoding='UTF-8'?>\n" + '<quota_class_set>' + '<metadata_items>10</metadata_items>' + '<injected_file_content_bytes>20' + '</injected_file_content_bytes>' + '<ram>50</ram>' + '<floating_ips>60</floating_ips>' + '<fixed_ips>-1</fixed_ips>' + '<instances>70</instances>' + '<injected_files>80</injected_files>' + '<cores>90</cores>' + '<security_groups>10</security_groups>' + '<security_group_rules>20</security_group_rules>' + '<key_pairs>100</key_pairs>' + '</quota_class_set>') + + result = self.deserializer.deserialize(intext)['body'] + self.assertEqual(result, exemplar) diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_server_diagnostics.py b/nova/tests/api/openstack/compute/plugins/v3/test_server_diagnostics.py new file mode 100644 index 000000000..61b78fea8 --- /dev/null +++ b/nova/tests/api/openstack/compute/plugins/v3/test_server_diagnostics.py @@ -0,0 +1,81 @@ +# Copyright 2011 Eldar Nugaev +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from lxml import etree + +from nova.api.openstack import compute +from nova.api.openstack.compute.plugins.v3 import server_diagnostics +from nova.api.openstack import wsgi +from nova.compute import api as compute_api +from nova.openstack.common import jsonutils +from nova import test +from nova.tests.api.openstack import fakes + + +UUID = 'abc' + + +def fake_get_diagnostics(self, _context, instance_uuid): + return {'data': 'Some diagnostic info'} + + +def fake_instance_get(self, _context, instance_uuid): + if instance_uuid != UUID: + raise Exception("Invalid UUID") + return {'uuid': instance_uuid} + + +class ServerDiagnosticsTest(test.TestCase): + + def setUp(self): + super(ServerDiagnosticsTest, self).setUp() + self.stubs.Set(compute_api.API, 'get_diagnostics', + fake_get_diagnostics) + self.stubs.Set(compute_api.API, 'get', fake_instance_get) + + self.router = compute.APIRouterV3(init_only=('servers', 'os-server-diagnostics')) + + def test_get_diagnostics(self): + req = fakes.HTTPRequestV3.blank( + '/servers/%s/os-server-diagnostics' % UUID) + res = req.get_response(self.router) + output = jsonutils.loads(res.body) + self.assertEqual(output, {'data': 'Some diagnostic info'}) + + +class TestServerDiagnosticsXMLSerializer(test.TestCase): + namespace = wsgi.XMLNS_V11 + + def _tag(self, elem): + tagname = elem.tag + self.assertEqual(tagname[0], '{') + tmp = tagname.partition('}') + namespace = tmp[0][1:] + self.assertEqual(namespace, self.namespace) + return tmp[2] + + def test_index_serializer(self): + serializer = server_diagnostics.ServerDiagnosticsTemplate() + exemplar = dict(diag1='foo', diag2='bar') + text = serializer.serialize(exemplar) + + tree = etree.fromstring(text) + + self.assertEqual('diagnostics', self._tag(tree)) + self.assertEqual(len(tree), len(exemplar)) + for child in tree: + tag = self._tag(child) + self.assertTrue(tag in exemplar) + self.assertEqual(child.text, exemplar[tag]) diff --git a/nova/tests/api/openstack/compute/plugins/v3/test_servers.py b/nova/tests/api/openstack/compute/plugins/v3/test_servers.py index da17d8fd5..4505a1750 100644 --- a/nova/tests/api/openstack/compute/plugins/v3/test_servers.py +++ b/nova/tests/api/openstack/compute/plugins/v3/test_servers.py @@ -228,7 +228,7 @@ class ServersControllerTest(test.TestCase): self.assertEquals(res, [(None, None, port)]) def test_get_server_by_uuid(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) res_dict = self.controller.show(req, FAKE_UUID) self.assertEqual(res_dict['server']['id'], FAKE_UUID) @@ -246,7 +246,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get', return_instance_with_host) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) server1 = self.controller.show(req, FAKE_UUID) server2 = self.controller.show(req, FAKE_UUID) @@ -255,11 +255,11 @@ class ServersControllerTest(test.TestCase): def test_get_server_by_id(self): self.flags(use_ipv6=True) - image_bookmark = "http://localhost/fake/images/10" - flavor_bookmark = "http://localhost/fake/flavors/1" + image_bookmark = "http://localhost/images/10" + flavor_bookmark = "http://localhost/flavors/1" uuid = FAKE_UUID - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % uuid) + req = fakes.HTTPRequestV3.blank('/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { @@ -305,11 +305,11 @@ class ServersControllerTest(test.TestCase): "links": [ { "rel": "self", - "href": "http://localhost/v3/fake/servers/%s" % uuid, + "href": "http://localhost/v3/servers/%s" % uuid, }, { "rel": "bookmark", - "href": "http://localhost/fake/servers/%s" % uuid, + "href": "http://localhost/servers/%s" % uuid, }, ], } @@ -318,15 +318,15 @@ class ServersControllerTest(test.TestCase): self.assertThat(res_dict, matchers.DictMatches(expected_server)) def test_get_server_with_active_status_by_id(self): - image_bookmark = "http://localhost/fake/images/10" - flavor_bookmark = "http://localhost/fake/flavors/1" + image_bookmark = "http://localhost/images/10" + flavor_bookmark = "http://localhost/flavors/1" new_return_server = fakes.fake_instance_get( vm_state=vm_states.ACTIVE, progress=100) self.stubs.Set(db, 'instance_get_by_uuid', new_return_server) uuid = FAKE_UUID - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % uuid) + req = fakes.HTTPRequestV3.blank('/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { "server": { @@ -371,11 +371,11 @@ class ServersControllerTest(test.TestCase): "links": [ { "rel": "self", - "href": "http://localhost/v3/fake/servers/%s" % uuid, + "href": "http://localhost/v3/servers/%s" % uuid, }, { "rel": "bookmark", - "href": "http://localhost/fake/servers/%s" % uuid, + "href": "http://localhost/servers/%s" % uuid, }, ], } @@ -385,9 +385,9 @@ class ServersControllerTest(test.TestCase): def test_get_server_with_id_image_ref_by_id(self): image_ref = "10" - image_bookmark = "http://localhost/fake/images/10" + image_bookmark = "http://localhost/images/10" flavor_id = "1" - flavor_bookmark = "http://localhost/fake/flavors/1" + flavor_bookmark = "http://localhost/flavors/1" new_return_server = fakes.fake_instance_get( vm_state=vm_states.ACTIVE, image_ref=image_ref, @@ -395,7 +395,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', new_return_server) uuid = FAKE_UUID - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % uuid) + req = fakes.HTTPRequestV3.blank('/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { "server": { @@ -440,11 +440,11 @@ class ServersControllerTest(test.TestCase): "links": [ { "rel": "self", - "href": "http://localhost/v3/fake/servers/%s" % uuid, + "href": "http://localhost/v3/servers/%s" % uuid, }, { "rel": "bookmark", - "href": "http://localhost/fake/servers/%s" % uuid, + "href": "http://localhost/servers/%s" % uuid, }, ], } @@ -484,7 +484,7 @@ class ServersControllerTest(test.TestCase): return_server = fakes.fake_instance_get(nw_cache=nw_cache) self.stubs.Set(db, 'instance_get_by_uuid', return_server) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s/ips' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s/ips' % FAKE_UUID) res_dict = self.ips_controller.index(req, FAKE_UUID) expected = { @@ -504,7 +504,7 @@ class ServersControllerTest(test.TestCase): self.assertThat(res_dict, matchers.DictMatches(expected)) def test_get_server_addresses_nonexistent_network(self): - url = '/v3/fake/servers/%s/ips/network_0' % FAKE_UUID + url = '/v3/servers/%s/ips/network_0' % FAKE_UUID req = fakes.HTTPRequestV3.blank(url) self.assertRaises(webob.exc.HTTPNotFound, self.ips_controller.show, req, FAKE_UUID, 'network_0') @@ -516,7 +516,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get) server_id = str(uuid.uuid4()) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s/ips' % server_id) + req = fakes.HTTPRequestV3.blank('/servers/%s/ips' % server_id) self.assertRaises(webob.exc.HTTPNotFound, self.ips_controller.index, req, server_id) @@ -524,14 +524,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_empty) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') res_dict = self.controller.index(req) num_servers = len(res_dict['servers']) self.assertEqual(0, num_servers) def test_get_server_list_with_reservation_id(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?reservation_id=foo') + req = fakes.HTTPRequestV3.blank('/servers?reservation_id=foo') res_dict = self.controller.index(req) i = 0 @@ -540,7 +540,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list_with_reservation_id_empty(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail?' + req = fakes.HTTPRequestV3.blank('/servers/detail?' 'reservation_id=foo') res_dict = self.controller.detail(req) @@ -550,7 +550,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list_with_reservation_id_details(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail?' + req = fakes.HTTPRequestV3.blank('/servers/detail?' 'reservation_id=foo') res_dict = self.controller.detail(req) @@ -560,7 +560,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') res_dict = self.controller.index(req) self.assertEqual(len(res_dict['servers']), 5) @@ -572,18 +572,18 @@ class ServersControllerTest(test.TestCase): expected_links = [ { "rel": "self", - "href": "http://localhost/v3/fake/servers/%s" % s['id'], + "href": "http://localhost/v3/servers/%s" % s['id'], }, { "rel": "bookmark", - "href": "http://localhost/fake/servers/%s" % s['id'], + "href": "http://localhost/servers/%s" % s['id'], }, ] self.assertEqual(s['links'], expected_links) def test_get_servers_with_limit(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?limit=3') + req = fakes.HTTPRequestV3.blank('/servers?limit=3') res_dict = self.controller.index(req) servers = res_dict['servers'] @@ -593,14 +593,14 @@ class ServersControllerTest(test.TestCase): servers_links = res_dict['servers_links'] self.assertEqual(servers_links[0]['rel'], 'next') href_parts = urlparse.urlparse(servers_links[0]['href']) - self.assertEqual('/v3/fake/servers', href_parts.path) + self.assertEqual('/v3/servers', href_parts.path) params = urlparse.parse_qs(href_parts.query) expected_params = {'limit': ['3'], 'marker': [fakes.get_fake_uuid(2)]} self.assertThat(params, matchers.DictMatches(expected_params)) def test_get_servers_with_limit_bad_value(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?limit=aaa') + req = fakes.HTTPRequestV3.blank('/servers?limit=aaa') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) @@ -608,14 +608,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_empty) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail') + req = fakes.HTTPRequestV3.blank('/servers/detail') res_dict = self.controller.index(req) num_servers = len(res_dict['servers']) self.assertEqual(0, num_servers) def test_get_server_details_with_limit(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail?limit=3') + req = fakes.HTTPRequestV3.blank('/servers/detail?limit=3') res = self.controller.detail(req) servers = res['servers'] @@ -626,18 +626,18 @@ class ServersControllerTest(test.TestCase): self.assertEqual(servers_links[0]['rel'], 'next') href_parts = urlparse.urlparse(servers_links[0]['href']) - self.assertEqual('/v3/fake/servers', href_parts.path) + self.assertEqual('/v3/servers', href_parts.path) params = urlparse.parse_qs(href_parts.query) expected = {'limit': ['3'], 'marker': [fakes.get_fake_uuid(2)]} self.assertThat(params, matchers.DictMatches(expected)) def test_get_server_details_with_limit_bad_value(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail?limit=aaa') + req = fakes.HTTPRequestV3.blank('/servers/detail?limit=aaa') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail, req) def test_get_server_details_with_limit_and_other_params(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail' + req = fakes.HTTPRequestV3.blank('/servers/detail' '?limit=3&blah=2:t') res = self.controller.detail(req) @@ -649,36 +649,36 @@ class ServersControllerTest(test.TestCase): self.assertEqual(servers_links[0]['rel'], 'next') href_parts = urlparse.urlparse(servers_links[0]['href']) - self.assertEqual('/v3/fake/servers', href_parts.path) + self.assertEqual('/v3/servers', href_parts.path) params = urlparse.parse_qs(href_parts.query) expected = {'limit': ['3'], 'blah': ['2:t'], 'marker': [fakes.get_fake_uuid(2)]} self.assertThat(params, matchers.DictMatches(expected)) def test_get_servers_with_too_big_limit(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?limit=30') + req = fakes.HTTPRequestV3.blank('/servers?limit=30') res_dict = self.controller.index(req) self.assertTrue('servers_links' not in res_dict) def test_get_servers_with_bad_limit(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?limit=asdf') + req = fakes.HTTPRequestV3.blank('/servers?limit=asdf') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) def test_get_servers_with_marker(self): - url = '/v3/fake/servers?marker=%s' % fakes.get_fake_uuid(2) + url = '/v3/servers?marker=%s' % fakes.get_fake_uuid(2) req = fakes.HTTPRequestV3.blank(url) servers = self.controller.index(req)['servers'] self.assertEqual([s['name'] for s in servers], ["server4", "server5"]) def test_get_servers_with_limit_and_marker(self): - url = '/v3/fake/servers?limit=2&marker=%s' % fakes.get_fake_uuid(1) + url = '/v3/servers?limit=2&marker=%s' % fakes.get_fake_uuid(1) req = fakes.HTTPRequestV3.blank(url) servers = self.controller.index(req)['servers'] self.assertEqual([s['name'] for s in servers], ['server3', 'server4']) def test_get_servers_with_bad_marker(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?limit=2&marker=asdf') + req = fakes.HTTPRequestV3.blank('/servers?limit=2&marker=asdf') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) @@ -692,7 +692,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?unknownoption=whee') + req = fakes.HTTPRequestV3.blank('/servers?unknownoption=whee') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -711,7 +711,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?image=12345') + req = fakes.HTTPRequestV3.blank('/servers?image=12345') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -728,7 +728,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?tenant_id=fake', + req = fakes.HTTPRequestV3.blank('/servers?tenant_id=fake', use_admin_context=True) res = self.controller.index(req) @@ -744,7 +744,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers', + req = fakes.HTTPRequestV3.blank('/servers', use_admin_context=True) res = self.controller.index(req) @@ -769,7 +769,7 @@ class ServersControllerTest(test.TestCase): common_policy.set_rules(common_policy.Rules(rules)) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?all_tenants=1') + req = fakes.HTTPRequestV3.blank('/servers?all_tenants=1') res = self.controller.index(req) self.assertTrue('servers' in res) @@ -791,7 +791,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?all_tenants=1') + req = fakes.HTTPRequestV3.blank('/servers?all_tenants=1') self.assertRaises(exception.PolicyNotAuthorized, self.controller.index, req) @@ -809,14 +809,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?flavor=12345') + req = fakes.HTTPRequestV3.blank('/servers?flavor=12345') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) self.assertEqual(servers[0]['id'], server_uuid) def test_get_servers_with_bad_flavor(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?flavor=abcde') + req = fakes.HTTPRequestV3.blank('/servers?flavor=abcde') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 0) @@ -834,7 +834,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?status=active') + req = fakes.HTTPRequestV3.blank('/servers?status=active') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -842,13 +842,13 @@ class ServersControllerTest(test.TestCase): def test_get_servers_invalid_status(self): # Test getting servers by invalid status. - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?status=baloney', + req = fakes.HTTPRequestV3.blank('/servers?status=baloney', use_admin_context=False) servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 0) def test_get_servers_deleted_status_as_user(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?status=deleted', + req = fakes.HTTPRequestV3.blank('/servers?status=deleted', use_admin_context=False) self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail, req) @@ -866,7 +866,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?status=deleted', + req = fakes.HTTPRequestV3.blank('/servers?status=deleted', use_admin_context=True) servers = self.controller.detail(req)['servers'] @@ -886,7 +886,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?name=whee.*') + req = fakes.HTTPRequestV3.blank('/servers?name=whee.*') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -909,7 +909,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) params = 'changes-since=2011-01-24T17:08:01Z' - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?%s' % params) + req = fakes.HTTPRequestV3.blank('/servers?%s' % params) servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -917,7 +917,7 @@ class ServersControllerTest(test.TestCase): def test_get_servers_allows_changes_since_bad_value(self): params = 'changes-since=asdf' - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?%s' % params) + req = fakes.HTTPRequestV3.blank('/servers?%s' % params) self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) def test_get_servers_admin_filters_as_user(self): @@ -943,7 +943,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) query_str = "name=foo&ip=10.*&status=active&unknown_option=meow" - req = fakes.HTTPRequest.blank('/v3/fake/servers?%s' % query_str) + req = fakes.HTTPRequest.blank('/servers?%s' % query_str) res = self.controller.index(req) servers = res['servers'] @@ -972,7 +972,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) query_str = "name=foo&ip=10.*&status=active&unknown_option=meow" - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?%s' % query_str, + req = fakes.HTTPRequestV3.blank('/servers?%s' % query_str, use_admin_context=True) servers = self.controller.index(req)['servers'] @@ -994,7 +994,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?ip=10\..*') + req = fakes.HTTPRequestV3.blank('/servers?ip=10\..*') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -1016,7 +1016,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers?ip6=ffff.*', + req = fakes.HTTPRequestV3.blank('/servers?ip6=ffff.*', use_admin_context=True) servers = self.controller.index(req)['servers'] @@ -1028,7 +1028,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(name='server_test', access_ipv4='0.0.0.0', access_ipv6='beef::0123')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': { @@ -1045,7 +1045,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123') def test_update_server_invalid_xml_raises_lookup(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/xml' #xml request which raises LookupError @@ -1057,7 +1057,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res.status_int, 400) def test_update_server_invalid_xml_raises_expat(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/xml' #xml request which raises ExpatError @@ -1071,7 +1071,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_name(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(name='server_test')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1084,7 +1084,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_name_too_long(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(name='server_test')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'x' * 256}} @@ -1095,7 +1095,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': '0.0.0.0'}} @@ -1108,7 +1108,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_bad_format(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': 'bad_format'}} @@ -1119,7 +1119,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_none(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': None}} @@ -1132,7 +1132,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_blank(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': ''}} @@ -1145,7 +1145,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': 'beef::0123'}} @@ -1158,7 +1158,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_bad_format(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': 'bad_format'}} @@ -1169,7 +1169,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_none(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': None}} @@ -1182,7 +1182,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_blank(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': ''}} @@ -1193,7 +1193,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res_dict['server']['accessIPv6'], '') def test_update_server_personality(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = { @@ -1223,7 +1223,7 @@ class ServersControllerTest(test.TestCase): # self.stubs.Set(db, 'instance_get', # return_server_with_attributes(name='server_test')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = "application/json" req.body = jsonutils.dumps(body) @@ -1237,7 +1237,7 @@ class ServersControllerTest(test.TestCase): raise exception.InstanceNotFound(instance_id='fake') self.stubs.Set(compute_api.API, 'get', fake_get) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1250,7 +1250,7 @@ class ServersControllerTest(test.TestCase): raise exception.InstanceNotFound(instance_id='fake') self.stubs.Set(compute_api.API, 'update', fake_update) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1263,7 +1263,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid access_ipv4 = 'bad_format' access_ipv6 = 'fead::1234' body = { @@ -1285,7 +1285,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1297,7 +1297,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid access_ipv4 = '0.0.0.0' access_ipv6 = 'fead::1234' body = { @@ -1319,7 +1319,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1331,7 +1331,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid access_ipv4 = '0.0.0.0' access_ipv6 = 'fead::1234' body = { @@ -1353,7 +1353,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1365,7 +1365,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid access_ipv4 = '0.0.0.0' access_ipv6 = 'fead::1234' body = { @@ -1387,7 +1387,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1407,7 +1407,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid body = { 'rebuild': { 'name': 'new_name', @@ -1415,7 +1415,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1435,7 +1435,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid body = { 'rebuild': { 'name': 'new_name', @@ -1443,7 +1443,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1464,7 +1464,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid body = { 'rebuild': { 'name': 'new_name', @@ -1472,7 +1472,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1490,7 +1490,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid body = { 'rebuild': { 'name': 'new_name', @@ -1498,7 +1498,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1510,7 +1510,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_states.ACTIVE)) # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid + image_href = 'http://localhost/v3/images/%s' % image_uuid access_ipv4 = '1.2.3.4' access_ipv6 = 'bad_format' body = { @@ -1532,7 +1532,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/a/action') + req = fakes.HTTPRequestV3.blank('/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1545,7 +1545,7 @@ class ServersControllerTest(test.TestCase): "links": [ { "rel": "bookmark", - "href": 'http://localhost/fake/flavors/1', + "href": 'http://localhost/flavors/1', }, ], } @@ -1554,11 +1554,11 @@ class ServersControllerTest(test.TestCase): "links": [ { "rel": "bookmark", - "href": 'http://localhost/fake/images/10', + "href": 'http://localhost/images/10', }, ], } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail') + req = fakes.HTTPRequestV3.blank('/servers/detail') res_dict = self.controller.detail(req) for i, s in enumerate(res_dict['servers']): @@ -1586,7 +1586,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_with_host) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/detail') + req = fakes.HTTPRequestV3.blank('/servers/detail') res_dict = self.controller.detail(req) server_list = res_dict['servers'] @@ -1601,7 +1601,7 @@ class ServersControllerTest(test.TestCase): def _delete_server_instance(self, uuid=FAKE_UUID): fakes.stub_out_instance_quota(self.stubs, 0, 10) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % uuid) + req = fakes.HTTPRequestV3.blank('/servers/%s' % uuid) req.method = 'DELETE' self.server_delete_called = False @@ -1626,7 +1626,7 @@ class ServersControllerTest(test.TestCase): def test_delete_server_instance_while_building(self): fakes.stub_out_instance_quota(self.stubs, 0, 10) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'DELETE' self.server_delete_called = False @@ -1640,7 +1640,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(self.server_delete_called, True) def test_delete_server_instance_while_resize(self): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'DELETE' self.server_delete_called = False @@ -1673,7 +1673,7 @@ class ServerStatusTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_state, task_state=task_state)) - request = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + request = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) return self.controller.show(request, FAKE_UUID) def test_active(self): @@ -1699,7 +1699,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:reboot': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/1234/action') + req = fakes.HTTPRequestV3.blank('/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_reboot, req, '1234', {'reboot': {'type': 'HARD'}}) @@ -1727,7 +1727,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:confirm_resize': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/1234/action') + req = fakes.HTTPRequestV3.blank('/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_confirm_resize, req, '1234', {}) @@ -1749,7 +1749,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:revert_resize': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/1234/action') + req = fakes.HTTPRequestV3.blank('/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_revert_resize, req, '1234', {}) @@ -1881,7 +1881,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_uuid, flavorRef=2, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1902,7 +1902,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1943,7 +1943,7 @@ class ServersControllerCreateTest(test.TestCase): self.addCleanup(image_service.update, context, image_uuid, {'status': 'active'}) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' body = dict(server=dict( name='server_test', imageRef=image_uuid, flavorRef=2, @@ -1973,7 +1973,7 @@ class ServersControllerCreateTest(test.TestCase): self.addCleanup(image_service.update, context, image_uuid, {'size': orig_size}) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' body = dict(server=dict(name='server_test', imageRef=image_uuid, @@ -2001,7 +2001,7 @@ class ServersControllerCreateTest(test.TestCase): # 'flavorRef': flavor_ref, # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2025,7 +2025,7 @@ class ServersControllerCreateTest(test.TestCase): # 'flavorRef': flavor_ref, # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2049,7 +2049,7 @@ class ServersControllerCreateTest(test.TestCase): # 'flavorRef': flavor_ref, # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2073,7 +2073,7 @@ class ServersControllerCreateTest(test.TestCase): # 'flavorRef': flavor_ref, # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2103,7 +2103,7 @@ class ServersControllerCreateTest(test.TestCase): # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2134,7 +2134,7 @@ class ServersControllerCreateTest(test.TestCase): # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2165,7 +2165,7 @@ class ServersControllerCreateTest(test.TestCase): # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2247,7 +2247,7 @@ class ServersControllerCreateTest(test.TestCase): # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2272,7 +2272,7 @@ class ServersControllerCreateTest(test.TestCase): # } # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -2281,8 +2281,8 @@ class ServersControllerCreateTest(test.TestCase): def test_create_instance_image_ref_is_bookmark(self): image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' body = { 'server': { 'name': 'server_test', @@ -2291,7 +2291,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2302,8 +2302,8 @@ class ServersControllerCreateTest(test.TestCase): def test_create_instance_image_ref_is_invalid(self): image_uuid = 'this_is_not_a_valid_uuid' - image_href = 'http://localhost/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' body = { 'server': { 'name': 'server_test', @@ -2312,7 +2312,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2330,7 +2330,7 @@ class ServersControllerCreateTest(test.TestCase): server.pop('imageRef', None) server.update(params) body = dict(server=server) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2764,8 +2764,8 @@ class ServersControllerCreateTest(test.TestCase): def test_create_instance_with_access_ip(self): # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/v3/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' access_ipv4 = '1.2.3.4' access_ipv6 = 'fead::1234' body = { @@ -2788,7 +2788,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2804,8 +2804,8 @@ class ServersControllerCreateTest(test.TestCase): # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/v3/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' access_ipv4 = '1.2.3.4' access_ipv6 = 'fead::1234' body = { @@ -2828,7 +2828,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2841,8 +2841,8 @@ class ServersControllerCreateTest(test.TestCase): def test_create_instance_bad_format_access_ip_v4(self): # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/v3/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' access_ipv4 = 'bad_format' access_ipv6 = 'fead::1234' body = { @@ -2865,7 +2865,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2875,8 +2875,8 @@ class ServersControllerCreateTest(test.TestCase): def test_create_instance_bad_format_access_ip_v6(self): # proper local hrefs must start with 'http://localhost/v3/' image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - image_href = 'http://localhost/v3/fake/images/%s' % image_uuid - flavor_ref = 'http://localhost/fake/flavors/3' + image_href = 'http://localhost/v3/images/%s' % image_uuid + flavor_ref = 'http://localhost/flavors/3' access_ipv4 = '1.2.3.4' access_ipv6 = 'bad_format' body = { @@ -2899,7 +2899,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2930,7 +2930,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2961,7 +2961,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2996,7 +2996,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3024,7 +3024,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3048,7 +3048,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3072,7 +3072,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3096,7 +3096,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3110,7 +3110,7 @@ class ServersControllerCreateTest(test.TestCase): body = dict(server=dict( name='server_test', imageRef=image_href, flavorRef=flavor_ref, key_name='nonexistentkey')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3124,7 +3124,7 @@ class ServersControllerCreateTest(test.TestCase): body = dict(server=dict( name='server_test', imageRef=image_href, flavorRef=flavor_ref, key_name='key')) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3140,7 +3140,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3149,13 +3149,13 @@ class ServersControllerCreateTest(test.TestCase): self.controller.create, req, body) def test_create_instance_invalid_flavor_id_int(self): - image_href = 'http://localhost/v3/fake/images/2' + image_href = 'http://localhost/v3/images/2' flavor_ref = -1 body = dict(server=dict( name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3170,7 +3170,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3198,7 +3198,7 @@ class ServersControllerCreateTest(test.TestCase): # }, # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -3227,7 +3227,7 @@ class ServersControllerCreateTest(test.TestCase): # }, # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -3256,7 +3256,7 @@ class ServersControllerCreateTest(test.TestCase): # }, # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -3283,7 +3283,7 @@ class ServersControllerCreateTest(test.TestCase): # }, # } - # req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + # req = fakes.HTTPRequestV3.blank('/servers') # req.method = 'POST' # req.body = jsonutils.dumps(body) # req.headers["content-type"] = "application/json" @@ -3311,7 +3311,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3330,7 +3330,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3350,7 +3350,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3371,7 +3371,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3392,7 +3392,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3430,7 +3430,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3438,8 +3438,8 @@ class ServersControllerCreateTest(test.TestCase): self.controller.create, req, body) def test_create_location(self): - selfhref = 'http://localhost/v3/fake/servers/%s' % FAKE_UUID - bookhref = 'http://localhost/fake/servers/%s' % FAKE_UUID + selfhref = 'http://localhost/v3/servers/%s' % FAKE_UUID + bookhref = 'http://localhost/servers/%s' % FAKE_UUID image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' image_href = 'http://localhost/v3/images/%s' % image_uuid flavor_ref = 'http://localhost/123/flavors/3' @@ -3461,7 +3461,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = 'application/json' @@ -3477,7 +3477,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_uuid, flavorRef=3, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -4255,10 +4255,10 @@ class ServersViewBuilderTest(test.TestCase): self.uuid = self.instance['uuid'] self.view_builder = views.servers.ViewBuilder() - self.request = fakes.HTTPRequestV3.blank("/v2") + self.request = fakes.HTTPRequestV3.blank("") def test_get_flavor_valid_instance_type(self): - flavor_bookmark = "http://localhost/fake/flavors/1" + flavor_bookmark = "http://localhost/flavors/1" expected = {"id": "1", "links": [{"rel": "bookmark", "href": flavor_bookmark}]} @@ -4266,8 +4266,8 @@ class ServersViewBuilderTest(test.TestCase): self.assertEqual(result, expected) def test_build_server(self): - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4296,12 +4296,12 @@ class ServersViewBuilderTest(test.TestCase): "links": [ { "rel": "self", - "href": "http://localhost/v3/fake/servers/%s" % + "href": "http://localhost/v3/servers/%s" % self.uuid, }, { "rel": "bookmark", - "href": "http://localhost/fake/servers/%s" % self.uuid, + "href": "http://localhost/servers/%s" % self.uuid, }, ], } @@ -4311,10 +4311,10 @@ class ServersViewBuilderTest(test.TestCase): self.assertThat(output, matchers.DictMatches(expected_server)) def test_build_server_detail(self): - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4384,10 +4384,10 @@ class ServersViewBuilderTest(test.TestCase): 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), } - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4517,10 +4517,10 @@ class ServersViewBuilderTest(test.TestCase): 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), } - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid output = self.view_builder.show(self.request, self.instance) self.assertFalse('fault' in output['server']) @@ -4529,10 +4529,10 @@ class ServersViewBuilderTest(test.TestCase): #set the power state of the instance to running self.instance['vm_state'] = vm_states.ACTIVE self.instance['progress'] = 100 - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4591,10 +4591,10 @@ class ServersViewBuilderTest(test.TestCase): self.instance['access_ip_v4'] = '1.2.3.4' - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4653,10 +4653,10 @@ class ServersViewBuilderTest(test.TestCase): self.instance['access_ip_v6'] = 'fead::1234' - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -4717,10 +4717,10 @@ class ServersViewBuilderTest(test.TestCase): metadata.append(models.InstanceMetadata(key="Open", value="Stack")) self.instance['metadata'] = metadata - image_bookmark = "http://localhost/fake/images/5" - flavor_bookmark = "http://localhost/fake/flavors/1" - self_link = "http://localhost/v3/fake/servers/%s" % self.uuid - bookmark_link = "http://localhost/fake/servers/%s" % self.uuid + image_bookmark = "http://localhost/images/5" + flavor_bookmark = "http://localhost/flavors/1" + self_link = "http://localhost/v3/servers/%s" % self.uuid + bookmark_link = "http://localhost/servers/%s" % self.uuid expected_server = { "server": { "id": self.uuid, @@ -5777,7 +5777,7 @@ class ServersUnprocessableEntityTestCase(test.TestCase): self.controller = servers.ServersController(extension_info=ext_info) def _unprocessable_server_create(self, body): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers') + req = fakes.HTTPRequestV3.blank('/servers') req.method = 'POST' self.assertRaises(webob.exc.HTTPUnprocessableEntity, @@ -5795,7 +5795,7 @@ class ServersUnprocessableEntityTestCase(test.TestCase): self._unprocessable_server_create(body=body) def _unprocessable_server_update(self, body): - req = fakes.HTTPRequestV3.blank('/v3/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequestV3.blank('/servers/%s' % FAKE_UUID) req.method = 'PUT' self.assertRaises(webob.exc.HTTPUnprocessableEntity, diff --git a/nova/tests/api/openstack/compute/test_flavors.py b/nova/tests/api/openstack/compute/test_flavors.py index 77e637044..3741fcd33 100644 --- a/nova/tests/api/openstack/compute/test_flavors.py +++ b/nova/tests/api/openstack/compute/test_flavors.py @@ -792,6 +792,7 @@ class ParseIsPublicTest(test.TestCase): def test_string_none(self): self.assertPublic(None, 'none') + self.assertPublic(None, 'None') def test_other(self): self.assertRaises( diff --git a/nova/tests/api/openstack/compute/test_limits.py b/nova/tests/api/openstack/compute/test_limits.py index b9dc72b1f..3dbc7bfea 100644 --- a/nova/tests/api/openstack/compute/test_limits.py +++ b/nova/tests/api/openstack/compute/test_limits.py @@ -32,14 +32,18 @@ from nova.openstack.common import jsonutils from nova import test from nova.tests.api.openstack import fakes from nova.tests import matchers +from nova import utils TEST_LIMITS = [ - limits.Limit("GET", "/delayed", "^/delayed", 1, limits.PER_MINUTE), - limits.Limit("POST", "*", ".*", 7, limits.PER_MINUTE), - limits.Limit("POST", "/servers", "^/servers", 3, limits.PER_MINUTE), - limits.Limit("PUT", "*", "", 10, limits.PER_MINUTE), - limits.Limit("PUT", "/servers", "^/servers", 5, limits.PER_MINUTE), + limits.Limit("GET", "/delayed", "^/delayed", 1, + utils.TIME_UNITS['MINUTE']), + limits.Limit("POST", "*", ".*", 7, utils.TIME_UNITS['MINUTE']), + limits.Limit("POST", "/servers", "^/servers", 3, + utils.TIME_UNITS['MINUTE']), + limits.Limit("PUT", "*", "", 10, utils.TIME_UNITS['MINUTE']), + limits.Limit("PUT", "/servers", "^/servers", 5, + utils.TIME_UNITS['MINUTE']), ] NS = { 'atom': 'http://www.w3.org/2005/Atom', @@ -312,7 +316,7 @@ class LimitsControllerTest(BaseLimitTestSuite): req, 1, {}) -class TestLimiter(limits.Limiter): +class MockLimiter(limits.Limiter): pass @@ -331,12 +335,12 @@ class LimitMiddlewareTest(BaseLimitTestSuite): super(LimitMiddlewareTest, self).setUp() _limits = '(GET, *, .*, 1, MINUTE)' self.app = limits.RateLimitingMiddleware(self._empty_app, _limits, - "%s.TestLimiter" % + "%s.MockLimiter" % self.__class__.__module__) def test_limit_class(self): # Test that middleware selected correct limiter class. - assert isinstance(self.app._limiter, TestLimiter) + assert isinstance(self.app._limiter, MockLimiter) def test_good_request(self): # Test successful GET request through middleware. @@ -485,8 +489,8 @@ class ParseLimitsTest(BaseLimitTestSuite): self.assertEqual([t.value for t in l], expected) # ...and the units... - expected = [limits.PER_MINUTE, limits.PER_HOUR, - limits.PER_SECOND, limits.PER_DAY] + expected = [utils.TIME_UNITS['MINUTE'], utils.TIME_UNITS['HOUR'], + utils.TIME_UNITS['SECOND'], utils.TIME_UNITS['DAY']] self.assertEqual([t.unit for t in l], expected) diff --git a/nova/tests/api/openstack/compute/test_servers.py b/nova/tests/api/openstack/compute/test_servers.py index af8a4a276..82bb6b868 100644 --- a/nova/tests/api/openstack/compute/test_servers.py +++ b/nova/tests/api/openstack/compute/test_servers.py @@ -231,7 +231,7 @@ class ServersControllerTest(test.TestCase): self.assertEquals(res, [(None, None, port)]) def test_get_server_by_uuid(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) res_dict = self.controller.show(req, FAKE_UUID) self.assertEqual(res_dict['server']['id'], FAKE_UUID) @@ -250,7 +250,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get', return_instance_with_host) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) server1 = self.controller.show(req, FAKE_UUID) server2 = self.controller.show(req, FAKE_UUID) @@ -263,7 +263,7 @@ class ServersControllerTest(test.TestCase): flavor_bookmark = "http://localhost/fake/flavors/1" uuid = FAKE_UUID - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % uuid) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { @@ -330,7 +330,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', new_return_server) uuid = FAKE_UUID - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % uuid) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { "server": { @@ -399,7 +399,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', new_return_server) uuid = FAKE_UUID - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % uuid) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % uuid) res_dict = self.controller.show(req, uuid) expected_server = { "server": { @@ -488,7 +488,7 @@ class ServersControllerTest(test.TestCase): return_server = fakes.fake_instance_get(nw_cache=nw_cache) self.stubs.Set(db, 'instance_get_by_uuid', return_server) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s/ips' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s/ips' % FAKE_UUID) res_dict = self.ips_controller.index(req, FAKE_UUID) expected = { @@ -508,7 +508,7 @@ class ServersControllerTest(test.TestCase): self.assertThat(res_dict, matchers.DictMatches(expected)) def test_get_server_addresses_nonexistent_network(self): - url = '/v2/fake/servers/%s/ips/network_0' % FAKE_UUID + url = '/fake/servers/%s/ips/network_0' % FAKE_UUID req = fakes.HTTPRequest.blank(url) self.assertRaises(webob.exc.HTTPNotFound, self.ips_controller.show, req, FAKE_UUID, 'network_0') @@ -520,7 +520,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get) server_id = str(uuid.uuid4()) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s/ips' % server_id) + req = fakes.HTTPRequest.blank('/fake/servers/%s/ips' % server_id) self.assertRaises(webob.exc.HTTPNotFound, self.ips_controller.index, req, server_id) @@ -528,14 +528,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_empty) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') res_dict = self.controller.index(req) num_servers = len(res_dict['servers']) self.assertEqual(0, num_servers) def test_get_server_list_with_reservation_id(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?reservation_id=foo') + req = fakes.HTTPRequest.blank('/fake/servers?reservation_id=foo') res_dict = self.controller.index(req) i = 0 @@ -544,7 +544,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list_with_reservation_id_empty(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail?' + req = fakes.HTTPRequest.blank('/fake/servers/detail?' 'reservation_id=foo') res_dict = self.controller.detail(req) @@ -554,7 +554,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list_with_reservation_id_details(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail?' + req = fakes.HTTPRequest.blank('/fake/servers/detail?' 'reservation_id=foo') res_dict = self.controller.detail(req) @@ -564,7 +564,7 @@ class ServersControllerTest(test.TestCase): i += 1 def test_get_server_list(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') res_dict = self.controller.index(req) self.assertEqual(len(res_dict['servers']), 5) @@ -587,7 +587,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(s['links'], expected_links) def test_get_servers_with_limit(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?limit=3') + req = fakes.HTTPRequest.blank('/fake/servers?limit=3') res_dict = self.controller.index(req) servers = res_dict['servers'] @@ -604,7 +604,7 @@ class ServersControllerTest(test.TestCase): self.assertThat(params, matchers.DictMatches(expected_params)) def test_get_servers_with_limit_bad_value(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?limit=aaa') + req = fakes.HTTPRequest.blank('/fake/servers?limit=aaa') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) @@ -612,14 +612,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_empty) - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail') + req = fakes.HTTPRequest.blank('/fake/servers/detail') res_dict = self.controller.index(req) num_servers = len(res_dict['servers']) self.assertEqual(0, num_servers) def test_get_server_details_with_limit(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail?limit=3') + req = fakes.HTTPRequest.blank('/fake/servers/detail?limit=3') res = self.controller.detail(req) servers = res['servers'] @@ -636,12 +636,12 @@ class ServersControllerTest(test.TestCase): self.assertThat(params, matchers.DictMatches(expected)) def test_get_server_details_with_limit_bad_value(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail?limit=aaa') + req = fakes.HTTPRequest.blank('/fake/servers/detail?limit=aaa') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail, req) def test_get_server_details_with_limit_and_other_params(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail' + req = fakes.HTTPRequest.blank('/fake/servers/detail' '?limit=3&blah=2:t') res = self.controller.detail(req) @@ -660,12 +660,12 @@ class ServersControllerTest(test.TestCase): self.assertThat(params, matchers.DictMatches(expected)) def test_get_servers_with_too_big_limit(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?limit=30') + req = fakes.HTTPRequest.blank('/fake/servers?limit=30') res_dict = self.controller.index(req) self.assertTrue('servers_links' not in res_dict) def test_get_servers_with_bad_limit(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?limit=asdf') + req = fakes.HTTPRequest.blank('/fake/servers?limit=asdf') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) @@ -682,7 +682,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual([s['name'] for s in servers], ['server3', 'server4']) def test_get_servers_with_bad_marker(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?limit=2&marker=asdf') + req = fakes.HTTPRequest.blank('/fake/servers?limit=2&marker=asdf') self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) @@ -696,7 +696,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?unknownoption=whee') + req = fakes.HTTPRequest.blank('/fake/servers?unknownoption=whee') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -715,7 +715,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?image=12345') + req = fakes.HTTPRequest.blank('/fake/servers?image=12345') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -732,7 +732,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?tenant_id=fake', + req = fakes.HTTPRequest.blank('/fake/servers?tenant_id=fake', use_admin_context=True) res = self.controller.index(req) @@ -748,7 +748,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers', + req = fakes.HTTPRequest.blank('/fake/servers', use_admin_context=True) res = self.controller.index(req) @@ -773,7 +773,7 @@ class ServersControllerTest(test.TestCase): common_policy.set_rules(common_policy.Rules(rules)) - req = fakes.HTTPRequest.blank('/v2/fake/servers?all_tenants=1') + req = fakes.HTTPRequest.blank('/fake/servers?all_tenants=1') res = self.controller.index(req) self.assertTrue('servers' in res) @@ -795,7 +795,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?all_tenants=1') + req = fakes.HTTPRequest.blank('/fake/servers?all_tenants=1') self.assertRaises(exception.PolicyNotAuthorized, self.controller.index, req) @@ -813,14 +813,14 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?flavor=12345') + req = fakes.HTTPRequest.blank('/fake/servers?flavor=12345') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) self.assertEqual(servers[0]['id'], server_uuid) def test_get_servers_with_bad_flavor(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?flavor=abcde') + req = fakes.HTTPRequest.blank('/fake/servers?flavor=abcde') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 0) @@ -838,7 +838,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?status=active') + req = fakes.HTTPRequest.blank('/fake/servers?status=active') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -846,13 +846,13 @@ class ServersControllerTest(test.TestCase): def test_get_servers_invalid_status(self): # Test getting servers by invalid status. - req = fakes.HTTPRequest.blank('/v2/fake/servers?status=baloney', + req = fakes.HTTPRequest.blank('/fake/servers?status=baloney', use_admin_context=False) servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 0) def test_get_servers_deleted_status_as_user(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers?status=deleted', + req = fakes.HTTPRequest.blank('/fake/servers?status=deleted', use_admin_context=False) self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail, req) @@ -870,7 +870,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?status=deleted', + req = fakes.HTTPRequest.blank('/fake/servers?status=deleted', use_admin_context=True) servers = self.controller.detail(req)['servers'] @@ -890,7 +890,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?name=whee.*') + req = fakes.HTTPRequest.blank('/fake/servers?name=whee.*') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -913,7 +913,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) params = 'changes-since=2011-01-24T17:08:01Z' - req = fakes.HTTPRequest.blank('/v2/fake/servers?%s' % params) + req = fakes.HTTPRequest.blank('/fake/servers?%s' % params) servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -921,7 +921,7 @@ class ServersControllerTest(test.TestCase): def test_get_servers_allows_changes_since_bad_value(self): params = 'changes-since=asdf' - req = fakes.HTTPRequest.blank('/v2/fake/servers?%s' % params) + req = fakes.HTTPRequest.blank('/fake/servers?%s' % params) self.assertRaises(webob.exc.HTTPBadRequest, self.controller.index, req) def test_get_servers_admin_filters_as_user(self): @@ -947,7 +947,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) query_str = "name=foo&ip=10.*&status=active&unknown_option=meow" - req = fakes.HTTPRequest.blank('/v2/fake/servers?%s' % query_str) + req = fakes.HTTPRequest.blank('/fake/servers?%s' % query_str) res = self.controller.index(req) servers = res['servers'] @@ -976,7 +976,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) query_str = "name=foo&ip=10.*&status=active&unknown_option=meow" - req = fakes.HTTPRequest.blank('/v2/fake/servers?%s' % query_str, + req = fakes.HTTPRequest.blank('/fake/servers?%s' % query_str, use_admin_context=True) servers = self.controller.index(req)['servers'] @@ -997,7 +997,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?ip=10\..*') + req = fakes.HTTPRequest.blank('/fake/servers?ip=10\..*') servers = self.controller.index(req)['servers'] self.assertEqual(len(servers), 1) @@ -1019,7 +1019,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(compute_api.API, 'get_all', fake_get_all) - req = fakes.HTTPRequest.blank('/v2/fake/servers?ip6=ffff.*', + req = fakes.HTTPRequest.blank('/fake/servers?ip6=ffff.*', use_admin_context=True) servers = self.controller.index(req)['servers'] @@ -1031,7 +1031,7 @@ class ServersControllerTest(test.TestCase): fakes.fake_instance_get(name='server_test', access_ipv4='0.0.0.0', access_ipv6='beef::0123')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': { @@ -1048,7 +1048,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123') def test_update_server_invalid_xml_raises_lookup(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/xml' #xml request which raises LookupError @@ -1060,7 +1060,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res.status_int, 400) def test_update_server_invalid_xml_raises_expat(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/xml' #xml request which raises ExpatError @@ -1074,7 +1074,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_name(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(name='server_test')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1087,7 +1087,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_name_too_long(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(name='server_test')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'x' * 256}} @@ -1109,7 +1109,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': '0.0.0.0'}} @@ -1122,7 +1122,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_bad_format(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': 'bad_format'}} @@ -1133,7 +1133,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_none(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': None}} @@ -1146,7 +1146,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv4_blank(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv4='0.0.0.0')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv4': ''}} @@ -1159,7 +1159,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': 'beef::0123'}} @@ -1172,7 +1172,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_bad_format(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': 'bad_format'}} @@ -1183,7 +1183,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_none(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': None}} @@ -1196,7 +1196,7 @@ class ServersControllerTest(test.TestCase): def test_update_server_access_ipv6_blank(self): self.stubs.Set(db, 'instance_get', fakes.fake_instance_get(access_ipv6='beef::0123')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'accessIPv6': ''}} @@ -1207,7 +1207,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(res_dict['server']['accessIPv6'], '') def test_update_server_personality(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = { @@ -1237,7 +1237,7 @@ class ServersControllerTest(test.TestCase): # self.stubs.Set(db, 'instance_get', # return_server_with_attributes(name='server_test')) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = "application/json" req.body = jsonutils.dumps(body) @@ -1251,7 +1251,7 @@ class ServersControllerTest(test.TestCase): raise exception.InstanceNotFound(instance_id='fake') self.stubs.Set(compute_api.API, 'get', fake_get) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1264,7 +1264,7 @@ class ServersControllerTest(test.TestCase): raise exception.InstanceNotFound(instance_id='fake') self.stubs.Set(compute_api.API, 'update', fake_update) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' req.content_type = 'application/json' body = {'server': {'name': 'server_test'}} @@ -1299,7 +1299,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1333,7 +1333,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1367,7 +1367,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1401,7 +1401,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1429,7 +1429,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1457,7 +1457,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1486,7 +1486,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1512,7 +1512,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1546,7 +1546,7 @@ class ServersControllerTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action') + req = fakes.HTTPRequest.blank('/fake/servers/a/action') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1572,7 +1572,7 @@ class ServersControllerTest(test.TestCase): }, ], } - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail') + req = fakes.HTTPRequest.blank('/fake/servers/detail') res_dict = self.controller.detail(req) for i, s in enumerate(res_dict['servers']): @@ -1600,7 +1600,7 @@ class ServersControllerTest(test.TestCase): self.stubs.Set(db, 'instance_get_all_by_filters', return_servers_with_host) - req = fakes.HTTPRequest.blank('/v2/fake/servers/detail') + req = fakes.HTTPRequest.blank('/fake/servers/detail') res_dict = self.controller.detail(req) server_list = res_dict['servers'] @@ -1615,7 +1615,7 @@ class ServersControllerTest(test.TestCase): def _delete_server_instance(self, uuid=FAKE_UUID): fakes.stub_out_instance_quota(self.stubs, 0, 10) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % uuid) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % uuid) req.method = 'DELETE' self.server_delete_called = False @@ -1640,7 +1640,7 @@ class ServersControllerTest(test.TestCase): def test_delete_server_instance_while_building(self): fakes.stub_out_instance_quota(self.stubs, 0, 10) - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'DELETE' self.server_delete_called = False @@ -1654,7 +1654,7 @@ class ServersControllerTest(test.TestCase): self.assertEqual(self.server_delete_called, True) def test_delete_server_instance_while_resize(self): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'DELETE' self.server_delete_called = False @@ -1688,7 +1688,7 @@ class ServerStatusTest(test.TestCase): fakes.fake_instance_get(vm_state=vm_state, task_state=task_state)) - request = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + request = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) return self.controller.show(request, FAKE_UUID) def test_active(self): @@ -1714,7 +1714,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:reboot': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequest.blank('/v2/fake/servers/1234/action') + req = fakes.HTTPRequest.blank('/fake/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_reboot, req, '1234', {'reboot': {'type': 'HARD'}}) @@ -1742,7 +1742,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:confirm_resize': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequest.blank('/v2/fake/servers/1234/action') + req = fakes.HTTPRequest.blank('/fake/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_confirm_resize, req, '1234', {}) @@ -1764,7 +1764,7 @@ class ServerStatusTest(test.TestCase): rule = {'compute:revert_resize': common_policy.parse_rule('role:admin')} common_policy.set_rules(common_policy.Rules(rule)) - req = fakes.HTTPRequest.blank('/v2/fake/servers/1234/action') + req = fakes.HTTPRequest.blank('/fake/servers/1234/action') self.assertRaises(exception.PolicyNotAuthorized, self.controller._action_revert_resize, req, '1234', {}) @@ -1900,7 +1900,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_uuid, flavorRef=2, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1921,7 +1921,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1942,7 +1942,7 @@ class ServersControllerCreateTest(test.TestCase): 'networks': {'uuid': '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'}, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -1960,7 +1960,7 @@ class ServersControllerCreateTest(test.TestCase): self.addCleanup(image_service.update, context, image_uuid, {'status': 'active'}) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' body = dict(server=dict( name='server_test', imageRef=image_uuid, flavorRef=2, @@ -1990,7 +1990,7 @@ class ServersControllerCreateTest(test.TestCase): self.addCleanup(image_service.update, context, image_uuid, {'size': orig_size}) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' body = dict(server=dict(name='server_test', imageRef=image_uuid, @@ -2016,7 +2016,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2038,7 +2038,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2060,7 +2060,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2082,7 +2082,7 @@ class ServersControllerCreateTest(test.TestCase): 'flavorRef': flavor_ref, } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2110,7 +2110,7 @@ class ServersControllerCreateTest(test.TestCase): } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2139,7 +2139,7 @@ class ServersControllerCreateTest(test.TestCase): } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2168,7 +2168,7 @@ class ServersControllerCreateTest(test.TestCase): } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2244,7 +2244,7 @@ class ServersControllerCreateTest(test.TestCase): } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2267,7 +2267,7 @@ class ServersControllerCreateTest(test.TestCase): } } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2286,7 +2286,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2307,7 +2307,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2325,7 +2325,7 @@ class ServersControllerCreateTest(test.TestCase): server.pop('imageRef', None) server.update(params) body = dict(server=server) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2805,7 +2805,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2845,7 +2845,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2882,7 +2882,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2916,7 +2916,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -2947,7 +2947,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3009,7 +3009,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3044,7 +3044,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3072,7 +3072,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3096,7 +3096,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3120,7 +3120,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3144,7 +3144,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3158,7 +3158,7 @@ class ServersControllerCreateTest(test.TestCase): body = dict(server=dict( name='server_test', imageRef=image_href, flavorRef=flavor_ref, key_name='nonexistentkey')) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3172,7 +3172,7 @@ class ServersControllerCreateTest(test.TestCase): body = dict(server=dict( name='server_test', imageRef=image_href, flavorRef=flavor_ref, key_name='key')) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3188,7 +3188,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3203,7 +3203,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3218,7 +3218,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3244,34 +3244,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') - req.method = 'POST' - req.body = jsonutils.dumps(body) - req.headers["content-type"] = "application/json" - res = self.controller.create(req, body).obj - - server = res['server'] - self.assertEqual(FAKE_UUID, server['id']) - - def test_create_instance_with_config_drive_as_id(self): - self.ext_mgr.extensions = {'os-config-drive': 'fake'} - image_href = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' - flavor_ref = 'http://localhost/v2/fake/flavors/3' - body = { - 'server': { - 'name': 'config_drive_test', - 'imageRef': image_href, - 'flavorRef': flavor_ref, - 'metadata': { - 'hello': 'world', - 'open': 'stack', - }, - 'personality': {}, - 'config_drive': image_href, - }, - } - - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3281,6 +3254,7 @@ class ServersControllerCreateTest(test.TestCase): self.assertEqual(FAKE_UUID, server['id']) def test_create_instance_with_bad_config_drive(self): + # Test with an image href as config drive value. self.ext_mgr.extensions = {'os-config-drive': 'fake'} image_href = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6' flavor_ref = 'http://localhost/v2/fake/flavors/3' @@ -3294,15 +3268,14 @@ class ServersControllerCreateTest(test.TestCase): 'open': 'stack', }, 'personality': {}, - 'config_drive': 'asdf', + 'config_drive': image_href, }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" - self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create, req, body) @@ -3323,7 +3296,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3351,7 +3324,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_href, flavorRef=flavor_ref, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3370,7 +3343,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3390,7 +3363,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3411,7 +3384,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3432,7 +3405,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = "application/json" @@ -3470,7 +3443,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -3501,7 +3474,7 @@ class ServersControllerCreateTest(test.TestCase): }, } - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers['content-type'] = 'application/json' @@ -3517,7 +3490,7 @@ class ServersControllerCreateTest(test.TestCase): name='server_test', imageRef=image_uuid, flavorRef=3, metadata={'hello': 'world', 'open': 'stack'}, personality={})) - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' req.body = jsonutils.dumps(body) req.headers["content-type"] = "application/json" @@ -4285,7 +4258,7 @@ class ServersViewBuilderTest(test.TestCase): self.uuid = self.instance['uuid'] self.view_builder = views.servers.ViewBuilder() - self.request = fakes.HTTPRequest.blank("/v2") + self.request = fakes.HTTPRequest.blank("/v2/fake") def test_get_flavor_valid_flavor(self): flavor_bookmark = "http://localhost/fake/flavors/1" @@ -5808,7 +5781,7 @@ class ServersUnprocessableEntityTestCase(test.TestCase): self.controller = servers.Controller(self.ext_mgr) def _unprocessable_server_create(self, body): - req = fakes.HTTPRequest.blank('/v2/fake/servers') + req = fakes.HTTPRequest.blank('/fake/servers') req.method = 'POST' self.assertRaises(webob.exc.HTTPUnprocessableEntity, @@ -5826,7 +5799,7 @@ class ServersUnprocessableEntityTestCase(test.TestCase): self._unprocessable_server_create(body=body) def _unprocessable_server_update(self, body): - req = fakes.HTTPRequest.blank('/v2/fake/servers/%s' % FAKE_UUID) + req = fakes.HTTPRequest.blank('/fake/servers/%s' % FAKE_UUID) req.method = 'PUT' self.assertRaises(webob.exc.HTTPUnprocessableEntity, |