def test_optional_extensions_no_error(self):
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
ext_mgr.add_extension(
ext_stubs.StubExtension('foo_alias', optional=['cats']))
ext_mgr.extend_resources("2.0", attr_map)
self.assertIn('foo_alias', ext_mgr.extensions)
def test_missing_required_extensions_gracefully_error(self):
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
default_ext = list(constants.DEFAULT_SERVICE_PLUGINS.values())[0]
ext_mgr.add_extension(ext_stubs.StubExtensionWithReqs(default_ext))
ext_mgr.extend_resources("2.0", attr_map)
self.assertIn(default_ext, ext_mgr.extensions)
def test_extension_extends_sub_resource(self):
"""Unit test for bug 1722842
Check that an extension can extend a sub-resource
"""
RESOURCE = "test_resource"
SUB_RESOURCE_NAME = "test_sub_resource"
INITIAL_PARAM = "dummy_param1"
ADDITIONAL_PARAM = "dummy_param2"
SUB_RESOURCE = {
'parent': {'member_name': RESOURCE},
'parameters': {
INITIAL_PARAM: {'allow_post': False,
'allow_put': False,
'validate': {'type:uuid': None},
'is_visible': True}
}
}
class BaseExtension(ext_stubs.StubExtension):
def get_extended_resources(self, version):
return {
SUB_RESOURCE_NAME: SUB_RESOURCE
}
class ExtensionExtendingASubresource(ext_stubs.StubExtension):
def get_extended_resources(self, version):
return {
SUB_RESOURCE_NAME: {
'parameters': {
ADDITIONAL_PARAM: {'allow_post': False,
'allow_put': False,
'validate': {'type:uuid': None},
'is_visible': True}
}
}
}
def get_required_extensions(self):
return ['base_extension']
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
ext_mgr.add_extension(BaseExtension('base_extension'))
ext_mgr.add_extension(
ExtensionExtendingASubresource())
ext_mgr.extend_resources("2.0", attr_map)
# check that the parent descriptor is untouched
self.assertEqual(SUB_RESOURCE['parent'],
attr_map[SUB_RESOURCE_NAME]['parent'])
# check that the initial attribute is still here
self.assertIn(INITIAL_PARAM,
attr_map[SUB_RESOURCE_NAME]['parameters'])
# check that the new attribute is here as well
self.assertIn(ADDITIONAL_PARAM,
attr_map[SUB_RESOURCE_NAME]['parameters'])
def test_missing_required_extensions_gracefully_error(self):
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
default_ext = list(constants.DEFAULT_SERVICE_PLUGINS.values())[0]
ext_mgr.add_extension(ext_stubs.StubExtensionWithReqs(default_ext))
ext_mgr.extend_resources("2.0", attr_map)
# none of the default extensions should be loaded as their
# requirements are not satisfied, and yet we do not fail.
self.assertFalse(ext_mgr.extensions)
def test_assignment_of_attr_map(self):
"""Unit test for bug 1443342
In this bug, an extension that extended multiple resources with the
same dict would cause future extensions to inadvertently modify the
resources of all of the resources since they were referencing the same
dictionary.
"""
class MultiResourceExtension(ext_stubs.StubExtension):
"""Generated Extended Resources.
This extension's extended resource will assign
to more than one resource.
"""
def get_extended_resources(self, version):
EXTENDED_TIMESTAMP = {
'created_at': {
'allow_post': False,
'allow_put': False,
'is_visible': True
}
}
EXTENDED_RESOURCES = ["ext1", "ext2"]
attrs = {}
for resources in EXTENDED_RESOURCES:
attrs[resources] = EXTENDED_TIMESTAMP
return attrs
class AttrExtension(ext_stubs.StubExtension):
def get_extended_resources(self, version):
attrs = {
self.alias: {
'%s-attr' % self.alias: {
'allow_post': False,
'allow_put': False,
'is_visible': True
}
}
}
return attrs
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
ext_mgr.add_extension(MultiResourceExtension('timestamp'))
ext_mgr.extend_resources("2.0", attr_map)
ext_mgr.add_extension(AttrExtension("ext1"))
ext_mgr.add_extension(AttrExtension("ext2"))
ext_mgr.extend_resources("2.0", attr_map)
self.assertIn('created_at', attr_map['ext2'])
self.assertIn('created_at', attr_map['ext1'])
# now we need to make sure the attrextensions didn't leak across
self.assertNotIn('ext1-attr', attr_map['ext2'])
self.assertNotIn('ext2-attr', attr_map['ext1'])
def test_proper_load_order(self):
"""
Verifies that loading policies by way of admin context after
populating extensions and extending the resource map results in
networks with router:external are visible to regular tenants.
"""
extension_manager = extensions.ExtensionManager(self.extension_path)
extension_manager.extend_resources(self.api_version,
attributes.RESOURCE_ATTRIBUTE_MAP)
admin_context = context.get_admin_context()
tenant_context = context.Context('test_user', 'test_tenant_id', False)
self.assertTrue(self._check_external_router_policy(admin_context))
self.assertTrue(self._check_external_router_policy(tenant_context))
def test_premature_loading(self):
"""
Verifies that loading policies by way of admin context before
populating extensions and extending the resource map results in
networks with router:external is true being invisible to regular
tenants.
"""
extension_manager = extensions.ExtensionManager(self.extension_path)
admin_context = context.get_admin_context()
tenant_context = context.Context('test_user', 'test_tenant_id', False)
extension_manager.extend_resources(self.api_version,
attributes.RESOURCES)
self.assertTrue(self._check_external_router_policy(admin_context))
self.assertFalse(self._check_external_router_policy(tenant_context))
def test_invalid_extensions_are_not_registered(self):
class InvalidExtension(object):
"""Invalid extension.
This Extension doesn't implement extension methods :
get_name, get_description and get_updated
"""
def get_alias(self):
return "invalid_extension"
ext_mgr = extensions.ExtensionManager('')
ext_mgr.add_extension(InvalidExtension())
ext_mgr.add_extension(ext_stubs.StubExtension("valid_extension"))
self.assertIn('valid_extension', ext_mgr.extensions)
self.assertNotIn('invalid_extension', ext_mgr.extensions)
def test_proper_load_order(self):
"""Test proper policy load order
Verifies that loading policies by way of admin context after
populating extensions and extending the resource map results in
networks with router:external are visible to regular tenants.
"""
policy.reset()
extension_manager = extensions.ExtensionManager(self.extension_path)
extension_manager.extend_resources(self.api_version,
attributes.RESOURCES)
# TODO(amotoki): Consider this should be part of
# neutron.policy.reset (or refresh), but as of now
# this is only required for unit testing.
policies.reload_default_policies()
policy.init()
admin_context = context.get_admin_context()
tenant_context = context.Context('test_user', 'test_tenant_id', False)
self.assertTrue(self._check_external_router_policy(admin_context))
self.assertTrue(self._check_external_router_policy(tenant_context))
def test_assignment_of_attr_map(self):
class ExtendResourceExtension(object):
"""Generated Extended Resources.
This extension's extended resource will assign
to more than one resource.
"""
def get_name(self):
return "extension"
def get_alias(self):
return "extension"
def get_description(self):
return "Extension for test"
def get_updated(self):
return "2013-07-23T10:00:00-00:00"
def get_extended_resources(self, version):
EXTENDED_TIMESTAMP = {
'created_at': {
'allow_post': False,
'allow_put': False,
'is_visible': True
}
}
EXTENDED_RESOURCES = ["ext1", "ext2"]
attrs = {}
for resources in EXTENDED_RESOURCES:
attrs[resources] = EXTENDED_TIMESTAMP
return attrs
ext_mgr = extensions.ExtensionManager('')
ext_mgr.add_extension(ExtendResourceExtension())
ext_mgr.add_extension(ext_stubs.StubExtension("ext1"))
ext_mgr.add_extension(ext_stubs.StubExtension("ext2"))
attr_map = {}
ext_mgr.extend_resources("2.0", attr_map)
self.assertNotEqual(id(attr_map['ext1']), id(attr_map['ext2']))
def test__check_faulty_extensions_raise_not_default_ext(self):
ext_mgr = extensions.ExtensionManager('')
with testtools.ExpectedException(exceptions.ExtensionsNotFound):
ext_mgr._check_faulty_extensions(set(['foo']))
def test_missing_required_extensions_raise_error(self):
ext_mgr = extensions.ExtensionManager('')
attr_map = {}
ext_mgr.add_extension(ext_stubs.StubExtensionWithReqs('foo_alias'))
self.assertRaises(exceptions.ExtensionsNotFound,
ext_mgr.extend_resources, "2.0", attr_map)
def _setUpExtensions(self, plugin, service_type,
extension_classes,
resource_prefix, plural_mappings=None,
translate_resource_name=False,
allow_pagination=False, allow_sorting=False,
supported_extension_aliases=None,
use_quota=False,
):
self._resource_prefix = resource_prefix
self._plural_mappings = plural_mappings or {}
self._translate_resource_name = translate_resource_name
# Ensure existing ExtensionManager is not used
extensions.PluginAwareExtensionManager._instance = None
self.useFixture(fixture.APIDefinitionFixture())
# Create the default configurations
self.config_parse()
core_plugin = CORE_PLUGIN if service_type else plugin
self.setup_coreplugin(core_plugin, load_plugins=False)
if service_type:
cfg.CONF.set_override('service_plugins', [plugin])
self._plugin_patcher = mock.patch(plugin, autospec=True)
self.plugin = self._plugin_patcher.start()
instance = self.plugin.return_value
if service_type:
instance.get_plugin_type.return_value = service_type
manager.init()
if supported_extension_aliases is not None:
instance.supported_extension_aliases = supported_extension_aliases
if allow_pagination:
# instance.__native_pagination_support = True
native_pagination_attr_name = ("_%s__native_pagination_support"
% instance.__class__.__name__)
setattr(instance, native_pagination_attr_name, True)
if allow_sorting:
# instance.__native_sorting_support = True
native_sorting_attr_name = ("_%s__native_sorting_support"
% instance.__class__.__name__)
setattr(instance, native_sorting_attr_name, True)
if use_quota:
quota.QUOTAS._driver = None
cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver',
group='QUOTAS')
setattr(instance, 'path_prefix', resource_prefix)
####################################################################
ext_mgr = extensions.ExtensionManager('')
for extension_class in extension_classes:
ext = extension_class()
ext_mgr.add_extension(ext)
####################################################################
self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr)
self.api = webtest.TestApp(self.ext_mdw)
