1117 lines
46 KiB
Python
1117 lines
46 KiB
Python
# 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
|
|
|
|
import webob
|
|
|
|
from glance.api.v2 import metadef_namespaces as namespaces
|
|
from glance.api.v2 import metadef_objects as objects
|
|
from glance.api.v2 import metadef_properties as properties
|
|
from glance.api.v2 import metadef_resource_types as resource_types
|
|
import glance.api.v2.model.metadef_namespace
|
|
from glance.tests.unit import base
|
|
import glance.tests.unit.utils as unit_test_utils
|
|
|
|
DATETIME = datetime.datetime(2012, 5, 16, 15, 27, 36, 325355)
|
|
ISOTIME = '2012-05-16T15:27:36Z'
|
|
|
|
NAMESPACE1 = 'Namespace1'
|
|
NAMESPACE2 = 'Namespace2'
|
|
NAMESPACE3 = 'Namespace3'
|
|
NAMESPACE4 = 'Namespace4'
|
|
NAMESPACE5 = 'Namespace5'
|
|
NAMESPACE6 = 'Namespace6'
|
|
|
|
PROPERTY1 = 'Property1'
|
|
PROPERTY2 = 'Property2'
|
|
PROPERTY3 = 'Property3'
|
|
|
|
OBJECT1 = 'Object1'
|
|
OBJECT2 = 'Object2'
|
|
OBJECT3 = 'Object3'
|
|
|
|
RESOURCE_TYPE1 = 'ResourceType1'
|
|
RESOURCE_TYPE2 = 'ResourceType2'
|
|
RESOURCE_TYPE3 = 'ResourceType3'
|
|
|
|
TENANT1 = '6838eb7b-6ded-434a-882c-b344c77fe8df'
|
|
TENANT2 = '2c014f32-55eb-467d-8fcb-4bd706012f81'
|
|
TENANT3 = '5a3e60e8-cfa9-4a9e-a90a-62b42cea92b8'
|
|
TENANT4 = 'c6c87f25-8a94-47ed-8c83-053c25f42df4'
|
|
|
|
|
|
def _db_namespace_fixture(namespace, **kwargs):
|
|
obj = {
|
|
'namespace': namespace,
|
|
'display_name': None,
|
|
'description': None,
|
|
'visibility': 'public',
|
|
'protected': False,
|
|
'owner': None,
|
|
}
|
|
obj.update(kwargs)
|
|
return obj
|
|
|
|
|
|
def _db_property_fixture(name, **kwargs):
|
|
obj = {
|
|
'name': name,
|
|
'schema': {"type": "string", "title": "title"},
|
|
}
|
|
obj.update(kwargs)
|
|
return obj
|
|
|
|
|
|
def _db_object_fixture(name, **kwargs):
|
|
obj = {
|
|
'name': name,
|
|
'description': None,
|
|
'schema': {},
|
|
'required': '[]',
|
|
}
|
|
obj.update(kwargs)
|
|
return obj
|
|
|
|
|
|
def _db_resource_type_fixture(name, **kwargs):
|
|
obj = {
|
|
'name': name,
|
|
'protected': False,
|
|
}
|
|
obj.update(kwargs)
|
|
return obj
|
|
|
|
|
|
def _db_namespace_resource_type_fixture(name, **kwargs):
|
|
obj = {
|
|
'name': name,
|
|
'properties_target': None,
|
|
'prefix': None,
|
|
}
|
|
obj.update(kwargs)
|
|
return obj
|
|
|
|
|
|
class TestMetadefsControllers(base.IsolatedUnitTest):
|
|
|
|
def setUp(self):
|
|
super(TestMetadefsControllers, self).setUp()
|
|
self.db = unit_test_utils.FakeDB()
|
|
self.policy = unit_test_utils.FakePolicyEnforcer()
|
|
self._create_namespaces()
|
|
self._create_properties()
|
|
self._create_objects()
|
|
self._create_resource_types()
|
|
self._create_namespaces_resource_types()
|
|
self.namespace_controller = namespaces.NamespaceController(self.db,
|
|
self.policy)
|
|
self.property_controller = \
|
|
properties.NamespacePropertiesController(self.db, self.policy)
|
|
self.object_controller = objects.MetadefObjectsController(self.db,
|
|
self.policy)
|
|
self.rt_controller = resource_types.ResourceTypeController(self.db,
|
|
self.policy)
|
|
|
|
def _create_namespaces(self):
|
|
self.db.reset()
|
|
req = unit_test_utils.get_fake_request()
|
|
self.namespaces = [
|
|
_db_namespace_fixture(NAMESPACE1, owner=TENANT1,
|
|
visibility='private', protected=True),
|
|
_db_namespace_fixture(NAMESPACE2, owner=TENANT2,
|
|
visibility='private'),
|
|
_db_namespace_fixture(NAMESPACE3, owner=TENANT3),
|
|
_db_namespace_fixture(NAMESPACE5, owner=TENANT4),
|
|
_db_namespace_fixture(NAMESPACE6, owner=TENANT4),
|
|
]
|
|
[self.db.metadef_namespace_create(req.context, namespace)
|
|
for namespace in self.namespaces]
|
|
|
|
def _create_properties(self):
|
|
req = unit_test_utils.get_fake_request()
|
|
self.properties = [
|
|
(NAMESPACE3, _db_property_fixture(PROPERTY1)),
|
|
(NAMESPACE3, _db_property_fixture(PROPERTY2)),
|
|
(NAMESPACE1, _db_property_fixture(PROPERTY1)),
|
|
]
|
|
[self.db.metadef_property_create(req.context, namespace, property)
|
|
for namespace, property in self.properties]
|
|
|
|
def _create_objects(self):
|
|
req = unit_test_utils.get_fake_request()
|
|
self.objects = [
|
|
(NAMESPACE3, _db_object_fixture(OBJECT1)),
|
|
(NAMESPACE3, _db_object_fixture(OBJECT2)),
|
|
(NAMESPACE1, _db_object_fixture(OBJECT1)),
|
|
]
|
|
[self.db.metadef_object_create(req.context, namespace, object)
|
|
for namespace, object in self.objects]
|
|
|
|
def _create_resource_types(self):
|
|
req = unit_test_utils.get_fake_request()
|
|
self.resource_types = [
|
|
_db_resource_type_fixture(RESOURCE_TYPE1),
|
|
_db_resource_type_fixture(RESOURCE_TYPE2),
|
|
]
|
|
[self.db.metadef_resource_type_create(req.context, resource_type)
|
|
for resource_type in self.resource_types]
|
|
|
|
def _create_namespaces_resource_types(self):
|
|
req = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.ns_resource_types = [
|
|
(NAMESPACE1, _db_namespace_resource_type_fixture(RESOURCE_TYPE1)),
|
|
(NAMESPACE3, _db_namespace_resource_type_fixture(RESOURCE_TYPE1)),
|
|
(NAMESPACE2, _db_namespace_resource_type_fixture(RESOURCE_TYPE1)),
|
|
(NAMESPACE2, _db_namespace_resource_type_fixture(RESOURCE_TYPE2)),
|
|
]
|
|
[self.db.metadef_resource_type_association_create(req.context,
|
|
namespace,
|
|
ns_resource_type)
|
|
for namespace, ns_resource_type in self.ns_resource_types]
|
|
|
|
def test_namespace_index(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.namespace_controller.index(request)
|
|
output = output.to_dict()
|
|
self.assertEqual(4, len(output['namespaces']))
|
|
actual = set([namespace.namespace for
|
|
namespace in output['namespaces']])
|
|
expected = set([NAMESPACE1, NAMESPACE3, NAMESPACE5, NAMESPACE6])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_index_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
output = self.namespace_controller.index(request)
|
|
output = output.to_dict()
|
|
self.assertEqual(5, len(output['namespaces']))
|
|
actual = set([namespace.namespace for
|
|
namespace in output['namespaces']])
|
|
expected = set([NAMESPACE1, NAMESPACE2, NAMESPACE3, NAMESPACE5,
|
|
NAMESPACE6])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_index_visibility_public(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
filters = {'visibility': 'public'}
|
|
output = self.namespace_controller.index(request, filters=filters)
|
|
output = output.to_dict()
|
|
self.assertEqual(3, len(output['namespaces']))
|
|
actual = set([namespace.namespace for namespace
|
|
in output['namespaces']])
|
|
expected = set([NAMESPACE3, NAMESPACE5, NAMESPACE6])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_index_resource_type(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
filters = {'resource_types': [RESOURCE_TYPE1]}
|
|
output = self.namespace_controller.index(request, filters=filters)
|
|
output = output.to_dict()
|
|
self.assertEqual(2, len(output['namespaces']))
|
|
actual = set([namespace.namespace for namespace
|
|
in output['namespaces']])
|
|
expected = set([NAMESPACE1, NAMESPACE3])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_show(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.namespace_controller.show(request, NAMESPACE1)
|
|
output = output.to_dict()
|
|
self.assertEqual(output['namespace'], NAMESPACE1)
|
|
self.assertEqual(output['owner'], TENANT1)
|
|
self.assertTrue(output['protected'])
|
|
self.assertEqual(output['visibility'], 'private')
|
|
|
|
def test_namespace_show_with_related_resources(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.namespace_controller.show(request, NAMESPACE3)
|
|
output = output.to_dict()
|
|
self.assertEqual(output['namespace'], NAMESPACE3)
|
|
self.assertEqual(output['owner'], TENANT3)
|
|
self.assertFalse(output['protected'])
|
|
self.assertEqual(output['visibility'], 'public')
|
|
|
|
self.assertEqual(2, len(output['properties']))
|
|
actual = set([property for property in output['properties']])
|
|
expected = set([PROPERTY1, PROPERTY2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
self.assertEqual(2, len(output['objects']))
|
|
actual = set([object.name for object in output['objects']])
|
|
expected = set([OBJECT1, OBJECT2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
self.assertEqual(1, len(output['resource_type_associations']))
|
|
actual = set([rt.name for rt in output['resource_type_associations']])
|
|
expected = set([RESOURCE_TYPE1])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_show_with_property_prefix(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE2
|
|
rt.prefix = 'pref'
|
|
rt = self.rt_controller.create(request, rt, NAMESPACE3)
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT3
|
|
object.required = []
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY2
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
object.properties = {'prop1': property}
|
|
object = self.object_controller.create(request, object, NAMESPACE3)
|
|
|
|
filters = {'resource_type': RESOURCE_TYPE2}
|
|
output = self.namespace_controller.show(request, NAMESPACE3, filters)
|
|
output = output.to_dict()
|
|
|
|
[self.assertTrue(property_name.startswith(rt.prefix)) for
|
|
property_name in output['properties'].keys()]
|
|
|
|
for object in output['objects']:
|
|
[self.assertTrue(property_name.startswith(rt.prefix)) for
|
|
property_name in object.properties.keys()]
|
|
|
|
def test_namespace_show_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, 'FakeName')
|
|
|
|
def test_namespace_show_non_visible(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, NAMESPACE2)
|
|
|
|
def test_namespace_delete(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.namespace_controller.delete(request, NAMESPACE2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, NAMESPACE2)
|
|
|
|
def test_namespace_delete_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.delete, request,
|
|
'FakeName')
|
|
|
|
def test_namespace_delete_non_visible(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.delete, request,
|
|
NAMESPACE2)
|
|
|
|
def test_namespace_delete_non_visible_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.namespace_controller.delete(request, NAMESPACE2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, NAMESPACE2)
|
|
|
|
def test_namespace_delete_protected(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.namespace_controller.delete, request,
|
|
NAMESPACE1)
|
|
|
|
def test_namespace_delete_protected_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.namespace_controller.delete, request,
|
|
NAMESPACE1)
|
|
|
|
def test_namespace_delete_with_contents(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
self.namespace_controller.delete(request, NAMESPACE3)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, NAMESPACE3)
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.show,
|
|
request, NAMESPACE3, OBJECT1)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.show, request, NAMESPACE3,
|
|
OBJECT1)
|
|
|
|
def test_namespace_create(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE4
|
|
namespace = self.namespace_controller.create(request, namespace)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
def test_namespace_create_different_owner(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE4
|
|
namespace.owner = TENANT4
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.namespace_controller.create, request, namespace)
|
|
|
|
def test_namespace_create_different_owner_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE4
|
|
namespace.owner = TENANT4
|
|
namespace = self.namespace_controller.create(request, namespace)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
def test_namespace_create_with_related_resources(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE4
|
|
|
|
prop1 = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
prop1.type = 'string'
|
|
prop1.title = 'title'
|
|
prop2 = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
prop2.type = 'string'
|
|
prop2.title = 'title'
|
|
namespace.properties = {PROPERTY1: prop1, PROPERTY2: prop2}
|
|
|
|
object1 = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object1.name = OBJECT1
|
|
object1.required = []
|
|
object1.properties = {}
|
|
object2 = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object2.name = OBJECT2
|
|
object2.required = []
|
|
object2.properties = {}
|
|
namespace.objects = [object1, object2]
|
|
|
|
output = self.namespace_controller.create(request, namespace)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
output = output.to_dict()
|
|
|
|
self.assertEqual(2, len(output['properties']))
|
|
actual = set([property for property in output['properties']])
|
|
expected = set([PROPERTY1, PROPERTY2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
self.assertEqual(2, len(output['objects']))
|
|
actual = set([object.name for object in output['objects']])
|
|
expected = set([OBJECT1, OBJECT2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
output = self.namespace_controller.show(request, NAMESPACE4)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
output = output.to_dict()
|
|
|
|
self.assertEqual(2, len(output['properties']))
|
|
actual = set([property for property in output['properties']])
|
|
expected = set([PROPERTY1, PROPERTY2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
self.assertEqual(2, len(output['objects']))
|
|
actual = set([object.name for object in output['objects']])
|
|
expected = set([OBJECT1, OBJECT2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_namespace_create_conflict(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE1
|
|
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.namespace_controller.create, request, namespace)
|
|
|
|
def test_namespace_update(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
namespace = self.namespace_controller.show(request, NAMESPACE1)
|
|
|
|
namespace.protected = False
|
|
namespace = self.namespace_controller.update(request, namespace,
|
|
NAMESPACE1)
|
|
self.assertFalse(namespace.protected)
|
|
|
|
namespace = self.namespace_controller.show(request, NAMESPACE1)
|
|
self.assertFalse(namespace.protected)
|
|
|
|
def test_namespace_update_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE4
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.update, request, namespace,
|
|
NAMESPACE4)
|
|
|
|
def test_namespace_update_non_visible(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
namespace = glance.api.v2.model.metadef_namespace.Namespace()
|
|
namespace.namespace = NAMESPACE2
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.update, request, namespace,
|
|
NAMESPACE2)
|
|
|
|
def test_namespace_update_non_visible_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
namespace = self.namespace_controller.show(request, NAMESPACE2)
|
|
|
|
namespace.protected = False
|
|
namespace = self.namespace_controller.update(request, namespace,
|
|
NAMESPACE2)
|
|
self.assertFalse(namespace.protected)
|
|
|
|
namespace = self.namespace_controller.show(request, NAMESPACE2)
|
|
self.assertFalse(namespace.protected)
|
|
|
|
def test_namespace_update_name(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
namespace = self.namespace_controller.show(request, NAMESPACE1)
|
|
|
|
namespace.namespace = NAMESPACE4
|
|
namespace = self.namespace_controller.update(request, namespace,
|
|
NAMESPACE1)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
namespace = self.namespace_controller.show(request, NAMESPACE4)
|
|
self.assertEqual(namespace.namespace, NAMESPACE4)
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.namespace_controller.show, request, NAMESPACE1)
|
|
|
|
def test_namespace_update_name_conflict(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
namespace = self.namespace_controller.show(request, NAMESPACE1)
|
|
namespace.namespace = NAMESPACE2
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.namespace_controller.update, request, namespace,
|
|
NAMESPACE1)
|
|
|
|
def test_property_index(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.property_controller.index(request, NAMESPACE3)
|
|
self.assertEqual(2, len(output.properties))
|
|
actual = set([property for property in output.properties])
|
|
expected = set([PROPERTY1, PROPERTY2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_property_index_empty(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
output = self.property_controller.index(request, NAMESPACE2)
|
|
self.assertEqual(0, len(output.properties))
|
|
|
|
def test_property_index_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.index, request, NAMESPACE4)
|
|
|
|
def test_property_show(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.property_controller.show(request, NAMESPACE3, PROPERTY1)
|
|
self.assertEqual(output.name, PROPERTY1)
|
|
|
|
def test_property_show_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.show, request, NAMESPACE2,
|
|
PROPERTY1)
|
|
|
|
def test_property_show_non_visible(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.show, request, NAMESPACE1,
|
|
PROPERTY1)
|
|
|
|
def test_property_show_non_visible_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
output = self.property_controller.show(request, NAMESPACE1, PROPERTY1)
|
|
self.assertEqual(output.name, PROPERTY1)
|
|
|
|
def test_property_delete(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
self.property_controller.delete(request, NAMESPACE3, PROPERTY1)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.show, request, NAMESPACE3,
|
|
PROPERTY1)
|
|
|
|
def test_property_delete_other_owner(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.property_controller.delete, request, NAMESPACE3,
|
|
PROPERTY1)
|
|
|
|
def test_property_delete_other_owner_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.property_controller.delete(request, NAMESPACE3, PROPERTY1)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.show, request, NAMESPACE3,
|
|
PROPERTY1)
|
|
|
|
def test_property_delete_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.delete, request, NAMESPACE5,
|
|
PROPERTY2)
|
|
|
|
def test_property_delete_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.delete, request, NAMESPACE4,
|
|
PROPERTY1)
|
|
|
|
def test_property_delete_non_visible(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.delete, request, NAMESPACE1,
|
|
PROPERTY1)
|
|
|
|
def test_property_delete_admin_protected(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.property_controller.delete, request, NAMESPACE1,
|
|
PROPERTY1)
|
|
|
|
def test_property_create(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY2
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
property = self.property_controller.create(request, NAMESPACE1,
|
|
property)
|
|
self.assertEqual(property.name, PROPERTY2)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
property = self.property_controller.show(request, NAMESPACE1,
|
|
PROPERTY2)
|
|
self.assertEqual(property.name, PROPERTY2)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
def test_property_create_conflict(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY1
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.property_controller.create, request, NAMESPACE1,
|
|
property)
|
|
|
|
def test_property_create_non_visible_namespace(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY1
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.property_controller.create, request, NAMESPACE1,
|
|
property)
|
|
|
|
def test_property_create_non_visible_namespace_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY2
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
property = self.property_controller.create(request, NAMESPACE1,
|
|
property)
|
|
self.assertEqual(property.name, PROPERTY2)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
property = self.property_controller.show(request, NAMESPACE1,
|
|
PROPERTY2)
|
|
self.assertEqual(property.name, PROPERTY2)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
def test_property_create_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY1
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.create, request, NAMESPACE4,
|
|
property)
|
|
|
|
def test_property_update(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
property = self.property_controller.show(request, NAMESPACE3,
|
|
PROPERTY1)
|
|
property.name = PROPERTY1
|
|
property.type = 'string123'
|
|
property.title = 'title123'
|
|
property = self.property_controller.update(request, NAMESPACE3,
|
|
PROPERTY1, property)
|
|
self.assertEqual(property.name, PROPERTY1)
|
|
self.assertEqual(property.type, 'string123')
|
|
self.assertEqual(property.title, 'title123')
|
|
|
|
property = self.property_controller.show(request, NAMESPACE3,
|
|
PROPERTY1)
|
|
self.assertEqual(property.name, PROPERTY1)
|
|
self.assertEqual(property.type, 'string123')
|
|
self.assertEqual(property.title, 'title123')
|
|
|
|
def test_property_update_name(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
property = self.property_controller.show(request, NAMESPACE3,
|
|
PROPERTY1)
|
|
property.name = PROPERTY3
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
property = self.property_controller.update(request, NAMESPACE3,
|
|
PROPERTY1, property)
|
|
self.assertEqual(property.name, PROPERTY3)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
property = self.property_controller.show(request, NAMESPACE3,
|
|
PROPERTY2)
|
|
self.assertEqual(property.name, PROPERTY2)
|
|
self.assertEqual(property.type, 'string')
|
|
self.assertEqual(property.title, 'title')
|
|
|
|
def test_property_update_conflict(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
property = self.property_controller.show(request, NAMESPACE3,
|
|
PROPERTY1)
|
|
property.name = PROPERTY2
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.property_controller.update, request, NAMESPACE3,
|
|
PROPERTY1, property)
|
|
|
|
def test_property_update_non_existing(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY1
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.update, request, NAMESPACE5,
|
|
PROPERTY1, property)
|
|
|
|
def test_property_update_namespace_non_existing(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
property = glance.api.v2.model.metadef_property_type.PropertyType()
|
|
property.name = PROPERTY1
|
|
property.type = 'string'
|
|
property.title = 'title'
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.property_controller.update, request, NAMESPACE4,
|
|
PROPERTY1, property)
|
|
|
|
def test_object_index(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.object_controller.index(request, NAMESPACE3)
|
|
output = output.to_dict()
|
|
self.assertEqual(2, len(output['objects']))
|
|
actual = set([object.name for object in output['objects']])
|
|
expected = set([OBJECT1, OBJECT2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_object_index_empty(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.object_controller.index(request, NAMESPACE5)
|
|
output = output.to_dict()
|
|
self.assertEqual(0, len(output['objects']))
|
|
|
|
def test_object_index_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.index,
|
|
request, NAMESPACE4)
|
|
|
|
def test_object_show(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
|
self.assertEqual(output.name, OBJECT1)
|
|
|
|
def test_object_show_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.show,
|
|
request, NAMESPACE5, OBJECT1)
|
|
|
|
def test_object_show_non_visible(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.show,
|
|
request, NAMESPACE1, OBJECT1)
|
|
|
|
def test_object_show_non_visible_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
|
|
output = self.object_controller.show(request, NAMESPACE1, OBJECT1)
|
|
self.assertEqual(output.name, OBJECT1)
|
|
|
|
def test_object_delete(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
self.object_controller.delete(request, NAMESPACE3, OBJECT1)
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.show,
|
|
request, NAMESPACE3, OBJECT1)
|
|
|
|
def test_object_delete_other_owner(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.object_controller.delete, request, NAMESPACE3,
|
|
OBJECT1)
|
|
|
|
def test_object_delete_other_owner_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.object_controller.delete(request, NAMESPACE3, OBJECT1)
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.object_controller.show,
|
|
request, NAMESPACE3, OBJECT1)
|
|
|
|
def test_object_delete_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.delete, request, NAMESPACE5,
|
|
OBJECT1)
|
|
|
|
def test_object_delete_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.delete, request, NAMESPACE4,
|
|
OBJECT1)
|
|
|
|
def test_object_delete_non_visible(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.delete, request, NAMESPACE1,
|
|
OBJECT1)
|
|
|
|
def test_object_delete_admin_protected(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.object_controller.delete, request, NAMESPACE1,
|
|
OBJECT1)
|
|
|
|
def test_object_create(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT2
|
|
object.required = []
|
|
object.properties = {}
|
|
object = self.object_controller.create(request, object, NAMESPACE1)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
self.assertEqual(object.required, [])
|
|
self.assertEqual(object.properties, {})
|
|
|
|
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
self.assertEqual(object.required, [])
|
|
self.assertEqual(object.properties, {})
|
|
|
|
def test_object_create_conflict(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT1
|
|
object.required = []
|
|
object.properties = {}
|
|
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.object_controller.create, request, object,
|
|
NAMESPACE1)
|
|
|
|
def test_object_create_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = PROPERTY1
|
|
object.required = []
|
|
object.properties = {}
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.create, request, object,
|
|
NAMESPACE4)
|
|
|
|
def test_object_create_non_visible_namespace(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT1
|
|
object.required = []
|
|
object.properties = {}
|
|
|
|
self.assertRaises(webob.exc.HTTPForbidden,
|
|
self.object_controller.create, request, object,
|
|
NAMESPACE1)
|
|
|
|
def test_object_create_non_visible_namespace_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT2
|
|
object.required = []
|
|
object.properties = {}
|
|
object = self.object_controller.create(request, object, NAMESPACE1)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
self.assertEqual(object.required, [])
|
|
self.assertEqual(object.properties, {})
|
|
|
|
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
self.assertEqual(object.required, [])
|
|
self.assertEqual(object.properties, {})
|
|
|
|
def test_object_update(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
object = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
|
object.name = OBJECT1
|
|
object.description = 'description'
|
|
object = self.object_controller.update(request, object, NAMESPACE3,
|
|
OBJECT1)
|
|
self.assertEqual(object.name, OBJECT1)
|
|
self.assertEqual(object.description, 'description')
|
|
|
|
property = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
|
self.assertEqual(property.name, OBJECT1)
|
|
self.assertEqual(object.description, 'description')
|
|
|
|
def test_object_update_name(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
object = self.object_controller.show(request, NAMESPACE1, OBJECT1)
|
|
object.name = OBJECT2
|
|
object = self.object_controller.update(request, object, NAMESPACE1,
|
|
OBJECT1)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
|
|
object = self.object_controller.show(request, NAMESPACE1, OBJECT2)
|
|
self.assertEqual(object.name, OBJECT2)
|
|
|
|
def test_object_update_conflict(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
object = self.object_controller.show(request, NAMESPACE3, OBJECT1)
|
|
object.name = OBJECT2
|
|
self.assertRaises(webob.exc.HTTPConflict,
|
|
self.object_controller.update, request, object,
|
|
NAMESPACE3, OBJECT1)
|
|
|
|
def test_object_update_non_existing(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT1
|
|
object.required = []
|
|
object.properties = {}
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.update, request, object,
|
|
NAMESPACE5, OBJECT1)
|
|
|
|
def test_object_update_namespace_non_existing(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
|
|
object = glance.api.v2.model.metadef_object.MetadefObject()
|
|
object.name = OBJECT1
|
|
object.required = []
|
|
object.properties = {}
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound,
|
|
self.object_controller.update, request, object,
|
|
NAMESPACE4, OBJECT1)
|
|
|
|
def test_resource_type_index(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.rt_controller.index(request)
|
|
|
|
self.assertEqual(2, len(output.resource_types))
|
|
actual = set([type.name for type in
|
|
output.resource_types])
|
|
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_resource_type_show(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.rt_controller.show(request, NAMESPACE3)
|
|
|
|
self.assertEqual(1, len(output.resource_type_associations))
|
|
actual = set([rt.name for rt in output.resource_type_associations])
|
|
expected = set([RESOURCE_TYPE1])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_resource_type_show_empty(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
output = self.rt_controller.show(request, NAMESPACE5)
|
|
|
|
self.assertEqual(0, len(output.resource_type_associations))
|
|
|
|
def test_resource_type_show_non_visible(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.show,
|
|
request, NAMESPACE2)
|
|
|
|
def test_resource_type_show_non_visible_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
|
|
output = self.rt_controller.show(request, NAMESPACE2)
|
|
self.assertEqual(2, len(output.resource_type_associations))
|
|
actual = set([rt.name for rt in output.resource_type_associations])
|
|
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_resource_type_show_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.show,
|
|
request, NAMESPACE4)
|
|
|
|
def test_resource_type_association_delete(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
self.rt_controller.delete(request, NAMESPACE3, RESOURCE_TYPE1)
|
|
|
|
output = self.rt_controller.show(request, NAMESPACE3)
|
|
self.assertEqual(0, len(output.resource_type_associations))
|
|
|
|
def test_resource_type_association_delete_other_owner(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPForbidden, self.rt_controller.delete,
|
|
request, NAMESPACE3, RESOURCE_TYPE1)
|
|
|
|
def test_resource_type_association_delete_other_owner_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.rt_controller.delete(request, NAMESPACE3, RESOURCE_TYPE1)
|
|
|
|
output = self.rt_controller.show(request, NAMESPACE3)
|
|
self.assertEqual(0, len(output.resource_type_associations))
|
|
|
|
def test_resource_type_association_delete_non_existing(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.delete,
|
|
request, NAMESPACE1, RESOURCE_TYPE2)
|
|
|
|
def test_resource_type_association_delete_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.delete,
|
|
request, NAMESPACE4, RESOURCE_TYPE1)
|
|
|
|
def test_resource_type_association_delete_non_visible(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT3)
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.delete,
|
|
request, NAMESPACE1, RESOURCE_TYPE1)
|
|
|
|
def test_resource_type_association_delete_protected_admin(self):
|
|
request = unit_test_utils.get_fake_request(is_admin=True)
|
|
self.assertRaises(webob.exc.HTTPForbidden, self.rt_controller.delete,
|
|
request, NAMESPACE1, RESOURCE_TYPE1)
|
|
|
|
def test_resource_type_association_create(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE2
|
|
rt.prefix = 'pref'
|
|
rt = self.rt_controller.create(request, rt, NAMESPACE1)
|
|
self.assertEqual(rt.name, RESOURCE_TYPE2)
|
|
self.assertEqual(rt.prefix, 'pref')
|
|
|
|
output = self.rt_controller.show(request, NAMESPACE1)
|
|
self.assertEqual(2, len(output.resource_type_associations))
|
|
actual = set([x.name for x in output.resource_type_associations])
|
|
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
|
self.assertEqual(actual, expected)
|
|
|
|
def test_resource_type_association_create_conflict(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE1
|
|
rt.prefix = 'pref'
|
|
self.assertRaises(webob.exc.HTTPConflict, self.rt_controller.create,
|
|
request, rt, NAMESPACE1)
|
|
|
|
def test_resource_type_association_create_non_existing_namespace(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE1
|
|
rt.prefix = 'pref'
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.create,
|
|
request, rt, NAMESPACE4)
|
|
|
|
def test_resource_type_association_create_non_existing_resource_type(self):
|
|
request = unit_test_utils.get_fake_request()
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE3
|
|
rt.prefix = 'pref'
|
|
self.assertRaises(webob.exc.HTTPNotFound, self.rt_controller.create,
|
|
request, rt, NAMESPACE1)
|
|
|
|
def test_resource_type_association_create_non_visible_namespace(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2)
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE2
|
|
rt.prefix = 'pref'
|
|
self.assertRaises(webob.exc.HTTPForbidden, self.rt_controller.create,
|
|
request, rt, NAMESPACE1)
|
|
|
|
def test_resource_type_association_create_non_visible_namesp_admin(self):
|
|
request = unit_test_utils.get_fake_request(tenant=TENANT2,
|
|
is_admin=True)
|
|
|
|
rt = glance.api.v2.model.metadef_resource_type.\
|
|
ResourceTypeAssociation()
|
|
rt.name = RESOURCE_TYPE2
|
|
rt.prefix = 'pref'
|
|
rt = self.rt_controller.create(request, rt, NAMESPACE1)
|
|
self.assertEqual(rt.name, RESOURCE_TYPE2)
|
|
self.assertEqual(rt.prefix, 'pref')
|
|
|
|
output = self.rt_controller.show(request, NAMESPACE1)
|
|
self.assertEqual(2, len(output.resource_type_associations))
|
|
actual = set([x.name for x in output.resource_type_associations])
|
|
expected = set([RESOURCE_TYPE1, RESOURCE_TYPE2])
|
|
self.assertEqual(actual, expected)
|