diff options
Diffstat (limited to 'tests/test_config')
27 files changed, 3440 insertions, 1665 deletions
diff --git a/tests/test_config/__init__.py b/tests/test_config/__init__.py index 81d9f4965..315e8c939 100644 --- a/tests/test_config/__init__.py +++ b/tests/test_config/__init__.py @@ -3,51 +3,70 @@ from zope.interface import implementer from zope.interface import Interface + class IFactory(Interface): pass -def dummy_tween_factory(handler, registry): pass -def dummy_tween_factory2(handler, registry): pass +def dummy_tween_factory(handler, registry): + pass + + +def dummy_tween_factory2(handler, registry): + pass + def dummy_include(config): config.registry.included = True config.action('discrim', None, config.package) + def dummy_include2(config): config.registry.also_included = True config.action('discrim', None, config.package) + includeme = dummy_include + class DummyContext: pass + @implementer(IFactory) class DummyFactory(object): def __call__(self): """ """ + def dummyfactory(request): """ """ + class IDummy(Interface): pass + def dummy_view(request): return 'OK' + def dummy_extend(config, discrim): config.action(discrim, None, config.package) + def dummy_extend2(config, discrim): config.action(discrim, None, config.registry) + from functools import partial + dummy_partial = partial(dummy_extend, discrim='partial') + class DummyCallable(object): def __call__(self, config, discrim): config.action(discrim, None, config.package) -dummy_callable = DummyCallable() + +dummy_callable = DummyCallable() diff --git a/tests/test_config/path/scanerror/__init__.py b/tests/test_config/path/scanerror/__init__.py index 86770ad89..934d6d3ad 100644 --- a/tests/test_config/path/scanerror/__init__.py +++ b/tests/test_config/path/scanerror/__init__.py @@ -1,3 +1 @@ # scan error package - - diff --git a/tests/test_config/pkgs/__init__.py b/tests/test_config/pkgs/__init__.py index ed88d78b4..5bb534f79 100644 --- a/tests/test_config/pkgs/__init__.py +++ b/tests/test_config/pkgs/__init__.py @@ -1,2 +1 @@ # package - diff --git a/tests/test_config/pkgs/asset/__init__.py b/tests/test_config/pkgs/asset/__init__.py index db5619fbc..5bb534f79 100644 --- a/tests/test_config/pkgs/asset/__init__.py +++ b/tests/test_config/pkgs/asset/__init__.py @@ -1,3 +1 @@ # package - - diff --git a/tests/test_config/pkgs/asset/subpackage/__init__.py b/tests/test_config/pkgs/asset/subpackage/__init__.py index d3173e636..5bb534f79 100644 --- a/tests/test_config/pkgs/asset/subpackage/__init__.py +++ b/tests/test_config/pkgs/asset/subpackage/__init__.py @@ -1 +1 @@ -#package +# package diff --git a/tests/test_config/pkgs/scanextrakw/__init__.py b/tests/test_config/pkgs/scanextrakw/__init__.py index ce5e07238..ddda504e1 100644 --- a/tests/test_config/pkgs/scanextrakw/__init__.py +++ b/tests/test_config/pkgs/scanextrakw/__init__.py @@ -1,14 +1,17 @@ import venusian + def foo(wrapped): def bar(scanner, name, wrapped): scanner.config.a = scanner.a + venusian.attach(wrapped, bar) return wrapped + @foo def hello(): pass -hello() # appease coverage +hello() # appease coverage diff --git a/tests/test_config/pkgs/scannable/__init__.py b/tests/test_config/pkgs/scannable/__init__.py index 562413a41..585f4357b 100644 --- a/tests/test_config/pkgs/scannable/__init__.py +++ b/tests/test_config/pkgs/scannable/__init__.py @@ -1,19 +1,23 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(renderer=null_renderer) def grokked(context, request): return 'grokked' + @view_config(request_method='POST', renderer=null_renderer) def grokked_post(context, request): return 'grokked_post' + @view_config(name='stacked2', renderer=null_renderer) @view_config(name='stacked1', renderer=null_renderer) def stacked(context, request): return 'stacked' + class stacked_class(object): def __init__(self, context, request): self.context = context @@ -22,11 +26,15 @@ class stacked_class(object): def __call__(self): return 'stacked_class' -stacked_class = view_config(name='stacked_class1', - renderer=null_renderer)(stacked_class) -stacked_class = view_config(name='stacked_class2', - renderer=null_renderer)(stacked_class) - + +stacked_class = view_config(name='stacked_class1', renderer=null_renderer)( + stacked_class +) +stacked_class = view_config(name='stacked_class2', renderer=null_renderer)( + stacked_class +) + + class oldstyle_grokked_class: def __init__(self, context, request): self.context = context @@ -34,10 +42,12 @@ class oldstyle_grokked_class: def __call__(self): return 'oldstyle_grokked_class' - -oldstyle_grokked_class = view_config(name='oldstyle_grokked_class', - renderer=null_renderer)( - oldstyle_grokked_class) + + +oldstyle_grokked_class = view_config( + name='oldstyle_grokked_class', renderer=null_renderer +)(oldstyle_grokked_class) + class grokked_class(object): def __init__(self, context, request): @@ -46,23 +56,30 @@ class grokked_class(object): def __call__(self): return 'grokked_class' - -grokked_class = view_config(name='grokked_class', - renderer=null_renderer)(grokked_class) + + +grokked_class = view_config(name='grokked_class', renderer=null_renderer)( + grokked_class +) + class Foo(object): def __call__(self, context, request): return 'grokked_instance' + grokked_instance = Foo() -grokked_instance = view_config(name='grokked_instance', - renderer=null_renderer)(grokked_instance) +grokked_instance = view_config( + name='grokked_instance', renderer=null_renderer +)(grokked_instance) + class Base(object): @view_config(name='basemethod', renderer=null_renderer) def basemethod(self): """ """ - + + class MethodViews(Base): def __init__(self, context, request): self.context = context @@ -81,16 +98,20 @@ class MethodViews(Base): def stacked(self): return 'stacked_method' + # ungrokkable A = 1 B = {} + def stuff(): """ """ + class Whatever(object): pass + class Whatever2: pass diff --git a/tests/test_config/pkgs/scannable/another.py b/tests/test_config/pkgs/scannable/another.py index 529821b5c..e8b71e5e3 100644 --- a/tests/test_config/pkgs/scannable/another.py +++ b/tests/test_config/pkgs/scannable/another.py @@ -1,19 +1,23 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(name='another', renderer=null_renderer) def grokked(context, request): return 'another_grokked' + @view_config(request_method='POST', name='another', renderer=null_renderer) def grokked_post(context, request): return 'another_grokked_post' + @view_config(name='another_stacked2', renderer=null_renderer) @view_config(name='another_stacked1', renderer=null_renderer) def stacked(context, request): return 'another_stacked' + class stacked_class(object): def __init__(self, context, request): self.context = context @@ -22,10 +26,14 @@ class stacked_class(object): def __call__(self): return 'another_stacked_class' -stacked_class = view_config(name='another_stacked_class1', - renderer=null_renderer)(stacked_class) -stacked_class = view_config(name='another_stacked_class2', - renderer=null_renderer)(stacked_class) + +stacked_class = view_config( + name='another_stacked_class1', renderer=null_renderer +)(stacked_class) +stacked_class = view_config( + name='another_stacked_class2', renderer=null_renderer +)(stacked_class) + class oldstyle_grokked_class: def __init__(self, context, request): @@ -34,10 +42,12 @@ class oldstyle_grokked_class: def __call__(self): return 'another_oldstyle_grokked_class' - -oldstyle_grokked_class = view_config(name='another_oldstyle_grokked_class', - renderer=null_renderer)( - oldstyle_grokked_class) + + +oldstyle_grokked_class = view_config( + name='another_oldstyle_grokked_class', renderer=null_renderer +)(oldstyle_grokked_class) + class grokked_class(object): def __init__(self, context, request): @@ -46,24 +56,28 @@ class grokked_class(object): def __call__(self): return 'another_grokked_class' - -grokked_class = view_config(name='another_grokked_class', - renderer=null_renderer)(grokked_class) + + +grokked_class = view_config( + name='another_grokked_class', renderer=null_renderer +)(grokked_class) + class Foo(object): def __call__(self, context, request): return 'another_grokked_instance' + grokked_instance = Foo() -grokked_instance = view_config(name='another_grokked_instance', - renderer=null_renderer)( - grokked_instance) +grokked_instance = view_config( + name='another_grokked_instance', renderer=null_renderer +)(grokked_instance) # ungrokkable A = 1 B = {} + def stuff(): """ """ - diff --git a/tests/test_config/pkgs/scannable/pod/notinit.py b/tests/test_config/pkgs/scannable/pod/notinit.py index 91dcd161b..03c93857f 100644 --- a/tests/test_config/pkgs/scannable/pod/notinit.py +++ b/tests/test_config/pkgs/scannable/pod/notinit.py @@ -1,6 +1,7 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(name='pod_notinit', renderer=null_renderer) def subpackage_notinit(context, request): return 'pod_notinit' diff --git a/tests/test_config/pkgs/scannable/subpackage/__init__.py b/tests/test_config/pkgs/scannable/subpackage/__init__.py index 9e0ddacbd..f89ca33f7 100644 --- a/tests/test_config/pkgs/scannable/subpackage/__init__.py +++ b/tests/test_config/pkgs/scannable/subpackage/__init__.py @@ -1,6 +1,7 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(name='subpackage_init', renderer=null_renderer) def subpackage_init(context, request): return 'subpackage_init' diff --git a/tests/test_config/pkgs/scannable/subpackage/notinit.py b/tests/test_config/pkgs/scannable/subpackage/notinit.py index f7edd0c68..65c2a4929 100644 --- a/tests/test_config/pkgs/scannable/subpackage/notinit.py +++ b/tests/test_config/pkgs/scannable/subpackage/notinit.py @@ -1,6 +1,7 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(name='subpackage_notinit', renderer=null_renderer) def subpackage_notinit(context, request): return 'subpackage_notinit' diff --git a/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py b/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py index fdda0dffe..ec4bab818 100644 --- a/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py +++ b/tests/test_config/pkgs/scannable/subpackage/subsubpackage/__init__.py @@ -1,6 +1,7 @@ from pyramid.view import view_config from pyramid.renderers import null_renderer + @view_config(name='subsubpackage_init', renderer=null_renderer) def subpackage_init(context, request): return 'subsubpackage_init' diff --git a/tests/test_config/pkgs/selfscan/__init__.py b/tests/test_config/pkgs/selfscan/__init__.py index 779ea3eed..8bc8761ca 100644 --- a/tests/test_config/pkgs/selfscan/__init__.py +++ b/tests/test_config/pkgs/selfscan/__init__.py @@ -1,11 +1,14 @@ from pyramid.view import view_config + @view_config(renderer='string') def abc(request): return 'root' + def main(): from pyramid.config import Configurator + c = Configurator() c.scan() return c diff --git a/tests/test_config/pkgs/selfscan/another.py b/tests/test_config/pkgs/selfscan/another.py index a30ad3297..79e0b08de 100644 --- a/tests/test_config/pkgs/selfscan/another.py +++ b/tests/test_config/pkgs/selfscan/another.py @@ -1,6 +1,6 @@ from pyramid.view import view_config + @view_config(name='two', renderer='string') def two(request): return 'two' - diff --git a/tests/test_config/test_adapters.py b/tests/test_config/test_adapters.py index e554520e7..6237995d0 100644 --- a/tests/test_config/test_adapters.py +++ b/tests/test_config/test_adapters.py @@ -3,23 +3,30 @@ import unittest from pyramid.compat import PY2 from . import IDummy + class AdaptersConfiguratorMixinTests(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_add_subscriber_defaults(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] + def subscriber(event): L.append(event) + config = self._makeOne(autocommit=True) config.add_subscriber(subscriber) event = Event() @@ -32,14 +39,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_iface_specified(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] + def subscriber(event): L.append(event) + config = self._makeOne(autocommit=True) config.add_subscriber(subscriber, IEvent) event = Event() @@ -52,9 +64,11 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_dottednames(self): import tests.test_config from pyramid.interfaces import INewRequest + config = self._makeOne(autocommit=True) - config.add_subscriber('tests.test_config', - 'pyramid.interfaces.INewRequest') + config.add_subscriber( + 'tests.test_config', 'pyramid.interfaces.INewRequest' + ) handlers = list(config.registry.registeredHandlers()) self.assertEqual(len(handlers), 1) handler = handlers[0] @@ -64,15 +78,20 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_object_event_subscriber(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: object = 'foo' + event = Event() L = [] + def subscriber(object, event): L.append(event) + config = self._makeOne(autocommit=True) config.add_subscriber(subscriber, (Interface, IEvent)) config.registry.subscribers((event.object, event), None) @@ -84,14 +103,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_with_specific_type_and_predicates_True(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] + def subscriber(event): L.append(event) + config = self._makeOne(autocommit=True) predlist = config.get_predlist('subscriber') jam_predicate = predicate_maker('jam') @@ -111,14 +135,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_with_default_type_predicates_True(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] + def subscriber(event): L.append(event) + config = self._makeOne(autocommit=True) predlist = config.get_predlist('subscriber') jam_predicate = predicate_maker('jam') @@ -138,13 +167,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_with_specific_type_and_predicates_False(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] - def subscriber(event): L.append(event) + + def subscriber(event): + L.append(event) + config = self._makeOne(autocommit=True) predlist = config.get_predlist('subscriber') jam_predicate = predicate_maker('jam') @@ -161,13 +196,19 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_with_default_type_predicates_False(self): from zope.interface import implementer from zope.interface import Interface + class IEvent(Interface): pass + @implementer(IEvent) class Event: pass + L = [] - def subscriber(event): L.append(event) + + def subscriber(event): + L.append(event) + config = self._makeOne(autocommit=True) predlist = config.get_predlist('subscriber') jam_predicate = predicate_maker('jam') @@ -184,33 +225,42 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_subscriber_predicate(self): config = self._makeOne() L = [] - def add_predicate(type, name, factory, weighs_less_than=None, - weighs_more_than=None): + + def add_predicate( + type, name, factory, weighs_less_than=None, weighs_more_than=None + ): self.assertEqual(type, 'subscriber') self.assertEqual(name, 'name') self.assertEqual(factory, 'factory') self.assertEqual(weighs_more_than, 1) self.assertEqual(weighs_less_than, 2) L.append(1) + config._add_predicate = add_predicate config.add_subscriber_predicate('name', 'factory', 1, 2) self.assertTrue(L) - + def test_add_response_adapter(self): from pyramid.interfaces import IResponse + config = self._makeOne(autocommit=True) + class Adapter(object): def __init__(self, other): self.other = other + config.add_response_adapter(Adapter, str) result = config.registry.queryAdapter('foo', IResponse) self.assertTrue(result.other, 'foo') def test_add_response_adapter_self(self): from pyramid.interfaces import IResponse + config = self._makeOne(autocommit=True) + class Adapter(object): pass + config.add_response_adapter(None, Adapter) adapter = Adapter() result = config.registry.queryAdapter(adapter, IResponse) @@ -218,6 +268,7 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_response_adapter_dottednames(self): from pyramid.interfaces import IResponse + config = self._makeOne(autocommit=True) if PY2: str_name = '__builtin__.str' @@ -229,10 +280,12 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_traverser_dotted_names(self): from pyramid.interfaces import ITraverser + config = self._makeOne(autocommit=True) config.add_traverser( 'tests.test_config.test_adapters.DummyTraverser', - 'tests.test_config.test_adapters.DummyIface') + 'tests.test_config.test_adapters.DummyIface', + ) iface = DummyIface() traverser = config.registry.getAdapter(iface, ITraverser) self.assertEqual(traverser.__class__, DummyTraverser) @@ -240,6 +293,7 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_traverser_default_iface_means_Interface(self): from pyramid.interfaces import ITraverser + config = self._makeOne(autocommit=True) config.add_traverser(DummyTraverser) traverser = config.registry.getAdapter(None, ITraverser) @@ -247,19 +301,20 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_traverser_nondefault_iface(self): from pyramid.interfaces import ITraverser + config = self._makeOne(autocommit=True) config.add_traverser(DummyTraverser, DummyIface) iface = DummyIface() traverser = config.registry.getAdapter(iface, ITraverser) self.assertEqual(traverser.__class__, DummyTraverser) self.assertEqual(traverser.root, iface) - + def test_add_traverser_introspectables(self): config = self._makeOne() config.add_traverser(DummyTraverser, DummyIface) actions = config.action_state.actions self.assertEqual(len(actions), 1) - intrs = actions[0]['introspectables'] + intrs = actions[0]['introspectables'] self.assertEqual(len(intrs), 1) intr = intrs[0] self.assertEqual(intr.type_name, 'traverser') @@ -271,25 +326,25 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_resource_url_adapter_dotted_names(self): from pyramid.interfaces import IResourceURL + config = self._makeOne(autocommit=True) config.add_resource_url_adapter( 'tests.test_config.test_adapters.DummyResourceURL', 'tests.test_config.test_adapters.DummyIface', - ) + ) iface = DummyIface() - adapter = config.registry.getMultiAdapter((iface, iface), - IResourceURL) + adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL) self.assertEqual(adapter.__class__, DummyResourceURL) self.assertEqual(adapter.resource, iface) self.assertEqual(adapter.request, iface) def test_add_resource_url_default_resource_iface_means_Interface(self): from pyramid.interfaces import IResourceURL + config = self._makeOne(autocommit=True) config.add_resource_url_adapter(DummyResourceURL) iface = DummyIface() - adapter = config.registry.getMultiAdapter((iface, iface), - IResourceURL) + adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL) self.assertEqual(adapter.__class__, DummyResourceURL) self.assertEqual(adapter.resource, iface) self.assertEqual(adapter.request, iface) @@ -297,18 +352,17 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): def test_add_resource_url_nodefault_resource_iface(self): from zope.interface import Interface from pyramid.interfaces import IResourceURL + config = self._makeOne(autocommit=True) config.add_resource_url_adapter(DummyResourceURL, DummyIface) iface = DummyIface() - adapter = config.registry.getMultiAdapter((iface, iface), - IResourceURL) + adapter = config.registry.getMultiAdapter((iface, iface), IResourceURL) self.assertEqual(adapter.__class__, DummyResourceURL) self.assertEqual(adapter.resource, iface) self.assertEqual(adapter.request, iface) bad_result = config.registry.queryMultiAdapter( - (Interface, Interface), - IResourceURL, - ) + (Interface, Interface), IResourceURL + ) self.assertEqual(bad_result, None) def test_add_resource_url_adapter_introspectables(self): @@ -316,50 +370,62 @@ class AdaptersConfiguratorMixinTests(unittest.TestCase): config.add_resource_url_adapter(DummyResourceURL, DummyIface) actions = config.action_state.actions self.assertEqual(len(actions), 1) - intrs = actions[0]['introspectables'] + intrs = actions[0]['introspectables'] self.assertEqual(len(intrs), 1) intr = intrs[0] self.assertEqual(intr.type_name, 'resource url adapter') - self.assertEqual(intr.discriminator, - ('resource url adapter', DummyIface)) + self.assertEqual( + intr.discriminator, ('resource url adapter', DummyIface) + ) self.assertEqual(intr.category_name, 'resource url adapters') self.assertEqual( intr.title, "resource url adapter for resource iface " - "<class 'tests.test_config.test_adapters.DummyIface'>" - ) + "<class 'tests.test_config.test_adapters.DummyIface'>", + ) self.assertEqual(intr['adapter'], DummyResourceURL) self.assertEqual(intr['resource_iface'], DummyIface) + class Test_eventonly(unittest.TestCase): def _callFUT(self, callee): from pyramid.config.adapters import eventonly + return eventonly(callee) def test_defaults(self): - def acallable(event, a=1, b=2): pass + def acallable(event, a=1, b=2): + pass + self.assertTrue(self._callFUT(acallable)) + class DummyTraverser(object): def __init__(self, root): self.root = root + class DummyIface(object): pass + class DummyResourceURL(object): def __init__(self, resource, request): self.resource = resource self.request = request - + + def predicate_maker(name): class Predicate(object): def __init__(self, val, config): self.val = val + def phash(self): return 'phash' + text = phash + def __call__(self, event): return getattr(event, name, None) == self.val - return Predicate + return Predicate diff --git a/tests/test_config/test_assets.py b/tests/test_config/test_assets.py index b16977b99..875846dbd 100644 --- a/tests/test_config/test_assets.py +++ b/tests/test_config/test_assets.py @@ -5,48 +5,66 @@ from pyramid.testing import cleanUp # we use this folder here = os.path.dirname(os.path.abspath(__file__)) + class TestAssetsConfiguratorMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_override_asset_samename(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() self.assertRaises(ConfigurationError, config.override_asset, 'a', 'a') def test_override_asset_directory_with_file(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_asset, - 'a:foo/', - 'tests.test_config.pkgs.asset:foo.pt') + self.assertRaises( + ConfigurationError, + config.override_asset, + 'a:foo/', + 'tests.test_config.pkgs.asset:foo.pt', + ) def test_override_asset_file_with_directory(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_asset, - 'a:foo.pt', - 'tests.test_config.pkgs.asset:templates/') + self.assertRaises( + ConfigurationError, + config.override_asset, + 'a:foo.pt', + 'tests.test_config.pkgs.asset:templates/', + ) 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', - 'tests.test_config.pkgs.asset') + self.assertRaises( + ConfigurationError, + config.override_asset, + 'a:foo.pt', + 'tests.test_config.pkgs.asset', + ) def test_override_asset_file_with_file(self): from pyramid.config.assets import PackageAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( 'tests.test_config.pkgs.asset:templates/foo.pt', 'tests.test_config.pkgs.asset.subpackage:templates/bar.pt', - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset from tests.test_config.pkgs.asset import subpackage + self.assertEqual(override.package, asset) self.assertEqual(override.path, 'templates/foo.pt') source = override.source @@ -55,21 +73,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, 'templates/bar.pt') resource_name = '' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_package_with_package(self): from pyramid.config.assets import PackageAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( 'tests.test_config.pkgs.asset', 'tests.test_config.pkgs.asset.subpackage', - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset from tests.test_config.pkgs.asset import subpackage + self.assertEqual(override.package, asset) self.assertEqual(override.path, '') source = override.source @@ -78,21 +99,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, '') resource_name = 'templates/bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_directory_with_directory(self): from pyramid.config.assets import PackageAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( 'tests.test_config.pkgs.asset:templates/', 'tests.test_config.pkgs.asset.subpackage:templates/', - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset from tests.test_config.pkgs.asset import subpackage + self.assertEqual(override.package, asset) self.assertEqual(override.path, 'templates/') source = override.source @@ -101,21 +125,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, 'templates/') resource_name = 'bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_directory_with_package(self): from pyramid.config.assets import PackageAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( 'tests.test_config.pkgs.asset:templates/', 'tests.test_config.pkgs.asset.subpackage', - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset from tests.test_config.pkgs.asset import subpackage + self.assertEqual(override.package, asset) self.assertEqual(override.path, 'templates/') source = override.source @@ -124,21 +151,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, '') resource_name = 'templates/bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_package_with_directory(self): from pyramid.config.assets import PackageAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() config.override_asset( 'tests.test_config.pkgs.asset', 'tests.test_config.pkgs.asset.subpackage:templates/', - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset from tests.test_config.pkgs.asset import subpackage + self.assertEqual(override.package, asset) self.assertEqual(override.path, '') source = override.source @@ -147,44 +177,59 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, 'templates/') resource_name = 'bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_directory_with_absfile(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_asset, - 'a:foo/', - os.path.join(here, 'pkgs', 'asset', 'foo.pt')) + self.assertRaises( + ConfigurationError, + config.override_asset, + 'a:foo/', + os.path.join(here, 'pkgs', 'asset', 'foo.pt'), + ) def test_override_asset_file_with_absdirectory(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() - abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates') - self.assertRaises(ConfigurationError, config.override_asset, - 'a:foo.pt', - abspath) + abspath = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates' + ) + self.assertRaises( + ConfigurationError, config.override_asset, 'a:foo.pt', abspath + ) def test_override_asset_file_with_missing_abspath(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_asset, - 'a:foo.pt', - os.path.join(here, 'wont_exist')) + self.assertRaises( + ConfigurationError, + config.override_asset, + 'a:foo.pt', + os.path.join(here, 'wont_exist'), + ) def test_override_asset_file_with_absfile(self): from pyramid.config.assets import FSAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() - abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', - 'templates', 'bar.pt') + abspath = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) config.override_asset( 'tests.test_config.pkgs.asset:templates/foo.pt', abspath, - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset + self.assertEqual(override.package, asset) self.assertEqual(override.path, 'templates/foo.pt') source = override.source @@ -192,21 +237,26 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, abspath) resource_name = '' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_directory_with_absdirectory(self): from pyramid.config.assets import FSAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() - abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates') + abspath = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates' + ) config.override_asset( 'tests.test_config.pkgs.asset:templates/', abspath, - _override=override) + _override=override, + ) from tests.test_config.pkgs import asset + self.assertEqual(override.package, asset) self.assertEqual(override.path, 'templates/') source = override.source @@ -214,21 +264,24 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, abspath) resource_name = 'bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test_override_asset_package_with_absdirectory(self): from pyramid.config.assets import FSAssetSource + config = self._makeOne(autocommit=True) override = DummyUnderOverride() - abspath = os.path.join(here, 'pkgs', 'asset', 'subpackage', 'templates') + abspath = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates' + ) config.override_asset( - 'tests.test_config.pkgs.asset', - abspath, - _override=override) + 'tests.test_config.pkgs.asset', abspath, _override=override + ) from tests.test_config.pkgs import asset + self.assertEqual(override.package, asset) self.assertEqual(override.path, '') source = override.source @@ -236,33 +289,39 @@ class TestAssetsConfiguratorMixin(unittest.TestCase): self.assertEqual(source.prefix, abspath) resource_name = 'bar.pt' - expected = os.path.join(here, 'pkgs', 'asset', - 'subpackage', 'templates', 'bar.pt') - self.assertEqual(override.source.get_filename(resource_name), - expected) + expected = os.path.join( + here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt' + ) + self.assertEqual(override.source.get_filename(resource_name), expected) def test__override_not_yet_registered(self): from pyramid.interfaces import IPackageOverrides + package = DummyPackage('package') source = DummyAssetSource() config = self._makeOne() - config._override(package, 'path', source, - PackageOverrides=DummyPackageOverrides) - overrides = config.registry.queryUtility(IPackageOverrides, - name='package') + config._override( + package, 'path', source, PackageOverrides=DummyPackageOverrides + ) + overrides = config.registry.queryUtility( + IPackageOverrides, name='package' + ) self.assertEqual(overrides.inserted, [('path', source)]) self.assertEqual(overrides.package, package) def test__override_already_registered(self): from pyramid.interfaces import IPackageOverrides + package = DummyPackage('package') source = DummyAssetSource() overrides = DummyPackageOverrides(package) config = self._makeOne() - config.registry.registerUtility(overrides, IPackageOverrides, - name='package') - config._override(package, 'path', source, - PackageOverrides=DummyPackageOverrides) + config.registry.registerUtility( + overrides, IPackageOverrides, name='package' + ) + config._override( + package, 'path', source, PackageOverrides=DummyPackageOverrides + ) self.assertEqual(overrides.inserted, [('path', source)]) self.assertEqual(overrides.package, package) @@ -276,6 +335,7 @@ class TestOverrideProvider(unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import OverrideProvider + return OverrideProvider def _makeOne(self, module): @@ -285,12 +345,14 @@ class TestOverrideProvider(unittest.TestCase): def _registerOverrides(self, overrides, name='tests.test_config'): from pyramid.interfaces import IPackageOverrides from pyramid.threadlocal import get_current_registry + reg = get_current_registry() reg.registerUtility(overrides, IPackageOverrides, name=name) def test_get_resource_filename_no_overrides(self): resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) expected = os.path.join(here, resource_name) result = provider.get_resource_filename(None, resource_name) @@ -299,6 +361,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_stream_no_overrides(self): resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) with provider.get_resource_stream(None, resource_name) as result: _assertBody(result.read(), os.path.join(here, resource_name)) @@ -306,6 +369,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_string_no_overrides(self): resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.get_resource_string(None, resource_name) _assertBody(result, os.path.join(here, resource_name)) @@ -313,6 +377,7 @@ class TestOverrideProvider(unittest.TestCase): def test_has_resource_no_overrides(self): resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.has_resource(resource_name) self.assertEqual(result, True) @@ -321,6 +386,7 @@ class TestOverrideProvider(unittest.TestCase): file_resource_name = 'test_assets.py' directory_resource_name = 'files' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.resource_isdir(file_resource_name) self.assertEqual(result, False) @@ -330,6 +396,7 @@ class TestOverrideProvider(unittest.TestCase): def test_resource_listdir_no_overrides(self): resource_name = 'files' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.resource_listdir(resource_name) self.assertTrue(result) @@ -339,16 +406,18 @@ class TestOverrideProvider(unittest.TestCase): self._registerOverrides(overrides) resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) expected = os.path.join(here, resource_name) result = provider.get_resource_filename(None, resource_name) self.assertEqual(result, expected) - + def test_get_resource_stream_override_returns_None(self): overrides = DummyOverrides(None) self._registerOverrides(overrides) resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) with provider.get_resource_stream(None, resource_name) as result: _assertBody(result.read(), os.path.join(here, resource_name)) @@ -358,6 +427,7 @@ class TestOverrideProvider(unittest.TestCase): self._registerOverrides(overrides) resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.get_resource_string(None, resource_name) _assertBody(result, os.path.join(here, resource_name)) @@ -367,6 +437,7 @@ class TestOverrideProvider(unittest.TestCase): self._registerOverrides(overrides) resource_name = 'test_assets.py' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.has_resource(resource_name) self.assertEqual(result, True) @@ -376,6 +447,7 @@ class TestOverrideProvider(unittest.TestCase): self._registerOverrides(overrides) resource_name = 'files' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.resource_isdir(resource_name) self.assertEqual(result, True) @@ -385,6 +457,7 @@ class TestOverrideProvider(unittest.TestCase): self._registerOverrides(overrides) resource_name = 'files' import tests.test_config + provider = self._makeOne(tests.test_config) result = provider.resource_listdir(resource_name) self.assertTrue(result) @@ -392,6 +465,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_filename_override_returns_value(self): overrides = DummyOverrides('value') import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) result = provider.get_resource_filename(None, 'test_assets.py') @@ -399,8 +473,10 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_stream_override_returns_value(self): from io import BytesIO + overrides = DummyOverrides(BytesIO(b'value')) import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) with provider.get_resource_stream(None, 'test_assets.py') as stream: @@ -409,6 +485,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_string_override_returns_value(self): overrides = DummyOverrides('value') import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) result = provider.get_resource_string(None, 'test_assets.py') @@ -417,6 +494,7 @@ class TestOverrideProvider(unittest.TestCase): def test_has_resource_override_returns_True(self): overrides = DummyOverrides(True) import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) result = provider.has_resource('test_assets.py') @@ -425,6 +503,7 @@ class TestOverrideProvider(unittest.TestCase): def test_resource_isdir_override_returns_False(self): overrides = DummyOverrides(False) import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) result = provider.resource_isdir('files') @@ -433,14 +512,17 @@ class TestOverrideProvider(unittest.TestCase): def test_resource_listdir_override_returns_values(self): overrides = DummyOverrides(['a']) import tests.test_config + self._registerOverrides(overrides) provider = self._makeOne(tests.test_config) result = provider.resource_listdir('files') self.assertEqual(result, ['a']) + class TestPackageOverrides(unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import PackageOverrides + return PackageOverrides def _makeOne(self, package=None, pkg_resources=None): @@ -454,21 +536,25 @@ class TestPackageOverrides(unittest.TestCase): def test_class_conforms_to_IPackageOverrides(self): from zope.interface.verify import verifyClass from pyramid.interfaces import IPackageOverrides + verifyClass(IPackageOverrides, self._getTargetClass()) def test_instance_conforms_to_IPackageOverrides(self): from zope.interface.verify import verifyObject from pyramid.interfaces import IPackageOverrides + verifyObject(IPackageOverrides, self._makeOne()) def test_class_conforms_to_IPEP302Loader(self): from zope.interface.verify import verifyClass from pyramid.interfaces import IPEP302Loader + verifyClass(IPEP302Loader, self._getTargetClass()) def test_instance_conforms_to_IPEP302Loader(self): from zope.interface.verify import verifyObject from pyramid.interfaces import IPEP302Loader + verifyObject(IPEP302Loader, self._makeOne()) def test_ctor_package_already_has_loader_of_different_type(self): @@ -491,11 +577,13 @@ class TestPackageOverrides(unittest.TestCase): def test_ctor_registers_loader_type(self): from pyramid.config.assets import OverrideProvider + dummy_pkg_resources = DummyPkgResources() package = DummyPackage('package') po = self._makeOne(package, dummy_pkg_resources) - self.assertEqual(dummy_pkg_resources.registered, [(po.__class__, - OverrideProvider)]) + self.assertEqual( + dummy_pkg_resources.registered, [(po.__class__, OverrideProvider)] + ) def test_ctor_sets_local_state(self): package = DummyPackage('package') @@ -505,6 +593,7 @@ class TestPackageOverrides(unittest.TestCase): def test_insert_directory(self): from pyramid.config.assets import DirectoryOverride + package = DummyPackage('package') po = self._makeOne(package) po.overrides = [None] @@ -515,6 +604,7 @@ class TestPackageOverrides(unittest.TestCase): def test_insert_file(self): from pyramid.config.assets import FileOverride + package = DummyPackage('package') po = self._makeOne(package) po.overrides = [None] @@ -526,6 +616,7 @@ class TestPackageOverrides(unittest.TestCase): def test_insert_emptystring(self): # XXX is this a valid case for a directory? from pyramid.config.assets import DirectoryOverride + package = DummyPackage('package') po = self._makeOne(package) po.overrides = [None] @@ -536,7 +627,7 @@ class TestPackageOverrides(unittest.TestCase): self.assertEqual(override.__class__, DirectoryOverride) def test_filtered_sources(self): - overrides = [ DummyOverride(None), DummyOverride('foo')] + overrides = [DummyOverride(None), DummyOverride('foo')] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -544,7 +635,7 @@ class TestPackageOverrides(unittest.TestCase): def test_get_filename(self): source = DummyAssetSource(filename='foo.pt') - overrides = [ DummyOverride(None), DummyOverride((source, ''))] + overrides = [DummyOverride(None), DummyOverride((source, ''))] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -554,7 +645,10 @@ class TestPackageOverrides(unittest.TestCase): def test_get_filename_file_doesnt_exist(self): source = DummyAssetSource(filename=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -569,10 +663,13 @@ class TestPackageOverrides(unittest.TestCase): po.overrides = overrides self.assertEqual(po.get_stream('whatever'), 'a stream?') self.assertEqual(source.resource_name, 'foo.pt') - + def test_get_stream_file_doesnt_exist(self): source = DummyAssetSource(stream=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -587,10 +684,13 @@ class TestPackageOverrides(unittest.TestCase): po.overrides = overrides self.assertEqual(po.get_string('whatever'), 'a string') self.assertEqual(source.resource_name, 'foo.pt') - + def test_get_string_file_doesnt_exist(self): source = DummyAssetSource(string=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -608,7 +708,10 @@ class TestPackageOverrides(unittest.TestCase): def test_has_resource_file_doesnt_exist(self): source = DummyAssetSource(exists=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -635,7 +738,10 @@ class TestPackageOverrides(unittest.TestCase): def test_isdir_doesnt_exist(self): source = DummyAssetSource(isdir=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -653,7 +759,10 @@ class TestPackageOverrides(unittest.TestCase): def test_listdir_doesnt_exist(self): source = DummyAssetSource(listdir=None) - overrides = [DummyOverride(None), DummyOverride((source, 'wont_exist'))] + overrides = [ + DummyOverride(None), + DummyOverride((source, 'wont_exist')), + ] package = DummyPackage('package') po = self._makeOne(package) po.overrides = overrides @@ -668,7 +777,7 @@ class TestPackageOverrides(unittest.TestCase): def test_get_data_pkg_has___loader__(self): package = DummyPackage('package') - loader = package.__loader__ = DummyLoader() + loader = package.__loader__ = DummyLoader() po = self._makeOne(package) self.assertEqual(po.get_data('whatever'), b'DEADBEEF') self.assertEqual(loader._got_data, 'whatever') @@ -680,7 +789,7 @@ class TestPackageOverrides(unittest.TestCase): def test_is_package_pkg_has___loader__(self): package = DummyPackage('package') - loader = package.__loader__ = DummyLoader() + loader = package.__loader__ = DummyLoader() po = self._makeOne(package) self.assertTrue(po.is_package('whatever')) self.assertEqual(loader._is_package, 'whatever') @@ -692,7 +801,7 @@ class TestPackageOverrides(unittest.TestCase): def test_get_code_pkg_has___loader__(self): package = DummyPackage('package') - loader = package.__loader__ = DummyLoader() + loader = package.__loader__ = DummyLoader() po = self._makeOne(package) self.assertEqual(po.get_code('whatever'), b'DEADBEEF') self.assertEqual(loader._got_code, 'whatever') @@ -709,17 +818,20 @@ class TestPackageOverrides(unittest.TestCase): self.assertEqual(po.get_source('whatever'), 'def foo():\n pass') self.assertEqual(loader._got_source, 'whatever') -class AssetSourceIntegrationTests(object): +class AssetSourceIntegrationTests(object): def test_get_filename(self): source = self._makeOne('') - self.assertEqual(source.get_filename('test_assets.py'), - os.path.join(here, 'test_assets.py')) + self.assertEqual( + source.get_filename('test_assets.py'), + os.path.join(here, 'test_assets.py'), + ) def test_get_filename_with_prefix(self): source = self._makeOne('test_assets.py') - self.assertEqual(source.get_filename(''), - os.path.join(here, 'test_assets.py')) + self.assertEqual( + source.get_filename(''), os.path.join(here, 'test_assets.py') + ) def test_get_filename_file_doesnt_exist(self): source = self._makeOne('') @@ -741,13 +853,16 @@ class AssetSourceIntegrationTests(object): def test_get_string(self): source = self._makeOne('') - _assertBody(source.get_string('test_assets.py'), - os.path.join(here, 'test_assets.py')) + _assertBody( + source.get_string('test_assets.py'), + os.path.join(here, 'test_assets.py'), + ) def test_get_string_with_prefix(self): source = self._makeOne('test_assets.py') - _assertBody(source.get_string(''), - os.path.join(here, 'test_assets.py')) + _assertBody( + source.get_string(''), os.path.join(here, 'test_assets.py') + ) def test_get_string_file_doesnt_exist(self): source = self._makeOne('') @@ -785,28 +900,33 @@ class AssetSourceIntegrationTests(object): source = self._makeOne('') self.assertEqual(source.listdir('wont_exist'), None) -class TestPackageAssetSource(AssetSourceIntegrationTests, unittest.TestCase): +class TestPackageAssetSource(AssetSourceIntegrationTests, unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import PackageAssetSource + return PackageAssetSource def _makeOne(self, prefix, package='tests.test_config'): klass = self._getTargetClass() return klass(package, prefix) + class TestFSAssetSource(AssetSourceIntegrationTests, unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import FSAssetSource + return FSAssetSource def _makeOne(self, prefix, base_prefix=here): klass = self._getTargetClass() return klass(os.path.join(base_prefix, prefix)) + class TestDirectoryOverride(unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import DirectoryOverride + return DirectoryOverride def _makeOne(self, path, source): @@ -818,16 +938,18 @@ class TestDirectoryOverride(unittest.TestCase): o = self._makeOne('foo/', source) result = o('foo/something.pt') self.assertEqual(result, (source, 'something.pt')) - + def test_it_no_match(self): source = DummyAssetSource() o = self._makeOne('foo/', source) result = o('baz/notfound.pt') self.assertEqual(result, None) + class TestFileOverride(unittest.TestCase): def _getTargetClass(self): from pyramid.config.assets import FileOverride + return FileOverride def _makeOne(self, path, source): @@ -839,13 +961,14 @@ class TestFileOverride(unittest.TestCase): o = self._makeOne('foo.pt', source) result = o('foo.pt') self.assertEqual(result, (source, '')) - + def test_it_no_match(self): source = DummyAssetSource() o = self._makeOne('foo.pt', source) result = o('notfound.pt') self.assertEqual(result, None) + class DummyOverride: def __init__(self, result): self.result = result @@ -853,6 +976,7 @@ class DummyOverride: def __call__(self, resource_name): return self.result + class DummyOverrides: def __init__(self, result): self.result = result @@ -862,6 +986,7 @@ class DummyOverrides: listdir = isdir = has_resource = get_stream = get_string = get_filename + class DummyPackageOverrides: def __init__(self, package): self.package = package @@ -869,7 +994,8 @@ class DummyPackageOverrides: def insert(self, path, source): self.inserted.append((path, source)) - + + class DummyPkgResources: def __init__(self): self.registered = [] @@ -877,10 +1003,12 @@ class DummyPkgResources: def register_loader_type(self, typ, inst): self.registered.append((typ, inst)) + class DummyPackage: def __init__(self, name): self.__name__ = name + class DummyAssetSource: def __init__(self, **kw): self.kw = kw @@ -908,33 +1036,41 @@ class DummyAssetSource: def listdir(self, resource_name): self.resource_name = resource_name return self.kw['listdir'] - + + class DummyLoader: _got_data = _is_package = None + def get_data(self, path): self._got_data = path return b'DEADBEEF' + def is_package(self, fullname): self._is_package = fullname return True + def get_code(self, fullname): self._got_code = fullname return b'DEADBEEF' + def get_source(self, fullname): self._got_source = fullname return 'def foo():\n pass' + class DummyUnderOverride: def __call__(self, package, path, source, _info=''): self.package = package self.path = path self.source = source + def read_(src): with open(src, 'rb') as f: contents = f.read() return contents + def _assertBody(body, filename): # strip both \n and \r for windows body = body.replace(b'\r', b'') @@ -942,4 +1078,4 @@ def _assertBody(body, filename): data = read_(filename) data = data.replace(b'\r', b'') data = data.replace(b'\n', b'') - assert(body == data) + assert body == data diff --git a/tests/test_config/test_factories.py b/tests/test_config/test_factories.py index ea8dec720..325ba52f3 100644 --- a/tests/test_config/test_factories.py +++ b/tests/test_config/test_factories.py @@ -2,14 +2,17 @@ import unittest from . import dummyfactory + class TestFactoriesMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_set_request_factory(self): from pyramid.interfaces import IRequestFactory + config = self._makeOne(autocommit=True) factory = object() config.set_request_factory(factory) @@ -17,14 +20,16 @@ class TestFactoriesMixin(unittest.TestCase): def test_set_request_factory_dottedname(self): from pyramid.interfaces import IRequestFactory + config = self._makeOne(autocommit=True) - config.set_request_factory( - 'tests.test_config.dummyfactory') - self.assertEqual(config.registry.getUtility(IRequestFactory), - dummyfactory) + config.set_request_factory('tests.test_config.dummyfactory') + self.assertEqual( + config.registry.getUtility(IRequestFactory), dummyfactory + ) def test_set_response_factory(self): from pyramid.interfaces import IResponseFactory + config = self._makeOne(autocommit=True) factory = lambda r: object() config.set_response_factory(factory) @@ -32,58 +37,72 @@ class TestFactoriesMixin(unittest.TestCase): def test_set_response_factory_dottedname(self): from pyramid.interfaces import IResponseFactory + config = self._makeOne(autocommit=True) - config.set_response_factory( - 'tests.test_config.dummyfactory') - self.assertEqual(config.registry.getUtility(IResponseFactory), - dummyfactory) + config.set_response_factory('tests.test_config.dummyfactory') + self.assertEqual( + config.registry.getUtility(IResponseFactory), dummyfactory + ) def test_set_root_factory(self): from pyramid.interfaces import IRootFactory + config = self._makeOne() config.set_root_factory(dummyfactory) self.assertEqual(config.registry.queryUtility(IRootFactory), None) config.commit() - self.assertEqual(config.registry.getUtility(IRootFactory), dummyfactory) + self.assertEqual( + config.registry.getUtility(IRootFactory), dummyfactory + ) def test_set_root_factory_as_None(self): from pyramid.interfaces import IRootFactory from pyramid.traversal import DefaultRootFactory + config = self._makeOne() config.set_root_factory(None) self.assertEqual(config.registry.queryUtility(IRootFactory), None) config.commit() - self.assertEqual(config.registry.getUtility(IRootFactory), - DefaultRootFactory) + self.assertEqual( + config.registry.getUtility(IRootFactory), DefaultRootFactory + ) def test_set_root_factory_dottedname(self): from pyramid.interfaces import IRootFactory + config = self._makeOne() config.set_root_factory('tests.test_config.dummyfactory') self.assertEqual(config.registry.queryUtility(IRootFactory), None) config.commit() - self.assertEqual(config.registry.getUtility(IRootFactory), dummyfactory) + self.assertEqual( + config.registry.getUtility(IRootFactory), dummyfactory + ) def test_set_session_factory(self): from pyramid.interfaces import ISessionFactory + config = self._makeOne() config.set_session_factory(dummyfactory) self.assertEqual(config.registry.queryUtility(ISessionFactory), None) config.commit() - self.assertEqual(config.registry.getUtility(ISessionFactory), - dummyfactory) + self.assertEqual( + config.registry.getUtility(ISessionFactory), dummyfactory + ) def test_set_session_factory_dottedname(self): from pyramid.interfaces import ISessionFactory + config = self._makeOne() config.set_session_factory('tests.test_config.dummyfactory') self.assertEqual(config.registry.queryUtility(ISessionFactory), None) config.commit() - self.assertEqual(config.registry.getUtility(ISessionFactory), - dummyfactory) + self.assertEqual( + config.registry.getUtility(ISessionFactory), dummyfactory + ) def test_add_request_method_with_callable(self): from pyramid.interfaces import IRequestExtensions + config = self._makeOne(autocommit=True) callable = lambda x: None config.add_request_method(callable, name='foo') @@ -92,23 +111,34 @@ class TestFactoriesMixin(unittest.TestCase): def test_add_request_method_with_unnamed_callable(self): from pyramid.interfaces import IRequestExtensions + config = self._makeOne(autocommit=True) - def foo(self): pass + + def foo(self): + pass + config.add_request_method(foo) exts = config.registry.getUtility(IRequestExtensions) self.assertTrue('foo' in exts.methods) def test_set_multiple_request_methods_conflict(self): from pyramid.exceptions import ConfigurationConflictError + config = self._makeOne() - def foo(self): pass - def bar(self): pass + + def foo(self): + pass + + def bar(self): + pass + config.add_request_method(foo, name='bar') config.add_request_method(bar, name='bar') self.assertRaises(ConfigurationConflictError, config.commit) def test_add_request_method_with_None_callable(self): from pyramid.interfaces import IRequestExtensions + config = self._makeOne(autocommit=True) config.add_request_method(name='foo') exts = config.registry.queryUtility(IRequestExtensions) @@ -116,8 +146,12 @@ class TestFactoriesMixin(unittest.TestCase): def test_add_request_method_with_None_callable_conflict(self): from pyramid.exceptions import ConfigurationConflictError + config = self._makeOne() - def bar(self): pass + + def bar(self): + pass + config.add_request_method(name='foo') config.add_request_method(bar, name='foo') self.assertRaises(ConfigurationConflictError, config.commit) @@ -132,7 +166,9 @@ class TestFactoriesMixin(unittest.TestCase): from pyramid.exceptions import ConfigurationError config = self._makeOne(autocommit=True) - def boomshaka(r): pass + + def boomshaka(r): + pass def get_bad_name(): if PY2: @@ -146,8 +182,12 @@ class TestFactoriesMixin(unittest.TestCase): def test_set_execution_policy(self): from pyramid.interfaces import IExecutionPolicy + config = self._makeOne(autocommit=True) - def dummy_policy(environ, router): pass + + def dummy_policy(environ, router): + pass + config.set_execution_policy(dummy_policy) registry = config.registry result = registry.queryUtility(IExecutionPolicy) @@ -156,6 +196,7 @@ class TestFactoriesMixin(unittest.TestCase): def test_set_execution_policy_to_None(self): from pyramid.interfaces import IExecutionPolicy from pyramid.router import default_execution_policy + config = self._makeOne(autocommit=True) config.set_execution_policy(None) registry = config.registry diff --git a/tests/test_config/test_i18n.py b/tests/test_config/test_i18n.py index 87805f671..5961e9ff2 100644 --- a/tests/test_config/test_i18n.py +++ b/tests/test_config/test_i18n.py @@ -5,56 +5,73 @@ from . import dummyfactory here = os.path.dirname(__file__) locale = os.path.abspath( - os.path.join(here, '..', 'pkgs', 'localeapp', 'locale')) + os.path.join(here, '..', 'pkgs', 'localeapp', 'locale') +) locale2 = os.path.abspath( - os.path.join(here, '..', 'pkgs', 'localeapp', 'locale2')) + os.path.join(here, '..', 'pkgs', 'localeapp', 'locale2') +) locale3 = os.path.abspath( - os.path.join(here, '..', 'pkgs', 'localeapp', 'locale3')) + os.path.join(here, '..', 'pkgs', 'localeapp', 'locale3') +) + class TestI18NConfiguratorMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_set_locale_negotiator(self): from pyramid.interfaces import ILocaleNegotiator + config = self._makeOne(autocommit=True) - def negotiator(request): pass + + def negotiator(request): + pass + config.set_locale_negotiator(negotiator) - self.assertEqual(config.registry.getUtility(ILocaleNegotiator), - negotiator) + self.assertEqual( + config.registry.getUtility(ILocaleNegotiator), negotiator + ) def test_set_locale_negotiator_dottedname(self): from pyramid.interfaces import ILocaleNegotiator + config = self._makeOne(autocommit=True) - config.set_locale_negotiator( - 'tests.test_config.dummyfactory') - self.assertEqual(config.registry.getUtility(ILocaleNegotiator), - dummyfactory) + config.set_locale_negotiator('tests.test_config.dummyfactory') + self.assertEqual( + config.registry.getUtility(ILocaleNegotiator), dummyfactory + ) def test_add_translation_dirs_missing_dir(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() config.add_translation_dirs('/wont/exist/on/my/system') self.assertRaises(ConfigurationError, config.commit) def test_add_translation_dirs_no_specs(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne() config.add_translation_dirs() - self.assertEqual(config.registry.queryUtility(ITranslationDirectories), - None) + self.assertEqual( + config.registry.queryUtility(ITranslationDirectories), None + ) def test_add_translation_dirs_asset_spec(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) config.add_translation_dirs('tests.pkgs.localeapp:locale') - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale]) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), [locale] + ) def test_add_translation_dirs_asset_spec_existing_translation_dirs(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) directories = ['abc'] config.registry.registerUtility(directories, ITranslationDirectories) @@ -64,69 +81,93 @@ class TestI18NConfiguratorMixin(unittest.TestCase): def test_add_translation_dirs_multiple_specs(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) - config.add_translation_dirs('tests.pkgs.localeapp:locale', - 'tests.pkgs.localeapp:locale2') - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale, locale2]) + config.add_translation_dirs( + 'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2' + ) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), + [locale, locale2], + ) def test_add_translation_dirs_multiple_specs_multiple_calls(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) - config.add_translation_dirs('tests.pkgs.localeapp:locale', - 'tests.pkgs.localeapp:locale2') + config.add_translation_dirs( + 'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2' + ) config.add_translation_dirs('tests.pkgs.localeapp:locale3') - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale3, locale, locale2]) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), + [locale3, locale, locale2], + ) def test_add_translation_dirs_override_multiple_specs_multiple_calls(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) - config.add_translation_dirs('tests.pkgs.localeapp:locale', - 'tests.pkgs.localeapp:locale2') - config.add_translation_dirs('tests.pkgs.localeapp:locale3', - override=True) - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale, locale2, locale3]) + config.add_translation_dirs( + 'tests.pkgs.localeapp:locale', 'tests.pkgs.localeapp:locale2' + ) + config.add_translation_dirs( + 'tests.pkgs.localeapp:locale3', override=True + ) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), + [locale, locale2, locale3], + ) def test_add_translation_dirs_invalid_kwargs(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) with self.assertRaises(TypeError): - config.add_translation_dirs('tests.pkgs.localeapp:locale', - foo=1) + config.add_translation_dirs('tests.pkgs.localeapp:locale', foo=1) def test_add_translation_dirs_abspath(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) config.add_translation_dirs(locale) - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale]) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), [locale] + ) def test_add_translation_dirs_uses_override_out_of_order(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne() config.add_translation_dirs('tests.pkgs.localeapp:locale') - config.override_asset('tests.pkgs.localeapp:locale/', - 'tests.pkgs.localeapp:locale2/') + config.override_asset( + 'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/' + ) config.commit() - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale2]) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), [locale2] + ) def test_add_translation_dirs_doesnt_use_override_w_autocommit(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) config.add_translation_dirs('tests.pkgs.localeapp:locale') - config.override_asset('tests.pkgs.localeapp:locale/', - 'tests.pkgs.localeapp:locale2/') - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale]) + config.override_asset( + 'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/' + ) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), [locale] + ) def test_add_translation_dirs_uses_override_w_autocommit(self): from pyramid.interfaces import ITranslationDirectories + config = self._makeOne(autocommit=True) - config.override_asset('tests.pkgs.localeapp:locale/', - 'tests.pkgs.localeapp:locale2/') + config.override_asset( + 'tests.pkgs.localeapp:locale/', 'tests.pkgs.localeapp:locale2/' + ) config.add_translation_dirs('tests.pkgs.localeapp:locale') - self.assertEqual(config.registry.getUtility(ITranslationDirectories), - [locale2]) + self.assertEqual( + config.registry.getUtility(ITranslationDirectories), [locale2] + ) diff --git a/tests/test_config/test_init.py b/tests/test_config/test_init.py index a3c83357e..a7b19a1ac 100644 --- a/tests/test_config/test_init.py +++ b/tests/test_config/test_init.py @@ -17,20 +17,29 @@ from pyramid.exceptions import ConfigurationConflictError from pyramid.interfaces import IRequest + class ConfiguratorTests(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config - def _getViewCallable(self, config, ctx_iface=None, request_iface=None, - name='', exception_view=False): + def _getViewCallable( + self, + config, + ctx_iface=None, + request_iface=None, + name='', + exception_view=False, + ): from zope.interface import Interface from pyramid.interfaces import IRequest from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier - if exception_view: # pragma: no cover + + if exception_view: # pragma: no cover classifier = IExceptionViewClassifier else: classifier = IViewClassifier @@ -39,16 +48,22 @@ class ConfiguratorTests(unittest.TestCase): if request_iface is None: request_iface = IRequest return config.registry.adapters.lookup( - (classifier, request_iface, ctx_iface), IView, name=name, - default=None) + (classifier, request_iface, ctx_iface), + IView, + name=name, + default=None, + ) def _registerEventListener(self, config, event_iface=None): - if event_iface is None: # pragma: no cover + if event_iface is None: # pragma: no cover from zope.interface import Interface + event_iface = Interface L = [] + def subscriber(*event): L.extend(event) + config.registry.registerHandler(subscriber, (event_iface,)) return L @@ -62,6 +77,7 @@ class ConfiguratorTests(unittest.TestCase): from pyramid.interfaces import ISettings from pyramid.config import Configurator from pyramid.interfaces import IRendererFactory + config = Configurator() this_pkg = sys.modules['tests.test_config'] self.assertTrue(config.registry.getUtility(ISettings)) @@ -72,27 +88,32 @@ class ConfiguratorTests(unittest.TestCase): def test_begin(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() config.manager = manager config.begin() - self.assertEqual(manager.pushed, - {'registry':config.registry, 'request':None}) + self.assertEqual( + manager.pushed, {'registry': config.registry, 'request': None} + ) self.assertEqual(manager.popped, False) def test_begin_with_request(self): from pyramid.config import Configurator + config = Configurator() request = object() manager = DummyThreadLocalManager() config.manager = manager config.begin(request=request) - self.assertEqual(manager.pushed, - {'registry':config.registry, 'request':request}) + self.assertEqual( + manager.pushed, {'registry': config.registry, 'request': request} + ) self.assertEqual(manager.popped, False) def test_begin_overrides_request(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() req = object() @@ -107,6 +128,7 @@ class ConfiguratorTests(unittest.TestCase): def test_begin_propagates_request_for_same_registry(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() req = object() @@ -120,6 +142,7 @@ class ConfiguratorTests(unittest.TestCase): def test_begin_does_not_propagate_request_for_diff_registry(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() req = object() @@ -133,6 +156,7 @@ class ConfiguratorTests(unittest.TestCase): def test_end(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() pushed = manager.pushed @@ -143,14 +167,16 @@ class ConfiguratorTests(unittest.TestCase): def test_context_manager(self): from pyramid.config import Configurator + config = Configurator() manager = DummyThreadLocalManager() config.manager = manager view = lambda r: None with config as ctx: self.assertTrue(config is ctx) - self.assertEqual(manager.pushed, - {'registry': config.registry, 'request': None}) + self.assertEqual( + manager.pushed, {'registry': config.registry, 'request': None} + ) self.assertFalse(manager.popped) config.add_view(view) self.assertTrue(manager.popped) @@ -160,14 +186,15 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_with_package_registry(self): import sys from pyramid.config import Configurator + pkg = sys.modules['pyramid'] config = Configurator(package=pkg) self.assertEqual(config.package, pkg) def test_ctor_noreg_custom_settings(self): from pyramid.interfaces import ISettings - settings = {'reload_templates':True, - 'mysetting':True} + + settings = {'reload_templates': True, 'mysetting': True} config = self._makeOne(settings=settings) settings = config.registry.getUtility(ISettings) self.assertEqual(settings['reload_templates'], True) @@ -176,12 +203,14 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_noreg_debug_logger_None_default(self): from pyramid.interfaces import IDebugLogger + config = self._makeOne() logger = config.registry.getUtility(IDebugLogger) self.assertEqual(logger.name, 'tests.test_config') def test_ctor_noreg_debug_logger_non_None(self): from pyramid.interfaces import IDebugLogger + logger = object() config = self._makeOne(debug_logger=logger) result = config.registry.getUtility(IDebugLogger) @@ -189,6 +218,7 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_authentication_policy(self): from pyramid.interfaces import IAuthenticationPolicy + policy = object() config = self._makeOne(authentication_policy=policy) config.commit() @@ -202,6 +232,7 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_no_root_factory(self): from pyramid.interfaces import IRootFactory + config = self._makeOne() self.assertEqual(config.registry.queryUtility(IRootFactory), None) config.commit() @@ -209,6 +240,7 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_with_root_factory(self): from pyramid.interfaces import IRootFactory + factory = object() config = self._makeOne(root_factory=factory) self.assertEqual(config.registry.queryUtility(IRootFactory), None) @@ -217,27 +249,36 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_alternate_renderers(self): from pyramid.interfaces import IRendererFactory + renderer = object() config = self._makeOne(renderers=[('yeah', renderer)]) config.commit() - self.assertEqual(config.registry.getUtility(IRendererFactory, 'yeah'), - renderer) + self.assertEqual( + config.registry.getUtility(IRendererFactory, 'yeah'), renderer + ) def test_ctor_default_renderers(self): from pyramid.interfaces import IRendererFactory from pyramid.renderers import json_renderer_factory + config = self._makeOne() - self.assertEqual(config.registry.getUtility(IRendererFactory, 'json'), - json_renderer_factory) + self.assertEqual( + config.registry.getUtility(IRendererFactory, 'json'), + json_renderer_factory, + ) def test_ctor_default_permission(self): from pyramid.interfaces import IDefaultPermission + config = self._makeOne(default_permission='view') config.commit() - self.assertEqual(config.registry.getUtility(IDefaultPermission), 'view') + self.assertEqual( + config.registry.getUtility(IDefaultPermission), 'view' + ) def test_ctor_session_factory(self): from pyramid.interfaces import ISessionFactory + factory = object() config = self._makeOne(session_factory=factory) self.assertEqual(config.registry.queryUtility(ISessionFactory), None) @@ -246,39 +287,46 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_default_view_mapper(self): from pyramid.interfaces import IViewMapperFactory + mapper = object() config = self._makeOne(default_view_mapper=mapper) config.commit() - self.assertEqual(config.registry.getUtility(IViewMapperFactory), - mapper) + self.assertEqual( + config.registry.getUtility(IViewMapperFactory), mapper + ) def test_ctor_httpexception_view_default(self): from pyramid.interfaces import IExceptionResponse from pyramid.httpexceptions import default_exceptionresponse_view from pyramid.interfaces import IRequest + config = self._makeOne() - view = self._getViewCallable(config, - ctx_iface=IExceptionResponse, - request_iface=IRequest) + view = self._getViewCallable( + config, ctx_iface=IExceptionResponse, request_iface=IRequest + ) self.assertTrue(view.__wraps__ is default_exceptionresponse_view) def test_ctor_exceptionresponse_view_None(self): from pyramid.interfaces import IExceptionResponse from pyramid.interfaces import IRequest + config = self._makeOne(exceptionresponse_view=None) - view = self._getViewCallable(config, - ctx_iface=IExceptionResponse, - request_iface=IRequest) + view = self._getViewCallable( + config, ctx_iface=IExceptionResponse, request_iface=IRequest + ) self.assertTrue(view is None) def test_ctor_exceptionresponse_view_custom(self): from pyramid.interfaces import IExceptionResponse from pyramid.interfaces import IRequest - def exceptionresponse_view(context, request): pass + + def exceptionresponse_view(context, request): + pass + config = self._makeOne(exceptionresponse_view=exceptionresponse_view) - view = self._getViewCallable(config, - ctx_iface=IExceptionResponse, - request_iface=IRequest) + view = self._getViewCallable( + config, ctx_iface=IExceptionResponse, request_iface=IRequest + ) self.assertTrue(view.__wraps__ is exceptionresponse_view) def test_ctor_with_introspection(self): @@ -287,27 +335,33 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_default_webob_response_adapter_registered(self): from webob import Response as WebobResponse + response = WebobResponse() from pyramid.interfaces import IResponse + config = self._makeOne(autocommit=True) result = config.registry.queryAdapter(response, IResponse) self.assertEqual(result, response) - + def test_with_package_module(self): from . import test_init + config = self._makeOne() newconfig = config.with_package(test_init) import tests.test_config + self.assertEqual(newconfig.package, tests.test_config) def test_with_package_package(self): from tests import test_config + config = self._makeOne() newconfig = config.with_package(test_config) self.assertEqual(newconfig.package, test_config) def test_with_package(self): import tests + config = self._makeOne() config.basepath = 'basepath' config.info = 'info' @@ -325,6 +379,7 @@ class ConfiguratorTests(unittest.TestCase): def test_maybe_dotted_string_success(self): import tests.test_config + config = self._makeOne() result = config.maybe_dotted('tests.test_config') self.assertEqual(result, tests.test_config) @@ -335,24 +390,28 @@ class ConfiguratorTests(unittest.TestCase): def test_maybe_dotted_notstring_success(self): import tests.test_config + config = self._makeOne() result = config.maybe_dotted(tests.test_config) self.assertEqual(result, tests.test_config) def test_absolute_asset_spec_already_absolute(self): import tests.test_config + config = self._makeOne(package=tests.test_config) result = config.absolute_asset_spec('already:absolute') self.assertEqual(result, 'already:absolute') def test_absolute_asset_spec_notastring(self): import tests.test_config + config = self._makeOne(package=tests.test_config) result = config.absolute_asset_spec(None) self.assertEqual(result, None) def test_absolute_asset_spec_relative(self): import tests.test_config + config = self._makeOne(package=tests.test_config) result = config.absolute_asset_spec('files') self.assertEqual(result, 'tests.test_config:files') @@ -373,13 +432,17 @@ class ConfiguratorTests(unittest.TestCase): def test__fix_registry_queryAdapterOrSelf(self): from zope.interface import Interface from zope.interface import implementer + class IFoo(Interface): pass + @implementer(IFoo) class Foo(object): pass + class Bar(object): pass + adaptation = () foo = Foo() bar = Bar() @@ -397,9 +460,16 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(len(reg.adapters), 1) args, kw = reg.adapters[0] self.assertEqual(args[0]('abc'), 'abc') - self.assertEqual(kw, - {'info': '', 'provided': 'provided', - 'required': 'required', 'name': 'abc', 'event': True}) + self.assertEqual( + kw, + { + 'info': '', + 'provided': 'provided', + 'required': 'required', + 'name': 'abc', + 'event': True, + }, + ) def test__fix_registry_adds__lock(self): reg = DummyRegistry() @@ -428,6 +498,7 @@ class ConfiguratorTests(unittest.TestCase): from webob.exc import WSGIHTTPException from pyramid.interfaces import IExceptionResponse from pyramid.view import default_exceptionresponse_view + reg = DummyRegistry() config = self._makeOne(reg) views = [] @@ -435,17 +506,29 @@ class ConfiguratorTests(unittest.TestCase): config.add_default_view_predicates = lambda *arg: None config._add_tween = lambda *arg, **kw: False config.setup_registry() - self.assertEqual(views[0], ((default_exceptionresponse_view,), - {'context':IExceptionResponse})) - self.assertEqual(views[1], ((default_exceptionresponse_view,), - {'context':WSGIHTTPException})) + self.assertEqual( + views[0], + ( + (default_exceptionresponse_view,), + {'context': IExceptionResponse}, + ), + ) + self.assertEqual( + views[1], + ( + (default_exceptionresponse_view,), + {'context': WSGIHTTPException}, + ), + ) def test_setup_registry_registers_default_view_predicates(self): reg = DummyRegistry() config = self._makeOne(reg) vp_called = [] config.add_view = lambda *arg, **kw: None - config.add_default_view_predicates = lambda *arg: vp_called.append(True) + config.add_default_view_predicates = lambda *arg: vp_called.append( + True + ) config._add_tween = lambda *arg, **kw: False config.setup_registry() self.assertTrue(vp_called) @@ -453,11 +536,13 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_registers_default_webob_iresponse_adapter(self): from webob import Response from pyramid.interfaces import IResponse + config = self._makeOne() config.setup_registry() response = Response() self.assertTrue( - config.registry.queryAdapter(response, IResponse) is response) + config.registry.queryAdapter(response, IResponse) is response + ) def test_setup_registry_explicit_notfound_trumps_iexceptionresponse(self): from pyramid.renderers import null_renderer @@ -465,24 +550,29 @@ class ConfiguratorTests(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPNotFound from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg, autocommit=True) - config.setup_registry() # registers IExceptionResponse default view + config.setup_registry() # registers IExceptionResponse default view + def myview(context, request): return 'OK' + config.add_view(myview, context=HTTPNotFound, renderer=null_renderer) request = self._makeRequest(config) - view = self._getViewCallable(config, - ctx_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + ctx_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) result = view(None, request) self.assertEqual(result, 'OK') def test_setup_registry_custom_settings(self): from pyramid.registry import Registry from pyramid.interfaces import ISettings - settings = {'reload_templates':True, - 'mysetting':True} + + settings = {'reload_templates': True, 'mysetting': True} reg = Registry() config = self._makeOne(reg) config.setup_registry(settings=settings) @@ -494,6 +584,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_debug_logger_None_default(self): from pyramid.registry import Registry from pyramid.interfaces import IDebugLogger + reg = Registry() config = self._makeOne(reg) config.setup_registry() @@ -503,6 +594,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_debug_logger_non_None(self): from pyramid.registry import Registry from pyramid.interfaces import IDebugLogger + logger = object() reg = Registry() config = self._makeOne(reg) @@ -513,6 +605,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_debug_logger_name(self): from pyramid.registry import Registry from pyramid.interfaces import IDebugLogger + reg = Registry() config = self._makeOne(reg) config.setup_registry(debug_logger='foo') @@ -522,6 +615,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_authentication_policy(self): from pyramid.registry import Registry from pyramid.interfaces import IAuthenticationPolicy + policy = object() reg = Registry() config = self._makeOne(reg) @@ -533,29 +627,36 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_authentication_policy_dottedname(self): from pyramid.registry import Registry from pyramid.interfaces import IAuthenticationPolicy + reg = Registry() config = self._makeOne(reg) config.setup_registry(authentication_policy='tests.test_config') config.commit() result = reg.getUtility(IAuthenticationPolicy) import tests.test_config + self.assertEqual(result, tests.test_config) def test_setup_registry_authorization_policy_dottedname(self): from pyramid.registry import Registry from pyramid.interfaces import IAuthorizationPolicy + reg = Registry() config = self._makeOne(reg) dummy = object() - config.setup_registry(authentication_policy=dummy, - authorization_policy='tests.test_config') + config.setup_registry( + authentication_policy=dummy, + authorization_policy='tests.test_config', + ) config.commit() result = reg.getUtility(IAuthorizationPolicy) import tests.test_config + self.assertEqual(result, tests.test_config) def test_setup_registry_authorization_policy_only(self): from pyramid.registry import Registry + policy = object() reg = Registry() config = self._makeOne(reg) @@ -565,6 +666,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_no_default_root_factory(self): from pyramid.registry import Registry from pyramid.interfaces import IRootFactory + reg = Registry() config = self._makeOne(reg) config.setup_registry() @@ -574,9 +676,11 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_dottedname_root_factory(self): from pyramid.registry import Registry from pyramid.interfaces import IRootFactory + reg = Registry() config = self._makeOne(reg) import tests.test_config + config.setup_registry(root_factory='tests.test_config') self.assertEqual(reg.queryUtility(IRootFactory), None) config.commit() @@ -585,9 +689,11 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_locale_negotiator_dottedname(self): from pyramid.registry import Registry from pyramid.interfaces import ILocaleNegotiator + reg = Registry() config = self._makeOne(reg) import tests.test_config + config.setup_registry(locale_negotiator='tests.test_config') self.assertEqual(reg.queryUtility(ILocaleNegotiator), None) config.commit() @@ -597,6 +703,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_locale_negotiator(self): from pyramid.registry import Registry from pyramid.interfaces import ILocaleNegotiator + reg = Registry() config = self._makeOne(reg) negotiator = object() @@ -609,6 +716,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_request_factory(self): from pyramid.registry import Registry from pyramid.interfaces import IRequestFactory + reg = Registry() config = self._makeOne(reg) factory = object() @@ -621,6 +729,7 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_response_factory(self): from pyramid.registry import Registry from pyramid.interfaces import IResponseFactory + reg = Registry() config = self._makeOne(reg) factory = lambda r: object() @@ -633,9 +742,11 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_request_factory_dottedname(self): from pyramid.registry import Registry from pyramid.interfaces import IRequestFactory + reg = Registry() config = self._makeOne(reg) import tests.test_config + config.setup_registry(request_factory='tests.test_config') self.assertEqual(reg.queryUtility(IRequestFactory), None) config.commit() @@ -645,17 +756,18 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_alternate_renderers(self): from pyramid.registry import Registry from pyramid.interfaces import IRendererFactory + renderer = object() reg = Registry() config = self._makeOne(reg) config.setup_registry(renderers=[('yeah', renderer)]) config.commit() - self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), - renderer) + self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), renderer) def test_setup_registry_default_permission(self): from pyramid.registry import Registry from pyramid.interfaces import IDefaultPermission + reg = Registry() config = self._makeOne(reg) config.setup_registry(default_permission='view') @@ -664,12 +776,12 @@ class ConfiguratorTests(unittest.TestCase): def test_setup_registry_includes(self): from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg) settings = { - 'pyramid.includes': -"""tests.test_config.dummy_include -tests.test_config.dummy_include2""", + 'pyramid.includes': """tests.test_config.dummy_include +tests.test_config.dummy_include2""" } config.setup_registry(settings=settings) self.assertTrue(reg.included) @@ -677,11 +789,11 @@ tests.test_config.dummy_include2""", def test_setup_registry_includes_spaces(self): from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg) settings = { - 'pyramid.includes': -"""tests.test_config.dummy_include tests.test_config.dummy_include2""", + 'pyramid.includes': """tests.test_config.dummy_include tests.test_config.dummy_include2""" } config.setup_registry(settings=settings) self.assertTrue(reg.included) @@ -690,19 +802,17 @@ tests.test_config.dummy_include2""", def test_setup_registry_tweens(self): from pyramid.interfaces import ITweens from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg) - settings = { - 'pyramid.tweens': - 'tests.test_config.dummy_tween_factory' - } + settings = {'pyramid.tweens': 'tests.test_config.dummy_tween_factory'} config.setup_registry(settings=settings) config.commit() tweens = config.registry.getUtility(ITweens) self.assertEqual( tweens.explicit, - [('tests.test_config.dummy_tween_factory', - dummy_tween_factory)]) + [('tests.test_config.dummy_tween_factory', dummy_tween_factory)], + ) def test_introspector_decorator(self): inst = self._makeOne() @@ -723,6 +833,7 @@ tests.test_config.dummy_include2""", import pyramid.config from pyramid.router import Router from pyramid.interfaces import IApplicationCreated + manager = DummyThreadLocalManager() config = self._makeOne() subscriber = self._registerEventListener(config, IApplicationCreated) @@ -739,6 +850,7 @@ tests.test_config.dummy_include2""", def test_include_with_dotted_name(self): from tests import test_config + config = self._makeOne() config.include('tests.test_config.dummy_include') after = config.action_state @@ -751,6 +863,7 @@ tests.test_config.dummy_include2""", def test_include_with_python_callable(self): from tests import test_config + config = self._makeOne() config.include(dummy_include) after = config.action_state @@ -763,6 +876,7 @@ tests.test_config.dummy_include2""", def test_include_with_module_defaults_to_includeme(self): from tests import test_config + config = self._makeOne() config.include('tests.test_config') after = config.action_state @@ -775,24 +889,31 @@ tests.test_config.dummy_include2""", def test_include_with_module_defaults_to_includeme_missing(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() self.assertRaises(ConfigurationError, config.include, 'tests') def test_include_with_route_prefix(self): root_config = self._makeOne(autocommit=True) + def dummy_subapp(config): self.assertEqual(config.route_prefix, 'root') + root_config.include(dummy_subapp, route_prefix='root') def test_include_with_nested_route_prefix(self): root_config = self._makeOne(autocommit=True, route_prefix='root') + def dummy_subapp2(config): self.assertEqual(config.route_prefix, 'root/nested') + def dummy_subapp3(config): self.assertEqual(config.route_prefix, 'root/nested/nested2') config.include(dummy_subapp4) + def dummy_subapp4(config): self.assertEqual(config.route_prefix, 'root/nested/nested2') + def dummy_subapp(config): self.assertEqual(config.route_prefix, 'root/nested') config.include(dummy_subapp2) @@ -803,31 +924,39 @@ tests.test_config.dummy_include2""", def test_include_with_missing_source_file(self): from pyramid.exceptions import ConfigurationError import inspect + config = self._makeOne() + class DummyInspect(object): def getmodule(self, c): return inspect.getmodule(c) + def getsourcefile(self, c): return None + config.inspect = DummyInspect() try: config.include('tests.test_config.dummy_include') except ConfigurationError as e: self.assertEqual( - e.args[0], + e.args[0], "No source file for module 'tests.test_config' (.py " - "file must exist, refusing to use orphan .pyc or .pyo file).") - else: # pragma: no cover + "file must exist, refusing to use orphan .pyc or .pyo file).", + ) + else: # pragma: no cover raise AssertionError def test_include_constant_root_package(self): import tests from tests import test_config + config = self._makeOne(root_package=tests) results = {} + def include(config): results['package'] = config.package results['root_package'] = config.root_package + config.include(include) self.assertEqual(results['root_package'], tests) self.assertEqual(results['package'], test_config) @@ -835,9 +964,12 @@ tests.test_config.dummy_include2""", def test_include_threadlocals_active(self): from pyramid.threadlocal import get_current_registry from tests import test_config + stack = [] + def include(config): stack.append(get_current_registry()) + config = self._makeOne() config.include(include) self.assertTrue(stack[0] is config.registry) @@ -848,10 +980,11 @@ tests.test_config.dummy_include2""", def test_action_branching_kw_is_not_None(self): config = self._makeOne(autocommit=True) - self.assertEqual(config.action('discrim', kw={'a':1}), None) + self.assertEqual(config.action('discrim', kw={'a': 1}), None) def test_action_autocommit_with_introspectables(self): from pyramid.config.util import ActionInfo + config = self._makeOne(autocommit=True) intr = DummyIntrospectable() config.action('discrim', introspectables=(intr,)) @@ -865,25 +998,32 @@ tests.test_config.dummy_include2""", intr = DummyIntrospectable() config.action('discrim', introspectables=(intr,)) self.assertEqual(len(intr.registered), 0) - + def test_action_branching_nonautocommit_with_config_info(self): config = self._makeOne(autocommit=False) config.info = 'abc' state = DummyActionState() state.autocommit = False config.action_state = state - config.action('discrim', kw={'a':1}) + config.action('discrim', kw={'a': 1}) self.assertEqual( state.actions, - [((), - {'args': (), - 'callable': None, - 'discriminator': 'discrim', - 'includepath': (), - 'info': 'abc', - 'introspectables': (), - 'kw': {'a': 1}, - 'order': 0})]) + [ + ( + (), + { + 'args': (), + 'callable': None, + 'discriminator': 'discrim', + 'includepath': (), + 'info': 'abc', + 'introspectables': (), + 'kw': {'a': 1}, + 'order': 0, + }, + ) + ], + ) def test_action_branching_nonautocommit_without_config_info(self): config = self._makeOne(autocommit=False) @@ -892,18 +1032,25 @@ tests.test_config.dummy_include2""", state = DummyActionState() config.action_state = state state.autocommit = False - config.action('discrim', kw={'a':1}) + config.action('discrim', kw={'a': 1}) self.assertEqual( state.actions, - [((), - {'args': (), - 'callable': None, - 'discriminator': 'discrim', - 'includepath': (), - 'info': 'z', - 'introspectables': (), - 'kw': {'a': 1}, - 'order': 0})]) + [ + ( + (), + { + 'args': (), + 'callable': None, + 'discriminator': 'discrim', + 'includepath': (), + 'info': 'z', + 'introspectables': (), + 'kw': {'a': 1}, + 'order': 0, + }, + ) + ], + ) def test_action_branching_nonautocommit_with_introspectables(self): config = self._makeOne(autocommit=False) @@ -914,8 +1061,7 @@ tests.test_config.dummy_include2""", state.autocommit = False intr = DummyIntrospectable() config.action('discrim', introspectables=(intr,)) - self.assertEqual( - state.actions[0][1]['introspectables'], (intr,)) + self.assertEqual(state.actions[0][1]['introspectables'], (intr,)) def test_action_nonautocommit_with_introspectables_introspection_off(self): config = self._makeOne(autocommit=False) @@ -927,14 +1073,14 @@ tests.test_config.dummy_include2""", state.autocommit = False intr = DummyIntrospectable() config.action('discrim', introspectables=(intr,)) - self.assertEqual( - state.actions[0][1]['introspectables'], ()) - + self.assertEqual(state.actions[0][1]['introspectables'], ()) + def test_scan_integration(self): from zope.interface import alsoProvides from pyramid.interfaces import IRequest from pyramid.view import render_view_to_response import tests.test_config.pkgs.scannable as package + config = self._makeOne(autocommit=True) config.scan(package) @@ -951,13 +1097,13 @@ tests.test_config.dummy_include2""", result = render_view_to_response(ctx, req, '') self.assertEqual(result, 'grokked_post') - result= render_view_to_response(ctx, req, 'grokked_class') + result = render_view_to_response(ctx, req, 'grokked_class') self.assertEqual(result, 'grokked_class') - result= render_view_to_response(ctx, req, 'grokked_instance') + result = render_view_to_response(ctx, req, 'grokked_instance') self.assertEqual(result, 'grokked_instance') - result= render_view_to_response(ctx, req, 'oldstyle_grokked_class') + result = render_view_to_response(ctx, req, 'oldstyle_grokked_class') self.assertEqual(result, 'oldstyle_grokked_class') req.method = 'GET' @@ -968,14 +1114,15 @@ tests.test_config.dummy_include2""", result = render_view_to_response(ctx, req, 'another') self.assertEqual(result, 'another_grokked_post') - result= render_view_to_response(ctx, req, 'another_grokked_class') + result = render_view_to_response(ctx, req, 'another_grokked_class') self.assertEqual(result, 'another_grokked_class') - result= render_view_to_response(ctx, req, 'another_grokked_instance') + result = render_view_to_response(ctx, req, 'another_grokked_instance') self.assertEqual(result, 'another_grokked_instance') - result= render_view_to_response(ctx, req, - 'another_oldstyle_grokked_class') + result = render_view_to_response( + ctx, req, 'another_oldstyle_grokked_class' + ) self.assertEqual(result, 'another_oldstyle_grokked_class') result = render_view_to_response(ctx, req, 'stacked1') @@ -1007,8 +1154,9 @@ tests.test_config.dummy_include2""", # assertion may fail there. We don't support Jython at the moment, # this is just a note to a future self. - self.assertRaises(TypeError, - render_view_to_response, ctx, req, 'basemethod') + self.assertRaises( + TypeError, render_view_to_response, ctx, req, 'basemethod' + ) result = render_view_to_response(ctx, req, 'method1') self.assertEqual(result, 'method1') @@ -1039,9 +1187,9 @@ tests.test_config.dummy_include2""", from pyramid.interfaces import IRequest from pyramid.view import render_view_to_response import tests.test_config.pkgs.scannable as package + config = self._makeOne(autocommit=True) - config.scan(package, - ignore='tests.test_config.pkgs.scannable.another') + config.scan(package, ignore='tests.test_config.pkgs.scannable.another') ctx = DummyContext() req = DummyRequest() @@ -1055,11 +1203,12 @@ tests.test_config.dummy_include2""", # ignored v = render_view_to_response(ctx, req, 'another_stacked_class2') self.assertEqual(v, None) - + def test_scan_integration_dottedname_package(self): from zope.interface import alsoProvides from pyramid.interfaces import IRequest from pyramid.view import render_view_to_response + config = self._makeOne(autocommit=True) config.scan('tests.test_config.pkgs.scannable') @@ -1081,45 +1230,56 @@ tests.test_config.dummy_include2""", # fancy sys.path manipulation here to appease "setup.py test" which # fails miserably when it can't import something in the package import sys + try: here = os.path.dirname(__file__) path = os.path.join(here, 'path') sys.path.append(path) config = self._makeOne(autocommit=True) + class FooException(Exception): pass + def onerror(name): raise FooException - self.assertRaises(FooException, config.scan, 'scanerror', - onerror=onerror) + + self.assertRaises( + FooException, config.scan, 'scanerror', onerror=onerror + ) finally: sys.path.remove(path) def test_scan_integration_conflict(self): from tests.test_config.pkgs import selfscan from pyramid.config import Configurator + c = Configurator() c.scan(selfscan) c.scan(selfscan) try: c.commit() except ConfigurationConflictError as why: + def scanconflicts(e): conflicts = e._conflicts.values() for conflict in conflicts: for confinst in conflict: yield confinst.src + which = list(scanconflicts(why)) self.assertEqual(len(which), 4) self.assertTrue("@view_config(renderer='string')" in which) - self.assertTrue("@view_config(name='two', renderer='string')" in - which) + self.assertTrue( + "@view_config(name='two', renderer='string')" in which + ) @skip_on('py3') def test_hook_zca(self): from zope.component import getSiteManager + def foo(): '123' + try: config = self._makeOne() config.hook_zca() @@ -1132,8 +1292,10 @@ tests.test_config.dummy_include2""", @skip_on('py3') def test_unhook_zca(self): from zope.component import getSiteManager + def foo(): '123' + try: getSiteManager.sethook(foo) config = self._makeOne() @@ -1145,18 +1307,29 @@ tests.test_config.dummy_include2""", def test_commit_conflict_simple(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass + + def view1(request): + pass + + def view2(request): + pass + config.add_view(view1) config.add_view(view2) self.assertRaises(ConfigurationConflictError, config.commit) def test_commit_conflict_resolved_with_include(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass + + def view1(request): + pass + + def view2(request): + pass + def includeme(config): config.add_view(view2) + config.add_view(view1) config.include(includeme) config.commit() @@ -1165,12 +1338,19 @@ tests.test_config.dummy_include2""", def test_commit_conflict_with_two_includes(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass + + def view1(request): + pass + + def view2(request): + pass + def includeme1(config): config.add_view(view1) + def includeme2(config): config.add_view(view2) + config.include(includeme1) config.include(includeme2) try: @@ -1179,18 +1359,27 @@ tests.test_config.dummy_include2""", c1, c2 = _conflictFunctions(why) self.assertEqual(c1, 'includeme1') self.assertEqual(c2, 'includeme2') - else: #pragma: no cover + else: # pragma: no cover raise AssertionError def test_commit_conflict_resolved_with_two_includes_and_local(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass - def view3(request): pass + + def view1(request): + pass + + def view2(request): + pass + + def view3(request): + pass + def includeme1(config): config.add_view(view1) + def includeme2(config): config.add_view(view2) + config.include(includeme1) config.include(includeme2) config.add_view(view3) @@ -1200,10 +1389,18 @@ tests.test_config.dummy_include2""", def test_autocommit_no_conflicts(self): from pyramid.renderers import null_renderer + config = self._makeOne(autocommit=True) - def view1(request): pass - def view2(request): pass - def view3(request): pass + + def view1(request): + pass + + def view2(request): + pass + + def view3(request): + pass + config.add_view(view1, renderer=null_renderer) config.add_view(view2, renderer=null_renderer) config.add_view(view3, renderer=null_renderer) @@ -1213,8 +1410,13 @@ tests.test_config.dummy_include2""", def test_conflict_set_notfound_view(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass + + def view1(request): + pass + + def view2(request): + pass + config.set_notfound_view(view1) config.set_notfound_view(view2) try: @@ -1223,13 +1425,18 @@ tests.test_config.dummy_include2""", c1, c2 = _conflictFunctions(why) self.assertEqual(c1, 'test_conflict_set_notfound_view') self.assertEqual(c2, 'test_conflict_set_notfound_view') - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test_conflict_set_forbidden_view(self): config = self._makeOne() - def view1(request): pass - def view2(request): pass + + def view1(request): + pass + + def view2(request): + pass + config.set_forbidden_view(view1) config.set_forbidden_view(view2) try: @@ -1238,7 +1445,7 @@ tests.test_config.dummy_include2""", c1, c2 = _conflictFunctions(why) self.assertEqual(c1, 'test_conflict_set_forbidden_view') self.assertEqual(c2, 'test_conflict_set_forbidden_view') - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test___getattr__missing_when_directives_exist(self): @@ -1253,31 +1460,38 @@ tests.test_config.dummy_include2""", def test___getattr__matches(self): config = self._makeOne() - def foo(config): pass - directives = {'foo':(foo, True)} + + def foo(config): + pass + + directives = {'foo': (foo, True)} config.registry._directives = directives foo_meth = config.foo self.assertTrue(getattr(foo_meth, im_func).__docobj__ is foo) def test___getattr__matches_no_action_wrap(self): config = self._makeOne() - def foo(config): pass - directives = {'foo':(foo, False)} + + def foo(config): + pass + + directives = {'foo': (foo, False)} config.registry._directives = directives foo_meth = config.foo self.assertTrue(getattr(foo_meth, im_func) is foo) -class TestConfigurator_add_directive(unittest.TestCase): +class TestConfigurator_add_directive(unittest.TestCase): def setUp(self): from pyramid.config import Configurator + self.config = Configurator() def test_extend_with_dotted_name(self): from tests import test_config + config = self.config - config.add_directive( - 'dummy_extend', 'tests.test_config.dummy_extend') + config.add_directive('dummy_extend', 'tests.test_config.dummy_extend') self.assertTrue(hasattr(config, 'dummy_extend')) config.dummy_extend('discrim') after = config.action_state @@ -1288,9 +1502,11 @@ class TestConfigurator_add_directive(unittest.TestCase): def test_add_directive_with_partial(self): from tests import test_config + config = self.config config.add_directive( - 'dummy_partial', 'tests.test_config.dummy_partial') + 'dummy_partial', 'tests.test_config.dummy_partial' + ) self.assertTrue(hasattr(config, 'dummy_partial')) config.dummy_partial() after = config.action_state @@ -1301,9 +1517,11 @@ class TestConfigurator_add_directive(unittest.TestCase): def test_add_directive_with_custom_callable(self): from tests import test_config + config = self.config config.add_directive( - 'dummy_callable', 'tests.test_config.dummy_callable') + 'dummy_callable', 'tests.test_config.dummy_callable' + ) self.assertTrue(hasattr(config, 'dummy_callable')) config.dummy_callable('discrim') after = config.action_state @@ -1314,9 +1532,9 @@ class TestConfigurator_add_directive(unittest.TestCase): def test_extend_with_python_callable(self): from tests import test_config + config = self.config - config.add_directive( - 'dummy_extend', dummy_extend) + config.add_directive('dummy_extend', dummy_extend) self.assertTrue(hasattr(config, 'dummy_extend')) config.dummy_extend('discrim') after = config.action_state @@ -1327,10 +1545,8 @@ class TestConfigurator_add_directive(unittest.TestCase): def test_extend_same_name_doesnt_conflict(self): config = self.config - config.add_directive( - 'dummy_extend', dummy_extend) - config.add_directive( - 'dummy_extend', dummy_extend2) + config.add_directive('dummy_extend', dummy_extend) + config.add_directive('dummy_extend', dummy_extend2) self.assertTrue(hasattr(config, 'dummy_extend')) config.dummy_extend('discrim') after = config.action_state @@ -1341,8 +1557,7 @@ class TestConfigurator_add_directive(unittest.TestCase): def test_extend_action_method_successful(self): config = self.config - config.add_directive( - 'dummy_extend', dummy_extend) + config.add_directive('dummy_extend', dummy_extend) config.dummy_extend('discrim') config.dummy_extend('discrim') self.assertRaises(ConfigurationConflictError, config.commit) @@ -1360,16 +1575,25 @@ class TestConfigurator_add_directive(unittest.TestCase): self.assertEqual(action['callable'], None) self.assertEqual(action['args'], config2.package) + class TestConfigurator__add_predicate(unittest.TestCase): def _makeOne(self): from pyramid.config import Configurator + return Configurator() def test_factory_as_object(self): config = self._makeOne() - def _fakeAction(discriminator, callable=None, args=(), kw=None, - order=0, introspectables=(), **extra): + def _fakeAction( + discriminator, + callable=None, + args=(), + kw=None, + order=0, + introspectables=(), + **extra + ): self.assertEqual(len(introspectables), 1) self.assertEqual(introspectables[0]['name'], 'testing') self.assertEqual(introspectables[0]['factory'], DummyPredicate) @@ -1380,63 +1604,82 @@ class TestConfigurator__add_predicate(unittest.TestCase): def test_factory_as_dotted_name(self): config = self._makeOne() - def _fakeAction(discriminator, callable=None, args=(), - kw=None, order=0, introspectables=(), **extra): + def _fakeAction( + discriminator, + callable=None, + args=(), + kw=None, + order=0, + introspectables=(), + **extra + ): self.assertEqual(len(introspectables), 1) self.assertEqual(introspectables[0]['name'], 'testing') self.assertEqual(introspectables[0]['factory'], DummyPredicate) config.action = _fakeAction config._add_predicate( - 'route', - 'testing', - 'tests.test_config.test_init.DummyPredicate' - ) - + 'route', 'testing', 'tests.test_config.test_init.DummyPredicate' + ) + + class TestActionState(unittest.TestCase): def _makeOne(self): from pyramid.config import ActionState + return ActionState() - + def test_it(self): c = self._makeOne() self.assertEqual(c.actions, []) def test_action_simple(self): from . import dummyfactory as f + c = self._makeOne() c.actions = [] - c.action(1, f, (1,), {'x':1}) + c.action(1, f, (1,), {'x': 1}) self.assertEqual( c.actions, - [{'args': (1,), - 'callable': f, - 'discriminator': 1, - 'includepath': (), - 'info': None, - 'introspectables': (), - 'kw': {'x': 1}, - 'order': 0}]) + [ + { + 'args': (1,), + 'callable': f, + 'discriminator': 1, + 'includepath': (), + 'info': None, + 'introspectables': (), + 'kw': {'x': 1}, + 'order': 0, + } + ], + ) c.action(None) self.assertEqual( c.actions, - [{'args': (1,), - 'callable': f, - 'discriminator': 1, - 'includepath': (), - 'info': None, - 'introspectables': (), - 'kw': {'x': 1}, - 'order': 0}, - - {'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': (), - 'info': None, - 'introspectables': (), - 'kw': {}, - 'order': 0},]) + [ + { + 'args': (1,), + 'callable': f, + 'discriminator': 1, + 'includepath': (), + 'info': None, + 'introspectables': (), + 'kw': {'x': 1}, + 'order': 0, + }, + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': (), + 'info': None, + 'introspectables': (), + 'kw': {}, + 'order': 0, + }, + ], + ) def test_action_with_includepath(self): c = self._makeOne() @@ -1444,42 +1687,57 @@ class TestActionState(unittest.TestCase): c.action(None, includepath=('abc',)) self.assertEqual( c.actions, - [{'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': ('abc',), - 'info': None, - 'introspectables': (), - 'kw': {}, - 'order': 0}]) + [ + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': ('abc',), + 'info': None, + 'introspectables': (), + 'kw': {}, + 'order': 0, + } + ], + ) def test_action_with_info(self): c = self._makeOne() c.action(None, info='abc') self.assertEqual( c.actions, - [{'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': (), - 'info': 'abc', - 'introspectables': (), - 'kw': {}, - 'order': 0}]) + [ + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': (), + 'info': 'abc', + 'introspectables': (), + 'kw': {}, + 'order': 0, + } + ], + ) def test_action_with_includepath_and_info(self): c = self._makeOne() c.action(None, includepath=('spec',), info='bleh') self.assertEqual( c.actions, - [{'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': ('spec',), - 'info': 'bleh', - 'introspectables': (), - 'kw': {}, - 'order': 0}]) + [ + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': ('spec',), + 'info': 'bleh', + 'introspectables': (), + 'kw': {}, + 'order': 0, + } + ], + ) def test_action_with_order(self): c = self._makeOne() @@ -1487,14 +1745,19 @@ class TestActionState(unittest.TestCase): c.action(None, order=99999) self.assertEqual( c.actions, - [{'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': (), - 'info': None, - 'introspectables': (), - 'kw': {}, - 'order': 99999}]) + [ + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': (), + 'info': None, + 'introspectables': (), + 'kw': {}, + 'order': 99999, + } + ], + ) def test_action_with_introspectables(self): c = self._makeOne() @@ -1503,14 +1766,19 @@ class TestActionState(unittest.TestCase): c.action(None, introspectables=(intr,)) self.assertEqual( c.actions, - [{'args': (), - 'callable': None, - 'discriminator': None, - 'includepath': (), - 'info': None, - 'introspectables': (intr,), - 'kw': {}, - 'order': 0}]) + [ + { + 'args': (), + 'callable': None, + 'discriminator': None, + 'includepath': (), + 'info': None, + 'introspectables': (intr,), + 'kw': {}, + 'order': 0, + } + ], + ) def test_processSpec(self): c = self._makeOne() @@ -1519,190 +1787,269 @@ class TestActionState(unittest.TestCase): def test_execute_actions_tuples(self): output = [] + def f(*a, **k): output.append((a, k)) + c = self._makeOne() c.actions = [ (1, f, (1,)), - (1, f, (11,), {}, ('x', )), + (1, f, (11,), {}, ('x',)), (2, f, (2,)), (None, None), - ] + ] c.execute_actions() - self.assertEqual(output, [((1,), {}), ((2,), {})]) + self.assertEqual(output, [((1,), {}), ((2,), {})]) def test_execute_actions_dicts(self): output = [] + def f(*a, **k): output.append((a, k)) + c = self._makeOne() c.actions = [ - {'discriminator':1, 'callable':f, 'args':(1,), 'kw':{}, - 'order':0, 'includepath':(), 'info':None, - 'introspectables':()}, - {'discriminator':1, 'callable':f, 'args':(11,), 'kw':{}, - 'includepath':('x',), 'order': 0, 'info':None, - 'introspectables':()}, - {'discriminator':2, 'callable':f, 'args':(2,), 'kw':{}, - 'order':0, 'includepath':(), 'info':None, - 'introspectables':()}, - {'discriminator':None, 'callable':None, 'args':(), 'kw':{}, - 'order':0, 'includepath':(), 'info':None, - 'introspectables':()}, - ] + { + 'discriminator': 1, + 'callable': f, + 'args': (1,), + 'kw': {}, + 'order': 0, + 'includepath': (), + 'info': None, + 'introspectables': (), + }, + { + 'discriminator': 1, + 'callable': f, + 'args': (11,), + 'kw': {}, + 'includepath': ('x',), + 'order': 0, + 'info': None, + 'introspectables': (), + }, + { + 'discriminator': 2, + 'callable': f, + 'args': (2,), + 'kw': {}, + 'order': 0, + 'includepath': (), + 'info': None, + 'introspectables': (), + }, + { + 'discriminator': None, + 'callable': None, + 'args': (), + 'kw': {}, + 'order': 0, + 'includepath': (), + 'info': None, + 'introspectables': (), + }, + ] c.execute_actions() - self.assertEqual(output, [((1,), {}), ((2,), {})]) + self.assertEqual(output, [((1,), {}), ((2,), {})]) def test_execute_actions_with_introspectables(self): output = [] + def f(*a, **k): output.append((a, k)) + c = self._makeOne() intr = DummyIntrospectable() c.actions = [ - {'discriminator':1, 'callable':f, 'args':(1,), 'kw':{}, - 'order':0, 'includepath':(), 'info':None, - 'introspectables':(intr,)}, - ] + { + 'discriminator': 1, + 'callable': f, + 'args': (1,), + 'kw': {}, + 'order': 0, + 'includepath': (), + 'info': None, + 'introspectables': (intr,), + } + ] introspector = object() c.execute_actions(introspector=introspector) - self.assertEqual(output, [((1,), {})]) + self.assertEqual(output, [((1,), {})]) self.assertEqual(intr.registered, [(introspector, None)]) def test_execute_actions_with_introspectable_no_callable(self): c = self._makeOne() intr = DummyIntrospectable() c.actions = [ - {'discriminator':1, 'callable':None, 'args':(1,), 'kw':{}, - 'order':0, 'includepath':(), 'info':None, - 'introspectables':(intr,)}, - ] + { + 'discriminator': 1, + 'callable': None, + 'args': (1,), + 'kw': {}, + 'order': 0, + 'includepath': (), + 'info': None, + 'introspectables': (intr,), + } + ] introspector = object() c.execute_actions(introspector=introspector) self.assertEqual(intr.registered, [(introspector, None)]) def test_execute_actions_error(self): output = [] + def f(*a, **k): output.append(('f', a, k)) + def bad(): raise NotImplementedError + c = self._makeOne() c.actions = [ (1, f, (1,)), - (1, f, (11,), {}, ('x', )), + (1, f, (11,), {}, ('x',)), (2, f, (2,)), - (3, bad, (), {}, (), 'oops') - ] + (3, bad, (), {}, (), 'oops'), + ] self.assertRaises(ConfigurationExecutionError, c.execute_actions) self.assertEqual(output, [('f', (1,), {}), ('f', (2,), {})]) def test_reentrant_action(self): output = [] c = self._makeOne() + def f(*a, **k): output.append(('f', a, k)) c.actions.append((3, g, (8,), {})) + def g(*a, **k): output.append(('g', a, k)) - c.actions = [ - (1, f, (1,)), - ] + + c.actions = [(1, f, (1,))] c.execute_actions() self.assertEqual(output, [('f', (1,), {}), ('g', (8,), {})]) def test_reentrant_action_with_deferred_discriminator(self): # see https://github.com/Pylons/pyramid/issues/2697 from pyramid.registry import Deferred + output = [] c = self._makeOne() + def f(*a, **k): output.append(('f', a, k)) c.actions.append((4, g, (4,), {}, (), None, 2)) + def g(*a, **k): output.append(('g', a, k)) + def h(*a, **k): output.append(('h', a, k)) + def discrim(): self.assertEqual(output, [('f', (1,), {}), ('g', (2,), {})]) return 3 + d = Deferred(discrim) c.actions = [ - (d, h, (3,), {}, (), None, 1), # order 1 - (1, f, (1,)), # order 0 - (2, g, (2,)), # order 0 + (d, h, (3,), {}, (), None, 1), # order 1 + (1, f, (1,)), # order 0 + (2, g, (2,)), # order 0 ] c.execute_actions() - self.assertEqual(output, [ - ('f', (1,), {}), ('g', (2,), {}), ('h', (3,), {}), ('g', (4,), {})]) + self.assertEqual( + output, + [ + ('f', (1,), {}), + ('g', (2,), {}), + ('h', (3,), {}), + ('g', (4,), {}), + ], + ) def test_reentrant_action_error(self): from pyramid.exceptions import ConfigurationError + c = self._makeOne() + def f(*a, **k): c.actions.append((3, g, (8,), {}, (), None, -1)) - def g(*a, **k): pass - c.actions = [ - (1, f, (1,)), - ] + + def g(*a, **k): + pass + + c.actions = [(1, f, (1,))] self.assertRaises(ConfigurationError, c.execute_actions) def test_reentrant_action_without_clear(self): c = self._makeOne() + def f(*a, **k): c.actions.append((3, g, (8,))) - def g(*a, **k): pass - c.actions = [ - (1, f, (1,)), - ] + + def g(*a, **k): + pass + + c.actions = [(1, f, (1,))] c.execute_actions(clear=False) - self.assertEqual(c.actions, [ - (1, f, (1,)), - (3, g, (8,)), - ]) + self.assertEqual(c.actions, [(1, f, (1,)), (3, g, (8,))]) def test_executing_conflicting_action_across_orders(self): from pyramid.exceptions import ConfigurationConflictError + c = self._makeOne() - def f(*a, **k): pass - def g(*a, **k): pass - c.actions = [ - (1, f, (1,), {}, (), None, -1), - (1, g, (2,)), - ] + + def f(*a, **k): + pass + + def g(*a, **k): + pass + + c.actions = [(1, f, (1,), {}, (), None, -1), (1, g, (2,))] self.assertRaises(ConfigurationConflictError, c.execute_actions) def test_executing_conflicting_action_across_reentrant_orders(self): from pyramid.exceptions import ConfigurationConflictError + c = self._makeOne() + def f(*a, **k): c.actions.append((1, g, (8,))) - def g(*a, **k): pass - c.actions = [ - (1, f, (1,), {}, (), None, -1), - ] + + def g(*a, **k): + pass + + c.actions = [(1, f, (1,), {}, (), None, -1)] self.assertRaises(ConfigurationConflictError, c.execute_actions) + class Test_reentrant_action_functional(unittest.TestCase): def _makeConfigurator(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_functional(self): def add_auto_route(config, name, view): - def register(): - config.add_view(route_name=name, view=view) - config.add_route(name, '/' + name) - config.action( - ('auto route', name), register, order=-30 - ) + def register(): + config.add_view(route_name=name, view=view) + config.add_route(name, '/' + name) + + config.action(('auto route', name), register, order=-30) + config = self._makeConfigurator() config.add_directive('add_auto_route', add_auto_route) - def my_view(request): return request.response + + def my_view(request): + return request.response + config.add_auto_route('foo', my_view) config.commit() from pyramid.interfaces import IRoutesMapper + mapper = config.registry.getUtility(IRoutesMapper) routes = mapper.get_routes() route = routes[0] @@ -1713,291 +2060,352 @@ class Test_reentrant_action_functional(unittest.TestCase): def test_deferred_discriminator(self): # see https://github.com/Pylons/pyramid/issues/2697 from pyramid.config import PHASE0_CONFIG + config = self._makeConfigurator() - def deriver(view, info): return view + + def deriver(view, info): + return view + deriver.options = ('foo',) config.add_view_deriver(deriver, 'foo_view') # add_view uses a deferred discriminator and will fail if executed # prior to add_view_deriver executing its action config.add_view(lambda r: r.response, name='', foo=1) + def dummy_action(): # trigger a re-entrant action config.action(None, lambda: None) + config.action(None, dummy_action, order=PHASE0_CONFIG) config.commit() + class Test_resolveConflicts(unittest.TestCase): def _callFUT(self, actions): from pyramid.config import resolveConflicts + return resolveConflicts(actions) def test_it_success_tuples(self): from . import dummyfactory as f - result = self._callFUT([ - (None, f), - (1, f, (1,), {}, (), 'first'), - (1, f, (2,), {}, ('x',), 'second'), - (1, f, (3,), {}, ('y',), 'third'), - (4, f, (4,), {}, ('y',), 'should be last', 99999), - (3, f, (3,), {}, ('y',)), - (None, f, (5,), {}, ('y',)), - ]) + + result = self._callFUT( + [ + (None, f), + (1, f, (1,), {}, (), 'first'), + (1, f, (2,), {}, ('x',), 'second'), + (1, f, (3,), {}, ('y',), 'third'), + (4, f, (4,), {}, ('y',), 'should be last', 99999), + (3, f, (3,), {}, ('y',)), + (None, f, (5,), {}, ('y',)), + ] + ) result = list(result) self.assertEqual( result, - [{'info': None, - 'args': (), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': None, - 'includepath': (), - 'order': 0}, - - {'info': 'first', - 'args': (1,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 1, - 'includepath': (), - 'order': 0}, - - {'info': None, - 'args': (3,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 3, - 'includepath': ('y',), - 'order': 0}, - - {'info': None, - 'args': (5,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': None, - 'includepath': ('y',), - 'order': 0}, - - {'info': 'should be last', - 'args': (4,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 4, - 'includepath': ('y',), - 'order': 99999} - ] - ) + [ + { + 'info': None, + 'args': (), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': None, + 'includepath': (), + 'order': 0, + }, + { + 'info': 'first', + 'args': (1,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 1, + 'includepath': (), + 'order': 0, + }, + { + 'info': None, + 'args': (3,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 3, + 'includepath': ('y',), + 'order': 0, + }, + { + 'info': None, + 'args': (5,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': None, + 'includepath': ('y',), + 'order': 0, + }, + { + 'info': 'should be last', + 'args': (4,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 4, + 'includepath': ('y',), + 'order': 99999, + }, + ], + ) def test_it_success_dicts(self): from . import dummyfactory as f - result = self._callFUT([ - (None, f), - (1, f, (1,), {}, (), 'first'), - (1, f, (2,), {}, ('x',), 'second'), - (1, f, (3,), {}, ('y',), 'third'), - (4, f, (4,), {}, ('y',), 'should be last', 99999), - (3, f, (3,), {}, ('y',)), - (None, f, (5,), {}, ('y',)), - ]) + + result = self._callFUT( + [ + (None, f), + (1, f, (1,), {}, (), 'first'), + (1, f, (2,), {}, ('x',), 'second'), + (1, f, (3,), {}, ('y',), 'third'), + (4, f, (4,), {}, ('y',), 'should be last', 99999), + (3, f, (3,), {}, ('y',)), + (None, f, (5,), {}, ('y',)), + ] + ) result = list(result) self.assertEqual( result, - [{'info': None, - 'args': (), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': None, - 'includepath': (), - 'order': 0}, - - {'info': 'first', - 'args': (1,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 1, - 'includepath': (), - 'order': 0}, - - {'info': None, - 'args': (3,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 3, - 'includepath': ('y',), - 'order': 0}, - - {'info': None, - 'args': (5,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': None, - 'includepath': ('y',), - 'order': 0}, - - {'info': 'should be last', - 'args': (4,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 4, - 'includepath': ('y',), - 'order': 99999} - ] - ) + [ + { + 'info': None, + 'args': (), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': None, + 'includepath': (), + 'order': 0, + }, + { + 'info': 'first', + 'args': (1,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 1, + 'includepath': (), + 'order': 0, + }, + { + 'info': None, + 'args': (3,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 3, + 'includepath': ('y',), + 'order': 0, + }, + { + 'info': None, + 'args': (5,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': None, + 'includepath': ('y',), + 'order': 0, + }, + { + 'info': 'should be last', + 'args': (4,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 4, + 'includepath': ('y',), + 'order': 99999, + }, + ], + ) def test_it_conflict(self): from . import dummyfactory as f - result = self._callFUT([ - (None, f), - (1, f, (2,), {}, ('x',), 'eek'), # will conflict - (1, f, (3,), {}, ('y',), 'ack'), # will conflict - (4, f, (4,), {}, ('y',)), - (3, f, (3,), {}, ('y',)), - (None, f, (5,), {}, ('y',)), - ]) + + result = self._callFUT( + [ + (None, f), + (1, f, (2,), {}, ('x',), 'eek'), # will conflict + (1, f, (3,), {}, ('y',), 'ack'), # will conflict + (4, f, (4,), {}, ('y',)), + (3, f, (3,), {}, ('y',)), + (None, f, (5,), {}, ('y',)), + ] + ) self.assertRaises(ConfigurationConflictError, list, result) def test_it_with_actions_grouped_by_order(self): from . import dummyfactory as f - result = self._callFUT([ - (None, f), # X - (1, f, (1,), {}, (), 'third', 10), # X - (1, f, (2,), {}, ('x',), 'fourth', 10), - (1, f, (3,), {}, ('y',), 'fifth', 10), - (2, f, (1,), {}, (), 'sixth', 10), # X - (3, f, (1,), {}, (), 'seventh', 10), # X - (5, f, (4,), {}, ('y',), 'eighth', 99999), # X - (4, f, (3,), {}, (), 'first', 5), # X - (4, f, (5,), {}, ('y',), 'second', 5), - ]) + + result = self._callFUT( + [ + (None, f), # X + (1, f, (1,), {}, (), 'third', 10), # X + (1, f, (2,), {}, ('x',), 'fourth', 10), + (1, f, (3,), {}, ('y',), 'fifth', 10), + (2, f, (1,), {}, (), 'sixth', 10), # X + (3, f, (1,), {}, (), 'seventh', 10), # X + (5, f, (4,), {}, ('y',), 'eighth', 99999), # X + (4, f, (3,), {}, (), 'first', 5), # X + (4, f, (5,), {}, ('y',), 'second', 5), + ] + ) result = list(result) self.assertEqual(len(result), 6) # resolved actions should be grouped by (order, i) self.assertEqual( result, - [{'info': None, - 'args': (), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': None, - 'includepath': (), - 'order': 0}, - - {'info': 'first', - 'args': (3,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 4, - 'includepath': (), - 'order': 5}, - - {'info': 'third', - 'args': (1,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 1, - 'includepath': (), - 'order': 10}, - - {'info': 'sixth', - 'args': (1,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 2, - 'includepath': (), - 'order': 10}, - - {'info': 'seventh', - 'args': (1,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 3, - 'includepath': (), - 'order': 10}, - - {'info': 'eighth', - 'args': (4,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 5, - 'includepath': ('y',), - 'order': 99999} - ] - ) + [ + { + 'info': None, + 'args': (), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': None, + 'includepath': (), + 'order': 0, + }, + { + 'info': 'first', + 'args': (3,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 4, + 'includepath': (), + 'order': 5, + }, + { + 'info': 'third', + 'args': (1,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 1, + 'includepath': (), + 'order': 10, + }, + { + 'info': 'sixth', + 'args': (1,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 2, + 'includepath': (), + 'order': 10, + }, + { + 'info': 'seventh', + 'args': (1,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 3, + 'includepath': (), + 'order': 10, + }, + { + 'info': 'eighth', + 'args': (4,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 5, + 'includepath': ('y',), + 'order': 99999, + }, + ], + ) def test_override_success_across_orders(self): from . import dummyfactory as f - result = self._callFUT([ - (1, f, (2,), {}, ('x',), 'eek', 0), - (1, f, (3,), {}, ('x', 'y'), 'ack', 10), - ]) + + result = self._callFUT( + [ + (1, f, (2,), {}, ('x',), 'eek', 0), + (1, f, (3,), {}, ('x', 'y'), 'ack', 10), + ] + ) result = list(result) - self.assertEqual(result, [ - {'info': 'eek', - 'args': (2,), - 'callable': f, - 'introspectables': (), - 'kw': {}, - 'discriminator': 1, - 'includepath': ('x',), - 'order': 0}, - ]) + self.assertEqual( + result, + [ + { + 'info': 'eek', + 'args': (2,), + 'callable': f, + 'introspectables': (), + 'kw': {}, + 'discriminator': 1, + 'includepath': ('x',), + 'order': 0, + } + ], + ) def test_conflicts_across_orders(self): from . import dummyfactory as f - result = self._callFUT([ - (1, f, (2,), {}, ('x', 'y'), 'eek', 0), - (1, f, (3,), {}, ('x'), 'ack', 10), - ]) + + result = self._callFUT( + [ + (1, f, (2,), {}, ('x', 'y'), 'eek', 0), + (1, f, (3,), {}, ('x'), 'ack', 10), + ] + ) self.assertRaises(ConfigurationConflictError, list, result) + class TestGlobalRegistriesIntegration(unittest.TestCase): def setUp(self): from pyramid.config import global_registries + global_registries.empty() tearDown = setUp def _makeConfigurator(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_global_registries_empty(self): from pyramid.config import global_registries + self.assertEqual(global_registries.last, None) def test_global_registries(self): from pyramid.config import global_registries + config1 = self._makeConfigurator() config1.make_wsgi_app() self.assertEqual(global_registries.last, config1.registry) config2 = self._makeConfigurator() config2.make_wsgi_app() self.assertEqual(global_registries.last, config2.registry) - self.assertEqual(list(global_registries), - [config1.registry, config2.registry]) + self.assertEqual( + list(global_registries), [config1.registry, config2.registry] + ) global_registries.remove(config2.registry) self.assertEqual(global_registries.last, config1.registry) + class DummyRequest: subpath = () matchdict = None request_iface = IRequest + def __init__(self, environ=None): if environ is None: environ = {} @@ -2005,63 +2413,86 @@ class DummyRequest: self.params = {} self.cookies = {} + class DummyThreadLocalManager(object): def __init__(self): self.pushed = {'registry': None, 'request': None} self.popped = False + def push(self, d): self.pushed = d + def get(self): return self.pushed + def pop(self): self.popped = True + from zope.interface import implementer + + @implementer(IDummy) class DummyEvent: pass + class DummyRegistry(object): def __init__(self, adaptation=None, util=None): self.utilities = [] self.adapters = [] self.adaptation = adaptation self.util = util + def subscribers(self, events, name): self.events = events return events + def registerUtility(self, *arg, **kw): self.utilities.append((arg, kw)) + def registerAdapter(self, *arg, **kw): self.adapters.append((arg, kw)) + def queryAdapter(self, *arg, **kw): return self.adaptation + def queryUtility(self, *arg, **kw): return self.util + from zope.interface import Interface + + class IOther(Interface): pass + def _conflictFunctions(e): conflicts = e._conflicts.values() for conflict in conflicts: for confinst in conflict: yield confinst.function + class DummyActionState(object): autocommit = False info = '' + def __init__(self): self.actions = [] + def action(self, *arg, **kw): self.actions.append((arg, kw)) + class DummyIntrospectable(object): def __init__(self): self.registered = [] + def register(self, introspector, action_info): self.registered.append((introspector, action_info)) - + + class DummyPredicate(object): pass diff --git a/tests/test_config/test_rendering.py b/tests/test_config/test_rendering.py index 8794fa9df..a33977c28 100644 --- a/tests/test_config/test_rendering.py +++ b/tests/test_config/test_rendering.py @@ -1,34 +1,43 @@ import unittest + class TestRenderingConfiguratorMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_add_default_renderers(self): from pyramid.config.rendering import DEFAULT_RENDERERS from pyramid.interfaces import IRendererFactory + config = self._makeOne(autocommit=True) config.add_default_renderers() for name, impl in DEFAULT_RENDERERS: self.assertTrue( - config.registry.queryUtility(IRendererFactory, name) is not None - ) + config.registry.queryUtility(IRendererFactory, name) + is not None + ) def test_add_renderer(self): from pyramid.interfaces import IRendererFactory + config = self._makeOne(autocommit=True) renderer = object() config.add_renderer('name', renderer) - self.assertEqual(config.registry.getUtility(IRendererFactory, 'name'), - renderer) + self.assertEqual( + config.registry.getUtility(IRendererFactory, 'name'), renderer + ) def test_add_renderer_dottedname_factory(self): from pyramid.interfaces import IRendererFactory + config = self._makeOne(autocommit=True) import tests.test_config - config.add_renderer('name', 'tests.test_config') - self.assertEqual(config.registry.getUtility(IRendererFactory, 'name'), - tests.test_config) + config.add_renderer('name', 'tests.test_config') + self.assertEqual( + config.registry.getUtility(IRendererFactory, 'name'), + tests.test_config, + ) diff --git a/tests/test_config/test_routes.py b/tests/test_config/test_routes.py index 870abe0ee..0999f8072 100644 --- a/tests/test_config/test_routes.py +++ b/tests/test_config/test_routes.py @@ -4,14 +4,17 @@ from . import dummyfactory from . import DummyContext from pyramid.compat import text_ + class RoutesConfiguratorMixinTests(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def _assertRoute(self, config, name, path, num_predicates=0): from pyramid.interfaces import IRoutesMapper + mapper = config.registry.getUtility(IRoutesMapper) routes = mapper.get_routes() route = routes[0] @@ -33,6 +36,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_get_routes_mapper_already_registered(self): from pyramid.interfaces import IRoutesMapper + config = self._makeOne() mapper = object() config.registry.registerUtility(mapper, IRoutesMapper) @@ -53,8 +57,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_discriminator(self): config = self._makeOne() config.add_route('name', 'path') - self.assertEqual(config.action_state.actions[-1]['discriminator'], - ('route', 'name')) + self.assertEqual( + config.action_state.actions[-1]['discriminator'], ('route', 'name') + ) def test_add_route_with_factory(self): config = self._makeOne(autocommit=True) @@ -68,13 +73,13 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): config.add_route('name', 'path/{foo}', static=True) mapper = config.get_routes_mapper() self.assertEqual(len(mapper.get_routes()), 0) - self.assertEqual(mapper.generate('name', {"foo":"a"}), '/path/a') + self.assertEqual(mapper.generate('name', {"foo": "a"}), '/path/a') def test_add_route_with_factory_dottedname(self): config = self._makeOne(autocommit=True) config.add_route( - 'name', 'path', - factory='tests.test_config.dummyfactory') + 'name', 'path', factory='tests.test_config.dummyfactory' + ) route = self._assertRoute(config, 'name', 'path') self.assertEqual(route.factory, dummyfactory) @@ -116,8 +121,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_with_path_info_highorder(self): config = self._makeOne(autocommit=True) - config.add_route('name', 'path', - path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8')) + config.add_route( + 'name', 'path', path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8') + ) route = self._assertRoute(config, 'name', 'path', 1) predicate = route.predicates[0] request = self._makeRequest(config) @@ -129,8 +135,9 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_with_path_info_regex(self): config = self._makeOne(autocommit=True) - config.add_route('name', 'path', - path_info=text_(br'/La Pe\w*', 'utf-8')) + config.add_route( + 'name', 'path', path_info=text_(br'/La Pe\w*', 'utf-8') + ) route = self._assertRoute(config, 'name', 'path', 1) predicate = route.predicates[0] request = self._makeRequest(config) @@ -146,7 +153,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): route = self._assertRoute(config, 'name', 'path', 1) predicate = route.predicates[0] request = self._makeRequest(config) - request.params = {'abc':'123'} + request.params = {'abc': '123'} self.assertEqual(predicate(None, request), True) request = self._makeRequest(config) request.params = {} @@ -154,9 +161,15 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_with_custom_predicates(self): import warnings + config = self._makeOne(autocommit=True) - def pred1(context, request): pass - def pred2(context, request): pass + + def pred1(context, request): + pass + + def pred2(context, request): + pass + with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') config.add_route('name', 'path', custom_predicates=(pred1, pred2)) @@ -170,7 +183,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): route = self._assertRoute(config, 'name', 'path', 1) predicate = route.predicates[0] request = self._makeRequest(config) - request.headers = {'Host':'example.com'} + request.headers = {'Host': 'example.com'} self.assertEqual(predicate(None, request), True) request = self._makeRequest(config) request.headers = {} @@ -222,6 +235,7 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_no_path_no_pattern(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() self.assertRaises(ConfigurationError, config.add_route, 'name') @@ -234,46 +248,52 @@ class RoutesConfiguratorMixinTests(unittest.TestCase): def test_add_route_no_view_with_view_attr(self): config = self._makeOne(autocommit=True) from pyramid.exceptions import ConfigurationError + try: config.add_route('name', '/pattern', view_attr='abc') except ConfigurationError: pass - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test_add_route_no_view_with_view_context(self): config = self._makeOne(autocommit=True) from pyramid.exceptions import ConfigurationError + try: config.add_route('name', '/pattern', view_context=DummyContext) except ConfigurationError: pass - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test_add_route_no_view_with_view_permission(self): config = self._makeOne(autocommit=True) from pyramid.exceptions import ConfigurationError + try: config.add_route('name', '/pattern', view_permission='edit') except ConfigurationError: pass - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test_add_route_no_view_with_view_renderer(self): config = self._makeOne(autocommit=True) from pyramid.exceptions import ConfigurationError + try: config.add_route('name', '/pattern', view_renderer='json') except ConfigurationError: pass - else: # pragma: no cover + else: # pragma: no cover raise AssertionError + class DummyRequest: subpath = () matchdict = None + def __init__(self, environ=None): if environ is None: environ = {} @@ -281,6 +301,7 @@ class DummyRequest: self.params = {} self.cookies = {} + class DummyAccept(object): def __init__(self, *matches, **kw): self.matches = list(matches) diff --git a/tests/test_config/test_security.py b/tests/test_config/test_security.py index 5db8e21fc..77f7f0440 100644 --- a/tests/test_config/test_security.py +++ b/tests/test_config/test_security.py @@ -3,9 +3,11 @@ import unittest from pyramid.exceptions import ConfigurationExecutionError from pyramid.exceptions import ConfigurationError + class ConfiguratorSecurityMethodsTests(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config @@ -18,12 +20,14 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): def test_set_authentication_policy_no_authz_policy_autocommit(self): config = self._makeOne(autocommit=True) policy = object() - self.assertRaises(ConfigurationError, - config.set_authentication_policy, policy) + self.assertRaises( + ConfigurationError, config.set_authentication_policy, policy + ) def test_set_authentication_policy_with_authz_policy(self): from pyramid.interfaces import IAuthenticationPolicy from pyramid.interfaces import IAuthorizationPolicy + config = self._makeOne() authn_policy = object() authz_policy = object() @@ -31,11 +35,13 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): config.set_authentication_policy(authn_policy) config.commit() self.assertEqual( - config.registry.getUtility(IAuthenticationPolicy), authn_policy) + config.registry.getUtility(IAuthenticationPolicy), authn_policy + ) def test_set_authentication_policy_with_authz_policy_autocommit(self): from pyramid.interfaces import IAuthenticationPolicy from pyramid.interfaces import IAuthorizationPolicy + config = self._makeOne(autocommit=True) authn_policy = object() authz_policy = object() @@ -43,7 +49,8 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): config.set_authentication_policy(authn_policy) config.commit() self.assertEqual( - config.registry.getUtility(IAuthenticationPolicy), authn_policy) + config.registry.getUtility(IAuthenticationPolicy), authn_policy + ) def test_set_authorization_policy_no_authn_policy(self): config = self._makeOne() @@ -53,15 +60,18 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): def test_set_authorization_policy_no_authn_policy_autocommit(self): from pyramid.interfaces import IAuthorizationPolicy + config = self._makeOne(autocommit=True) policy = object() config.set_authorization_policy(policy) self.assertEqual( - config.registry.getUtility(IAuthorizationPolicy), policy) + config.registry.getUtility(IAuthorizationPolicy), policy + ) def test_set_authorization_policy_with_authn_policy(self): from pyramid.interfaces import IAuthorizationPolicy from pyramid.interfaces import IAuthenticationPolicy + config = self._makeOne() authn_policy = object() authz_policy = object() @@ -69,25 +79,30 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): config.set_authorization_policy(authz_policy) config.commit() self.assertEqual( - config.registry.getUtility(IAuthorizationPolicy), authz_policy) + config.registry.getUtility(IAuthorizationPolicy), authz_policy + ) def test_set_authorization_policy_with_authn_policy_autocommit(self): from pyramid.interfaces import IAuthorizationPolicy from pyramid.interfaces import IAuthenticationPolicy + config = self._makeOne(autocommit=True) authn_policy = object() authz_policy = object() config.registry.registerUtility(authn_policy, IAuthenticationPolicy) config.set_authorization_policy(authz_policy) self.assertEqual( - config.registry.getUtility(IAuthorizationPolicy), authz_policy) + config.registry.getUtility(IAuthorizationPolicy), authz_policy + ) def test_set_default_permission(self): from pyramid.interfaces import IDefaultPermission + config = self._makeOne(autocommit=True) config.set_default_permission('view') - self.assertEqual(config.registry.getUtility(IDefaultPermission), - 'view') + self.assertEqual( + config.registry.getUtility(IDefaultPermission), 'view' + ) def test_add_permission(self): config = self._makeOne(autocommit=True) @@ -100,23 +115,34 @@ class ConfiguratorSecurityMethodsTests(unittest.TestCase): def test_set_default_csrf_options(self): from pyramid.interfaces import IDefaultCSRFOptions + config = self._makeOne(autocommit=True) config.set_default_csrf_options() result = config.registry.getUtility(IDefaultCSRFOptions) self.assertEqual(result.require_csrf, True) self.assertEqual(result.token, 'csrf_token') self.assertEqual(result.header, 'X-CSRF-Token') - self.assertEqual(list(sorted(result.safe_methods)), - ['GET', 'HEAD', 'OPTIONS', 'TRACE']) + self.assertEqual( + list(sorted(result.safe_methods)), + ['GET', 'HEAD', 'OPTIONS', 'TRACE'], + ) self.assertTrue(result.callback is None) def test_changing_set_default_csrf_options(self): from pyramid.interfaces import IDefaultCSRFOptions + config = self._makeOne(autocommit=True) - def callback(request): return True + + def callback(request): + return True + config.set_default_csrf_options( - require_csrf=False, token='DUMMY', header=None, - safe_methods=('PUT',), callback=callback) + require_csrf=False, + token='DUMMY', + header=None, + safe_methods=('PUT',), + callback=callback, + ) result = config.registry.getUtility(IDefaultCSRFOptions) self.assertEqual(result.require_csrf, False) self.assertEqual(result.token, 'DUMMY') diff --git a/tests/test_config/test_settings.py b/tests/test_config/test_settings.py index a3afd24e7..2fe769add 100644 --- a/tests/test_config/test_settings.py +++ b/tests/test_config/test_settings.py @@ -4,6 +4,7 @@ import unittest class TestSettingsConfiguratorMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config @@ -21,27 +22,29 @@ class TestSettingsConfiguratorMixin(unittest.TestCase): def test__set_settings_as_dictwithvalues(self): config = self._makeOne() - settings = config._set_settings({'a':'1'}) + settings = config._set_settings({'a': '1'}) self.assertEqual(settings['a'], '1') def test_get_settings_nosettings(self): from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg) self.assertEqual(config.get_settings(), None) def test_get_settings_withsettings(self): - settings = {'a':1} + settings = {'a': 1} config = self._makeOne() config.registry.settings = settings self.assertEqual(config.get_settings(), settings) def test_add_settings_settings_already_registered(self): from pyramid.registry import Registry + reg = Registry() config = self._makeOne(reg) - config._set_settings({'a':1}) - config.add_settings({'b':2}) + config._set_settings({'a': 1}) + config.add_settings({'b': 2}) settings = reg.settings self.assertEqual(settings['a'], 1) self.assertEqual(settings['b'], 2) @@ -49,15 +52,17 @@ class TestSettingsConfiguratorMixin(unittest.TestCase): def test_add_settings_settings_not_yet_registered(self): from pyramid.registry import Registry from pyramid.interfaces import ISettings + reg = Registry() config = self._makeOne(reg) - config.add_settings({'a':1}) + config.add_settings({'a': 1}) settings = reg.getUtility(ISettings) self.assertEqual(settings['a'], 1) def test_add_settings_settings_None(self): from pyramid.registry import Registry from pyramid.interfaces import ISettings + reg = Registry() config = self._makeOne(reg) config.add_settings(None, a=1) @@ -68,6 +73,7 @@ class TestSettingsConfiguratorMixin(unittest.TestCase): class ReadOnlyDict(dict): def __readonly__(self, *args, **kwargs): # pragma: no cover raise RuntimeError("Cannot modify ReadOnlyDict") + __setitem__ = __readonly__ __delitem__ = __readonly__ pop = __readonly__ @@ -83,9 +89,9 @@ class TestSettingsConfiguratorMixin(unittest.TestCase): class TestSettings(unittest.TestCase): - def _getTargetClass(self): from pyramid.config.settings import Settings + return Settings def _makeOne(self, d=None, environ=None): @@ -112,28 +118,30 @@ class TestSettings(unittest.TestCase): settings = self._makeOne({}) self.assertEqual(settings['prevent_http_cache'], False) self.assertEqual(settings['pyramid.prevent_http_cache'], False) - result = self._makeOne({'prevent_http_cache':'false'}) + result = self._makeOne({'prevent_http_cache': 'false'}) self.assertEqual(result['prevent_http_cache'], False) self.assertEqual(result['pyramid.prevent_http_cache'], False) - result = self._makeOne({'prevent_http_cache':'t'}) + result = self._makeOne({'prevent_http_cache': 't'}) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) - result = self._makeOne({'prevent_http_cache':'1'}) + result = self._makeOne({'prevent_http_cache': '1'}) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) - result = self._makeOne({'pyramid.prevent_http_cache':'t'}) + result = self._makeOne({'pyramid.prevent_http_cache': 't'}) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) - result = self._makeOne({}, {'PYRAMID_PREVENT_HTTP_CACHE':'1'}) + result = self._makeOne({}, {'PYRAMID_PREVENT_HTTP_CACHE': '1'}) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) - result = self._makeOne({'prevent_http_cache':'false', - 'pyramid.prevent_http_cache':'1'}) + result = self._makeOne( + {'prevent_http_cache': 'false', 'pyramid.prevent_http_cache': '1'} + ) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) - result = self._makeOne({'prevent_http_cache':'false', - 'pyramid.prevent_http_cache':'f'}, - {'PYRAMID_PREVENT_HTTP_CACHE':'1'}) + result = self._makeOne( + {'prevent_http_cache': 'false', 'pyramid.prevent_http_cache': 'f'}, + {'PYRAMID_PREVENT_HTTP_CACHE': '1'}, + ) self.assertEqual(result['prevent_http_cache'], True) self.assertEqual(result['pyramid.prevent_http_cache'], True) @@ -141,28 +149,30 @@ class TestSettings(unittest.TestCase): settings = self._makeOne({}) self.assertEqual(settings['prevent_cachebust'], False) self.assertEqual(settings['pyramid.prevent_cachebust'], False) - result = self._makeOne({'prevent_cachebust':'false'}) + result = self._makeOne({'prevent_cachebust': 'false'}) self.assertEqual(result['prevent_cachebust'], False) self.assertEqual(result['pyramid.prevent_cachebust'], False) - result = self._makeOne({'prevent_cachebust':'t'}) + result = self._makeOne({'prevent_cachebust': 't'}) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) - result = self._makeOne({'prevent_cachebust':'1'}) + result = self._makeOne({'prevent_cachebust': '1'}) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) - result = self._makeOne({'pyramid.prevent_cachebust':'t'}) + result = self._makeOne({'pyramid.prevent_cachebust': 't'}) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) - result = self._makeOne({}, {'PYRAMID_PREVENT_CACHEBUST':'1'}) + result = self._makeOne({}, {'PYRAMID_PREVENT_CACHEBUST': '1'}) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) - result = self._makeOne({'prevent_cachebust':'false', - 'pyramid.prevent_cachebust':'1'}) + result = self._makeOne( + {'prevent_cachebust': 'false', 'pyramid.prevent_cachebust': '1'} + ) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) - result = self._makeOne({'prevent_cachebust':'false', - 'pyramid.prevent_cachebust':'f'}, - {'PYRAMID_PREVENT_CACHEBUST':'1'}) + result = self._makeOne( + {'prevent_cachebust': 'false', 'pyramid.prevent_cachebust': 'f'}, + {'PYRAMID_PREVENT_CACHEBUST': '1'}, + ) self.assertEqual(result['prevent_cachebust'], True) self.assertEqual(result['pyramid.prevent_cachebust'], True) @@ -170,27 +180,29 @@ class TestSettings(unittest.TestCase): settings = self._makeOne({}) self.assertEqual(settings['reload_templates'], False) self.assertEqual(settings['pyramid.reload_templates'], False) - result = self._makeOne({'reload_templates':'false'}) + result = self._makeOne({'reload_templates': 'false'}) self.assertEqual(result['reload_templates'], False) self.assertEqual(result['pyramid.reload_templates'], False) - result = self._makeOne({'reload_templates':'t'}) + result = self._makeOne({'reload_templates': 't'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) - result = self._makeOne({'reload_templates':'1'}) + result = self._makeOne({'reload_templates': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) - result = self._makeOne({'pyramid.reload_templates':'1'}) + result = self._makeOne({'pyramid.reload_templates': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) - result = self._makeOne({}, {'PYRAMID_RELOAD_TEMPLATES':'1'}) + result = self._makeOne({}, {'PYRAMID_RELOAD_TEMPLATES': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) - result = self._makeOne({'reload_templates':'false', - 'pyramid.reload_templates':'1'}) + result = self._makeOne( + {'reload_templates': 'false', 'pyramid.reload_templates': '1'} + ) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) - result = self._makeOne({'reload_templates':'false'}, - {'PYRAMID_RELOAD_TEMPLATES':'1'}) + result = self._makeOne( + {'reload_templates': 'false'}, {'PYRAMID_RELOAD_TEMPLATES': '1'} + ) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['pyramid.reload_templates'], True) @@ -201,40 +213,42 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['reload_assets'], False) self.assertEqual(result['pyramid.reload_resources'], False) self.assertEqual(result['pyramid.reload_assets'], False) - result = self._makeOne({'reload_resources':'false'}) + result = self._makeOne({'reload_resources': 'false'}) self.assertEqual(result['reload_resources'], False) self.assertEqual(result['reload_assets'], False) self.assertEqual(result['pyramid.reload_resources'], False) self.assertEqual(result['pyramid.reload_assets'], False) - result = self._makeOne({'reload_resources':'t'}) + result = self._makeOne({'reload_resources': 't'}) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_resources':'1'}) + result = self._makeOne({'reload_resources': '1'}) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'pyramid.reload_resources':'1'}) + result = self._makeOne({'pyramid.reload_resources': '1'}) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({}, {'PYRAMID_RELOAD_RESOURCES':'1'}) + result = self._makeOne({}, {'PYRAMID_RELOAD_RESOURCES': '1'}) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_resources':'false', - 'pyramid.reload_resources':'1'}) + result = self._makeOne( + {'reload_resources': 'false', 'pyramid.reload_resources': '1'} + ) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_resources':'false', - 'pyramid.reload_resources':'false'}, - {'PYRAMID_RELOAD_RESOURCES':'1'}) + result = self._makeOne( + {'reload_resources': 'false', 'pyramid.reload_resources': 'false'}, + {'PYRAMID_RELOAD_RESOURCES': '1'}, + ) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) @@ -247,40 +261,42 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['reload_resources'], False) self.assertEqual(result['pyramid.reload_assets'], False) self.assertEqual(result['pyramid.reload_resources'], False) - result = self._makeOne({'reload_assets':'false'}) + result = self._makeOne({'reload_assets': 'false'}) self.assertEqual(result['reload_resources'], False) self.assertEqual(result['reload_assets'], False) self.assertEqual(result['pyramid.reload_assets'], False) self.assertEqual(result['pyramid.reload_resources'], False) - result = self._makeOne({'reload_assets':'t'}) + result = self._makeOne({'reload_assets': 't'}) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) - result = self._makeOne({'reload_assets':'1'}) + result = self._makeOne({'reload_assets': '1'}) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) - result = self._makeOne({'pyramid.reload_assets':'1'}) + result = self._makeOne({'pyramid.reload_assets': '1'}) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) - result = self._makeOne({}, {'PYRAMID_RELOAD_ASSETS':'1'}) + result = self._makeOne({}, {'PYRAMID_RELOAD_ASSETS': '1'}) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) - result = self._makeOne({'reload_assets':'false', - 'pyramid.reload_assets':'1'}) + result = self._makeOne( + {'reload_assets': 'false', 'pyramid.reload_assets': '1'} + ) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) self.assertEqual(result['pyramid.reload_resources'], True) - result = self._makeOne({'reload_assets':'false', - 'pyramid.reload_assets':'false'}, - {'PYRAMID_RELOAD_ASSETS':'1'}) + result = self._makeOne( + {'reload_assets': 'false', 'pyramid.reload_assets': 'false'}, + {'PYRAMID_RELOAD_ASSETS': '1'}, + ) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) @@ -294,52 +310,54 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.reload_templates'], False) self.assertEqual(result['pyramid.reload_resources'], False) self.assertEqual(result['pyramid.reload_assets'], False) - result = self._makeOne({'reload_all':'false'}) + result = self._makeOne({'reload_all': 'false'}) self.assertEqual(result['reload_templates'], False) self.assertEqual(result['reload_resources'], False) self.assertEqual(result['reload_assets'], False) self.assertEqual(result['pyramid.reload_templates'], False) self.assertEqual(result['pyramid.reload_resources'], False) self.assertEqual(result['pyramid.reload_assets'], False) - result = self._makeOne({'reload_all':'t'}) + result = self._makeOne({'reload_all': 't'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_templates'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_all':'1'}) + result = self._makeOne({'reload_all': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_templates'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'pyramid.reload_all':'1'}) + result = self._makeOne({'pyramid.reload_all': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_templates'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({}, {'PYRAMID_RELOAD_ALL':'1'}) + result = self._makeOne({}, {'PYRAMID_RELOAD_ALL': '1'}) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_templates'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_all':'false', - 'pyramid.reload_all':'1'}) + result = self._makeOne( + {'reload_all': 'false', 'pyramid.reload_all': '1'} + ) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) self.assertEqual(result['pyramid.reload_templates'], True) self.assertEqual(result['pyramid.reload_resources'], True) self.assertEqual(result['pyramid.reload_assets'], True) - result = self._makeOne({'reload_all':'false', - 'pyramid.reload_all':'false'}, - {'PYRAMID_RELOAD_ALL':'1'}) + result = self._makeOne( + {'reload_all': 'false', 'pyramid.reload_all': 'false'}, + {'PYRAMID_RELOAD_ALL': '1'}, + ) self.assertEqual(result['reload_templates'], True) self.assertEqual(result['reload_resources'], True) self.assertEqual(result['reload_assets'], True) @@ -351,28 +369,36 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['debug_authorization'], False) self.assertEqual(result['pyramid.debug_authorization'], False) - result = self._makeOne({'debug_authorization':'false'}) + result = self._makeOne({'debug_authorization': 'false'}) self.assertEqual(result['debug_authorization'], False) self.assertEqual(result['pyramid.debug_authorization'], False) - result = self._makeOne({'debug_authorization':'t'}) + result = self._makeOne({'debug_authorization': 't'}) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) - result = self._makeOne({'debug_authorization':'1'}) + result = self._makeOne({'debug_authorization': '1'}) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) - result = self._makeOne({'pyramid.debug_authorization':'1'}) + result = self._makeOne({'pyramid.debug_authorization': '1'}) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) - result = self._makeOne({}, {'PYRAMID_DEBUG_AUTHORIZATION':'1'}) + result = self._makeOne({}, {'PYRAMID_DEBUG_AUTHORIZATION': '1'}) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) - result = self._makeOne({'debug_authorization':'false', - 'pyramid.debug_authorization':'1'}) + result = self._makeOne( + { + 'debug_authorization': 'false', + 'pyramid.debug_authorization': '1', + } + ) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) - result = self._makeOne({'debug_authorization':'false', - 'pyramid.debug_authorization':'false'}, - {'PYRAMID_DEBUG_AUTHORIZATION':'1'}) + result = self._makeOne( + { + 'debug_authorization': 'false', + 'pyramid.debug_authorization': 'false', + }, + {'PYRAMID_DEBUG_AUTHORIZATION': '1'}, + ) self.assertEqual(result['debug_authorization'], True) self.assertEqual(result['pyramid.debug_authorization'], True) @@ -380,28 +406,30 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['debug_notfound'], False) self.assertEqual(result['pyramid.debug_notfound'], False) - result = self._makeOne({'debug_notfound':'false'}) + result = self._makeOne({'debug_notfound': 'false'}) self.assertEqual(result['debug_notfound'], False) self.assertEqual(result['pyramid.debug_notfound'], False) - result = self._makeOne({'debug_notfound':'t'}) + result = self._makeOne({'debug_notfound': 't'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) - result = self._makeOne({'debug_notfound':'1'}) + result = self._makeOne({'debug_notfound': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) - result = self._makeOne({'pyramid.debug_notfound':'1'}) + result = self._makeOne({'pyramid.debug_notfound': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) - result = self._makeOne({}, {'PYRAMID_DEBUG_NOTFOUND':'1'}) + result = self._makeOne({}, {'PYRAMID_DEBUG_NOTFOUND': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) - result = self._makeOne({'debug_notfound':'false', - 'pyramid.debug_notfound':'1'}) + result = self._makeOne( + {'debug_notfound': 'false', 'pyramid.debug_notfound': '1'} + ) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) - result = self._makeOne({'debug_notfound':'false', - 'pyramid.debug_notfound':'false'}, - {'PYRAMID_DEBUG_NOTFOUND':'1'}) + result = self._makeOne( + {'debug_notfound': 'false', 'pyramid.debug_notfound': 'false'}, + {'PYRAMID_DEBUG_NOTFOUND': '1'}, + ) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['pyramid.debug_notfound'], True) @@ -409,28 +437,30 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['debug_routematch'], False) self.assertEqual(result['pyramid.debug_routematch'], False) - result = self._makeOne({'debug_routematch':'false'}) + result = self._makeOne({'debug_routematch': 'false'}) self.assertEqual(result['debug_routematch'], False) self.assertEqual(result['pyramid.debug_routematch'], False) - result = self._makeOne({'debug_routematch':'t'}) + result = self._makeOne({'debug_routematch': 't'}) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) - result = self._makeOne({'debug_routematch':'1'}) + result = self._makeOne({'debug_routematch': '1'}) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) - result = self._makeOne({'pyramid.debug_routematch':'1'}) + result = self._makeOne({'pyramid.debug_routematch': '1'}) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) - result = self._makeOne({}, {'PYRAMID_DEBUG_ROUTEMATCH':'1'}) + result = self._makeOne({}, {'PYRAMID_DEBUG_ROUTEMATCH': '1'}) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) - result = self._makeOne({'debug_routematch':'false', - 'pyramid.debug_routematch':'1'}) + result = self._makeOne( + {'debug_routematch': 'false', 'pyramid.debug_routematch': '1'} + ) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) - result = self._makeOne({'debug_routematch':'false', - 'pyramid.debug_routematch':'false'}, - {'PYRAMID_DEBUG_ROUTEMATCH':'1'}) + result = self._makeOne( + {'debug_routematch': 'false', 'pyramid.debug_routematch': 'false'}, + {'PYRAMID_DEBUG_ROUTEMATCH': '1'}, + ) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['pyramid.debug_routematch'], True) @@ -438,28 +468,30 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['debug_templates'], False) self.assertEqual(result['pyramid.debug_templates'], False) - result = self._makeOne({'debug_templates':'false'}) + result = self._makeOne({'debug_templates': 'false'}) self.assertEqual(result['debug_templates'], False) self.assertEqual(result['pyramid.debug_templates'], False) - result = self._makeOne({'debug_templates':'t'}) + result = self._makeOne({'debug_templates': 't'}) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_templates':'1'}) + result = self._makeOne({'debug_templates': '1'}) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'pyramid.debug_templates':'1'}) + result = self._makeOne({'pyramid.debug_templates': '1'}) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({}, {'PYRAMID_DEBUG_TEMPLATES':'1'}) + result = self._makeOne({}, {'PYRAMID_DEBUG_TEMPLATES': '1'}) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_templates':'false', - 'pyramid.debug_templates':'1'}) + result = self._makeOne( + {'debug_templates': 'false', 'pyramid.debug_templates': '1'} + ) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_templates':'false', - 'pyramid.debug_templates':'false'}, - {'PYRAMID_DEBUG_TEMPLATES':'1'}) + result = self._makeOne( + {'debug_templates': 'false', 'pyramid.debug_templates': 'false'}, + {'PYRAMID_DEBUG_TEMPLATES': '1'}, + ) self.assertEqual(result['debug_templates'], True) self.assertEqual(result['pyramid.debug_templates'], True) @@ -473,7 +505,7 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], False) self.assertEqual(result['pyramid.debug_authorization'], False) self.assertEqual(result['pyramid.debug_templates'], False) - result = self._makeOne({'debug_all':'false'}) + result = self._makeOne({'debug_all': 'false'}) self.assertEqual(result['debug_notfound'], False) self.assertEqual(result['debug_routematch'], False) self.assertEqual(result['debug_authorization'], False) @@ -482,7 +514,7 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], False) self.assertEqual(result['pyramid.debug_authorization'], False) self.assertEqual(result['pyramid.debug_templates'], False) - result = self._makeOne({'debug_all':'t'}) + result = self._makeOne({'debug_all': 't'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -491,7 +523,7 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], True) self.assertEqual(result['pyramid.debug_authorization'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_all':'1'}) + result = self._makeOne({'debug_all': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -500,7 +532,7 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], True) self.assertEqual(result['pyramid.debug_authorization'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'pyramid.debug_all':'1'}) + result = self._makeOne({'pyramid.debug_all': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -509,7 +541,7 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], True) self.assertEqual(result['pyramid.debug_authorization'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({}, {'PYRAMID_DEBUG_ALL':'1'}) + result = self._makeOne({}, {'PYRAMID_DEBUG_ALL': '1'}) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -518,8 +550,9 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], True) self.assertEqual(result['pyramid.debug_authorization'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_all':'false', - 'pyramid.debug_all':'1'}) + result = self._makeOne( + {'debug_all': 'false', 'pyramid.debug_all': '1'} + ) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -528,9 +561,10 @@ class TestSettings(unittest.TestCase): self.assertEqual(result['pyramid.debug_routematch'], True) self.assertEqual(result['pyramid.debug_authorization'], True) self.assertEqual(result['pyramid.debug_templates'], True) - result = self._makeOne({'debug_all':'false', - 'pyramid.debug_all':'false'}, - {'PYRAMID_DEBUG_ALL':'1'}) + result = self._makeOne( + {'debug_all': 'false', 'pyramid.debug_all': 'false'}, + {'PYRAMID_DEBUG_ALL': '1'}, + ) self.assertEqual(result['debug_notfound'], True) self.assertEqual(result['debug_routematch'], True) self.assertEqual(result['debug_authorization'], True) @@ -544,22 +578,30 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['default_locale_name'], 'en') self.assertEqual(result['pyramid.default_locale_name'], 'en') - result = self._makeOne({'default_locale_name':'abc'}) + result = self._makeOne({'default_locale_name': 'abc'}) self.assertEqual(result['default_locale_name'], 'abc') self.assertEqual(result['pyramid.default_locale_name'], 'abc') - result = self._makeOne({'pyramid.default_locale_name':'abc'}) + result = self._makeOne({'pyramid.default_locale_name': 'abc'}) self.assertEqual(result['default_locale_name'], 'abc') self.assertEqual(result['pyramid.default_locale_name'], 'abc') - result = self._makeOne({}, {'PYRAMID_DEFAULT_LOCALE_NAME':'abc'}) + result = self._makeOne({}, {'PYRAMID_DEFAULT_LOCALE_NAME': 'abc'}) self.assertEqual(result['default_locale_name'], 'abc') self.assertEqual(result['pyramid.default_locale_name'], 'abc') - result = self._makeOne({'default_locale_name':'def', - 'pyramid.default_locale_name':'abc'}) + result = self._makeOne( + { + 'default_locale_name': 'def', + 'pyramid.default_locale_name': 'abc', + } + ) self.assertEqual(result['default_locale_name'], 'abc') self.assertEqual(result['pyramid.default_locale_name'], 'abc') - result = self._makeOne({'default_locale_name':'def', - 'pyramid.default_locale_name':'ghi'}, - {'PYRAMID_DEFAULT_LOCALE_NAME':'abc'}) + result = self._makeOne( + { + 'default_locale_name': 'def', + 'pyramid.default_locale_name': 'ghi', + }, + {'PYRAMID_DEFAULT_LOCALE_NAME': 'abc'}, + ) self.assertEqual(result['default_locale_name'], 'abc') self.assertEqual(result['pyramid.default_locale_name'], 'abc') @@ -567,16 +609,27 @@ class TestSettings(unittest.TestCase): result = self._makeOne({}) self.assertEqual(result['pyramid.csrf_trusted_origins'], []) result = self._makeOne({'pyramid.csrf_trusted_origins': 'example.com'}) - self.assertEqual(result['pyramid.csrf_trusted_origins'], ['example.com']) - result = self._makeOne({'pyramid.csrf_trusted_origins': ['example.com']}) - self.assertEqual(result['pyramid.csrf_trusted_origins'], ['example.com']) - result = self._makeOne({'pyramid.csrf_trusted_origins': ( - 'example.com foo.example.com\nasdf.example.com')}) - self.assertEqual(result['pyramid.csrf_trusted_origins'], [ - 'example.com', 'foo.example.com', 'asdf.example.com']) + self.assertEqual( + result['pyramid.csrf_trusted_origins'], ['example.com'] + ) + result = self._makeOne( + {'pyramid.csrf_trusted_origins': ['example.com']} + ) + self.assertEqual( + result['pyramid.csrf_trusted_origins'], ['example.com'] + ) + result = self._makeOne( + { + 'pyramid.csrf_trusted_origins': ( + 'example.com foo.example.com\nasdf.example.com' + ) + } + ) + self.assertEqual( + result['pyramid.csrf_trusted_origins'], + ['example.com', 'foo.example.com', 'asdf.example.com'], + ) def test_originals_kept(self): - result = self._makeOne({'a':'i am so a'}) + result = self._makeOne({'a': 'i am so a'}) self.assertEqual(result['a'], 'i am so a') - - diff --git a/tests/test_config/test_testing.py b/tests/test_config/test_testing.py index 5be4e48d3..c0a98f9ad 100644 --- a/tests/test_config/test_testing.py +++ b/tests/test_config/test_testing.py @@ -4,19 +4,24 @@ from pyramid.compat import text_ from pyramid.security import AuthenticationAPIMixin, AuthorizationAPIMixin from . import IDummy + class TestingConfiguratorMixinTests(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_testing_securitypolicy(self): from pyramid.testing import DummySecurityPolicy + config = self._makeOne(autocommit=True) - config.testing_securitypolicy('user', ('group1', 'group2'), - permissive=False) + config.testing_securitypolicy( + 'user', ('group1', 'group2'), permissive=False + ) from pyramid.interfaces import IAuthenticationPolicy from pyramid.interfaces import IAuthorizationPolicy + ut = config.registry.getUtility(IAuthenticationPolicy) self.assertTrue(isinstance(ut, DummySecurityPolicy)) ut = config.registry.getUtility(IAuthorizationPolicy) @@ -26,10 +31,14 @@ class TestingConfiguratorMixinTests(unittest.TestCase): def test_testing_securitypolicy_remember_result(self): from pyramid.security import remember + config = self._makeOne(autocommit=True) pol = config.testing_securitypolicy( - 'user', ('group1', 'group2'), - permissive=False, remember_result=True) + 'user', + ('group1', 'group2'), + permissive=False, + remember_result=True, + ) request = DummyRequest() request.registry = config.registry val = remember(request, 'fred') @@ -38,10 +47,11 @@ class TestingConfiguratorMixinTests(unittest.TestCase): def test_testing_securitypolicy_forget_result(self): from pyramid.security import forget + config = self._makeOne(autocommit=True) pol = config.testing_securitypolicy( - 'user', ('group1', 'group2'), - permissive=False, forget_result=True) + 'user', ('group1', 'group2'), permissive=False, forget_result=True + ) request = DummyRequest() request.registry = config.registry val = forget(request) @@ -51,27 +61,30 @@ class TestingConfiguratorMixinTests(unittest.TestCase): def test_testing_resources(self): from pyramid.traversal import find_resource from pyramid.interfaces import ITraverser + ob1 = object() ob2 = object() - resources = {'/ob1':ob1, '/ob2':ob2} + resources = {'/ob1': ob1, '/ob2': ob2} config = self._makeOne(autocommit=True) config.testing_resources(resources) adapter = config.registry.getAdapter(None, ITraverser) - result = adapter(DummyRequest({'PATH_INFO':'/ob1'})) + result = adapter(DummyRequest({'PATH_INFO': '/ob1'})) self.assertEqual(result['context'], ob1) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob1'),)) self.assertEqual(result['virtual_root'], ob1) self.assertEqual(result['virtual_root_path'], ()) - result = adapter(DummyRequest({'PATH_INFO':'/ob2'})) + result = adapter(DummyRequest({'PATH_INFO': '/ob2'})) self.assertEqual(result['context'], ob2) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob2'),)) self.assertEqual(result['virtual_root'], ob2) self.assertEqual(result['virtual_root_path'], ()) - self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'})) + self.assertRaises( + KeyError, adapter, DummyRequest({'PATH_INFO': '/ob3'}) + ) try: config.begin() self.assertEqual(find_resource(None, '/ob1'), ob1) @@ -90,8 +103,7 @@ class TestingConfiguratorMixinTests(unittest.TestCase): def test_testing_add_subscriber_dottedname(self): config = self._makeOne(autocommit=True) - L = config.testing_add_subscriber( - 'tests.test_config.test_init.IDummy') + L = config.testing_add_subscriber('tests.test_config.test_init.IDummy') event = DummyEvent() config.registry.notify(event) self.assertEqual(len(L), 1) @@ -101,6 +113,7 @@ class TestingConfiguratorMixinTests(unittest.TestCase): def test_testing_add_subscriber_multiple(self): from zope.interface import Interface + config = self._makeOne(autocommit=True) L = config.testing_add_subscriber((Interface, IDummy)) event = DummyEvent() @@ -125,13 +138,16 @@ class TestingConfiguratorMixinTests(unittest.TestCase): config = self._makeOne(autocommit=True) renderer = config.testing_add_renderer('templates/foo.pt') from pyramid.testing import DummyTemplateRenderer + self.assertTrue(isinstance(renderer, 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) + 'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request + ) renderer.assert_(foo=1) renderer.assert_(bar=2) renderer.assert_(request=request) @@ -141,65 +157,81 @@ class TestingConfiguratorMixinTests(unittest.TestCase): renderer1 = config.testing_add_renderer('templates/foo.pt') renderer2 = config.testing_add_renderer('templates/bar.pt') from pyramid.testing import DummyTemplateRenderer + self.assertTrue(isinstance(renderer1, DummyTemplateRenderer)) self.assertTrue(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) + '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) + '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 + + class E(Exception): + pass + def renderer(kw, system): - self.assertEqual(kw, {'foo':1, 'bar':2}) + self.assertEqual(kw, {'foo': 1, 'bar': 2}) raise E + renderer = config.testing_add_renderer('templates/foo.pt', renderer) from pyramid.renderers import render_to_response + # must provide request to pass in registry (this is a functest) request = DummyRequest() request.registry = config.registry try: render_to_response( - 'templates/foo.pt', {'foo':1, 'bar':2}, request=request) + 'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request + ) except E: pass - else: # pragma: no cover + else: # pragma: no cover raise AssertionError def test_testing_add_template(self): config = self._makeOne(autocommit=True) renderer = config.testing_add_template('templates/foo.pt') from pyramid.testing import DummyTemplateRenderer + self.assertTrue(isinstance(renderer, 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', dict(foo=1, bar=2), - request=request) + render_to_response( + 'templates/foo.pt', dict(foo=1, bar=2), request=request + ) renderer.assert_(foo=1) renderer.assert_(bar=2) renderer.assert_(request=request) + from zope.interface import implementer + + @implementer(IDummy) class DummyEvent: pass + class DummyRequest(AuthenticationAPIMixin, AuthorizationAPIMixin): def __init__(self, environ=None): if environ is None: environ = {} self.environ = environ - diff --git a/tests/test_config/test_tweens.py b/tests/test_config/test_tweens.py index 25615c699..ed41c9a43 100644 --- a/tests/test_config/test_tweens.py +++ b/tests/test_config/test_tweens.py @@ -5,81 +5,101 @@ from . import dummy_tween_factory2 from pyramid.exceptions import ConfigurationConflictError + class TestTweensConfiguratorMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) return config def test_add_tweens_names_distinct(self): from pyramid.interfaces import ITweens from pyramid.tweens import excview_tween_factory - def factory1(handler, registry): return handler - def factory2(handler, registry): return handler + + def factory1(handler, registry): + return handler + + def factory2(handler, registry): + return handler + config = self._makeOne() - config.add_tween( - 'tests.test_config.dummy_tween_factory') - config.add_tween( - 'tests.test_config.dummy_tween_factory2') + config.add_tween('tests.test_config.dummy_tween_factory') + config.add_tween('tests.test_config.dummy_tween_factory2') config.commit() tweens = config.registry.queryUtility(ITweens) implicit = tweens.implicit() self.assertEqual( implicit, [ - ('tests.test_config.dummy_tween_factory2', - dummy_tween_factory2), - ('tests.test_config.dummy_tween_factory', - dummy_tween_factory), - ('pyramid.tweens.excview_tween_factory', - excview_tween_factory), - ] - ) + ( + 'tests.test_config.dummy_tween_factory2', + dummy_tween_factory2, + ), + ('tests.test_config.dummy_tween_factory', dummy_tween_factory), + ( + 'pyramid.tweens.excview_tween_factory', + excview_tween_factory, + ), + ], + ) def test_add_tweens_names_with_underover(self): from pyramid.interfaces import ITweens from pyramid.tweens import excview_tween_factory from pyramid.tweens import MAIN + config = self._makeOne() - config.add_tween( - 'tests.test_config.dummy_tween_factory', - over=MAIN) + config.add_tween('tests.test_config.dummy_tween_factory', over=MAIN) config.add_tween( 'tests.test_config.dummy_tween_factory2', over=MAIN, - under='tests.test_config.dummy_tween_factory') + under='tests.test_config.dummy_tween_factory', + ) config.commit() tweens = config.registry.queryUtility(ITweens) implicit = tweens.implicit() self.assertEqual( implicit, [ - ('pyramid.tweens.excview_tween_factory', excview_tween_factory), - ('tests.test_config.dummy_tween_factory', - dummy_tween_factory), - ('tests.test_config.dummy_tween_factory2', - dummy_tween_factory2), - ]) + ( + 'pyramid.tweens.excview_tween_factory', + excview_tween_factory, + ), + ('tests.test_config.dummy_tween_factory', dummy_tween_factory), + ( + 'tests.test_config.dummy_tween_factory2', + dummy_tween_factory2, + ), + ], + ) def test_add_tweens_names_with_under_nonstringoriter(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() self.assertRaises( - ConfigurationError, config.add_tween, + ConfigurationError, + config.add_tween, 'tests.test_config.dummy_tween_factory', - under=False) + under=False, + ) def test_add_tweens_names_with_over_nonstringoriter(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne() self.assertRaises( - ConfigurationError, config.add_tween, + ConfigurationError, + config.add_tween, 'tests.test_config.dummy_tween_factory', - over=False) + over=False, + ) def test_add_tween_dottedname(self): from pyramid.interfaces import ITweens from pyramid.tweens import excview_tween_factory + config = self._makeOne() config.add_tween('tests.test_config.dummy_tween_factory') config.commit() @@ -87,15 +107,20 @@ class TestTweensConfiguratorMixin(unittest.TestCase): self.assertEqual( tweens.implicit(), [ - ('tests.test_config.dummy_tween_factory', - dummy_tween_factory), - ('pyramid.tweens.excview_tween_factory', - excview_tween_factory), - ]) + ('tests.test_config.dummy_tween_factory', dummy_tween_factory), + ( + 'pyramid.tweens.excview_tween_factory', + excview_tween_factory, + ), + ], + ) def test_add_tween_instance(self): from pyramid.exceptions import ConfigurationError - class ATween(object): pass + + class ATween(object): + pass + atween = ATween() config = self._makeOne() self.assertRaises(ConfigurationError, config.add_tween, atween) @@ -103,19 +128,23 @@ class TestTweensConfiguratorMixin(unittest.TestCase): def test_add_tween_unsuitable(self): from pyramid.exceptions import ConfigurationError import tests.test_config + config = self._makeOne() - self.assertRaises(ConfigurationError, config.add_tween, - tests.test_config) + self.assertRaises( + ConfigurationError, config.add_tween, tests.test_config + ) def test_add_tween_name_ingress(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import INGRESS + config = self._makeOne() self.assertRaises(ConfigurationError, config.add_tween, INGRESS) def test_add_tween_name_main(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import MAIN + config = self._makeOne() self.assertRaises(ConfigurationError, config.add_tween, MAIN) @@ -128,79 +157,97 @@ class TestTweensConfiguratorMixin(unittest.TestCase): def test_add_tween_over_ingress(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import INGRESS + config = self._makeOne() self.assertRaises( ConfigurationError, config.add_tween, 'tests.test_config.dummy_tween_factory', - over=INGRESS) + over=INGRESS, + ) def test_add_tween_over_ingress_iterable(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import INGRESS + config = self._makeOne() self.assertRaises( ConfigurationError, config.add_tween, 'tests.test_config.dummy_tween_factory', - over=('a', INGRESS)) + over=('a', INGRESS), + ) def test_add_tween_under_main(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import MAIN + config = self._makeOne() self.assertRaises( ConfigurationError, config.add_tween, 'tests.test_config.dummy_tween_factory', - under=MAIN) + under=MAIN, + ) def test_add_tween_under_main_iterable(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import MAIN + config = self._makeOne() self.assertRaises( ConfigurationError, config.add_tween, 'tests.test_config.dummy_tween_factory', - under=('a', MAIN)) + under=('a', MAIN), + ) + class TestTweens(unittest.TestCase): def _makeOne(self): from pyramid.config.tweens import Tweens + return Tweens() def test_add_explicit(self): tweens = self._makeOne() tweens.add_explicit('name', 'factory') - self.assertEqual(tweens.explicit, [('name', 'factory')]) + self.assertEqual(tweens.explicit, [('name', 'factory')]) tweens.add_explicit('name2', 'factory2') - self.assertEqual(tweens.explicit, [('name', 'factory'), - ('name2', 'factory2')]) + self.assertEqual( + tweens.explicit, [('name', 'factory'), ('name2', 'factory2')] + ) def test_add_implicit(self): tweens = self._makeOne() tweens.add_implicit('name', 'factory') tweens.add_implicit('name2', 'factory2') - self.assertEqual(tweens.sorter.sorted(), - [('name2', 'factory2'), - ('name', 'factory')]) + self.assertEqual( + tweens.sorter.sorted(), + [('name2', 'factory2'), ('name', 'factory')], + ) def test___call___explicit(self): tweens = self._makeOne() + def factory1(handler, registry): return handler + def factory2(handler, registry): return '123' + tweens.explicit = [('name', factory1), ('name', factory2)] self.assertEqual(tweens(None, None), '123') def test___call___implicit(self): tweens = self._makeOne() + def factory1(handler, registry): return handler + def factory2(handler, registry): return '123' + tweens.add_implicit('name2', factory2) tweens.add_implicit('name1', factory1) self.assertEqual(tweens(None, None), '123') @@ -209,45 +256,46 @@ class TestTweens(unittest.TestCase): tweens = self._makeOne() tweens.add_implicit('name1', 'factory1') tweens.add_implicit('name2', 'factory2') - self.assertEqual(tweens.implicit(), - [ - ('name2', 'factory2'), - ('name1', 'factory1'), - ]) + self.assertEqual( + tweens.implicit(), [('name2', 'factory2'), ('name1', 'factory1')] + ) def test_implicit_ordering_2(self): from pyramid.tweens import MAIN + tweens = self._makeOne() tweens.add_implicit('name1', 'factory1') tweens.add_implicit('name2', 'factory2', over=MAIN) - self.assertEqual(tweens.implicit(), - [ - ('name1', 'factory1'), - ('name2', 'factory2'), - ]) + self.assertEqual( + tweens.implicit(), [('name1', 'factory1'), ('name2', 'factory2')] + ) def test_implicit_ordering_3(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('auth', 'auth_factory', under='browserid') - add('dbt', 'dbt_factory') + add('dbt', 'dbt_factory') add('retry', 'retry_factory', over='txnmgr', under='exceptionview') add('browserid', 'browserid_factory') add('txnmgr', 'txnmgr_factory', under='exceptionview') add('exceptionview', 'excview_factory', over=MAIN) - self.assertEqual(tweens.implicit(), - [ - ('browserid', 'browserid_factory'), - ('auth', 'auth_factory'), - ('dbt', 'dbt_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ('txnmgr', 'txnmgr_factory'), - ]) + self.assertEqual( + tweens.implicit(), + [ + ('browserid', 'browserid_factory'), + ('auth', 'auth_factory'), + ('dbt', 'dbt_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ('txnmgr', 'txnmgr_factory'), + ], + ) def test_implicit_ordering_4(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) @@ -255,19 +303,22 @@ class TestTweens(unittest.TestCase): add('retry', 'retry_factory', over='txnmgr', under='exceptionview') add('browserid', 'browserid_factory') add('txnmgr', 'txnmgr_factory', under='exceptionview') - add('dbt', 'dbt_factory') - self.assertEqual(tweens.implicit(), - [ - ('dbt', 'dbt_factory'), - ('browserid', 'browserid_factory'), - ('auth', 'auth_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ('txnmgr', 'txnmgr_factory'), - ]) + add('dbt', 'dbt_factory') + self.assertEqual( + tweens.implicit(), + [ + ('dbt', 'dbt_factory'), + ('browserid', 'browserid_factory'), + ('auth', 'auth_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ('txnmgr', 'txnmgr_factory'), + ], + ) def test_implicit_ordering_5(self): from pyramid.tweens import MAIN, INGRESS + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) @@ -275,19 +326,22 @@ class TestTweens(unittest.TestCase): add('retry', 'retry_factory', over='txnmgr', under='exceptionview') add('browserid', 'browserid_factory', under=INGRESS) add('txnmgr', 'txnmgr_factory', under='exceptionview', over=MAIN) - add('dbt', 'dbt_factory') - self.assertEqual(tweens.implicit(), - [ - ('dbt', 'dbt_factory'), - ('browserid', 'browserid_factory'), - ('auth', 'auth_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ('txnmgr', 'txnmgr_factory'), - ]) + add('dbt', 'dbt_factory') + self.assertEqual( + tweens.implicit(), + [ + ('dbt', 'dbt_factory'), + ('browserid', 'browserid_factory'), + ('auth', 'auth_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ('txnmgr', 'txnmgr_factory'), + ], + ) def test_implicit_ordering_missing_over_partial(self): from pyramid.exceptions import ConfigurationError + tweens = self._makeOne() add = tweens.add_implicit add('dbt', 'dbt_factory') @@ -298,6 +352,7 @@ class TestTweens(unittest.TestCase): def test_implicit_ordering_missing_under_partial(self): from pyramid.exceptions import ConfigurationError + tweens = self._makeOne() add = tweens.add_implicit add('dbt', 'dbt_factory') @@ -308,6 +363,7 @@ class TestTweens(unittest.TestCase): def test_implicit_ordering_missing_over_and_under_partials(self): from pyramid.exceptions import ConfigurationError + tweens = self._makeOne() add = tweens.add_implicit add('dbt', 'dbt_factory') @@ -318,72 +374,89 @@ class TestTweens(unittest.TestCase): def test_implicit_ordering_missing_over_partial_with_fallback(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) add('auth', 'auth_factory', under='browserid') - add('retry', 'retry_factory', over=('txnmgr',MAIN), - under='exceptionview') + add( + 'retry', + 'retry_factory', + over=('txnmgr', MAIN), + under='exceptionview', + ) add('browserid', 'browserid_factory') - add('dbt', 'dbt_factory') - self.assertEqual(tweens.implicit(), - [ - ('dbt', 'dbt_factory'), - ('browserid', 'browserid_factory'), - ('auth', 'auth_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ]) + add('dbt', 'dbt_factory') + self.assertEqual( + tweens.implicit(), + [ + ('dbt', 'dbt_factory'), + ('browserid', 'browserid_factory'), + ('auth', 'auth_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ], + ) def test_implicit_ordering_missing_under_partial_with_fallback(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) - add('auth', 'auth_factory', under=('txnmgr','browserid')) + add('auth', 'auth_factory', under=('txnmgr', 'browserid')) add('retry', 'retry_factory', under='exceptionview') add('browserid', 'browserid_factory') add('dbt', 'dbt_factory') - self.assertEqual(tweens.implicit(), - [ - ('dbt', 'dbt_factory'), - ('browserid', 'browserid_factory'), - ('auth', 'auth_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ]) + self.assertEqual( + tweens.implicit(), + [ + ('dbt', 'dbt_factory'), + ('browserid', 'browserid_factory'), + ('auth', 'auth_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ], + ) def test_implicit_ordering_with_partial_fallbacks(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=('wontbethere', MAIN)) add('retry', 'retry_factory', under='exceptionview') add('browserid', 'browserid_factory', over=('wont2', 'exceptionview')) - self.assertEqual(tweens.implicit(), - [ - ('browserid', 'browserid_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ]) + self.assertEqual( + tweens.implicit(), + [ + ('browserid', 'browserid_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ], + ) def test_implicit_ordering_with_multiple_matching_fallbacks(self): from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) add('retry', 'retry_factory', under='exceptionview') add('browserid', 'browserid_factory', over=('retry', 'exceptionview')) - self.assertEqual(tweens.implicit(), - [ - ('browserid', 'browserid_factory'), - ('exceptionview', 'excview_factory'), - ('retry', 'retry_factory'), - ]) + self.assertEqual( + tweens.implicit(), + [ + ('browserid', 'browserid_factory'), + ('exceptionview', 'excview_factory'), + ('retry', 'retry_factory'), + ], + ) def test_implicit_ordering_with_missing_fallbacks(self): from pyramid.exceptions import ConfigurationError from pyramid.tweens import MAIN + tweens = self._makeOne() add = tweens.add_implicit add('exceptionview', 'excview_factory', over=MAIN) @@ -393,6 +466,7 @@ class TestTweens(unittest.TestCase): def test_implicit_ordering_conflict_direct(self): from pyramid.exceptions import CyclicDependencyError + tweens = self._makeOne() add = tweens.add_implicit add('browserid', 'browserid_factory') @@ -401,10 +475,10 @@ class TestTweens(unittest.TestCase): def test_implicit_ordering_conflict_indirect(self): from pyramid.exceptions import CyclicDependencyError + tweens = self._makeOne() add = tweens.add_implicit add('browserid', 'browserid_factory') add('auth', 'auth_factory', over='browserid') add('dbt', 'dbt_factory', under='browserid', over='auth') self.assertRaises(CyclicDependencyError, tweens.implicit) - diff --git a/tests/test_config/test_util.py b/tests/test_config/test_util.py index 540f3d14c..a56c00082 100644 --- a/tests/test_config/test_util.py +++ b/tests/test_config/test_util.py @@ -2,9 +2,11 @@ import unittest from pyramid.compat import text_ + class TestActionInfo(unittest.TestCase): def _getTargetClass(self): from pyramid.config.util import ActionInfo + return ActionInfo def _makeOne(self, filename, lineno, function, linerepr): @@ -13,11 +15,13 @@ class TestActionInfo(unittest.TestCase): def test_class_conforms(self): from zope.interface.verify import verifyClass from pyramid.interfaces import IActionInfo + verifyClass(IActionInfo, self._getTargetClass()) def test_instance_conforms(self): from zope.interface.verify import verifyObject from pyramid.interfaces import IActionInfo + verifyObject(IActionInfo, self._makeOne('f', 0, 'f', 'f')) def test_ctor(self): @@ -29,15 +33,16 @@ class TestActionInfo(unittest.TestCase): def test___str__(self): inst = self._makeOne('filename', 0, 'function', ' linerepr ') - self.assertEqual(str(inst), - "Line 0 of file filename:\n linerepr ") + self.assertEqual( + str(inst), "Line 0 of file filename:\n linerepr " + ) class TestPredicateList(unittest.TestCase): - def _makeOne(self): from pyramid.config.util import PredicateList from pyramid import predicates + inst = PredicateList() for name, factory in ( ('xhr', predicates.XHRPredicate), @@ -51,7 +56,7 @@ class TestPredicateList(unittest.TestCase): ('match_param', predicates.MatchParamPredicate), ('custom', predicates.CustomPredicate), ('traverse', predicates.TraversePredicate), - ): + ): inst.add(name, factory) return inst @@ -67,6 +72,7 @@ class TestPredicateList(unittest.TestCase): def test_ordering_number_of_predicates(self): from pyramid.config.util import predvalseq + order1, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -78,7 +84,7 @@ class TestPredicateList(unittest.TestCase): containment='containment', request_type='request_type', custom=predvalseq([DummyCustomPredicate()]), - ) + ) order2, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -90,7 +96,7 @@ class TestPredicateList(unittest.TestCase): containment='containment', request_type='request_type', custom=predvalseq([DummyCustomPredicate()]), - ) + ) order3, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -101,7 +107,7 @@ class TestPredicateList(unittest.TestCase): accept='accept', containment='containment', request_type='request_type', - ) + ) order4, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -111,7 +117,7 @@ class TestPredicateList(unittest.TestCase): header='header', accept='accept', containment='containment', - ) + ) order5, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -120,7 +126,7 @@ class TestPredicateList(unittest.TestCase): match_param='foo=bar', header='header', accept='accept', - ) + ) order6, _, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -128,34 +134,28 @@ class TestPredicateList(unittest.TestCase): request_param='param', match_param='foo=bar', header='header', - ) + ) order7, _, _ = self._callFUT( xhr='xhr', request_method='request_method', path_info='path_info', request_param='param', match_param='foo=bar', - ) + ) order8, _, _ = self._callFUT( xhr='xhr', request_method='request_method', path_info='path_info', request_param='param', - ) + ) order9, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - path_info='path_info', - ) + xhr='xhr', request_method='request_method', path_info='path_info' + ) order10, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - ) - order11, _, _ = self._callFUT( - xhr='xhr', - ) - order12, _, _ = self._callFUT( - ) + xhr='xhr', request_method='request_method' + ) + order11, _, _ = self._callFUT(xhr='xhr') + order12, _, _ = self._callFUT() self.assertEqual(order1, order2) self.assertTrue(order3 > order2) self.assertTrue(order4 > order3) @@ -170,36 +170,19 @@ class TestPredicateList(unittest.TestCase): def test_ordering_importance_of_predicates(self): from pyramid.config.util import predvalseq - order1, _, _ = self._callFUT( - xhr='xhr', - ) - order2, _, _ = self._callFUT( - request_method='request_method', - ) - order3, _, _ = self._callFUT( - path_info='path_info', - ) - order4, _, _ = self._callFUT( - request_param='param', - ) - order5, _, _ = self._callFUT( - header='header', - ) - order6, _, _ = self._callFUT( - accept='accept', - ) - order7, _, _ = self._callFUT( - containment='containment', - ) - order8, _, _ = self._callFUT( - request_type='request_type', - ) - order9, _, _ = self._callFUT( - match_param='foo=bar', - ) + + order1, _, _ = self._callFUT(xhr='xhr') + order2, _, _ = self._callFUT(request_method='request_method') + order3, _, _ = self._callFUT(path_info='path_info') + order4, _, _ = self._callFUT(request_param='param') + order5, _, _ = self._callFUT(header='header') + order6, _, _ = self._callFUT(accept='accept') + order7, _, _ = self._callFUT(containment='containment') + order8, _, _ = self._callFUT(request_type='request_type') + order9, _, _ = self._callFUT(match_param='foo=bar') order10, _, _ = self._callFUT( - custom=predvalseq([DummyCustomPredicate()]), - ) + custom=predvalseq([DummyCustomPredicate()]) + ) self.assertTrue(order1 > order2) self.assertTrue(order2 > order3) self.assertTrue(order3 > order4) @@ -212,53 +195,50 @@ class TestPredicateList(unittest.TestCase): def test_ordering_importance_and_number(self): from pyramid.config.util import predvalseq + order1, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - ) + xhr='xhr', request_method='request_method' + ) order2, _, _ = self._callFUT( - custom=predvalseq([DummyCustomPredicate()]), - ) + custom=predvalseq([DummyCustomPredicate()]) + ) self.assertTrue(order1 < order2) order1, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - ) + xhr='xhr', request_method='request_method' + ) order2, _, _ = self._callFUT( request_method='request_method', custom=predvalseq([DummyCustomPredicate()]), - ) + ) self.assertTrue(order1 > order2) order1, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - path_info='path_info', - ) + xhr='xhr', request_method='request_method', path_info='path_info' + ) order2, _, _ = self._callFUT( request_method='request_method', custom=predvalseq([DummyCustomPredicate()]), - ) + ) self.assertTrue(order1 < order2) order1, _, _ = self._callFUT( - xhr='xhr', - request_method='request_method', - path_info='path_info', - ) + xhr='xhr', request_method='request_method', path_info='path_info' + ) order2, _, _ = self._callFUT( xhr='xhr', request_method='request_method', custom=predvalseq([DummyCustomPredicate()]), - ) + ) self.assertTrue(order1 > order2) def test_different_custom_predicates_with_same_hash(self): from pyramid.config.util import predvalseq + class PredicateWithHash(object): def __hash__(self): return 1 + a = PredicateWithHash() b = PredicateWithHash() _, _, a_phash = self._callFUT(custom=predvalseq([a])) @@ -269,57 +249,71 @@ class TestPredicateList(unittest.TestCase): order, predicates, phash = self._callFUT(traverse='/1/:a/:b') self.assertEqual(len(predicates), 1) pred = predicates[0] - info = {'traverse':'abc'} + info = {'traverse': 'abc'} request = DummyRequest() result = pred(info, request) self.assertEqual(result, True) - self.assertEqual(info, {'traverse':'abc'}) + self.assertEqual(info, {'traverse': 'abc'}) def test_traverse_matches(self): order, predicates, phash = self._callFUT(traverse='/1/:a/:b') self.assertEqual(len(predicates), 1) pred = predicates[0] - info = {'match':{'a':'a', 'b':'b'}} + info = {'match': {'a': 'a', 'b': 'b'}} request = DummyRequest() result = pred(info, request) self.assertEqual(result, True) - self.assertEqual(info, {'match': - {'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}}) + self.assertEqual( + info, {'match': {'a': 'a', 'b': 'b', 'traverse': ('1', 'a', 'b')}} + ) def test_traverse_matches_with_highorder_chars(self): order, predicates, phash = self._callFUT( - traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')) + traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8') + ) self.assertEqual(len(predicates), 1) pred = predicates[0] - info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}} + info = {'match': {'x': text_(b'Qu\xc3\xa9bec', 'utf-8')}} request = DummyRequest() result = pred(info, request) self.assertEqual(result, True) self.assertEqual( info['match']['traverse'], - (text_(b'La Pe\xc3\xb1a', 'utf-8'), - text_(b'Qu\xc3\xa9bec', 'utf-8')) - ) + ( + text_(b'La Pe\xc3\xb1a', 'utf-8'), + text_(b'Qu\xc3\xa9bec', 'utf-8'), + ), + ) def test_custom_predicates_can_affect_traversal(self): from pyramid.config.util import predvalseq + def custom(info, request): m = info['match'] m['dummy'] = 'foo' return True + _, predicates, _ = self._callFUT( - custom=predvalseq([custom]), - traverse='/1/:dummy/:a') + custom=predvalseq([custom]), traverse='/1/:dummy/:a' + ) self.assertEqual(len(predicates), 2) - info = {'match':{'a':'a'}} + info = {'match': {'a': 'a'}} request = DummyRequest() self.assertTrue(all([p(info, request) for p in predicates])) - self.assertEqual(info, {'match': - {'a':'a', 'dummy':'foo', - 'traverse':('1', 'foo', 'a')}}) + self.assertEqual( + info, + { + 'match': { + 'a': 'a', + 'dummy': 'foo', + 'traverse': ('1', 'foo', 'a'), + } + }, + ) def test_predicate_text_is_correct(self): from pyramid.config.util import predvalseq + _, predicates, _ = self._callFUT( xhr='xhr', request_method='request_method', @@ -336,10 +330,12 @@ class TestPredicateList(unittest.TestCase): DummyCustomPredicate.classmethod_predicate_no_text, ] ), - match_param='foo=bar') + match_param='foo=bar', + ) self.assertEqual(predicates[0].text(), 'xhr = True') - self.assertEqual(predicates[1].text(), - "request_method = request_method") + self.assertEqual( + predicates[1].text(), "request_method = request_method" + ) self.assertEqual(predicates[2].text(), 'path_info = path_info') self.assertEqual(predicates[3].text(), 'request_param param') self.assertEqual(predicates[4].text(), 'header header') @@ -354,25 +350,25 @@ class TestPredicateList(unittest.TestCase): def test_match_param_from_string(self): _, predicates, _ = self._callFUT(match_param='foo=bar') request = DummyRequest() - request.matchdict = {'foo':'bar', 'baz':'bum'} + request.matchdict = {'foo': 'bar', 'baz': 'bum'} self.assertTrue(predicates[0](Dummy(), request)) def test_match_param_from_string_fails(self): _, predicates, _ = self._callFUT(match_param='foo=bar') request = DummyRequest() - request.matchdict = {'foo':'bum', 'baz':'bum'} + request.matchdict = {'foo': 'bum', 'baz': 'bum'} self.assertFalse(predicates[0](Dummy(), request)) def test_match_param_from_dict(self): - _, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum')) + _, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum')) request = DummyRequest() - request.matchdict = {'foo':'bar', 'baz':'bum'} + request.matchdict = {'foo': 'bar', 'baz': 'bum'} self.assertTrue(predicates[0](Dummy(), request)) def test_match_param_from_dict_fails(self): - _, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum')) + _, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum')) request = DummyRequest() - request.matchdict = {'foo':'bar', 'baz':'foo'} + request.matchdict = {'foo': 'bar', 'baz': 'foo'} self.assertFalse(predicates[0](Dummy(), request)) def test_request_method_sequence(self): @@ -386,20 +382,22 @@ class TestPredicateList(unittest.TestCase): self.assertFalse(predicates[0](Dummy(), request)) def test_request_method_ordering_hashes_same(self): - hash1, _, __= self._callFUT(request_method=('GET', 'HEAD')) - hash2, _, __= self._callFUT(request_method=('HEAD', 'GET')) + hash1, _, __ = self._callFUT(request_method=('GET', 'HEAD')) + hash2, _, __ = self._callFUT(request_method=('HEAD', 'GET')) self.assertEqual(hash1, hash2) - hash1, _, __= self._callFUT(request_method=('GET',)) - hash2, _, __= self._callFUT(request_method='GET') + hash1, _, __ = self._callFUT(request_method=('GET',)) + hash2, _, __ = self._callFUT(request_method='GET') self.assertEqual(hash1, hash2) def test_unknown_predicate(self): from pyramid.exceptions import ConfigurationError + self.assertRaises(ConfigurationError, self._callFUT, unknown=1) def test_predicate_close_matches(self): from pyramid.exceptions import ConfigurationError - with self.assertRaises(ConfigurationError) as context: + + with self.assertRaises(ConfigurationError) as context: self._callFUT(method='GET') expected_msg = ( "Unknown predicate values: {'method': 'GET'} " @@ -410,81 +408,111 @@ class TestPredicateList(unittest.TestCase): def test_notted(self): from pyramid.config import not_ from pyramid.testing import DummyRequest + request = DummyRequest() _, predicates, _ = self._callFUT( - xhr='xhr', - request_method=not_('POST'), - header=not_('header'), - ) + xhr='xhr', request_method=not_('POST'), header=not_('header') + ) self.assertEqual(predicates[0].text(), 'xhr = True') - self.assertEqual(predicates[1].text(), - "!request_method = POST") + self.assertEqual(predicates[1].text(), "!request_method = POST") self.assertEqual(predicates[2].text(), '!header header') self.assertEqual(predicates[1](None, request), True) self.assertEqual(predicates[2](None, request), True) + class TestDeprecatedPredicates(unittest.TestCase): def test_it(self): import warnings + with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') from pyramid.config.predicates import XHRPredicate + self.assertEqual(len(w), 1) + class Test_sort_accept_offers(unittest.TestCase): def _callFUT(self, offers, order=None): from pyramid.config.util import sort_accept_offers + return sort_accept_offers(offers, order) def test_default_specificities(self): result = self._callFUT(['text/html', 'text/html;charset=utf8']) - self.assertEqual(result, [ - 'text/html;charset=utf8', 'text/html', - ]) + self.assertEqual(result, ['text/html;charset=utf8', 'text/html']) def test_specific_type_order(self): result = self._callFUT( - ['text/html', 'application/json', 'text/html;charset=utf8', 'text/plain'], + [ + 'text/html', + 'application/json', + 'text/html;charset=utf8', + 'text/plain', + ], ['application/json', 'text/html'], ) - self.assertEqual(result, [ - 'application/json', 'text/html;charset=utf8', 'text/html', 'text/plain', - ]) + self.assertEqual( + result, + [ + 'application/json', + 'text/html;charset=utf8', + 'text/html', + 'text/plain', + ], + ) def test_params_order(self): result = self._callFUT( - ['text/html;charset=utf8', 'text/html;charset=latin1', 'text/html;foo=bar'], + [ + 'text/html;charset=utf8', + 'text/html;charset=latin1', + 'text/html;foo=bar', + ], ['text/html;charset=latin1', 'text/html;charset=utf8'], ) - self.assertEqual(result, [ - 'text/html;charset=latin1', 'text/html;charset=utf8', 'text/html;foo=bar', - ]) + self.assertEqual( + result, + [ + 'text/html;charset=latin1', + 'text/html;charset=utf8', + 'text/html;foo=bar', + ], + ) def test_params_inherit_type_prefs(self): result = self._callFUT( ['text/html;charset=utf8', 'text/plain;charset=latin1'], ['text/plain', 'text/html'], ) - self.assertEqual(result, ['text/plain;charset=latin1', 'text/html;charset=utf8']) + self.assertEqual( + result, ['text/plain;charset=latin1', 'text/html;charset=utf8'] + ) + class DummyCustomPredicate(object): def __init__(self): self.__text__ = 'custom predicate' - def classmethod_predicate(*args): pass + def classmethod_predicate(*args): + pass + classmethod_predicate.__text__ = 'classmethod predicate' classmethod_predicate = classmethod(classmethod_predicate) @classmethod - def classmethod_predicate_no_text(*args): pass # pragma: no cover + def classmethod_predicate_no_text(*args): + pass # pragma: no cover + class Dummy(object): def __init__(self, **kw): self.__dict__.update(**kw) + class DummyRequest: subpath = () matchdict = None + def __init__(self, environ=None): if environ is None: environ = {} @@ -492,6 +520,7 @@ class DummyRequest: self.params = {} self.cookies = {} + class DummyConfigurator(object): def maybe_dotted(self, thing): return thing diff --git a/tests/test_config/test_views.py b/tests/test_config/test_views.py index 1af3f66bc..9b2a306f6 100644 --- a/tests/test_config/test_views.py +++ b/tests/test_config/test_views.py @@ -6,28 +6,34 @@ from . import IDummy from . import dummy_view -from pyramid.compat import ( - im_func, - text_, - ) +from pyramid.compat import im_func, text_ from pyramid.exceptions import ConfigurationError from pyramid.exceptions import ConfigurationExecutionError from pyramid.exceptions import ConfigurationConflictError + class TestViewsConfigurationMixin(unittest.TestCase): def _makeOne(self, *arg, **kw): from pyramid.config import Configurator + config = Configurator(*arg, **kw) config.set_default_csrf_options(require_csrf=False) return config - def _getViewCallable(self, config, ctx_iface=None, exc_iface=None, - request_iface=None, name=''): + def _getViewCallable( + self, + config, + ctx_iface=None, + exc_iface=None, + request_iface=None, + name='', + ): from zope.interface import Interface from pyramid.interfaces import IRequest from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + if exc_iface: classifier = IExceptionViewClassifier ctx_iface = exc_iface @@ -38,16 +44,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): if request_iface is None: request_iface = IRequest return config.registry.adapters.lookup( - (classifier, request_iface, ctx_iface), IView, name=name, - default=None) + (classifier, request_iface, ctx_iface), + IView, + name=name, + default=None, + ) def _registerRenderer(self, config, name='.txt'): from pyramid.interfaces import IRendererFactory + class Renderer: def __init__(self, info): self.__class__.info = info + def __call__(self, *arg): return b'Hello!' + config.registry.registerUtility(Renderer, IRendererFactory, name=name) return Renderer @@ -58,15 +70,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): def _assertNotFound(self, wrapper, *arg): from pyramid.httpexceptions import HTTPNotFound + self.assertRaises(HTTPNotFound, wrapper, *arg) def _getRouteRequestIface(self, config, name): from pyramid.interfaces import IRouteRequest + iface = config.registry.getUtility(IRouteRequest, name) return iface def _assertRoute(self, config, name, path, num_predicates=0): from pyramid.interfaces import IRoutesMapper + mapper = config.registry.getUtility(IRoutesMapper) routes = mapper.get_routes() route = routes[0] @@ -83,18 +98,29 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_and_route_name(self): config = self._makeOne(autocommit=True) view = lambda *arg: 'OK' - self.assertRaises(ConfigurationError, config.add_view, view, '', None, - None, True, True) + self.assertRaises( + ConfigurationError, + config.add_view, + view, + '', + None, + None, + True, + True, + ) def test_add_view_with_request_type(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides from pyramid.interfaces import IRequest + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, - request_type='pyramid.interfaces.IRequest', - renderer=null_renderer) + config.add_view( + view=view, + request_type='pyramid.interfaces.IRequest', + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) request = DummyRequest() self._assertNotFound(wrapper, None, request) @@ -122,8 +148,9 @@ class TestViewsConfigurationMixin(unittest.TestCase): introspector = DummyIntrospector() config.introspector = introspector config.add_view(renderer='dummy.pt') - self.assertFalse(('renderer factories', '.pt') in - introspector.related[-1]) + self.assertFalse( + ('renderer factories', '.pt') in introspector.related[-1] + ) view = self._getViewCallable(config) self.assertRaises(ValueError, view, None, None) @@ -131,37 +158,45 @@ class TestViewsConfigurationMixin(unittest.TestCase): config = self._makeOne(autocommit=True) introspector = DummyIntrospector(True) config.introspector = introspector + def dummy_factory(helper): return lambda val, system_vals: 'Hello!' + config.add_renderer('.pt', dummy_factory) config.add_view(renderer='dummy.pt') self.assertTrue( - ('renderer factories', '.pt') in introspector.related[-1]) + ('renderer factories', '.pt') in introspector.related[-1] + ) view = self._getViewCallable(config) self.assertTrue(b'Hello!' in view(None, None).body) def test_add_view_wrapped_view_is_decorated(self): - def view(request): # request-only wrapper + def view(request): # request-only wrapper """ """ + config = self._makeOne(autocommit=True) config.add_view(view=view) wrapper = self._getViewCallable(config) self.assertEqual(wrapper.__module__, view.__module__) self.assertEqual(wrapper.__name__, view.__name__) self.assertEqual(wrapper.__doc__, view.__doc__) - self.assertEqual(wrapper.__discriminator__(None, None).resolve()[0], - 'view') + self.assertEqual( + wrapper.__discriminator__(None, None).resolve()[0], 'view' + ) def test_add_view_view_callable_dottedname(self): from pyramid.renderers import null_renderer + config = self._makeOne(autocommit=True) - config.add_view(view='tests.test_config.dummy_view', - renderer=null_renderer) + config.add_view( + view='tests.test_config.dummy_view', renderer=null_renderer + ) wrapper = self._getViewCallable(config) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_with_function_callable(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -171,8 +206,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_function_callable_requestonly(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -181,6 +218,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, name='abc', renderer=null_renderer) @@ -190,6 +228,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_name_unicode(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) name = text_(b'La Pe\xc3\xb1a', 'utf-8') @@ -200,16 +239,21 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_decorator(self): from pyramid.renderers import null_renderer + def view(request): """ ABC """ return 'OK' + def view_wrapper(fn): def inner(context, request): return fn(context, request) + return inner + config = self._makeOne(autocommit=True) - config.add_view(view=view, decorator=view_wrapper, - renderer=null_renderer) + config.add_view( + view=view, decorator=view_wrapper, renderer=null_renderer + ) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -218,20 +262,29 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_decorator_tuple(self): from pyramid.renderers import null_renderer + def view(request): """ ABC """ return 'OK' + def view_wrapper1(fn): def inner(context, request): return 'wrapped1' + fn(context, request) + return inner + def view_wrapper2(fn): def inner(context, request): return 'wrapped2' + fn(context, request) + return inner + config = self._makeOne(autocommit=True) - config.add_view(view=view, decorator=(view_wrapper2, view_wrapper1), - renderer=null_renderer) + config.add_view( + view=view, + decorator=(view_wrapper2, view_wrapper1), + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -241,12 +294,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_http_cache(self): import datetime from pyramid.response import Response + response = Response('OK') + def view(request): """ ABC """ return response + config = self._makeOne(autocommit=True) - config.add_view(view=view, http_cache=(86400, {'public':True})) + config.add_view(view=view, http_cache=(86400, {'public': True})) wrapper = self._getViewCallable(config) self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) @@ -261,10 +317,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instance(self): from pyramid.renderers import null_renderer + class AView: def __call__(self, context, request): """ """ return 'OK' + view = AView() config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -274,11 +332,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instancemethod(self): from pyramid.renderers import null_renderer + class View: def index(self, context, request): return 'OK' + view = View() - config=self._makeOne(autocommit=True) + config = self._makeOne(autocommit=True) config.add_view(view=view.index, renderer=null_renderer) wrapper = self._getViewCallable(config) result = wrapper(None, None) @@ -286,11 +346,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instancemethod_requestonly(self): from pyramid.renderers import null_renderer + class View: def index(self, request): return 'OK' + view = View() - config=self._makeOne(autocommit=True) + config = self._makeOne(autocommit=True) config.add_view(view=view.index, renderer=null_renderer) wrapper = self._getViewCallable(config) result = wrapper(None, None) @@ -298,10 +360,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_instance_requestonly(self): from pyramid.renderers import null_renderer + class AView: def __call__(self, request): """ """ return 'OK' + view = AView() config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) @@ -311,6 +375,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_oldstyle_class(self): from pyramid.renderers import null_renderer + class view: def __init__(self, context, request): self.context = context @@ -318,6 +383,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -328,12 +394,14 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_as_oldstyle_class_requestonly(self): from pyramid.renderers import null_renderer + class view: def __init__(self, request): self.request = request def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) @@ -346,9 +414,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_class(self): from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' + class Foo: pass + config = self._makeOne(autocommit=True) config.add_view(context=Foo, view=view, renderer=null_renderer) foo = implementedBy(Foo) @@ -357,6 +428,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_iface(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(context=IDummy, view=view, renderer=null_renderer) @@ -365,19 +437,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_as_dottedname(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(context='tests.test_config.IDummy', - view=view, renderer=null_renderer) + config.add_view( + context='tests.test_config.IDummy', + view=view, + renderer=null_renderer, + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) def test_add_view_for__as_dottedname(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(for_='tests.test_config.IDummy', - view=view, renderer=null_renderer) + config.add_view( + for_='tests.test_config.IDummy', view=view, renderer=null_renderer + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) @@ -385,9 +463,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' + class Foo: pass + config = self._makeOne(autocommit=True) config.add_view(for_=Foo, view=view, renderer=null_renderer) foo = implementedBy(Foo) @@ -397,6 +478,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_for_as_iface(self): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(for_=IDummy, view=view, renderer=null_renderer) @@ -406,12 +488,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_context_trumps_for(self): # ``for_`` is older spelling for ``context`` from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + class Foo: pass - config.add_view(context=IDummy, for_=Foo, view=view, - renderer=null_renderer) + + config.add_view( + context=IDummy, for_=Foo, view=view, renderer=null_renderer + ) wrapper = self._getViewCallable(config, IDummy) self.assertEqual(wrapper, view) @@ -421,13 +507,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import ISecuredView from pyramid.interfaces import IViewClassifier + view = lambda *arg: 'OK' view.__call_permissive__ = view config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) wrapper = config.registry.adapters.lookup( (IViewClassifier, IRequest, Interface), - ISecuredView, name='', default=None) + ISecuredView, + name='', + default=None, + ) self.assertEqual(wrapper, view) def test_add_view_exception_register_secured_view(self): @@ -436,13 +526,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier + view = lambda *arg: 'OK' view.__call_permissive__ = view config = self._makeOne(autocommit=True) - config.add_view(view=view, context=RuntimeError, renderer=null_renderer) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = config.registry.adapters.lookup( (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='', default=None) + IView, + name='', + default=None, + ) self.assertEqual(wrapper, view) def test_add_view_same_phash_overrides_existing_single_view(self): @@ -453,15 +549,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + phash = md5() phash.update(b'xhr = True') view = lambda *arg: 'NOT OK' view.__phash__ = phash.hexdigest() config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, xhr=True, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -477,6 +577,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + phash = md5() phash.update(b'xhr = True') view = lambda *arg: 'NOT OK' @@ -485,13 +586,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, xhr=True, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, + xhr=True, + context=RuntimeError, + renderer=null_renderer, + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -504,12 +614,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -524,18 +638,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -549,13 +670,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' view.__phash__ = DEFAULT_PHASH config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + def newview(context, request): return 'OK' + config.add_view(view=newview, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertFalse(IMultiView.providedBy(wrapper)) @@ -571,19 +696,26 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'NOT OK' view.__phash__ = DEFAULT_PHASH config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) + def newview(context, request): return 'OK' - config.add_view(view=newview, context=RuntimeError, - renderer=null_renderer) + + config.add_view( + view=newview, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True @@ -596,11 +728,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -614,21 +748,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IExceptionViewClassifier from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view, context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') @@ -639,12 +780,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import ISecuredView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), - ISecuredView, name='') + view, (IViewClassifier, IRequest, Interface), ISecuredView, name='' + ) config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -658,20 +800,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - ISecuredView, name='') + ISecuredView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - ISecuredView, name='') - config.add_view(view=view, context=RuntimeError, renderer=null_renderer) + ISecuredView, + name='', + ) + config.add_view( + view=view, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') @@ -682,13 +832,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view2, accept='text/html', renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -701,16 +855,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_mixed_case_replaces_existing_view(self): from pyramid.renderers import null_renderer - def view(context, request): return 'OK' - def view2(context, request): return 'OK2' - def view3(context, request): return 'OK3' + + def view(context, request): + return 'OK' + + def view2(context, request): + return 'OK2' + + def view3(context, request): + return 'OK3' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) config.add_view(view=view2, accept='text/html', renderer=null_renderer) config.add_view(view=view3, accept='text/HTML', renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) - self.assertEqual(len(wrapper.media_views.items()),1) + self.assertEqual(len(wrapper.media_views.items()), 1) self.assertFalse('text/HTML' in wrapper.media_views) self.assertEqual(wrapper(None, None), 'OK') request = DummyRequest() @@ -719,9 +880,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_views_with_accept_multiview_replaces_existing(self): from pyramid.renderers import null_renderer - def view(context, request): return 'OK' - def view2(context, request): return 'OK2' - def view3(context, request): return 'OK3' + + def view(context, request): + return 'OK' + + def view2(context, request): + return 'OK2' + + def view3(context, request): + return 'OK3' + config = self._makeOne(autocommit=True) config.add_view(view=view, renderer=null_renderer) config.add_view(view=view2, accept='text/html', renderer=null_renderer) @@ -741,23 +909,35 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view2, accept='text/html', context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view2, + accept='text/html', + context=RuntimeError, + renderer=null_renderer, + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) @@ -773,15 +953,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + view.__accept__ = 'text/html' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) config.add_view(view=view2, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) @@ -800,25 +984,34 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + def view(context, request): return 'OK' + def view2(context, request): return 'OK2' + view.__accept__ = 'text/html' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') + IView, + name='', + ) config.registry.registerAdapter( view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IView, name='') - config.add_view(view=view2, context=RuntimeError, - renderer=null_renderer) + IView, + name='', + ) + config.add_view( + view=view2, context=RuntimeError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) @@ -833,16 +1026,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IRequest from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), - IMultiView, name='') + view, (IViewClassifier, IRequest, Interface), IMultiView, name='' + ) view2 = lambda *arg: 'OK2' config.add_view(view=view2, renderer=null_renderer) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) - self.assertEqual([(x[0], x[2]) for x in wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in wrapper.views], [(view2, None)] + ) self.assertEqual(wrapper(None, None), 'OK1') def test_add_view_exc_multiview_replaces_multiviews(self): @@ -852,30 +1048,42 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + hot_view = DummyMultiView() exc_view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( hot_view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) config.registry.registerAdapter( exc_view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) view2 = lambda *arg: 'OK2' - config.add_view(view=view2, context=RuntimeError, - renderer=null_renderer) + config.add_view( + view=view2, context=RuntimeError, renderer=null_renderer + ) hot_wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError)) + config, ctx_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(hot_wrapper)) - self.assertEqual([(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in hot_wrapper.views], [(view2, None)] + ) self.assertEqual(hot_wrapper(None, None), 'OK1') exc_wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(exc_wrapper)) - self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)] + ) self.assertEqual(exc_wrapper(None, None), 'OK1') def test_add_view_exc_multiview_replaces_only_exc_multiview(self): @@ -885,30 +1093,43 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + hot_view = DummyMultiView() exc_view = DummyMultiView() config = self._makeOne(autocommit=True) config.registry.registerAdapter( hot_view, (IViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) config.registry.registerAdapter( exc_view, (IExceptionViewClassifier, IRequest, implementedBy(RuntimeError)), - IMultiView, name='') + IMultiView, + name='', + ) view2 = lambda *arg: 'OK2' - config.add_view(view=view2, context=RuntimeError, exception_only=True, - renderer=null_renderer) + config.add_view( + view=view2, + context=RuntimeError, + exception_only=True, + renderer=null_renderer, + ) hot_wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError)) + config, ctx_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(hot_wrapper)) self.assertEqual(len(hot_wrapper.views), 0) self.assertEqual(hot_wrapper(None, None), 'OK1') exc_wrapper = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError)) + config, exc_iface=implementedBy(RuntimeError) + ) self.assertTrue(IMultiView.providedBy(exc_wrapper)) - self.assertEqual([(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)]) + self.assertEqual( + [(x[0], x[2]) for x in exc_wrapper.views], [(view2, None)] + ) self.assertEqual(exc_wrapper(None, None), 'OK1') def test_add_view_multiview_context_superclass_then_subclass(self): @@ -918,22 +1139,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier + class ISuper(Interface): pass + class ISub(ISuper): pass + view = lambda *arg: 'OK' view2 = lambda *arg: 'OK2' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, ISuper), IView, name='') + view, (IViewClassifier, IRequest, ISuper), IView, name='' + ) config.add_view(view=view2, for_=ISub, renderer=null_renderer) - wrapper = self._getViewCallable(config, ctx_iface=ISuper, - request_iface=IRequest) + wrapper = self._getViewCallable( + config, ctx_iface=ISuper, request_iface=IRequest + ) self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') - wrapper = self._getViewCallable(config, ctx_iface=ISub, - request_iface=IRequest) + wrapper = self._getViewCallable( + config, ctx_iface=ISub, request_iface=IRequest + ) self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK2') @@ -945,29 +1172,38 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IMultiView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IExceptionViewClassifier + class Super(Exception): pass + class Sub(Super): pass + view = lambda *arg: 'OK' view2 = lambda *arg: 'OK2' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Super), IView, name='') + view, (IViewClassifier, IRequest, Super), IView, name='' + ) config.registry.registerAdapter( - view, (IExceptionViewClassifier, IRequest, Super), IView, name='') + view, (IExceptionViewClassifier, IRequest, Super), IView, name='' + ) config.add_view(view=view2, for_=Sub, renderer=null_renderer) wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(Super), request_iface=IRequest) + config, ctx_iface=implementedBy(Super), request_iface=IRequest + ) wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(Super), request_iface=IRequest) + config, exc_iface=implementedBy(Super), request_iface=IRequest + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK') wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(Sub), request_iface=IRequest) + config, ctx_iface=implementedBy(Sub), request_iface=IRequest + ) wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(Sub), request_iface=IRequest) + config, exc_iface=implementedBy(Sub), request_iface=IRequest + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK2') @@ -975,28 +1211,55 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_multiview_call_ordering(self): from pyramid.renderers import null_renderer as nr from zope.interface import directlyProvides - def view1(context, request): return 'view1' - def view2(context, request): return 'view2' - def view3(context, request): return 'view3' - def view4(context, request): return 'view4' - def view5(context, request): return 'view5' - def view6(context, request): return 'view6' - def view7(context, request): return 'view7' - def view8(context, request): return 'view8' + + def view1(context, request): + return 'view1' + + def view2(context, request): + return 'view2' + + def view3(context, request): + return 'view3' + + def view4(context, request): + return 'view4' + + def view5(context, request): + return 'view5' + + def view6(context, request): + return 'view6' + + def view7(context, request): + return 'view7' + + def view8(context, request): + return 'view8' + config = self._makeOne(autocommit=True) config.add_view(view=view1, renderer=nr) config.add_view(view=view2, request_method='POST', renderer=nr) - config.add_view(view=view3,request_param='param', renderer=nr) + config.add_view(view=view3, request_param='param', renderer=nr) config.add_view(view=view4, containment=IDummy, renderer=nr) - config.add_view(view=view5, request_method='POST', - request_param='param', renderer=nr) - config.add_view(view=view6, request_method='POST', containment=IDummy, - renderer=nr) - config.add_view(view=view7, request_param='param', containment=IDummy, - renderer=nr) - config.add_view(view=view8, request_method='POST',request_param='param', - containment=IDummy, renderer=nr) - + config.add_view( + view=view5, + request_method='POST', + request_param='param', + renderer=nr, + ) + config.add_view( + view=view6, request_method='POST', containment=IDummy, renderer=nr + ) + config.add_view( + view=view7, request_param='param', containment=IDummy, renderer=nr + ) + config.add_view( + view=view8, + request_method='POST', + request_param='param', + containment=IDummy, + renderer=nr, + ) wrapper = self._getViewCallable(config) @@ -1014,7 +1277,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): ctx = DummyContext() request = self._makeRequest(config) - request.params = {'param':'1'} + request.params = {'param': '1'} request.method = 'GET' self.assertEqual(wrapper(ctx, request), 'view3') @@ -1028,7 +1291,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): ctx = DummyContext() request = self._makeRequest(config) request.method = 'POST' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view5') ctx = DummyContext() @@ -1042,40 +1305,55 @@ class TestViewsConfigurationMixin(unittest.TestCase): directlyProvides(ctx, IDummy) request = self._makeRequest(config) request.method = 'GET' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view7') ctx = DummyContext() directlyProvides(ctx, IDummy) request = self._makeRequest(config) request.method = 'POST' - request.params = {'param':'1'} + request.params = {'param': '1'} self.assertEqual(wrapper(ctx, request), 'view8') def test_view_with_most_specific_predicate(self): from pyramid.renderers import null_renderer as nr from pyramid.router import Router - class OtherBase(object): pass - class Int1(object): pass - class Int2(object): pass + class OtherBase(object): + pass + + class Int1(object): + pass + + class Int2(object): + pass class Resource(OtherBase, Int1, Int2): - def __init__(self, request): pass + def __init__(self, request): + pass - def unknown(context, request): return 'unknown' - def view(context, request): return 'hello' + def unknown(context, request): + return 'unknown' + + def view(context, request): + return 'hello' config = self._makeOne(autocommit=True) config.add_route('root', '/', factory=Resource) config.add_view(unknown, route_name='root', renderer=nr) config.add_view( - view, renderer=nr, route_name='root', - context=Int1, request_method='GET' + view, + renderer=nr, + route_name='root', + context=Int1, + request_method='GET', ) config.add_view( - view=view, renderer=nr, route_name='root', - context=Int2, request_method='POST' + view=view, + renderer=nr, + route_name='root', + context=Int2, + request_method='POST', ) request = self._makeRequest(config) request.method = 'POST' @@ -1088,15 +1366,24 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer as nr from pyramid.router import Router - class OtherBase(object): pass - class Int1(object): pass - class Int2(object): pass + class OtherBase(object): + pass + + class Int1(object): + pass + + class Int2(object): + pass class Resource(OtherBase, Int1, Int2): - def __init__(self, request): pass + def __init__(self, request): + pass + + def unknown(context, request): + return 'unknown' - def unknown(context, request): return 'unknown' - def view(context, request): return 'hello' + def view(context, request): + return 'hello' config = self._makeOne(autocommit=True) config.add_route('root', '/', factory=Resource) @@ -1110,12 +1397,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): ) config.add_view( - view, renderer=nr, route_name='root', - context=Int1, request_method='GET' + view, + renderer=nr, + route_name='root', + context=Int1, + request_method='GET', ) config.add_view( - view=view, renderer=nr, route_name='root', - context=Int2, request_method='POST' + view=view, + renderer=nr, + route_name='root', + context=Int2, + request_method='POST', ) request = self._makeRequest(config) request.method = 'POST' @@ -1127,16 +1420,21 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_multiview___discriminator__(self): from pyramid.renderers import null_renderer from zope.interface import Interface + class IFoo(Interface): pass + class IBar(Interface): pass + @implementer(IFoo) class Foo(object): pass + @implementer(IBar) class Bar(object): pass + foo = Foo() bar = Bar() @@ -1144,33 +1442,35 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import IMultiView + view = lambda *arg: 'OK' view.__phash__ = 'abc' config = self._makeOne(autocommit=True) config.registry.registerAdapter( - view, (IViewClassifier, IRequest, Interface), IView, name='') - config.add_view(view=view, renderer=null_renderer, - containment=IFoo) - config.add_view(view=view, renderer=null_renderer, - containment=IBar) + view, (IViewClassifier, IRequest, Interface), IView, name='' + ) + config.add_view(view=view, renderer=null_renderer, containment=IFoo) + config.add_view(view=view, renderer=null_renderer, containment=IBar) wrapper = self._getViewCallable(config) self.assertTrue(IMultiView.providedBy(wrapper)) request = self._makeRequest(config) self.assertNotEqual( wrapper.__discriminator__(foo, request), wrapper.__discriminator__(bar, request), - ) + ) def test_add_view_with_template_renderer(self): from tests import test_config from pyramid.interfaces import ISettings + class view(object): def __init__(self, context, request): self.request = request self.context = context def __call__(self): - return {'a':'1'} + return {'a': '1'} + config = self._makeOne(autocommit=True) renderer = self._registerRenderer(config) fixture = 'tests.test_config:files/minimal.txt' @@ -1195,13 +1495,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): self.context = context def __call__(self): - return {'a':'1'} + return {'a': '1'} + config = self._makeOne(autocommit=True) + class moo(object): def __init__(self, *arg, **kw): pass + def __call__(self, *arg, **kw): return b'moo' + config.add_renderer(None, moo) config.add_view(view=view) wrapper = self._getViewCallable(config) @@ -1212,6 +1516,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_template_renderer_no_callable(self): from tests import test_config from pyramid.interfaces import ISettings + config = self._makeOne(autocommit=True) renderer = self._registerRenderer(config) fixture = 'tests.test_config:files/minimal.txt' @@ -1232,8 +1537,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_as_iface(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + def view(context, request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(request_type=IDummy, view=view, renderer=null_renderer) wrapper = self._getViewCallable(config, None) @@ -1245,11 +1552,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_type_as_noniface(self): view = lambda *arg: 'OK' config = self._makeOne() - self.assertRaises(ConfigurationError, - config.add_view, view, '', None, None, object) + self.assertRaises( + ConfigurationError, config.add_view, view, '', None, None, object + ) def test_add_view_with_route_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_route('foo', '/a/b') @@ -1262,6 +1571,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_nonexistant_route_name(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne() config.add_view(view=view, route_name='foo', renderer=null_renderer) @@ -1270,28 +1580,39 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_route_name_exception(self): from pyramid.renderers import null_renderer from zope.interface import implementedBy + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_route('foo', '/a/b') - config.add_view(view=view, route_name='foo', context=RuntimeError, - renderer=null_renderer) + config.add_view( + view=view, + route_name='foo', + context=RuntimeError, + renderer=null_renderer, + ) request_iface = self._getRouteRequestIface(config, 'foo') wrapper_exc_view = self._getViewCallable( - config, exc_iface=implementedBy(RuntimeError), - request_iface=request_iface) + config, + exc_iface=implementedBy(RuntimeError), + request_iface=request_iface, + ) self.assertNotEqual(wrapper_exc_view, None) wrapper = self._getViewCallable( - config, ctx_iface=implementedBy(RuntimeError), - request_iface=request_iface) + config, + ctx_iface=implementedBy(RuntimeError), + request_iface=request_iface, + ) self.assertEqual(wrapper_exc_view, wrapper) self.assertEqual(wrapper_exc_view(None, None), 'OK') def test_add_view_with_request_method_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='POST', - renderer=null_renderer) + config.add_view( + view=view, request_method='POST', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'POST' @@ -1308,10 +1629,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_sequence_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method=('POST', 'GET'), - renderer=null_renderer) + config.add_view( + view=view, request_method=('POST', 'GET'), renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'POST' @@ -1319,12 +1642,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_sequence_conflict(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne() - config.add_view(view=view, request_method=('POST', 'GET'), - renderer=null_renderer) - config.add_view(view=view, request_method=('GET', 'POST'), - renderer=null_renderer) + config.add_view( + view=view, request_method=('POST', 'GET'), renderer=null_renderer + ) + config.add_view( + view=view, request_method=('GET', 'POST'), renderer=null_renderer + ) self.assertRaises(ConfigurationConflictError, config.commit) def test_add_view_with_request_method_sequence_false(self): @@ -1338,9 +1664,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_method_get_implies_head(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='GET', renderer=null_renderer) + config.add_view( + view=view, request_method='GET', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'HEAD' @@ -1348,12 +1677,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_param_noval_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, request_param='abc', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':''} + request.params = {'abc': ''} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_request_param_noval_false(self): @@ -1367,13 +1697,15 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_request_param_val_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_param='abc=123', - renderer=null_renderer) + config.add_view( + view=view, request_param='abc=123', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':'123'} + request.params = {'abc': '123'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_request_param_val_false(self): @@ -1382,11 +1714,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, request_param='abc=123') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.params = {'abc':''} + request.params = {'abc': ''} self._assertNotFound(wrapper, None, request) def test_add_view_with_xhr_true(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, xhr=True, renderer=null_renderer) @@ -1412,12 +1745,13 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_header_noval_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header='Host', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'whatever'} + request.headers = {'Host': 'whatever'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_header_noval_nomatch(self): @@ -1426,17 +1760,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, header='Host') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'NotHost':'whatever'} + request.headers = {'NotHost': 'whatever'} self._assertNotFound(wrapper, None, request) def test_add_view_with_header_val_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header=r'Host:\d', renderer=null_renderer) wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'1'} + request.headers = {'Host': '1'} self.assertEqual(wrapper(None, request), 'OK') def test_add_view_with_header_val_nomatch(self): @@ -1445,21 +1780,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.add_view(view=view, header=r'Host:\d') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'Host':'abc'} + request.headers = {'Host': 'abc'} self._assertNotFound(wrapper, None, request) def test_add_view_with_header_val_missing(self): from pyramid.httpexceptions import HTTPNotFound + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, header=r'Host:\d') wrapper = self._getViewCallable(config) request = self._makeRequest(config) - request.headers = {'NoHost':'1'} + request.headers = {'NoHost': '1'} self.assertRaises(HTTPNotFound, wrapper, None, request) def test_add_view_with_accept_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, accept='text/xml', renderer=null_renderer) @@ -1479,6 +1816,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_range_accept_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, accept='text/*', renderer=null_renderer) @@ -1499,6 +1837,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_containment_true(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, containment=IDummy, renderer=null_renderer) @@ -1518,12 +1857,14 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_containment_dottedname(self): from pyramid.renderers import null_renderer from zope.interface import directlyProvides + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view( view=view, containment='tests.test_config.IDummy', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1537,6 +1878,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_path_info_match(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_view(view=view, path_info='/foo', renderer=null_renderer) @@ -1557,6 +1899,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_check_csrf_predicates_match(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) with warnings.catch_warnings(record=True) as w: @@ -1574,17 +1917,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_custom_predicates_match(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + def pred2(context, request): return True + predicates = (pred1, pred2) with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') - config.add_view(view=view, custom_predicates=predicates, - renderer=null_renderer) + config.add_view( + view=view, custom_predicates=predicates, renderer=null_renderer + ) self.assertEqual(len(w), 1) wrapper = self._getViewCallable(config) request = self._makeRequest(config) @@ -1592,12 +1940,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_custom_predicates_nomatch(self): import warnings + view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + def pred2(context, request): return False + predicates = (pred1, pred2) with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') @@ -1610,17 +1962,22 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_custom_predicate_bests_standard_predicate(self): import warnings from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' view2 = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) + def pred1(context, request): return True + with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') - config.add_view(view=view, custom_predicates=(pred1,), - renderer=null_renderer) - config.add_view(view=view2, request_method='GET', - renderer=null_renderer) + config.add_view( + view=view, custom_predicates=(pred1,), renderer=null_renderer + ) + config.add_view( + view=view2, request_method='GET', renderer=null_renderer + ) self.assertEqual(len(w), 1) wrapper = self._getViewCallable(config) request = self._makeRequest(config) @@ -1629,13 +1986,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_custom_more_preds_first_bests_fewer_preds_last(self): from pyramid.renderers import null_renderer + view = lambda *arg: 'OK' view2 = lambda *arg: 'NOT OK' config = self._makeOne(autocommit=True) - config.add_view(view=view, request_method='GET', xhr=True, - renderer=null_renderer) - config.add_view(view=view2, request_method='GET', - renderer=null_renderer) + config.add_view( + view=view, request_method='GET', xhr=True, renderer=null_renderer + ) + config.add_view( + view=view2, request_method='GET', renderer=null_renderer + ) wrapper = self._getViewCallable(config) request = self._makeRequest(config) request.method = 'GET' @@ -1652,8 +2012,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_csrf_param(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf='st', renderer=null_renderer) view = self._getViewCallable(config) @@ -1667,8 +2029,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_csrf_header(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf=True, renderer=null_renderer) view = self._getViewCallable(config) @@ -1683,7 +2047,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_missing_csrf_header(self): from pyramid.exceptions import BadCSRFToken from pyramid.renderers import null_renderer - def view(request): return 'OK' + + def view(request): + return 'OK' + config = self._makeOne(autocommit=True) config.add_view(view, require_csrf=True, renderer=null_renderer) view = self._getViewCallable(config) @@ -1697,21 +2064,27 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' outerself = self + class DummyPolicy(object): def effective_principals(self, r): outerself.assertEqual(r, request) return ['abc'] + def permits(self, context, principals, permission): outerself.assertEqual(context, None) outerself.assertEqual(principals, ['abc']) outerself.assertEqual(permission, 'view') return True + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + autocommit=True, + ) config.add_view(view=view1, permission='view', renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1719,22 +2092,28 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_default_permission_no_explicit_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' outerself = self + class DummyPolicy(object): def effective_principals(self, r): outerself.assertEqual(r, request) return ['abc'] + def permits(self, context, principals, permission): outerself.assertEqual(context, None) outerself.assertEqual(principals, ['abc']) outerself.assertEqual(permission, 'view') return True + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - default_permission='view', - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + default_permission='view', + autocommit=True, + ) config.add_view(view=view1, renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1742,12 +2121,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_no_default_permission_no_explicit_permission(self): from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' - class DummyPolicy(object): pass # wont be called + + class DummyPolicy(object): + pass # wont be called + policy = DummyPolicy() - config = self._makeOne(authorization_policy=policy, - authentication_policy=policy, - autocommit=True) + config = self._makeOne( + authorization_policy=policy, + authentication_policy=policy, + autocommit=True, + ) config.add_view(view=view1, renderer=null_renderer) view = self._getViewCallable(config) request = self._makeRequest(config) @@ -1755,13 +2140,19 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_mapper(self): from pyramid.renderers import null_renderer + class Mapper(object): def __init__(self, **kw): self.__class__.kw = kw + def __call__(self, view): return view + config = self._makeOne(autocommit=True) - def view(context, request): return 'OK' + + def view(context, request): + return 'OK' + config.add_view(view=view, mapper=Mapper, renderer=null_renderer) view = self._getViewCallable(config) self.assertEqual(view(None, None), 'OK') @@ -1771,18 +2162,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) - config.add_view( - view=view, - renderer=null_renderer) + config.add_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1796,10 +2187,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + config = self._makeOne(autocommit=True) config.add_view( view='tests.test_config.test_views.DummyViewDefaultsClass', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1813,10 +2206,12 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides + config = self._makeOne(autocommit=True) config.add_view( 'tests.test_config.test_views.DummyViewDefaultsClass', - renderer=null_renderer) + renderer=null_renderer, + ) wrapper = self._getViewCallable(config) context = DummyContext() directlyProvides(context, IDummy) @@ -1828,40 +2223,30 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_with_view_config_and_view_defaults_doesnt_conflict(self): from pyramid.renderers import null_renderer + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + class view2(object): - __view_defaults__ = { - 'containment':'tests.test_config.IFactory' - } + __view_defaults__ = {'containment': 'tests.test_config.IFactory'} + config = self._makeOne(autocommit=False) - config.add_view( - view=view, - renderer=null_renderer) - config.add_view( - view=view2, - renderer=null_renderer) - config.commit() # does not raise + config.add_view(view=view, renderer=null_renderer) + config.add_view(view=view2, renderer=null_renderer) + config.commit() # does not raise def test_add_view_with_view_config_and_view_defaults_conflicts(self): from pyramid.renderers import null_renderer + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + class view2(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + config = self._makeOne(autocommit=False) - config.add_view( - view=view, - renderer=null_renderer) - config.add_view( - view=view2, - renderer=null_renderer) + config.add_view(view=view, renderer=null_renderer) + config.add_view(view=view2, renderer=null_renderer) self.assertRaises(ConfigurationConflictError, config.commit) def test_add_view_class_method_no_attr(self): @@ -1870,8 +2255,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.exceptions import ConfigurationError config = self._makeOne(autocommit=True) + class DummyViewClass(object): - def run(self): pass + def run(self): + pass def configure_view(): config.add_view(view=DummyViewClass.run, renderer=null_renderer) @@ -1881,41 +2268,62 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_exception_only_no_regular_view(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view1, context=Exception, exception_only=True, - renderer=null_renderer) - view = self._getViewCallable(config, ctx_iface=implementedBy(Exception)) + config.add_view( + view=view1, + context=Exception, + exception_only=True, + renderer=null_renderer, + ) + view = self._getViewCallable( + config, ctx_iface=implementedBy(Exception) + ) self.assertTrue(view is None) def test_add_view_exception_only(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_view(view=view1, context=Exception, exception_only=True, - renderer=null_renderer) + config.add_view( + view=view1, + context=Exception, + exception_only=True, + renderer=null_renderer, + ) view = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) self.assertEqual(view1, view) def test_add_view_exception_only_misconfiguration(self): view = lambda *arg: 'OK' config = self._makeOne(autocommit=True) + class NotAnException(object): pass + self.assertRaises( ConfigurationError, - config.add_view, view, context=NotAnException, exception_only=True) + config.add_view, + view, + context=NotAnException, + exception_only=True, + ) def test_add_exception_view(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) config.add_exception_view(view=view1, renderer=null_renderer) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) context = Exception() request = self._makeRequest(config) self.assertEqual(wrapper(context, request), 'OK') @@ -1923,71 +2331,86 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_exception_view_with_subclass(self): from zope.interface import implementedBy from pyramid.renderers import null_renderer + view1 = lambda *arg: 'OK' config = self._makeOne(autocommit=True) - config.add_exception_view(view=view1, context=ValueError, - renderer=null_renderer) + config.add_exception_view( + view=view1, context=ValueError, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(ValueError)) + config, exc_iface=implementedBy(ValueError) + ) context = ValueError() request = self._makeRequest(config) self.assertEqual(wrapper(context, request), 'OK') def test_add_exception_view_disallows_name(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - name='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + name='foo', + ) def test_add_exception_view_disallows_permission(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - permission='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + permission='foo', + ) def test_add_exception_view_disallows_require_csrf(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - require_csrf=True) + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + require_csrf=True, + ) def test_add_exception_view_disallows_for_(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - for_='foo') + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + for_='foo', + ) def test_add_exception_view_disallows_exception_only(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_exception_view, - context=Exception(), - exception_only=True) + self.assertRaises( + ConfigurationError, + config.add_exception_view, + context=Exception(), + exception_only=True, + ) def test_add_exception_view_with_view_defaults(self): from pyramid.renderers import null_renderer from pyramid.exceptions import PredicateMismatch from zope.interface import directlyProvides from zope.interface import implementedBy + class view(object): - __view_defaults__ = { - 'containment': 'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) config.add_exception_view( - view=view, - context=Exception, - renderer=null_renderer) + view=view, context=Exception, renderer=null_renderer + ) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(Exception)) + config, exc_iface=implementedBy(Exception) + ) context = DummyContext() directlyProvides(context, IDummy) request = self._makeRequest(config) @@ -1998,8 +2421,10 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_derive_view_function(self): from pyramid.renderers import null_renderer + def view(request): return 'OK' + config = self._makeOne() result = config.derive_view(view, renderer=null_renderer) self.assertFalse(result is view) @@ -2007,37 +2432,48 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_derive_view_dottedname(self): from pyramid.renderers import null_renderer + config = self._makeOne() result = config.derive_view( - 'tests.test_config.dummy_view', - renderer=null_renderer) + 'tests.test_config.dummy_view', renderer=null_renderer + ) self.assertFalse(result is dummy_view) self.assertEqual(result(None, None), 'OK') def test_derive_view_with_default_renderer_no_explicit_renderer(self): config = self._makeOne() + class moo(object): def __init__(self, view): pass + def __call__(self, *arg, **kw): return 'moo' + config.add_renderer(None, moo) config.commit() + def view(request): return 'OK' + result = config.derive_view(view) self.assertFalse(result is view) self.assertEqual(result(None, None).body, b'moo') def test_derive_view_with_default_renderer_with_explicit_renderer(self): - class moo(object): pass + class moo(object): + pass + class foo(object): def __init__(self, view): pass + def __call__(self, *arg, **kw): return b'foo' + def view(request): return 'OK' + config = self._makeOne() config.add_renderer(None, moo) config.add_renderer('foo', foo) @@ -2052,64 +2488,71 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import Interface from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier + config = self._makeOne(autocommit=True) config.add_static_view('static', 'files', renderer=null_renderer) request_type = self._getRouteRequestIface(config, '__static/') self._assertRoute(config, '__static/', 'static/*subpath') wrapped = config.registry.adapters.lookup( - (IViewClassifier, request_type, Interface), IView, name='') + (IViewClassifier, request_type, Interface), IView, name='' + ) from pyramid.request import Request + request = Request.blank('/static/minimal.txt') - request.subpath = ('minimal.txt', ) + request.subpath = ('minimal.txt',) result = wrapped(None, request) self.assertEqual(result.status, '200 OK') self.assertTrue(result.body.startswith(b'<div')) def test_add_static_view_package_relative(self): from pyramid.interfaces import IStaticURLInfo + info = DummyStaticURLInfo() config = self._makeOne(autocommit=True) config.registry.registerUtility(info, IStaticURLInfo) - config.add_static_view('static', - 'tests.test_config:files') + config.add_static_view('static', 'tests.test_config:files') self.assertEqual( - info.added, - [(config, 'static', 'tests.test_config:files', {})]) + info.added, [(config, 'static', 'tests.test_config:files', {})] + ) def test_add_static_view_package_here_relative(self): from pyramid.interfaces import IStaticURLInfo + info = DummyStaticURLInfo() config = self._makeOne(autocommit=True) config.registry.registerUtility(info, IStaticURLInfo) config.add_static_view('static', 'files') self.assertEqual( - info.added, - [(config, 'static', 'tests.test_config:files', {})]) + info.added, [(config, 'static', 'tests.test_config:files', {})] + ) def test_add_static_view_absolute(self): import os from pyramid.interfaces import IStaticURLInfo + info = DummyStaticURLInfo() config = self._makeOne(autocommit=True) config.registry.registerUtility(info, IStaticURLInfo) here = os.path.dirname(__file__) static_path = os.path.join(here, 'files') config.add_static_view('static', static_path) - self.assertEqual(info.added, - [(config, 'static', static_path, {})]) + self.assertEqual(info.added, [(config, 'static', static_path, {})]) def test_add_forbidden_view(self): from pyramid.renderers import null_renderer from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPForbidden + config = self._makeOne(autocommit=True) view = lambda *arg: 'OK' config.add_forbidden_view(view, renderer=null_renderer) request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPForbidden), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPForbidden), + request_iface=IRequest, + ) result = view(None, request) self.assertEqual(result, 'OK') @@ -2117,19 +2560,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPForbidden + config = self._makeOne(autocommit=True) config.setup_registry() config.add_forbidden_view() request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPForbidden), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPForbidden), + request_iface=IRequest, + ) context = HTTPForbidden() result = view(context, request) self.assertEqual(result, context) def test_add_forbidden_view_allows_other_predicates(self): from pyramid.renderers import null_renderer + config = self._makeOne(autocommit=True) # doesnt blow up config.add_view_predicate('dummy', DummyPredicate) @@ -2137,28 +2584,33 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_forbidden_view_disallows_name(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_forbidden_view, name='foo') + self.assertRaises( + ConfigurationError, config.add_forbidden_view, name='foo' + ) def test_add_forbidden_view_disallows_permission(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_forbidden_view, permission='foo') + self.assertRaises( + ConfigurationError, config.add_forbidden_view, permission='foo' + ) def test_add_forbidden_view_disallows_require_csrf(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_forbidden_view, require_csrf=True) + self.assertRaises( + ConfigurationError, config.add_forbidden_view, require_csrf=True + ) def test_add_forbidden_view_disallows_context(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_forbidden_view, context='foo') + self.assertRaises( + ConfigurationError, config.add_forbidden_view, context='foo' + ) def test_add_forbidden_view_disallows_for_(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_forbidden_view, for_='foo') + self.assertRaises( + ConfigurationError, config.add_forbidden_view, for_='foo' + ) def test_add_forbidden_view_with_view_defaults(self): from pyramid.interfaces import IRequest @@ -2167,21 +2619,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.httpexceptions import HTTPForbidden from zope.interface import directlyProvides from zope.interface import implementedBy + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) - config.add_forbidden_view( - view=view, - renderer=null_renderer) + config.add_forbidden_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(HTTPForbidden), - request_iface=IRequest) + config, + exc_iface=implementedBy(HTTPForbidden), + request_iface=IRequest, + ) context = DummyContext() directlyProvides(context, IDummy) request = self._makeRequest(config) @@ -2195,13 +2649,16 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPNotFound + config = self._makeOne(autocommit=True) view = lambda *arg: arg config.add_notfound_view(view, renderer=null_renderer) request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) result = view(None, request) self.assertEqual(result, (None, request)) @@ -2209,19 +2666,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPNotFound + config = self._makeOne(autocommit=True) config.setup_registry() config.add_notfound_view() request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) context = HTTPNotFound() result = view(context, request) self.assertEqual(result, context) def test_add_notfound_view_allows_other_predicates(self): from pyramid.renderers import null_renderer + config = self._makeOne(autocommit=True) # doesnt blow up config.add_view_predicate('dummy', DummyPredicate) @@ -2229,28 +2690,33 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_notfound_view_disallows_name(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_notfound_view, name='foo') + self.assertRaises( + ConfigurationError, config.add_notfound_view, name='foo' + ) def test_add_notfound_view_disallows_permission(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_notfound_view, permission='foo') + self.assertRaises( + ConfigurationError, config.add_notfound_view, permission='foo' + ) def test_add_notfound_view_disallows_require_csrf(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_notfound_view, require_csrf=True) + self.assertRaises( + ConfigurationError, config.add_notfound_view, require_csrf=True + ) def test_add_notfound_view_disallows_context(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_notfound_view, context='foo') + self.assertRaises( + ConfigurationError, config.add_notfound_view, context='foo' + ) def test_add_notfound_view_disallows_for_(self): config = self._makeOne(autocommit=True) - self.assertRaises(ConfigurationError, - config.add_notfound_view, for_='foo') + self.assertRaises( + ConfigurationError, config.add_notfound_view, for_='foo' + ) def test_add_notfound_view_append_slash(self): from pyramid.response import Response @@ -2258,17 +2724,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPTemporaryRedirect, HTTPNotFound + config = self._makeOne(autocommit=True) config.add_route('foo', '/foo/') - def view(request): return Response('OK') - config.add_notfound_view(view, renderer=null_renderer,append_slash=True) + + def view(request): + return Response('OK') + + config.add_notfound_view( + view, renderer=null_renderer, append_slash=True + ) request = self._makeRequest(config) request.environ['PATH_INFO'] = '/foo' request.query_string = 'a=1&b=2' request.path = '/scriptname/foo' - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) result = view(None, request) self.assertTrue(isinstance(result, HTTPTemporaryRedirect)) self.assertEqual(result.location, '/scriptname/foo/?a=1&b=2') @@ -2279,19 +2753,25 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPMovedPermanently, HTTPNotFound + config = self._makeOne(autocommit=True) config.add_route('foo', '/foo/') - def view(request): return Response('OK') + + def view(request): + return Response('OK') + config.add_notfound_view( - view, renderer=null_renderer,append_slash=HTTPMovedPermanently + view, renderer=null_renderer, append_slash=HTTPMovedPermanently ) request = self._makeRequest(config) request.environ['PATH_INFO'] = '/foo' request.query_string = 'a=1&b=2' request.path = '/scriptname/foo' - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) result = view(None, request) self.assertTrue(isinstance(result, HTTPMovedPermanently)) self.assertEqual(result.location, '/scriptname/foo/?a=1&b=2') @@ -2303,21 +2783,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): from pyramid.httpexceptions import HTTPNotFound from zope.interface import directlyProvides from zope.interface import implementedBy + class view(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + config = self._makeOne(autocommit=True) - config.add_notfound_view( - view=view, - renderer=null_renderer) + config.add_notfound_view(view=view, renderer=null_renderer) wrapper = self._getViewCallable( - config, exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) context = DummyContext() directlyProvides(context, IDummy) request = self._makeRequest(config) @@ -2329,6 +2811,7 @@ class TestViewsConfigurationMixin(unittest.TestCase): # Since Python 3 has to be all cool and fancy and different... def _assertBody(self, response, value): from pyramid.compat import text_type + if isinstance(value, text_type): # pragma: no cover self.assertEqual(response.text, value) else: # pragma: no cover @@ -2338,16 +2821,17 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPNotFound + config = self._makeOne(autocommit=True) view = lambda *arg: {} config.introspection = False - config.add_notfound_view( - view, - renderer='json') + config.add_notfound_view(view, renderer='json') request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPNotFound), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPNotFound), + request_iface=IRequest, + ) result = view(None, request) self._assertBody(result, '{}') @@ -2355,21 +2839,23 @@ class TestViewsConfigurationMixin(unittest.TestCase): from zope.interface import implementedBy from pyramid.interfaces import IRequest from pyramid.httpexceptions import HTTPForbidden + config = self._makeOne(autocommit=True) view = lambda *arg: {} config.introspection = False - config.add_forbidden_view( - view, - renderer='json') + config.add_forbidden_view(view, renderer='json') request = self._makeRequest(config) - view = self._getViewCallable(config, - exc_iface=implementedBy(HTTPForbidden), - request_iface=IRequest) + view = self._getViewCallable( + config, + exc_iface=implementedBy(HTTPForbidden), + request_iface=IRequest, + ) result = view(None, request) self._assertBody(result, '{}') def test_set_view_mapper(self): from pyramid.interfaces import IViewMapperFactory + config = self._makeOne(autocommit=True) mapper = object() config.set_view_mapper(mapper) @@ -2378,15 +2864,18 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_set_view_mapper_dottedname(self): from pyramid.interfaces import IViewMapperFactory + config = self._makeOne(autocommit=True) config.set_view_mapper('tests.test_config') result = config.registry.getUtility(IViewMapperFactory) from tests import test_config + self.assertEqual(result, test_config) def test_add_normal_and_exception_view_intr_derived_callable(self): from pyramid.renderers import null_renderer from pyramid.exceptions import BadCSRFToken + config = self._makeOne(autocommit=True) introspector = DummyIntrospector() config.introspector = introspector @@ -2410,27 +2899,33 @@ class TestViewsConfigurationMixin(unittest.TestCase): def test_add_view_does_not_accept_iterable_accept(self): from pyramid.exceptions import ConfigurationError + config = self._makeOne(autocommit=True) self.assertRaises( - ConfigurationError, config.add_view, accept=['image/*', 'text/*'], + ConfigurationError, config.add_view, accept=['image/*', 'text/*'] ) def test_default_accept_view_order(self): from pyramid.interfaces import IAcceptOrder + config = self._makeOne(autocommit=True) order = config.registry.getUtility(IAcceptOrder) result = [v for _, v in order.sorted()] - self.assertEqual(result, [ - 'text/html', - 'application/xhtml+xml', - 'application/xml', - 'text/xml', - 'text/plain', - 'application/json', - ]) + self.assertEqual( + result, + [ + 'text/html', + 'application/xhtml+xml', + 'application/xml', + 'text/xml', + 'text/plain', + 'application/json', + ], + ) def test_add_accept_view_order_override(self): from pyramid.interfaces import IAcceptOrder + config = self._makeOne(autocommit=False) config.add_accept_view_order( 'text/html', @@ -2440,57 +2935,75 @@ class TestViewsConfigurationMixin(unittest.TestCase): config.commit() order = config.registry.getUtility(IAcceptOrder) result = [v for _, v in order.sorted()] - self.assertEqual(result, [ - 'application/xhtml+xml', - 'application/xml', - 'text/html', - 'text/xml', - 'text/plain', - 'application/json', - ]) + self.assertEqual( + result, + [ + 'application/xhtml+xml', + 'application/xml', + 'text/html', + 'text/xml', + 'text/plain', + 'application/json', + ], + ) def test_add_accept_view_order_throws_on_wildcard(self): config = self._makeOne(autocommit=True) - self.assertRaises( - ValueError, config.add_accept_view_order, '*/*', - ) + self.assertRaises(ValueError, config.add_accept_view_order, '*/*') def test_add_accept_view_order_throws_on_type_mismatch(self): config = self._makeOne(autocommit=True) self.assertRaises( - ValueError, config.add_accept_view_order, - 'text/*', weighs_more_than='text/html', + ValueError, + config.add_accept_view_order, + 'text/*', + weighs_more_than='text/html', ) self.assertRaises( - ValueError, config.add_accept_view_order, - 'text/html', weighs_less_than='application/*', + ValueError, + config.add_accept_view_order, + 'text/html', + weighs_less_than='application/*', ) self.assertRaises( - ConfigurationError, config.add_accept_view_order, - 'text/html', weighs_more_than='text/html;charset=utf8', + ConfigurationError, + config.add_accept_view_order, + 'text/html', + weighs_more_than='text/html;charset=utf8', ) self.assertRaises( - ConfigurationError, config.add_accept_view_order, + ConfigurationError, + config.add_accept_view_order, 'text/html;charset=utf8', weighs_more_than='text/plain;charset=utf8', ) + class Test_runtime_exc_view(unittest.TestCase): def _makeOne(self, view1, view2): from pyramid.config.views import runtime_exc_view + return runtime_exc_view(view1, view2) def test_call(self): - def view1(context, request): return 'OK' - def view2(context, request): raise AssertionError + def view1(context, request): + return 'OK' + + def view2(context, request): + raise AssertionError + result_view = self._makeOne(view1, view2) request = DummyRequest() result = result_view(None, request) self.assertEqual(result, 'OK') def test_call_dispatches_on_exception(self): - def view1(context, request): raise AssertionError - def view2(context, request): return 'OK' + def view1(context, request): + raise AssertionError + + def view2(context, request): + return 'OK' + result_view = self._makeOne(view1, view2) request = DummyRequest() request.exception = Exception() @@ -2498,10 +3011,17 @@ class Test_runtime_exc_view(unittest.TestCase): self.assertEqual(result, 'OK') def test_permitted(self): - def errfn(context, request): raise AssertionError - def view1(context, request): raise AssertionError + def errfn(context, request): + raise AssertionError + + def view1(context, request): + raise AssertionError + view1.__permitted__ = lambda c, r: 'OK' - def view2(context, request): raise AssertionError + + def view2(context, request): + raise AssertionError + view2.__permitted__ = errfn result_view = self._makeOne(view1, view2) request = DummyRequest() @@ -2509,10 +3029,17 @@ class Test_runtime_exc_view(unittest.TestCase): self.assertEqual(result, 'OK') def test_permitted_dispatches_on_exception(self): - def errfn(context, request): raise AssertionError - def view1(context, request): raise AssertionError + def errfn(context, request): + raise AssertionError + + def view1(context, request): + raise AssertionError + view1.__permitted__ = errfn - def view2(context, request): raise AssertionError + + def view2(context, request): + raise AssertionError + view2.__permitted__ = lambda c, r: 'OK' result_view = self._makeOne(view1, view2) request = DummyRequest() @@ -2520,50 +3047,67 @@ class Test_runtime_exc_view(unittest.TestCase): result = result_view.__permitted__(None, request) self.assertEqual(result, 'OK') + class Test_requestonly(unittest.TestCase): def _callFUT(self, view, attr=None): from pyramid.config.views import requestonly + return requestonly(view, attr=attr) def test_defaults(self): - def aview(request, a=1, b=2): pass + def aview(request, a=1, b=2): + pass + self.assertTrue(self._callFUT(aview)) def test_otherattr(self): class AView(object): - def __init__(self, request, a=1, b=2): pass - def bleh(self): pass + def __init__(self, request, a=1, b=2): + pass + + def bleh(self): + pass + self.assertTrue(self._callFUT(AView, 'bleh')) + class Test_isexception(unittest.TestCase): def _callFUT(self, ob): from pyramid.config.views import isexception + return isexception(ob) def test_is_exception_instance(self): class E(Exception): pass + e = E() self.assertEqual(self._callFUT(e), True) def test_is_exception_class(self): class E(Exception): pass + self.assertEqual(self._callFUT(E), True) def test_is_IException(self): from pyramid.interfaces import IException + self.assertEqual(self._callFUT(IException), True) def test_is_IException_subinterface(self): from pyramid.interfaces import IException + class ISubException(IException): pass + self.assertEqual(self._callFUT(ISubException), True) + class TestMultiView(unittest.TestCase): def _getTargetClass(self): from pyramid.config.views import MultiView + return MultiView def _makeOne(self, name='name'): @@ -2572,11 +3116,13 @@ class TestMultiView(unittest.TestCase): def test_class_implements_ISecuredView(self): from zope.interface.verify import verifyClass from pyramid.interfaces import ISecuredView + verifyClass(ISecuredView, self._getTargetClass()) def test_instance_implements_ISecuredView(self): from zope.interface.verify import verifyObject from pyramid.interfaces import ISecuredView + verifyObject(ISecuredView, self._makeOne()) def test_add(self): @@ -2588,15 +3134,19 @@ class TestMultiView(unittest.TestCase): mv.add('view3', 100, accept='text/html') self.assertEqual(mv.media_views['text/html'], [(100, 'view3', None)]) mv.add('view4', 99, 'abc', accept='text/html') - self.assertEqual(mv.media_views['text/html'], - [(99, 'view4', 'abc'), (100, 'view3', None)]) + self.assertEqual( + mv.media_views['text/html'], + [(99, 'view4', 'abc'), (100, 'view3', None)], + ) mv.add('view5', 100, accept='text/xml') self.assertEqual(mv.media_views['text/xml'], [(100, 'view5', None)]) self.assertEqual(set(mv.accepts), set(['text/xml', 'text/html'])) self.assertEqual(mv.views, [(99, 'view2', None), (100, 'view', None)]) mv.add('view6', 98, accept='text/*') - self.assertEqual(mv.views, [ - (98, 'view6', None), (99, 'view2', None), (100, 'view', None)]) + self.assertEqual( + mv.views, + [(98, 'view6', None), (99, 'view2', None), (100, 'view', None)], + ) def test_add_with_phash(self): mv = self._makeOne() @@ -2605,43 +3155,64 @@ class TestMultiView(unittest.TestCase): mv.add('view', 100, phash='abc') self.assertEqual(mv.views, [(100, 'view', 'abc')]) mv.add('view', 100, phash='def') - self.assertEqual(mv.views, [(100, 'view', 'abc'), - (100, 'view', 'def')]) + self.assertEqual( + mv.views, [(100, 'view', 'abc'), (100, 'view', 'def')] + ) mv.add('view', 100, phash='abc') - self.assertEqual(mv.views, [(100, 'view', 'abc'), - (100, 'view', 'def')]) + self.assertEqual( + mv.views, [(100, 'view', 'abc'), (100, 'view', 'def')] + ) def test_add_with_phash_override_accept(self): mv = self._makeOne() - def view1(): pass - def view2(): pass - def view3(): pass + + def view1(): + pass + + def view2(): + pass + + def view3(): + pass + mv.add(view1, 100, accept='text/html', phash='abc') mv.add(view2, 100, accept='text/html', phash='abc') mv.add(view3, 99, accept='text/html', phash='def') - self.assertEqual(mv.media_views['text/html'], - [(99, view3, 'def'), (100, view2, 'abc')]) + self.assertEqual( + mv.media_views['text/html'], + [(99, view3, 'def'), (100, view2, 'abc')], + ) def test_add_with_phash_override_accept2(self): mv = self._makeOne() - def view1(): pass - def view2(): pass - def view3(): pass + + def view1(): + pass + + def view2(): + pass + + def view3(): + pass + mv.add(view1, 100, accept='text/html', phash='abc') mv.add(view2, 100, accept='text/html', phash='def') mv.add(view3, 99, accept='text/html', phash='ghi') - self.assertEqual(mv.media_views['text/html'], - [(99, view3, 'ghi'), - (100, view1, 'abc'), - (100, view2, 'def')] - ) + self.assertEqual( + mv.media_views['text/html'], + [(99, view3, 'ghi'), (100, view1, 'abc'), (100, view2, 'def')], + ) def test_multiple_with_functions_as_views(self): # this failed on py3 at one point, because functions aren't orderable # and we were sorting the views via a plain sort() rather than # sort(key=itemgetter(0)). - def view1(request): pass - def view2(request): pass + def view1(request): + pass + + def view2(request): + pass + mv = self._makeOne() mv.add(view1, 100, None) self.assertEqual(mv.views, [(100, view1, None)]) @@ -2682,6 +3253,7 @@ class TestMultiView(unittest.TestCase): def test_match_not_found(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() context = DummyContext() request = DummyRequest() @@ -2689,9 +3261,12 @@ class TestMultiView(unittest.TestCase): def test_match_predicate_fails(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() + def view(context, request): """ """ + view.__predicated__ = lambda *arg: False mv.views = [(100, view, None)] context = DummyContext() @@ -2700,8 +3275,10 @@ class TestMultiView(unittest.TestCase): def test_match_predicate_succeeds(self): mv = self._makeOne() + def view(context, request): """ """ + view.__predicated__ = lambda *arg: True mv.views = [(100, view, None)] context = DummyContext() @@ -2711,6 +3288,7 @@ class TestMultiView(unittest.TestCase): def test_permitted_no_views(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() context = DummyContext() request = DummyRequest() @@ -2718,17 +3296,22 @@ class TestMultiView(unittest.TestCase): def test_permitted_no_match_with__permitted__(self): mv = self._makeOne() + def view(context, request): """ """ + mv.views = [(100, view, None)] self.assertEqual(mv.__permitted__(None, None), True) def test_permitted(self): mv = self._makeOne() + def view(context, request): """ """ + def permitted(context, request): return False + view.__permitted__ = permitted mv.views = [(100, view, None)] context = DummyContext() @@ -2738,6 +3321,7 @@ class TestMultiView(unittest.TestCase): def test__call__not_found(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() context = DummyContext() request = DummyRequest() @@ -2745,29 +3329,37 @@ class TestMultiView(unittest.TestCase): def test___call__intermediate_not_found(self): from pyramid.exceptions import PredicateMismatch + mv = self._makeOne() context = DummyContext() request = DummyRequest() request.view_name = '' expected_response = DummyResponse() + def view1(context, request): raise PredicateMismatch + def view2(context, request): return expected_response + mv.views = [(100, view1, None), (99, view2, None)] response = mv(context, request) self.assertEqual(response, expected_response) def test___call__raise_not_found_isnt_interpreted_as_pred_mismatch(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() context = DummyContext() request = DummyRequest() request.view_name = '' + def view1(context, request): - raise HTTPNotFound + raise HTTPNotFound + def view2(context, request): """ """ + mv.views = [(100, view1, None), (99, view2, None)] self.assertRaises(HTTPNotFound, mv, context, request) @@ -2777,14 +3369,17 @@ class TestMultiView(unittest.TestCase): request = DummyRequest() request.view_name = '' expected_response = DummyResponse() + def view(context, request): return expected_response + mv.views = [(100, view, None)] response = mv(context, request) self.assertEqual(response, expected_response) def test__call_permissive__not_found(self): from pyramid.httpexceptions import HTTPNotFound + mv = self._makeOne() context = DummyContext() request = DummyRequest() @@ -2796,10 +3391,13 @@ class TestMultiView(unittest.TestCase): request = DummyRequest() request.view_name = '' expected_response = DummyResponse() + def view(context, request): """ """ + def permissive(context, request): return expected_response + view.__call_permissive__ = permissive mv.views = [(100, view, None)] response = mv.__call_permissive__(context, request) @@ -2811,8 +3409,10 @@ class TestMultiView(unittest.TestCase): request = DummyRequest() request.view_name = '' expected_response = DummyResponse() + def view(context, request): return expected_response + mv.views = [(100, view, None)] response = mv.__call_permissive__(context, request) self.assertEqual(response, expected_response) @@ -2823,8 +3423,10 @@ class TestMultiView(unittest.TestCase): request = DummyRequest() request.accept = DummyAccept('text/html', 'text/xml') expected_response = DummyResponse() + def view(context, request): return expected_response + mv.views = [(100, None)] mv.media_views['text/xml'] = [(100, view, None)] mv.accepts = ['text/xml'] @@ -2837,8 +3439,10 @@ class TestMultiView(unittest.TestCase): request = DummyRequest() request.accept = DummyAccept('text/plain', 'text/html') expected_response = DummyResponse() + def view(context, request): return expected_response + mv.views = [(100, view, None)] mv.media_views['text/xml'] = [(100, None, None)] mv.accepts = ['text/xml'] @@ -2846,7 +3450,6 @@ class TestMultiView(unittest.TestCase): self.assertEqual(response, expected_response) - class TestDefaultViewMapper(unittest.TestCase): def setUp(self): self.config = testing.setUp() @@ -2858,6 +3461,7 @@ class TestDefaultViewMapper(unittest.TestCase): def _makeOne(self, **kw): from pyramid.config.views import DefaultViewMapper + kw['registry'] = self.registry return DefaultViewMapper(**kw) @@ -2869,6 +3473,7 @@ class TestDefaultViewMapper(unittest.TestCase): def test_view_as_function_context_and_request(self): def view(context, request): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertTrue(result is view) @@ -2878,6 +3483,7 @@ class TestDefaultViewMapper(unittest.TestCase): def test__view_as_function_with_attr(self): def view(context, request): """ """ + mapper = self._makeOne(attr='__name__') result = mapper(view) self.assertFalse(result is view) @@ -2887,6 +3493,7 @@ class TestDefaultViewMapper(unittest.TestCase): def test_view_as_function_requestonly(self): def view(request): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertFalse(result is view) @@ -2896,6 +3503,7 @@ class TestDefaultViewMapper(unittest.TestCase): def test_view_as_function_requestonly_with_attr(self): def view(request): """ """ + mapper = self._makeOne(attr='__name__') result = mapper(view) self.assertFalse(result is view) @@ -2906,8 +3514,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view(object): def __init__(self, context, request): pass + def __call__(self): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertFalse(result is view) @@ -2918,8 +3528,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view(object): def __init__(self, context, request): pass + def index(self): return 'OK' + mapper = self._makeOne(attr='index') result = mapper(view) self.assertFalse(result is view) @@ -2930,8 +3542,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view(object): def __init__(self, request): pass + def __call__(self): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertFalse(result is view) @@ -2942,8 +3556,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view(object): def __init__(self, request): pass + def index(self): return 'OK' + mapper = self._makeOne(attr='index') result = mapper(view) self.assertFalse(result is view) @@ -2954,8 +3570,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view: def __init__(self, context, request): pass + def __call__(self): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertFalse(result is view) @@ -2966,8 +3584,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view: def __init__(self, context, request): pass + def index(self): return 'OK' + mapper = self._makeOne(attr='index') result = mapper(view) self.assertFalse(result is view) @@ -2978,8 +3598,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view: def __init__(self, request): pass + def __call__(self): return 'OK' + mapper = self._makeOne() result = mapper(view) self.assertFalse(result is view) @@ -2990,8 +3612,10 @@ class TestDefaultViewMapper(unittest.TestCase): class view: def __init__(self, request): pass + def index(self): return 'OK' + mapper = self._makeOne(attr='index') result = mapper(view) self.assertFalse(result is view) @@ -3002,6 +3626,7 @@ class TestDefaultViewMapper(unittest.TestCase): class View: def __call__(self, context, request): return 'OK' + view = View() mapper = self._makeOne() result = mapper(view) @@ -3013,6 +3638,7 @@ class TestDefaultViewMapper(unittest.TestCase): class View: def index(self, context, request): return 'OK' + view = View() mapper = self._makeOne(attr='index') result = mapper(view) @@ -3024,6 +3650,7 @@ class TestDefaultViewMapper(unittest.TestCase): class View: def __call__(self, request): return 'OK' + view = View() mapper = self._makeOne() result = mapper(view) @@ -3035,6 +3662,7 @@ class TestDefaultViewMapper(unittest.TestCase): class View: def index(self, request): return 'OK' + view = View() mapper = self._makeOne(attr='index') result = mapper(view) @@ -3042,27 +3670,36 @@ class TestDefaultViewMapper(unittest.TestCase): request = self._makeRequest() self.assertEqual(result(None, request), 'OK') + class Test_preserve_view_attrs(unittest.TestCase): def _callFUT(self, view, wrapped_view): from pyramid.config.views import preserve_view_attrs + return preserve_view_attrs(view, wrapped_view) def test_it_same(self): def view(context, request): """ """ + result = self._callFUT(view, view) self.assertTrue(result is view) def test_it_view_is_None(self): def view(context, request): """ """ + result = self._callFUT(None, view) self.assertTrue(result is view) def test_it_different_with_existing_original_view(self): - def view1(context, request): pass + def view1(context, request): + pass + view1.__original_view__ = 'abc' - def view2(context, request): pass + + def view2(context, request): + pass + result = self._callFUT(view1, view2) self.assertEqual(result.__original_view__, 'abc') self.assertFalse(result is view1) @@ -3070,28 +3707,40 @@ class Test_preserve_view_attrs(unittest.TestCase): def test_it_different(self): class DummyView1: """ 1 """ + __name__ = '1' __module__ = '1' + def __call__(self, context, request): """ """ + def __call_permissive__(self, context, request): """ """ + def __predicated__(self, context, request): """ """ + def __permitted__(self, context, request): """ """ + class DummyView2: """ 2 """ + __name__ = '2' __module__ = '2' + def __call__(self, context, request): """ """ + def __call_permissive__(self, context, request): """ """ + def __predicated__(self, context, request): """ """ + def __permitted__(self, context, request): """ """ + view1 = DummyView1() view2 = DummyView2() result = self._callFUT(view2, view1) @@ -3100,17 +3749,24 @@ class Test_preserve_view_attrs(unittest.TestCase): self.assertTrue(view1.__doc__ is view2.__doc__) self.assertTrue(view1.__module__ is view2.__module__) self.assertTrue(view1.__name__ is view2.__name__) - self.assertTrue(getattr(view1.__call_permissive__, im_func) is - getattr(view2.__call_permissive__, im_func)) - self.assertTrue(getattr(view1.__permitted__, im_func) is - getattr(view2.__permitted__, im_func)) - self.assertTrue(getattr(view1.__predicated__, im_func) is - getattr(view2.__predicated__, im_func)) + self.assertTrue( + getattr(view1.__call_permissive__, im_func) + is getattr(view2.__call_permissive__, im_func) + ) + self.assertTrue( + getattr(view1.__permitted__, im_func) + is getattr(view2.__permitted__, im_func) + ) + self.assertTrue( + getattr(view1.__predicated__, im_func) + is getattr(view2.__predicated__, im_func) + ) class TestStaticURLInfo(unittest.TestCase): def _getTargetClass(self): from pyramid.config.views import StaticURLInfo + return StaticURLInfo def _makeOne(self): @@ -3124,11 +3780,13 @@ class TestStaticURLInfo(unittest.TestCase): def test_verifyClass(self): from pyramid.interfaces import IStaticURLInfo from zope.interface.verify import verifyClass + verifyClass(IStaticURLInfo, self._getTargetClass()) def test_verifyObject(self): from pyramid.interfaces import IStaticURLInfo from zope.interface.verify import verifyObject + verifyObject(IStaticURLInfo, self._makeOne()) def test_generate_missing(self): @@ -3140,27 +3798,33 @@ class TestStaticURLInfo(unittest.TestCase): inst = self._makeOne() inst.registrations = [ (None, 'spec', 'route_name'), - ('http://example.com/foo/', 'package:path/', None)] + ('http://example.com/foo/', 'package:path/', None), + ] request = self._makeRequest() result = inst.generate('package:path/abc', request) self.assertEqual(result, 'http://example.com/foo/abc') def test_generate_slash_in_name1(self): inst = self._makeOne() - inst.registrations = [('http://example.com/foo/', 'package:path/', None)] + inst.registrations = [ + ('http://example.com/foo/', 'package:path/', None) + ] request = self._makeRequest() result = inst.generate('package:path/abc', request) self.assertEqual(result, 'http://example.com/foo/abc') def test_generate_slash_in_name2(self): inst = self._makeOne() - inst.registrations = [('http://example.com/foo/', 'package:path/', None)] + inst.registrations = [ + ('http://example.com/foo/', 'package:path/', None) + ] request = self._makeRequest() result = inst.generate('package:path/', request) self.assertEqual(result, 'http://example.com/foo/') def test_generate_quoting(self): from pyramid.interfaces import IStaticURLInfo + config = testing.setUp() try: config.add_static_view('images', path='mypkg:templates') @@ -3175,10 +3839,12 @@ class TestStaticURLInfo(unittest.TestCase): def test_generate_route_url(self): inst = self._makeOne() inst.registrations = [(None, 'package:path/', '__viewname/')] + def route_url(n, **kw): self.assertEqual(n, '__viewname/') - self.assertEqual(kw, {'subpath':'abc', 'a':1}) + self.assertEqual(kw, {'subpath': 'abc', 'a': 1}) return 'url' + request = self._makeRequest() request.route_url = route_url result = inst.generate('package:path/abc', request, a=1) @@ -3187,10 +3853,12 @@ class TestStaticURLInfo(unittest.TestCase): def test_generate_url_unquoted_local(self): inst = self._makeOne() inst.registrations = [(None, 'package:path/', '__viewname/')] + def route_url(n, **kw): self.assertEqual(n, '__viewname/') - self.assertEqual(kw, {'subpath':'abc def', 'a':1}) + self.assertEqual(kw, {'subpath': 'abc def', 'a': 1}) return 'url' + request = self._makeRequest() request.route_url = route_url result = inst.generate('package:path/abc def', request, a=1) @@ -3208,72 +3876,101 @@ class TestStaticURLInfo(unittest.TestCase): registrations = [('http://example.com/', 'package:path/', None)] inst.registrations = registrations request = self._makeRequest() - result = inst.generate('package:path/abc def', request, a=1, - _query='(openlayers)') - self.assertEqual(result, - 'http://example.com/abc%20def?(openlayers)') + result = inst.generate( + 'package:path/abc def', request, a=1, _query='(openlayers)' + ) + self.assertEqual(result, 'http://example.com/abc%20def?(openlayers)') def test_generate_url_with_custom_anchor(self): inst = self._makeOne() inst.registrations = [('http://example.com/', 'package:path/', None)] request = self._makeRequest() uc = text_(b'La Pe\xc3\xb1a', 'utf-8') - result = inst.generate('package:path/abc def', request, a=1, _anchor=uc) - self.assertEqual(result, - 'http://example.com/abc%20def#La%20Pe%C3%B1a') + result = inst.generate( + 'package:path/abc def', request, a=1, _anchor=uc + ) + self.assertEqual(result, 'http://example.com/abc%20def#La%20Pe%C3%B1a') def test_generate_url_cachebust(self): def cachebust(request, subpath, kw): kw['foo'] = 'bar' return 'foo' + '/' + subpath, kw + inst = self._makeOne() inst.registrations = [(None, 'package:path/', '__viewname')] inst.cache_busters = [('package:path/', cachebust, False)] request = self._makeRequest() called = [False] + def route_url(n, **kw): called[0] = True self.assertEqual(n, '__viewname') - self.assertEqual(kw, {'subpath': 'foo/abc', 'foo': 'bar', - 'pathspec': 'package:path/abc', - 'rawspec': 'package:path/abc'}) + self.assertEqual( + kw, + { + 'subpath': 'foo/abc', + 'foo': 'bar', + 'pathspec': 'package:path/abc', + 'rawspec': 'package:path/abc', + }, + ) + request.route_url = route_url inst.generate('package:path/abc', request) self.assertTrue(called[0]) def test_generate_url_cachebust_abspath(self): here = os.path.dirname(__file__) + os.sep + def cachebust(pathspec, subpath, kw): kw['foo'] = 'bar' return 'foo' + '/' + subpath, kw + inst = self._makeOne() inst.registrations = [(None, here, '__viewname')] inst.cache_busters = [(here, cachebust, False)] request = self._makeRequest() called = [False] + def route_url(n, **kw): called[0] = True self.assertEqual(n, '__viewname') - self.assertEqual(kw, {'subpath': 'foo/abc', 'foo': 'bar', - 'pathspec': here + 'abc', - 'rawspec': here + 'abc'}) + self.assertEqual( + kw, + { + 'subpath': 'foo/abc', + 'foo': 'bar', + 'pathspec': here + 'abc', + 'rawspec': here + 'abc', + }, + ) + request.route_url = route_url inst.generate(here + 'abc', request) self.assertTrue(called[0]) def test_generate_url_cachebust_nomatch(self): - def fake_cb(*a, **kw): raise AssertionError + def fake_cb(*a, **kw): + raise AssertionError + inst = self._makeOne() inst.registrations = [(None, 'package:path/', '__viewname')] inst.cache_busters = [('package:path2/', fake_cb, False)] request = self._makeRequest() called = [False] + def route_url(n, **kw): called[0] = True self.assertEqual(n, '__viewname') - self.assertEqual(kw, {'subpath': 'abc', - 'pathspec': 'package:path/abc', - 'rawspec': 'package:path/abc'}) + self.assertEqual( + kw, + { + 'subpath': 'abc', + 'pathspec': 'package:path/abc', + 'rawspec': 'package:path/abc', + }, + ) + request.route_url = route_url inst.generate('package:path/abc', request) self.assertTrue(called[0]) @@ -3284,13 +3981,16 @@ class TestStaticURLInfo(unittest.TestCase): request = testing.DummyRequest() config.add_static_view('static', 'path') config.override_asset( - 'tests.test_config:path/', - 'tests.test_config:other_path/') + 'tests.test_config:path/', 'tests.test_config:other_path/' + ) + def cb(val): def cb_(request, subpath, kw): kw['_query'] = {'x': val} return subpath, kw + return cb_ + config.add_cache_buster('path', cb('foo')) result = request.static_url('path/foo.png') self.assertEqual(result, 'http://example.com/static/foo.png?x=foo') @@ -3339,6 +4039,7 @@ class TestStaticURLInfo(unittest.TestCase): def test_add_viewname(self): from pyramid.security import NO_PERMISSION_REQUIRED from pyramid.static import static_view + config = DummyConfig() inst = self._makeOne() inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1) @@ -3352,7 +4053,7 @@ class TestStaticURLInfo(unittest.TestCase): config = DummyConfig() config.route_prefix = '/abc' inst = self._makeOne() - inst.add(config, 'view', 'anotherpackage:path',) + inst.add(config, 'view', 'anotherpackage:path') expected = [(None, 'anotherpackage:path/', '__/abc/view/')] self.assertEqual(inst.registrations, expected) self.assertEqual(config.route_args, ('__/abc/view/', 'view/*subpath')) @@ -3360,31 +4061,52 @@ class TestStaticURLInfo(unittest.TestCase): def test_add_viewname_with_permission(self): config = DummyConfig() inst = self._makeOne() - inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1, - permission='abc') + inst.add( + config, + 'view', + 'anotherpackage:path', + cache_max_age=1, + permission='abc', + ) self.assertEqual(config.view_kw['permission'], 'abc') def test_add_viewname_with_context(self): config = DummyConfig() inst = self._makeOne() - inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1, - context=DummyContext) + inst.add( + config, + 'view', + 'anotherpackage:path', + cache_max_age=1, + context=DummyContext, + ) self.assertEqual(config.view_kw['context'], DummyContext) def test_add_viewname_with_for_(self): config = DummyConfig() inst = self._makeOne() - inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1, - for_=DummyContext) + inst.add( + config, + 'view', + 'anotherpackage:path', + cache_max_age=1, + for_=DummyContext, + ) self.assertEqual(config.view_kw['context'], DummyContext) def test_add_viewname_with_renderer(self): config = DummyConfig() inst = self._makeOne() - inst.add(config, 'view', 'anotherpackage:path', cache_max_age=1, - renderer='mypackage:templates/index.pt') - self.assertEqual(config.view_kw['renderer'], - 'mypackage:templates/index.pt') + inst.add( + config, + 'view', + 'anotherpackage:path', + cache_max_age=1, + renderer='mypackage:templates/index.pt', + ) + self.assertEqual( + config.view_kw['renderer'], 'mypackage:templates/index.pt' + ) def test_add_cachebust_prevented(self): config = DummyConfig() @@ -3397,7 +4119,9 @@ class TestStaticURLInfo(unittest.TestCase): def test_add_cachebuster(self): config = DummyConfig() inst = self._makeOne() - inst.add_cache_buster(config, 'mypackage:path', DummyCacheBuster('foo')) + inst.add_cache_buster( + config, 'mypackage:path', DummyCacheBuster('foo') + ) cachebust = inst.cache_busters[-1][1] subpath, kw = cachebust(None, 'some/path', {}) self.assertEqual(subpath, 'some/path') @@ -3418,8 +4142,7 @@ class TestStaticURLInfo(unittest.TestCase): cb2 = DummyCacheBuster('bar') inst.add_cache_buster(config, 'mypackage:path/', cb1) inst.add_cache_buster(config, 'mypackage:path', cb2) - self.assertEqual(inst.cache_busters, - [('mypackage:path/', cb2, False)]) + self.assertEqual(inst.cache_busters, [('mypackage:path/', cb2, False)]) def test_add_cachebuster_overwrite_explicit(self): config = DummyConfig() @@ -3428,9 +4151,10 @@ class TestStaticURLInfo(unittest.TestCase): cb2 = DummyCacheBuster('bar') inst.add_cache_buster(config, 'mypackage:path/', cb1) inst.add_cache_buster(config, 'mypackage:path', cb2, True) - self.assertEqual(inst.cache_busters, - [('mypackage:path/', cb1, False), - ('mypackage:path/', cb2, True)]) + self.assertEqual( + inst.cache_busters, + [('mypackage:path/', cb1, False), ('mypackage:path/', cb2, True)], + ) def test_add_cachebuster_for_more_specific_path(self): config = DummyConfig() @@ -3447,36 +4171,47 @@ class TestStaticURLInfo(unittest.TestCase): inst.add_cache_buster(config, 'mypackage:path/sub/less', cb5, True) self.assertEqual( inst.cache_busters, - [('mypackage:path/', cb1, False), - ('mypackage:path/sub/other/', cb3, False), - ('mypackage:path/sub/', cb2, True), - ('mypackage:path/sub/less/', cb5, True), - ('mypackage:path/sub/other/', cb4, True)]) + [ + ('mypackage:path/', cb1, False), + ('mypackage:path/sub/other/', cb3, False), + ('mypackage:path/sub/', cb2, True), + ('mypackage:path/sub/less/', cb5, True), + ('mypackage:path/sub/other/', cb4, True), + ], + ) + class Test_view_description(unittest.TestCase): def _callFUT(self, view): from pyramid.config.views import view_description + return view_description(view) def test_with_text(self): - def view(): pass + def view(): + pass + view.__text__ = 'some text' result = self._callFUT(view) self.assertEqual(result, 'some text') def test_without_text(self): - def view(): pass + def view(): + pass + result = self._callFUT(view) - self.assertEqual(result, - 'function tests.test_config.test_views.view') + self.assertEqual(result, 'function tests.test_config.test_views.view') + class Test_viewdefaults(unittest.TestCase): def _makeOne(self, wrapped): from pyramid.decorator import reify + return reify(wrapped) def test_dunder_attrs_copied(self): from pyramid.config.views import viewdefaults + decorator = self._makeOne(viewdefaults) self.assertEqual(decorator.__doc__, viewdefaults.__doc__) self.assertEqual(decorator.__name__, viewdefaults.__name__) @@ -3492,11 +4227,10 @@ class DummyRegistry: def queryUtility(self, type_or_iface, name=None, default=None): return self.utility or default + from zope.interface import implementer -from pyramid.interfaces import ( - IResponse, - IRequest, - ) +from pyramid.interfaces import IResponse, IRequest + @implementer(IResponse) class DummyResponse(object): @@ -3504,10 +4238,11 @@ class DummyResponse(object): default_content_type = None body = None + class DummyRequest: subpath = () matchdict = None - request_iface = IRequest + request_iface = IRequest application_url = 'http://example.com/foo' def __init__(self, environ=None): @@ -3518,9 +4253,11 @@ class DummyRequest: self.cookies = {} self.response = DummyResponse() + class DummyContext: pass + class DummyAccept(object): def __init__(self, *matches, **kw): self.matches = list(matches) @@ -3536,11 +4273,13 @@ class DummyAccept(object): def __contains__(self, value): return self.contains + class DummyConfig: def __init__(self): self.registry = DummyRegistry() route_prefix = '' + def add_route(self, *args, **kw): self.route_args = args self.route_kw = kw @@ -3555,20 +4294,27 @@ class DummyConfig: def introspectable(self, *arg): return {} + from zope.interface import implementer from pyramid.interfaces import IMultiView + + @implementer(IMultiView) class DummyMultiView: def __init__(self): self.views = [] self.name = 'name' + def add(self, view, order, phash=None, accept=None, accept_order=None): self.views.append((view, phash, accept, accept_order)) + def __call__(self, context, request): return 'OK1' + def __permitted__(self, context, request): """ """ + class DummyCacheBuster(object): def __init__(self, token): self.token = token @@ -3577,19 +4323,23 @@ class DummyCacheBuster(object): kw['x'] = self.token return subpath, kw + def parse_httpdate(s): import datetime + # cannot use %Z, must use literal GMT; Jython honors timezone # but CPython does not return datetime.datetime.strptime(s, "%a, %d %b %Y %H:%M:%S GMT") + def assert_similar_datetime(one, two): for attr in ('year', 'month', 'day', 'hour', 'minute'): one_attr = getattr(one, attr) two_attr = getattr(two, attr) - if not one_attr == two_attr: # pragma: no cover + if not one_attr == two_attr: # pragma: no cover raise AssertionError('%r != %r in %s' % (one_attr, two_attr, attr)) + class DummyStaticURLInfo: def __init__(self): self.added = [] @@ -3597,15 +4347,17 @@ class DummyStaticURLInfo: def add(self, config, name, spec, **kw): self.added.append((config, name, spec, kw)) + class DummyViewDefaultsClass(object): - __view_defaults__ = { - 'containment':'tests.test_config.IDummy' - } + __view_defaults__ = {'containment': 'tests.test_config.IDummy'} + def __init__(self, request): pass + def __call__(self): return 'OK' + class DummyPredicate(object): def __init__(self, val, config): self.val = val @@ -3615,18 +4367,23 @@ class DummyPredicate(object): phash = text + class DummyIntrospector(object): def __init__(self, getval=None): self.related = [] self.introspectables = [] self.getval = getval + def add(self, introspectable): self.introspectables.append(introspectable) + def get(self, name, discrim): return self.getval + def relate(self, a, b): self.related.append((a, b)) + class DummySession(dict): def get_csrf_token(self): return self['csrf_token'] |