From 5ad48b8758203b91155ed2db71b4b5caf8401584 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Fri, 15 Apr 2011 17:04:59 -0400 Subject: condition coverage for pyramid.config --- pyramid/config.py | 60 ++++++------ pyramid/tests/test_config.py | 216 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 246 insertions(+), 30 deletions(-) diff --git a/pyramid/config.py b/pyramid/config.py index f412f703d..9fda75daa 100644 --- a/pyramid/config.py +++ b/pyramid/config.py @@ -381,18 +381,6 @@ class Configurator(object): return deriver(view) - def _override(self, package, path, override_package, override_prefix, - PackageOverrides=PackageOverrides): - pkg_name = package.__name__ - override_pkg_name = override_package.__name__ - override = self.registry.queryUtility( - IPackageOverrides, name=pkg_name) - if override is None: - override = PackageOverrides(package) - self.registry.registerUtility(override, IPackageOverrides, - name=pkg_name) - override.insert(path, override_pkg_name, override_prefix) - @action_method def _set_security_policies(self, authentication, authorization=None): if (authorization is not None) and (not authentication): @@ -1698,7 +1686,10 @@ class Configurator(object): request_iface = self.registry.queryUtility(IRouteRequest, name=name) if request_iface is None: - bases = use_global_views and (IRequest,) or () + if use_global_views: + bases = (IRequest,) + else: + bases = () request_iface = route_request_iface(name, bases) self.registry.registerUtility( request_iface, IRouteRequest, name=name) @@ -1832,6 +1823,17 @@ class Configurator(object): self.registry.registerUtility(factory, IRendererFactory, name=name) self.action((IRendererFactory, name), None) + def _override(self, package, path, override_package, override_prefix, + PackageOverrides=PackageOverrides): + pkg_name = package.__name__ + override_pkg_name = override_package.__name__ + override = self.registry.queryUtility(IPackageOverrides, name=pkg_name) + if override is None: + override = PackageOverrides(package) + self.registry.registerUtility(override, IPackageOverrides, + name=pkg_name) + override.insert(path, override_pkg_name, override_prefix) + @action_method def override_asset(self, to_override, override_with, _override=None): """ Add a :app:`Pyramid` asset override to the current @@ -1846,8 +1848,7 @@ class Configurator(object): See :ref:`assets_chapter` for more information about asset overrides.""" if to_override == override_with: - raise ConfigurationError('You cannot override an asset with ' - 'itself') + raise ConfigurationError('You cannot override an asset with itself') package = to_override path = '' @@ -1859,19 +1860,22 @@ class Configurator(object): if ':' in override_with: override_package, override_prefix = override_with.split(':', 1) - if path and path.endswith('/'): - if override_prefix and (not override_prefix.endswith('/')): - raise ConfigurationError( - 'A directory cannot be overridden with a file (put a ' - 'slash at the end of override_with if necessary)') + # *_isdir = override is package or directory + overridden_isdir = path=='' or path.endswith('/') + override_isdir = override_prefix=='' or override_prefix.endswith('/') - if override_prefix and override_prefix.endswith('/'): - if path and (not path.endswith('/')): - raise ConfigurationError( - 'A file cannot be overridden with a directory (put a ' - 'slash at the end of to_override if necessary)') + if overridden_isdir and (not override_isdir): + raise ConfigurationError( + 'A directory cannot be overridden with a file (put a ' + 'slash at the end of override_with if necessary)') + + if (not overridden_isdir) and override_isdir: + raise ConfigurationError( + 'A file cannot be overridden with a directory (put a ' + 'slash at the end of to_override if necessary)') override = _override or self._override # test jig + def register(): __import__(package) __import__(override_package) @@ -2666,10 +2670,8 @@ class ViewDeriver(object): def __init__(self, **kw): self.kw = kw self.registry = kw['registry'] - self.authn_policy = self.registry.queryUtility( - IAuthenticationPolicy) - self.authz_policy = self.registry.queryUtility( - IAuthorizationPolicy) + self.authn_policy = self.registry.queryUtility(IAuthenticationPolicy) + self.authz_policy = self.registry.queryUtility(IAuthorizationPolicy) self.logger = self.registry.queryUtility(IDebugLogger) def __call__(self, view): diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py index 202dce7bf..d2ff65878 100644 --- a/pyramid/tests/test_config.py +++ b/pyramid/tests/test_config.py @@ -1491,6 +1491,16 @@ class ConfiguratorTests(unittest.TestCase): self.failIfEqual(wrapper, None) self.assertEqual(wrapper(None, None), 'OK') + def test_add_view_with_route_name_deferred_views_already_exist(self): + view = lambda *arg: 'OK' + config = self._makeOne(autocommit=True) + config.registry.deferred_route_views = {'bar':[]} + config.add_view(view=view, route_name='foo') + self.assertEqual(len(config.registry.deferred_route_views), 2) + self.assertEqual(config.registry.deferred_route_views['bar'], []) + infos = config.registry.deferred_route_views['foo'] + self.assertEqual(len(infos), 1) + def test_deferred_route_views_retains_custom_predicates(self): view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) @@ -2489,6 +2499,16 @@ class ConfiguratorTests(unittest.TestCase): config.add_translation_dirs, '/wont/exist/on/my/system') + def test_add_translation_dirs_no_specs(self): + from pyramid.interfaces import ITranslationDirectories + from pyramid.interfaces import IChameleonTranslate + config = self._makeOne() + config.add_translation_dirs() + self.assertEqual(config.registry.queryUtility(ITranslationDirectories), + None) + self.assertEqual(config.registry.queryUtility(IChameleonTranslate), + None) + def test_add_translation_dirs_asset_spec(self): import os from pyramid.interfaces import ITranslationDirectories @@ -2499,6 +2519,18 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(config.registry.getUtility(ITranslationDirectories), [locale]) + def test_add_translation_dirs_asset_spec_existing_translation_dirs(self): + import os + from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) + directories = ['abc'] + config.registry.registerUtility(directories, ITranslationDirectories) + config.add_translation_dirs('pyramid.tests.localeapp:locale') + here = os.path.dirname(__file__) + locale = os.path.join(here, 'localeapp', 'locale') + result = config.registry.getUtility(ITranslationDirectories) + self.assertEqual(result, [locale, 'abc']) + def test_add_translation_dirs_registers_chameleon_translate(self): from pyramid.interfaces import IChameleonTranslate from pyramid.threadlocal import manager @@ -2539,7 +2571,13 @@ class ConfiguratorTests(unittest.TestCase): self.assertRaises(ConfigurationError, config.override_asset, 'a:foo.pt', 'a:foo/') - def test_override_asset_success(self): + def test_override_asset_file_with_package(self): + from pyramid.exceptions import ConfigurationError + config = self._makeOne() + self.assertRaises(ConfigurationError, config.override_asset, + 'a:foo.pt', 'a') + + def test_override_asset_file_with_file(self): config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( @@ -2553,6 +2591,62 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(override.override_package, subpackage) self.assertEqual(override.override_prefix, 'templates/bar.pt') + def test_override_asset_package_with_package(self): + config = self._makeOne(autocommit=True) + override = DummyUnderOverride() + config.override_asset( + 'pyramid.tests.fixtureapp', + 'pyramid.tests.fixtureapp.subpackage', + _override=override) + from pyramid.tests import fixtureapp + from pyramid.tests.fixtureapp import subpackage + self.assertEqual(override.package, fixtureapp) + self.assertEqual(override.path, '') + self.assertEqual(override.override_package, subpackage) + self.assertEqual(override.override_prefix, '') + + def test_override_asset_directory_with_directory(self): + config = self._makeOne(autocommit=True) + override = DummyUnderOverride() + config.override_asset( + 'pyramid.tests.fixtureapp:templates/', + 'pyramid.tests.fixtureapp.subpackage:templates/', + _override=override) + from pyramid.tests import fixtureapp + from pyramid.tests.fixtureapp import subpackage + self.assertEqual(override.package, fixtureapp) + self.assertEqual(override.path, 'templates/') + self.assertEqual(override.override_package, subpackage) + self.assertEqual(override.override_prefix, 'templates/') + + def test_override_asset_directory_with_package(self): + config = self._makeOne(autocommit=True) + override = DummyUnderOverride() + config.override_asset( + 'pyramid.tests.fixtureapp:templates/', + 'pyramid.tests.fixtureapp.subpackage', + _override=override) + from pyramid.tests import fixtureapp + from pyramid.tests.fixtureapp import subpackage + self.assertEqual(override.package, fixtureapp) + self.assertEqual(override.path, 'templates/') + self.assertEqual(override.override_package, subpackage) + self.assertEqual(override.override_prefix, '') + + def test_override_asset_package_with_directory(self): + config = self._makeOne(autocommit=True) + override = DummyUnderOverride() + config.override_asset( + 'pyramid.tests.fixtureapp', + 'pyramid.tests.fixtureapp.subpackage:templates/', + _override=override) + from pyramid.tests import fixtureapp + from pyramid.tests.fixtureapp import subpackage + self.assertEqual(override.package, fixtureapp) + self.assertEqual(override.path, '') + self.assertEqual(override.override_package, subpackage) + self.assertEqual(override.override_prefix, 'templates/') + def test_add_renderer(self): from pyramid.interfaces import IRendererFactory config = self._makeOne(autocommit=True) @@ -2816,6 +2910,28 @@ class ConfiguratorTests(unittest.TestCase): renderer.assert_(bar=2) renderer.assert_(request=request) + def test_testing_add_renderer_twice(self): + config = self._makeOne(autocommit=True) + renderer1 = config.testing_add_renderer('templates/foo.pt') + renderer2 = config.testing_add_renderer('templates/bar.pt') + from pyramid.testing import DummyTemplateRenderer + self.failUnless(isinstance(renderer1, DummyTemplateRenderer)) + self.failUnless(isinstance(renderer2, DummyTemplateRenderer)) + from pyramid.renderers import render_to_response + # must provide request to pass in registry (this is a functest) + request = DummyRequest() + request.registry = config.registry + render_to_response( + 'templates/foo.pt', {'foo':1, 'bar':2}, request=request) + renderer1.assert_(foo=1) + renderer1.assert_(bar=2) + renderer1.assert_(request=request) + render_to_response( + 'templates/bar.pt', {'foo':1, 'bar':2}, request=request) + renderer2.assert_(foo=1) + renderer2.assert_(bar=2) + renderer2.assert_(request=request) + def test_testing_add_renderer_explicitrenderer(self): config = self._makeOne(autocommit=True) class E(Exception): pass @@ -3351,6 +3467,52 @@ class TestViewDeriver(unittest.TestCase): "'view_name' against context None): Allowed " "(no authorization policy in use)") + def test_with_debug_authorization_authn_policy_no_authz_policy(self): + view = lambda *arg: 'OK' + self.config.registry.settings = dict(debug_authorization=True) + from pyramid.interfaces import IAuthenticationPolicy + policy = DummySecurityPolicy(False) + self.config.registry.registerUtility(policy, IAuthenticationPolicy) + logger = self._registerLogger() + deriver = self._makeOne(permission='view') + result = deriver(view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) + request = self._makeRequest() + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed " + "(no authorization policy in use)") + + def test_with_debug_authorization_authz_policy_no_authn_policy(self): + view = lambda *arg: 'OK' + self.config.registry.settings = dict(debug_authorization=True) + from pyramid.interfaces import IAuthorizationPolicy + policy = DummySecurityPolicy(False) + self.config.registry.registerUtility(policy, IAuthorizationPolicy) + logger = self._registerLogger() + deriver = self._makeOne(permission='view') + result = deriver(view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) + request = self._makeRequest() + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url url (view name " + "'view_name' against context None): Allowed " + "(no authorization policy in use)") + def test_with_debug_authorization_no_permission(self): view = lambda *arg: 'OK' self.config.registry.settings = dict( @@ -3394,6 +3556,24 @@ class TestViewDeriver(unittest.TestCase): "debug_authorization of url url (view name " "'view_name' against context None): True") + def test_debug_auth_permission_authpol_permitted_no_request(self): + view = lambda *arg: 'OK' + self.config.registry.settings = dict( + debug_authorization=True, reload_templates=True) + logger = self._registerLogger() + self._registerSecurityPolicy(True) + deriver = self._makeOne(permission='view') + result = deriver(view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result.__call_permissive__, view) + self.assertEqual(result(None, None), 'OK') + self.assertEqual(len(logger.messages), 1) + self.assertEqual(logger.messages[0], + "debug_authorization of url None (view name " + "None against context None): True") + def test_debug_auth_permission_authpol_denied(self): from pyramid.exceptions import Forbidden view = lambda *arg: 'OK' @@ -3454,6 +3634,40 @@ class TestViewDeriver(unittest.TestCase): "debug_authorization of url url (view name " "'view_name' against context None): False") + def test_secured_view_authn_policy_no_authz_policy(self): + view = lambda *arg: 'OK' + self.config.registry.settings = {} + from pyramid.interfaces import IAuthenticationPolicy + policy = DummySecurityPolicy(False) + self.config.registry.registerUtility(policy, IAuthenticationPolicy) + deriver = self._makeOne(permission='view') + result = deriver(view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) + request = self._makeRequest() + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + + def test_secured_view_authz_policy_no_authn_policy(self): + view = lambda *arg: 'OK' + self.config.registry.settings = {} + from pyramid.interfaces import IAuthorizationPolicy + policy = DummySecurityPolicy(False) + self.config.registry.registerUtility(policy, IAuthorizationPolicy) + deriver = self._makeOne(permission='view') + result = deriver(view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.failIf(hasattr(result, '__call_permissive__')) + request = self._makeRequest() + request.view_name = 'view_name' + request.url = 'url' + self.assertEqual(result(None, request), 'OK') + def test_with_predicates_all(self): view = lambda *arg: 'OK' predicates = [] -- cgit v1.2.3