From cbfafba1514ce2ce2b87aadb0093c06210219372 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 17 Nov 2009 21:59:54 +0000 Subject: Move configuration methods into Configurator. --- repoze/bfg/tests/test_configuration.py | 634 ++++++++++++++++++++++++++------- repoze/bfg/tests/test_integration.py | 1 - repoze/bfg/tests/test_registry.py | 456 ------------------------ repoze/bfg/tests/test_router.py | 139 ++++++-- repoze/bfg/tests/test_threadlocal.py | 21 +- repoze/bfg/tests/test_urldispatch.py | 191 ++-------- repoze/bfg/tests/test_zcml.py | 26 +- 7 files changed, 700 insertions(+), 768 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index 026002253..d7f707f87 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -8,61 +8,447 @@ class MakeRegistryTests(unittest.TestCase): def tearDown(self): cleanUp() + + def _makeOne(self): + from repoze.bfg.registry import Registry + from repoze.bfg.configuration import Configurator + reg = Registry() + config = Configurator(reg) + + +class ConfiguratorTests(unittest.TestCase): + def _makeOne(self, registry=None): + from repoze.bfg.registry import Registry + from repoze.bfg.configuration import Configurator + if registry is None: + registry = Registry() + return Configurator(registry) + + def _registerRenderer(self, config, name='.txt'): + from repoze.bfg.interfaces import IRendererFactory + from repoze.bfg.interfaces import ITemplateRenderer + from zope.interface import implements + class Renderer: + implements(ITemplateRenderer) + def __init__(self, path): + pass + def __call__(self, *arg): + return 'Hello!' + config.reg.registerUtility(Renderer, IRendererFactory, name=name) + + def test__override_not_yet_registered(self): + from repoze.bfg.interfaces import IPackageOverrides + package = DummyPackage('package') + opackage = DummyPackage('opackage') + config = self._makeOne() + config._override(package, 'path', opackage, 'oprefix', + PackageOverrides=DummyOverrides) + overrides = config.reg.queryUtility(IPackageOverrides, + name='package') + self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) + self.assertEqual(overrides.package, package) + + def test__override_already_registered(self): + from repoze.bfg.interfaces import IPackageOverrides + package = DummyPackage('package') + opackage = DummyPackage('opackage') + overrides = DummyOverrides(package) + config = self._makeOne() + config.reg.registerUtility(overrides, IPackageOverrides, + name='package') + config._override(package, 'path', opackage, 'oprefix', + PackageOverrides=DummyOverrides) + self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) + self.assertEqual(overrides.package, package) + + def test_map_view_as_function_context_and_request(self): + def view(context, request): + return 'OK' + config = self._makeOne() + result = config.map_view(view) + self.failUnless(result is view) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_function_with_attr(self): + def view(context, request): + """ """ + config = self._makeOne() + result = config.map_view(view, attr='__name__') + self.failIf(result is view) + self.assertRaises(TypeError, result, None, None) + + def test_map_view_as_function_with_attr_and_renderer(self): + config = self._makeOne() + self._registerRenderer(config) + def view(context, request): + """ """ + result = config.map_view(view, attr='__name__', + renderer_name='fixtures/minimal.txt') + self.failIf(result is view) + self.assertRaises(TypeError, result, None, None) - def _callFUT(self, *arg, **kw): - from repoze.bfg.router import make_registry - return make_registry(*arg, **kw) + def test_map_view_as_function_requestonly(self): + config = self._makeOne() + def view(request): + return 'OK' + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_function_requestonly_with_attr(self): + config = self._makeOne() + def view(request): + """ """ + result = config.map_view(view, attr='__name__') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertRaises(TypeError, result, None, None) + + def test_map_view_as_newstyle_class_context_and_request(self): + config = self._makeOne() + class view(object): + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_newstyle_class_context_and_request_with_attr(self): + config = self._makeOne() + class view(object): + def __init__(self, context, request): + pass + def index(self): + return 'OK' + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_newstyle_class_context_and_request_attr_and_renderer( + self): + config = self._makeOne() + self._registerRenderer(config) + class view(object): + def __init__(self, context, request): + pass + def index(self): + return {'a':'1'} + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_newstyle_class_requestonly(self): + config = self._makeOne() + class view(object): + def __init__(self, request): + pass + def __call__(self): + return 'OK' + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_newstyle_class_requestonly_with_attr(self): + config = self._makeOne() + class view(object): + def __init__(self, request): + pass + def index(self): + return 'OK' + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_newstyle_class_requestonly_with_attr_and_renderer( + self): + config = self._makeOne() + self._registerRenderer(config) + class view(object): + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_oldstyle_class_context_and_request(self): + config = self._makeOne() + class view: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_oldstyle_class_context_and_request_with_attr(self): + config = self._makeOne() + class view: + def __init__(self, context, request): + pass + def index(self): + return 'OK' + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_oldstyle_class_context_and_request_attr_and_renderer( + self): + config = self._makeOne() + self._registerRenderer(config) + class view: + def __init__(self, context, request): + pass + def index(self): + return {'a':'1'} + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') - def test_fixtureapp_default_filename_withpackage(self): + def test_map_view_as_oldstyle_class_requestonly(self): + config = self._makeOne() + class view: + def __init__(self, request): + pass + def __call__(self): + return 'OK' + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_oldstyle_class_requestonly_with_attr(self): + config = self._makeOne() + class view: + def __init__(self, request): + pass + def index(self): + return 'OK' + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): + config = self._makeOne() + self._registerRenderer(config) + class view: + def __init__(self, request): + pass + def index(self): + return {'a':'1'} + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.assertEqual(view.__name__, result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_instance_context_and_request(self): + config = self._makeOne() + class View: + def __call__(self, context, request): + return 'OK' + view = View() + result = config.map_view(view) + self.failUnless(result is view) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_instance_context_and_request_and_attr(self): + config = self._makeOne() + class View: + def index(self, context, request): + return 'OK' + view = View() + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_instance_context_and_request_attr_and_renderer(self): + config = self._makeOne() + self._registerRenderer(config) + class View: + def index(self, context, request): + return {'a':'1'} + view = View() + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_as_instance_requestonly(self): + config = self._makeOne() + class View: + def __call__(self, request): + return 'OK' + view = View() + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.failUnless('instance' in result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_instance_requestonly_with_attr(self): + config = self._makeOne() + class View: + def index(self, request): + return 'OK' + view = View() + result = config.map_view(view, attr='index') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.failUnless('instance' in result.__name__) + self.assertEqual(result(None, None), 'OK') + + def test_map_view_as_instance_requestonly_with_attr_and_renderer(self): + config = self._makeOne() + self._registerRenderer(config) + class View: + def index(self, request): + return {'a':'1'} + view = View() + result = config.map_view( + view, attr='index', + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + self.failUnless('instance' in result.__name__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_rendereronly(self): + config = self._makeOne() + self._registerRenderer(config) + def view(context, request): + return {'a':'1'} + result = config.map_view( + view, + renderer_name='repoze.bfg.tests:fixtures/minimal.txt') + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test_map_view_defaultrendereronly(self): + config = self._makeOne() + self._registerRenderer(config, name='') + def view(context, request): + return {'a':'1'} + result = config.map_view(view) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def _callDefaultConfiguration(self, *arg, **kw): + inst = self._makeOne() + inst.default_configuration(*arg, **kw) + return inst.reg + + def test_default_config_fixtureapp_default_filename_withpackage(self): manager = DummyRegistryManager() from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) - registry = self._callFUT(rootfactory, fixtureapp) - self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp') + registry = self._callDefaultConfiguration(rootfactory, fixtureapp) from repoze.bfg.tests.fixtureapp.models import IFixture self.failUnless(registry.queryUtility(IFixture)) # only in c.zcml - def test_fixtureapp_explicit_filename(self): + def test_default_config_fixtureapp_explicit_filename(self): manager = DummyRegistryManager() from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) - registry = self._callFUT( + registry = self._callDefaultConfiguration( rootfactory, fixtureapp, filename='another.zcml', manager=manager) - self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp') from repoze.bfg.tests.fixtureapp.models import IFixture self.failIf(registry.queryUtility(IFixture)) # only in c.zcml - def test_fixtureapp_explicit_filename_in_options(self): + def test_default_config_fixtureapp_explicit_filename_in_settings(self): import os manager = DummyRegistryManager() rootfactory = DummyRootFactory(None) from repoze.bfg.tests import fixtureapp zcmlfile = os.path.join(os.path.dirname(fixtureapp.__file__), 'another.zcml') - registry = self._callFUT( + registry = self._callDefaultConfiguration( rootfactory, fixtureapp, filename='configure.zcml', - options={'configure_zcml':zcmlfile}, + settings={'configure_zcml':zcmlfile}, manager=manager) - self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp') from repoze.bfg.tests.fixtureapp.models import IFixture self.failIf(registry.queryUtility(IFixture)) # only in c.zcml - def test_fixtureapp_explicit_specification_in_options(self): + def test_default_config_fixtureapp_explicit_specification_in_settings(self): manager = DummyRegistryManager() rootfactory = DummyRootFactory(None) from repoze.bfg.tests import fixtureapp zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml' - registry = self._callFUT( + registry = self._callDefaultConfiguration( rootfactory, fixtureapp, filename='configure.zcml', - options={'configure_zcml':zcmlfile}, + settings={'configure_zcml':zcmlfile}, manager=manager) - self.assertEqual(registry.__name__, - 'repoze.bfg.tests.fixtureapp.subpackage') from repoze.bfg.tests.fixtureapp.models import IFixture self.failIf(registry.queryUtility(IFixture)) # only in c.zcml - def test_fixtureapp_filename_hascolon_isabs(self): + def test_default_config_fixtureapp_filename_hascolon_isabs(self): manager = DummyRegistryManager() rootfactory = DummyRootFactory(None) from repoze.bfg.tests import fixtureapp @@ -72,35 +458,37 @@ class MakeRegistryTests(unittest.TestCase): return True os = Dummy() os.path = Dummy() - self.assertRaises(IOError, self._callFUT, + self.assertRaises(IOError, self._callDefaultConfiguration, rootfactory, fixtureapp, filename='configure.zcml', - options={'configure_zcml':zcmlfile}, + settings={'configure_zcml':zcmlfile}, manager=manager, os=os) - def test_custom_settings(self): + def test_default_config_custom_settings(self): manager = DummyRegistryManager() - options= {'mysetting':True} + settings = {'mysetting':True} from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) - registry = self._callFUT(rootfactory, fixtureapp, options=options, - manager=manager) + registry = self._callDefaultConfiguration( + rootfactory, fixtureapp, settings=settings, + manager=manager) from repoze.bfg.interfaces import ISettings settings = registry.getUtility(ISettings) self.assertEqual(settings.reload_templates, False) self.assertEqual(settings.debug_authorization, False) self.assertEqual(settings.mysetting, True) - def test_registrations(self): + def test_default_config_registrations(self): manager = DummyRegistryManager() - options= {'reload_templates':True, - 'debug_authorization':True} + settings = {'reload_templates':True, + 'debug_authorization':True} from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) - registry = self._callFUT(rootfactory, fixtureapp, options=options, - manager=manager) + registry = self._callDefaultConfiguration( + rootfactory, fixtureapp, settings=settings, + manager=manager) from repoze.bfg.interfaces import ISettings from repoze.bfg.interfaces import ILogger from repoze.bfg.interfaces import IRootFactory @@ -113,110 +501,106 @@ class MakeRegistryTests(unittest.TestCase): self.assertEqual(rootfactory, rootfactory) self.failUnless(manager.pushed and manager.popped) - def test_routes_in_config_with_rootfactory(self): - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.urldispatch import RoutesRootFactory - from repoze.bfg.tests import routesapp - rootfactory = DummyRootFactory(None) - registry = self._callFUT(rootfactory, routesapp, options=options) + def test_default_config_routes_in_config(self): from repoze.bfg.interfaces import ISettings from repoze.bfg.interfaces import ILogger from repoze.bfg.interfaces import IRootFactory - settings = registry.getUtility(ISettings) - logger = registry.getUtility(ILogger, name='repoze.bfg.debug') - effective_rootfactory = registry.getUtility(IRootFactory) - self.assertEqual(logger.name, 'repoze.bfg.debug') - self.assertEqual(settings.reload_templates, True) - self.assertEqual(settings.debug_authorization, True) - self.failUnless(isinstance(effective_rootfactory, RoutesRootFactory)) - self.assertEqual(effective_rootfactory.default_root_factory, - rootfactory) - - def test_routes_in_config_no_rootfactory(self): - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.urldispatch import RoutesRootFactory - from repoze.bfg.router import DefaultRootFactory + from repoze.bfg.interfaces import IRoutesMapper + settings = {'reload_templates':True, + 'debug_authorization':True} from repoze.bfg.tests import routesapp - registry = self._callFUT(None, routesapp, options=options) - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ILogger - from repoze.bfg.interfaces import IRootFactory + rootfactory = DummyRootFactory(None) + registry = self._callDefaultConfiguration( + rootfactory, routesapp, settings=settings) settings = registry.getUtility(ISettings) logger = registry.getUtility(ILogger, name='repoze.bfg.debug') - rootfactory = registry.getUtility(IRootFactory) - self.assertEqual(logger.name, 'repoze.bfg.debug') - self.assertEqual(settings.reload_templates, True) - self.assertEqual(settings.debug_authorization, True) - self.failUnless(isinstance(rootfactory, RoutesRootFactory)) - self.assertEqual(rootfactory.default_root_factory, DefaultRootFactory) - - def test_no_routes_in_config_no_rootfactory(self): - from repoze.bfg.router import DefaultRootFactory - from repoze.bfg.interfaces import IRootFactory - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.tests import fixtureapp - registry = self._callFUT(None, fixtureapp, options=options) - rootfactory = registry.getUtility(IRootFactory) - self.assertEqual(rootfactory, DefaultRootFactory) + self.assertEqual(registry.getUtility(IRootFactory), rootfactory) + self.failUnless(registry.getUtility(IRoutesMapper)) - def test_authorization_policy_no_authentication_policy(self): - from repoze.bfg.interfaces import IAuthorizationPolicy - authzpolicy = DummyContext() - from repoze.bfg.tests import routesapp - logger = DummyLogger() - registry = self._callFUT( - None, routesapp, authorization_policy=authzpolicy, - debug_logger=logger) - self.failIf(registry.queryUtility(IAuthorizationPolicy)) - self.assertEqual(logger.messages, []) - - def test_authentication_policy_no_authorization_policy(self): - from repoze.bfg.interfaces import IAuthorizationPolicy - from repoze.bfg.interfaces import IAuthenticationPolicy - from repoze.bfg.authorization import ACLAuthorizationPolicy - authnpolicy = DummyContext() - from repoze.bfg.tests import routesapp - logger = DummyLogger() - registry = self._callFUT( - None, routesapp, authentication_policy=authnpolicy, - debug_logger=logger) - self.assertEqual(registry.getUtility(IAuthenticationPolicy), - authnpolicy) - self.assertEqual( - registry.getUtility(IAuthorizationPolicy).__class__, - ACLAuthorizationPolicy) - self.assertEqual(len(logger.messages), 1) # deprecation warning - - def test_authentication_policy_and_authorization_policy(self): - from repoze.bfg.interfaces import IAuthorizationPolicy - from repoze.bfg.interfaces import IAuthenticationPolicy - authnpolicy = DummyContext() - authzpolicy = DummyContext() - from repoze.bfg.tests import routesapp - logger = DummyLogger() - registry = self._callFUT( - None, routesapp, authentication_policy=authnpolicy, - authorization_policy = authzpolicy, - debug_logger=logger) - self.assertEqual(registry.getUtility(IAuthenticationPolicy), - authnpolicy) - self.assertEqual(registry.getUtility(IAuthorizationPolicy), - authzpolicy) - self.assertEqual(len(logger.messages), 1) # deprecation warning - - def test_lock_and_unlock(self): + def test_default_config_lock_and_unlock(self): from repoze.bfg.tests import fixtureapp rootfactory = DummyRootFactory(None) dummylock = DummyLock() - registry = self._callFUT( + registry = self._callDefaultConfiguration( rootfactory, fixtureapp, filename='configure.zcml', lock=dummylock) self.assertEqual(dummylock.acquired, True) self.assertEqual(dummylock.released, True) +class TestBFGViewGrokker(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _getTargetClass(self): + from repoze.bfg.configuration import BFGViewGrokker + return BFGViewGrokker + + def _makeOne(self, *arg, **kw): + return self._getTargetClass()(*arg, **kw) + + def test_grok_is_bfg_view(self): + from zope.component import getSiteManager + from repoze.bfg.interfaces import IRequest + from repoze.bfg.interfaces import IView + from zope.interface import Interface + from repoze.bfg.configuration import Configurator + grokker = self._makeOne() + class obj: + def __init__(self, context, request): + pass + def __call__(self): + return 'OK' + settings = dict(permission='foo', for_=Interface, name='foo.html', + request_type=IRequest, route_name=None, + request_method=None, request_param=None, + containment=None, attr=None, renderer=None, + wrapper=None, xhr=False, header=None, + accept=None) + obj.__bfg_view_settings__ = [settings] + sm = getSiteManager() + config = Configurator(sm) + result = grokker.grok('name', obj, _info='', _configurator=config) + self.assertEqual(result, True) + wrapped = sm.adapters.lookup((Interface, IRequest), IView, + name='foo.html') + self.assertEqual(wrapped(None, None), 'OK') + + def test_grok_is_not_bfg_view(self): + grokker = self._makeOne() + class obj: + pass + context = DummyContext() + result = grokker.grok('name', obj) + self.assertEqual(result, False) + +class TestDefaultRootFactory(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.configuration import DefaultRootFactory + return DefaultRootFactory + + def _makeOne(self, environ): + return self._getTargetClass()(environ) + + def test_no_matchdict(self): + environ = {} + root = self._makeOne(environ) + self.assertEqual(root.__parent__, None) + self.assertEqual(root.__name__, None) + + def test_matchdict(self): + class DummyRequest: + pass + request = DummyRequest() + request.matchdict = {'a':1, 'b':2} + root = self._makeOne(request) + self.assertEqual(root.a, 1) + self.assertEqual(root.b, 2) + + + class DummyRequest: pass @@ -253,3 +637,15 @@ class DummyLock: def release(self): self.released = True +class DummyPackage: + def __init__(self, name): + self.__name__ = name + +class DummyOverrides: + def __init__(self, package): + self.package = package + self.inserted = [] + + def insert(self, path, package, prefix): + self.inserted.append((path, package, prefix)) + diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py index c1779cdb6..57d22c286 100644 --- a/repoze/bfg/tests/test_integration.py +++ b/repoze/bfg/tests/test_integration.py @@ -99,7 +99,6 @@ class TestGrokkedApp(unittest.TestCase): from repoze.bfg.view import render_view_to_response from zope.interface import directlyProvides from repoze.bfg.zcml import zcml_configure - from repoze.bfg.interfaces import IView from repoze.bfg.interfaces import IRequest import repoze.bfg.tests.grokkedapp as package diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py index 11f5cbf3a..b652d2155 100644 --- a/repoze/bfg/tests/test_registry.py +++ b/repoze/bfg/tests/test_registry.py @@ -38,450 +38,6 @@ class TestRegistry(unittest.TestCase): registry.registerSubscriptionAdapter(EventHandler, [IFoo], Interface) self.assertEqual(registry.has_listeners, True) - def test__override_not_yet_registered(self): - from repoze.bfg.interfaces import IPackageOverrides - package = DummyPackage('package') - opackage = DummyPackage('opackage') - registry = self._makeOne() - registry._override(package, 'path', opackage, 'oprefix', - PackageOverrides=DummyOverrides) - overrides = registry.queryUtility(IPackageOverrides, name='package') - self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) - self.assertEqual(overrides.package, package) - - def test__override_already_registered(self): - from repoze.bfg.interfaces import IPackageOverrides - package = DummyPackage('package') - opackage = DummyPackage('opackage') - overrides = DummyOverrides(package) - registry = self._makeOne() - registry.registerUtility(overrides, IPackageOverrides, name='package') - registry._override(package, 'path', opackage, 'oprefix', - PackageOverrides=DummyOverrides) - self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')]) - self.assertEqual(overrides.package, package) - - def _registerRenderer(self, reg, name='.txt'): - from repoze.bfg.interfaces import IRendererFactory - from repoze.bfg.interfaces import ITemplateRenderer - from zope.interface import implements - class Renderer: - implements(ITemplateRenderer) - def __init__(self, path): - pass - def __call__(self, *arg): - return 'Hello!' - reg.registerUtility(Renderer, IRendererFactory, name=name) - - def test_map_view_as_function_context_and_request(self): - def view(context, request): - return 'OK' - reg = self._makeOne() - result = reg.map_view(view) - self.failUnless(result is view) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_function_with_attr(self): - def view(context, request): - """ """ - reg = self._makeOne() - result = reg.map_view(view, attr='__name__') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) - - def test_map_view_as_function_with_attr_and_renderer(self): - reg = self._makeOne() - self._registerRenderer(reg) - def view(context, request): - """ """ - result = reg.map_view(view, attr='__name__', - renderer_name='fixtures/minimal.txt') - self.failIf(result is view) - self.assertRaises(TypeError, result, None, None) - - def test_map_view_as_function_requestonly(self): - reg = self._makeOne() - def view(request): - return 'OK' - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_function_requestonly_with_attr(self): - reg = self._makeOne() - def view(request): - """ """ - result = reg.map_view(view, attr='__name__') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertRaises(TypeError, result, None, None) - - def test_map_view_as_newstyle_class_context_and_request(self): - reg = self._makeOne() - class view(object): - def __init__(self, context, request): - pass - def __call__(self): - return 'OK' - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_newstyle_class_context_and_request_with_attr(self): - reg = self._makeOne() - class view(object): - def __init__(self, context, request): - pass - def index(self): - return 'OK' - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_newstyle_class_context_and_request_attr_and_renderer( - self): - reg = self._makeOne() - self._registerRenderer(reg) - class view(object): - def __init__(self, context, request): - pass - def index(self): - return {'a':'1'} - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_as_newstyle_class_requestonly(self): - reg = self._makeOne() - class view(object): - def __init__(self, request): - pass - def __call__(self): - return 'OK' - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_newstyle_class_requestonly_with_attr(self): - reg = self._makeOne() - class view(object): - def __init__(self, request): - pass - def index(self): - return 'OK' - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_newstyle_class_requestonly_with_attr_and_renderer(self): - reg = self._makeOne() - self._registerRenderer(reg) - class view(object): - def __init__(self, request): - pass - def index(self): - return {'a':'1'} - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_as_oldstyle_class_context_and_request(self): - reg = self._makeOne() - class view: - def __init__(self, context, request): - pass - def __call__(self): - return 'OK' - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_oldstyle_class_context_and_request_with_attr(self): - reg = self._makeOne() - class view: - def __init__(self, context, request): - pass - def index(self): - return 'OK' - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_oldstyle_class_context_and_request_attr_and_renderer( - self): - reg = self._makeOne() - self._registerRenderer(reg) - class view: - def __init__(self, context, request): - pass - def index(self): - return {'a':'1'} - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_as_oldstyle_class_requestonly(self): - reg = self._makeOne() - class view: - def __init__(self, request): - pass - def __call__(self): - return 'OK' - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_oldstyle_class_requestonly_with_attr(self): - reg = self._makeOne() - class view: - def __init__(self, request): - pass - def index(self): - return 'OK' - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self): - reg = self._makeOne() - self._registerRenderer(reg) - class view: - def __init__(self, request): - pass - def index(self): - return {'a':'1'} - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(view.__name__, result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_as_instance_context_and_request(self): - reg = self._makeOne() - class View: - def __call__(self, context, request): - return 'OK' - view = View() - result = reg.map_view(view) - self.failUnless(result is view) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_instance_context_and_request_and_attr(self): - reg = self._makeOne() - class View: - def index(self, context, request): - return 'OK' - view = View() - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_instance_context_and_request_attr_and_renderer(self): - reg = self._makeOne() - self._registerRenderer(reg) - class View: - def index(self, context, request): - return {'a':'1'} - view = View() - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_as_instance_requestonly(self): - reg = self._makeOne() - class View: - def __call__(self, request): - return 'OK' - view = View() - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.failUnless('instance' in result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_instance_requestonly_with_attr(self): - reg = self._makeOne() - class View: - def index(self, request): - return 'OK' - view = View() - result = reg.map_view(view, attr='index') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.failUnless('instance' in result.__name__) - self.assertEqual(result(None, None), 'OK') - - def test_map_view_as_instance_requestonly_with_attr_and_renderer(self): - reg = self._makeOne() - self._registerRenderer(reg) - class View: - def index(self, request): - return {'a':'1'} - view = View() - result = reg.map_view( - view, attr='index', - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - self.failUnless('instance' in result.__name__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_rendereronly(self): - reg = self._makeOne() - self._registerRenderer(reg) - def view(context, request): - return {'a':'1'} - result = reg.map_view( - view, - renderer_name='repoze.bfg.tests:fixtures/minimal.txt') - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - - def test_map_view_defaultrendereronly(self): - reg = self._makeOne() - self._registerRenderer(reg, name='') - def view(context, request): - return {'a':'1'} - result = reg.map_view(view) - self.failIf(result is view) - self.assertEqual(view.__module__, result.__module__) - self.assertEqual(view.__doc__, result.__doc__) - request = DummyRequest() - self.assertEqual(result(None, request).body, 'Hello!') - -class TestBFGViewGrokker(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _getTargetClass(self): - from repoze.bfg.registry import BFGViewGrokker - return BFGViewGrokker - - def _makeOne(self, *arg, **kw): - return self._getTargetClass()(*arg, **kw) - - def test_grok_is_bfg_view(self): - from zope.component import getSiteManager - from repoze.bfg.interfaces import IRequest - from repoze.bfg.interfaces import IView - from zope.interface import Interface - grokker = self._makeOne() - class obj: - def __init__(self, context, request): - pass - def __call__(self): - return 'OK' - settings = dict(permission='foo', for_=Interface, name='foo.html', - request_type=IRequest, route_name=None, - request_method=None, request_param=None, - containment=None, attr=None, renderer=None, - wrapper=None, xhr=False, header=None, - accept=None) - obj.__bfg_view_settings__ = [settings] - sm = getSiteManager() - result = grokker.grok('name', obj, _info='', _registry=sm) - self.assertEqual(result, True) - wrapped = sm.adapters.lookup((Interface, IRequest), IView, - name='foo.html') - self.assertEqual(wrapped(None, None), 'OK') - - def test_grok_is_not_bfg_view(self): - grokker = self._makeOne() - class obj: - pass - context = DummyContext() - result = grokker.grok('name', obj, context=context) - self.assertEqual(result, False) - actions = context.actions - self.assertEqual(len(actions), 0) - -class TestDefaultRootFactory(unittest.TestCase): - def _getTargetClass(self): - from repoze.bfg.registry import DefaultRootFactory - return DefaultRootFactory - - def _makeOne(self, environ): - return self._getTargetClass()(environ) - - def test_no_matchdict(self): - environ = {} - root = self._makeOne(environ) - self.assertEqual(root.__parent__, None) - self.assertEqual(root.__name__, None) - - def test_matchdict(self): - class DummyRequest: - pass - request = DummyRequest() - request.matchdict = {'a':1, 'b':2} - root = self._makeOne(request) - self.assertEqual(root.a, 1) - self.assertEqual(root.b, 2) - class DummyModule: __path__ = "foo" __name__ = "dummy" @@ -494,18 +50,6 @@ class DummyContext: self.info = None self.resolved = resolved -class DummyPackage: - def __init__(self, name): - self.__name__ = name - -class DummyOverrides: - def __init__(self, package): - self.package = package - self.inserted = [] - - def insert(self, path, package, prefix): - self.inserted.append((path, package, prefix)) - class DummyRequest: def __init__(self, environ=None): if environ is None: diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py index 07c10adaa..3321af938 100644 --- a/repoze/bfg/tests/test_router.py +++ b/repoze/bfg/tests/test_router.py @@ -14,6 +14,27 @@ class TestRouter(unittest.TestCase): getSiteManager.reset() cleanUp() + def _registerRouteRequest(self, name): + from repoze.bfg.interfaces import IRouteRequest + from zope.interface import Interface + from zope.component import getSiteManager + class IRequest(Interface): + """ """ + sm = getSiteManager() + sm.registerUtility(IRequest, IRouteRequest, name=name) + return IRequest + + def _connectRoute(self, path, name, factory=None): + from repoze.bfg.interfaces import IRoutesMapper + from zope.component import getSiteManager + from repoze.bfg.urldispatch import RoutesMapper + sm = getSiteManager() + mapper = sm.queryUtility(IRoutesMapper) + if mapper is None: + mapper = RoutesMapper() + sm.registerUtility(mapper, IRoutesMapper) + mapper.connect(path, name, factory) + def _registerLogger(self): from zope.component import getSiteManager gsm = getSiteManager() @@ -420,6 +441,80 @@ class TestRouter(unittest.TestCase): self.assertEqual(len(router.threadlocal_manager.pushed), 1) self.assertEqual(len(router.threadlocal_manager.popped), 1) + def test_call_route_matches_and_has_factory(self): + req_iface = self._registerRouteRequest('foo') + root = object() + def factory(request): + return root + self._connectRoute('archives/:action/:article', 'foo', factory) + context = DummyContext() + self._registerTraverserFactory(context) + response = DummyResponse() + response.app_iter = ['Hello world'] + view = DummyView(response) + environ = self._makeEnviron(PATH_INFO='/archives/action1/article1') + self._registerView(view, '', None, None) + rootfactory = self._registerRootFactory(context) + router = self._makeOne() + start_response = DummyStartResponse() + result = router(environ, start_response) + self.assertEqual(result, ['Hello world']) + self.assertEqual(start_response.headers, ()) + self.assertEqual(start_response.status, '200 OK') + request = view.request + self.assertEqual(request.view_name, '') + self.assertEqual(request.subpath, []) + self.assertEqual(request.context, context) + self.assertEqual(request.root, root) + routing_args = environ['wsgiorg.routing_args'][1] + self.assertEqual(routing_args['action'], 'action1') + self.assertEqual(routing_args['article'], 'article1') + self.assertEqual(environ['bfg.routes.matchdict'], routing_args) + self.assertEqual(environ['bfg.routes.route'].name, 'foo') + self.assertEqual(request.matchdict, routing_args) + self.failUnless(req_iface.providedBy(request)) + + def test_call_route_matches_doesnt_overwrite_subscriber_iface(self): + from repoze.bfg.interfaces import INewRequest + from zope.interface import alsoProvides + from zope.interface import Interface + req_iface = self._registerRouteRequest('foo') + class IFoo(Interface): + pass + def listener(event): + alsoProvides(event.request, IFoo) + self.registry.registerHandler(listener, (INewRequest,)) + root = object() + def factory(request): + return root + self._connectRoute('archives/:action/:article', 'foo', factory) + context = DummyContext() + self._registerTraverserFactory(context) + response = DummyResponse() + response.app_iter = ['Hello world'] + view = DummyView(response) + environ = self._makeEnviron(PATH_INFO='/archives/action1/article1') + self._registerView(view, '', None, None) + rootfactory = self._registerRootFactory(context) + router = self._makeOne() + start_response = DummyStartResponse() + result = router(environ, start_response) + self.assertEqual(result, ['Hello world']) + self.assertEqual(start_response.headers, ()) + self.assertEqual(start_response.status, '200 OK') + request = view.request + self.assertEqual(request.view_name, '') + self.assertEqual(request.subpath, []) + self.assertEqual(request.context, context) + self.assertEqual(request.root, root) + routing_args = environ['wsgiorg.routing_args'][1] + self.assertEqual(routing_args['action'], 'action1') + self.assertEqual(routing_args['article'], 'article1') + self.assertEqual(environ['bfg.routes.matchdict'], routing_args) + self.assertEqual(environ['bfg.routes.route'].name, 'foo') + self.assertEqual(request.matchdict, routing_args) + self.failUnless(req_iface.providedBy(request)) + self.failUnless(IFoo.providedBy(request)) class TestMakeApp(unittest.TestCase): def setUp(self): @@ -430,42 +525,34 @@ class TestMakeApp(unittest.TestCase): def _callFUT(self, *arg, **kw): from repoze.bfg.router import make_app - return make_app(None, *arg, **kw) - - def _get_make_registry(self, sm): - class DummyMakeRegistry(object): - def __call__(self, *arg): - self.arg = arg - return sm - return DummyMakeRegistry() + return make_app(*arg, **kw) def test_it(self): from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent from repoze.bfg.tests import fixtureapp from zope.component import getSiteManager sm = getSiteManager() - dummy_make_registry = self._get_make_registry(sm) def subscriber(event): event.app.created = True manager = DummyRegistryManager() sm.registerHandler(subscriber, (IWSGIApplicationCreatedEvent,)) rootfactory = DummyRootFactory(None) settings = {'a':1} - app = self._callFUT(rootfactory, fixtureapp, manager=manager, - settings=settings, - make_registry=dummy_make_registry) + app = self._callFUT(rootfactory, fixtureapp, settings=settings, + Configurator=DummyConfigurator, manager=manager) self.failUnless(app.created) self.failUnless(manager.pushed) self.failUnless(manager.popped) - self.assertEqual(len(dummy_make_registry.arg), 6) - self.assertEqual(dummy_make_registry.arg[-1], settings) + self.assertEqual(app.registry.root_factory, rootfactory) + self.assertEqual(app.registry.settings, settings) + self.assertEqual(app.registry.package, fixtureapp) + self.assertEqual(app.registry.filename, 'configure.zcml') def test_it_options_means_settings(self): from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent - from zope.component import getSiteManager from repoze.bfg.tests import fixtureapp + from zope.component import getSiteManager sm = getSiteManager() - dummy_make_registry = self._get_make_registry(sm) def subscriber(event): event.app.created = True manager = DummyRegistryManager() @@ -473,13 +560,14 @@ class TestMakeApp(unittest.TestCase): rootfactory = DummyRootFactory(None) settings = {'a':1} app = self._callFUT(rootfactory, fixtureapp, options=settings, - manager=manager, - make_registry=dummy_make_registry) + Configurator=DummyConfigurator, manager=manager) self.failUnless(app.created) self.failUnless(manager.pushed) self.failUnless(manager.popped) - self.assertEqual(len(dummy_make_registry.arg), 6) - self.assertEqual(dummy_make_registry.arg[-1], settings) + self.assertEqual(app.registry.root_factory, rootfactory) + self.assertEqual(app.registry.settings, settings) + self.assertEqual(app.registry.package, fixtureapp) + self.assertEqual(app.registry.filename, 'configure.zcml') class DummyContext: pass @@ -551,3 +639,14 @@ class DummyRegistryManager: def pop(self): self.popped = True +class DummyConfigurator(object): + def __init__(self, registry): + self.registry = registry + + def default_configuration(self, root_factory=None, package=None, + filename=None, settings=None): + self.registry.root_factory = root_factory + self.registry.package = package + self.registry.filename = filename + self.registry.settings = settings + diff --git a/repoze/bfg/tests/test_threadlocal.py b/repoze/bfg/tests/test_threadlocal.py index 09a25debd..b277d6cb9 100644 --- a/repoze/bfg/tests/test_threadlocal.py +++ b/repoze/bfg/tests/test_threadlocal.py @@ -1,12 +1,12 @@ -from repoze.bfg.testing import cleanUp +from repoze.bfg import testing import unittest class TestThreadLocalManager(unittest.TestCase): def setUp(self): - cleanUp() + testing.setUp() def tearDown(self): - cleanUp() + testing.tearDown() def _getTargetClass(self): from repoze.bfg.threadlocal import ThreadLocalManager @@ -67,24 +67,29 @@ class TestGetCurrentRequest(unittest.TestCase): class GetCurrentRegistryTests(unittest.TestCase): def setUp(self): - cleanUp() + testing.setUp() def tearDown(self): - cleanUp() + testing.tearDown() def _callFUT(self): from repoze.bfg.threadlocal import get_current_registry return get_current_registry() - def test_local(self): + def test_it(self): from repoze.bfg.threadlocal import manager try: manager.push({'registry':123}) self.assertEqual(self._callFUT(), 123) finally: manager.pop() - - def test_global(self): + +class GetCurrentRegistryWithoutTestingRegistry(unittest.TestCase): + def _callFUT(self): + from repoze.bfg.threadlocal import get_current_registry + return get_current_registry() + + def test_it(self): from zope.component import getGlobalSiteManager self.assertEqual(self._callFUT(), getGlobalSiteManager()) diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py index ecc76fe04..18ebe3e98 100644 --- a/repoze/bfg/tests/test_urldispatch.py +++ b/repoze/bfg/tests/test_urldispatch.py @@ -35,7 +35,7 @@ class TestRoute(unittest.TestCase): route = self._makeOne(':path') self.assertEqual(route.generate({'path':'abc'}), '/abc') -class RoutesRootFactoryTests(unittest.TestCase): +class RoutesMapperTests(unittest.TestCase): def setUp(self): testing.setUp() @@ -52,213 +52,92 @@ class RoutesRootFactoryTests(unittest.TestCase): request.registry = sm return request - def _registerRouteRequest(self, name): - from repoze.bfg.interfaces import IRouteRequest - from zope.interface import Interface - from zope.component import getSiteManager - class IRequest(Interface): - """ """ - sm = getSiteManager() - sm.registerUtility(IRequest, IRouteRequest, name=name) - return IRequest - def _getTargetClass(self): - from repoze.bfg.urldispatch import RoutesRootFactory - return RoutesRootFactory + from repoze.bfg.urldispatch import RoutesMapper + return RoutesMapper - def _makeOne(self, get_root): + def _makeOne(self): klass = self._getTargetClass() - return klass(get_root) - - def test_init_default_root_factory(self): - mapper = self._makeOne(None) - self.assertEqual(mapper.default_root_factory, None) + return klass() def test_no_route_matches(self): - root_factory = DummyRootFactory(123) - mapper = self._makeOne(root_factory) + mapper = self._makeOne() request = self._getRequest(PATH_INFO='/') result = mapper(request) - self.assertEqual(result, 123) - - def test_passed_environ_returns_default(self): - root_factory = DummyRootFactory(123) - mapper = self._makeOne(root_factory) - request = self._getRequest(PATH_INFO='/') - result = mapper(request.environ) - self.assertEqual(result, 123) - self.assertEqual(root_factory.request, request.environ) + self.assertEqual(result['match'], None) + self.assertEqual(result['route'], None) def test_route_matches(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('foo') - mapper = self._makeOne(root_factory) - mapper.connect('archives/:action/:article', 'foo') - request = self._getRequest(PATH_INFO='/archives/action1/article1') - result = mapper(request) - self.assertEqual(result, 123) - environ = request.environ - routing_args = environ['wsgiorg.routing_args'][1] - self.assertEqual(routing_args['action'], 'action1') - self.assertEqual(routing_args['article'], 'article1') - self.assertEqual(environ['bfg.routes.matchdict'], routing_args) - self.assertEqual(environ['bfg.routes.route'].name, 'foo') - self.assertEqual(request.matchdict, routing_args) - self.failUnless(req_iface.providedBy(request)) - - def test_route_matches_already_has_iface(self): - from zope.interface import Interface - from zope.interface import directlyProvides - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('foo') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('archives/:action/:article', 'foo') request = self._getRequest(PATH_INFO='/archives/action1/article1') - class IFoo(Interface): - pass - directlyProvides(request, IFoo) - result = mapper(request) - self.assertEqual(result, 123) - environ = request.environ - routing_args = environ['wsgiorg.routing_args'][1] - self.assertEqual(routing_args['action'], 'action1') - self.assertEqual(routing_args['article'], 'article1') - self.assertEqual(environ['bfg.routes.matchdict'], routing_args) - self.assertEqual(environ['bfg.routes.route'].name, 'foo') - self.assertEqual(request.matchdict, routing_args) - self.failUnless(req_iface.providedBy(request)) - self.failUnless(IFoo.providedBy(request)) - - def test_route_matches_and_has_factory(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('foo') - mapper = self._makeOne(root_factory) - factory = DummyRootFactory(456) - mapper.connect('archives/:action/:article', 'foo', factory) - request = self._getRequest(PATH_INFO='/archives/action1/article1') result = mapper(request) - self.assertEqual(result, 456) - self.assertEqual(factory.request, request) - environ = request.environ - routing_args = environ['wsgiorg.routing_args'][1] - self.assertEqual(routing_args['action'], 'action1') - self.assertEqual(routing_args['article'], 'article1') - self.assertEqual(environ['bfg.routes.matchdict'], routing_args) - self.assertEqual(environ['bfg.routes.route'].name, 'foo') - self.assertEqual(request.matchdict, routing_args) - self.failUnless(req_iface.providedBy(request)) + self.assertEqual(result['route'], mapper.routes['foo']) + self.assertEqual(result['match']['action'], 'action1') + self.assertEqual(result['match']['article'], 'article1') def test_route_matches_with_predicates(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('foo') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('archives/:action/:article', 'foo', predicates=[lambda *arg: True]) request = self._getRequest(PATH_INFO='/archives/action1/article1') result = mapper(request) - self.assertEqual(result, 123) - environ = request.environ - routing_args = environ['wsgiorg.routing_args'][1] - self.assertEqual(routing_args['action'], 'action1') - self.assertEqual(routing_args['article'], 'article1') - self.assertEqual(environ['bfg.routes.matchdict'], routing_args) - self.assertEqual(environ['bfg.routes.route'].name, 'foo') - self.assertEqual(request.matchdict, routing_args) - self.failUnless(req_iface.providedBy(request)) + self.assertEqual(result['route'], mapper.routes['foo']) + self.assertEqual(result['match']['action'], 'action1') + self.assertEqual(result['match']['article'], 'article1') def test_route_fails_to_match_with_predicates(self): - root_factory = DummyRootFactory(123) - foo_iface = self._registerRouteRequest('foo') - bar_iface = self._registerRouteRequest('bar') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('archives/:action/article1', 'foo', predicates=[lambda *arg: True, lambda *arg: False]) mapper.connect('archives/:action/:article', 'bar') request = self._getRequest(PATH_INFO='/archives/action1/article1') result = mapper(request) - self.assertEqual(result, 123) - environ = request.environ - routing_args = environ['wsgiorg.routing_args'][1] - self.assertEqual(routing_args['action'], 'action1') - self.assertEqual(routing_args['article'], 'article1') - self.assertEqual(environ['bfg.routes.matchdict'], routing_args) - self.assertEqual(environ['bfg.routes.route'].name, 'bar') - self.assertEqual(request.matchdict, routing_args) - self.failUnless(bar_iface.providedBy(request)) - self.failIf(foo_iface.providedBy(request)) + self.assertEqual(result['route'], mapper.routes['bar']) + self.assertEqual(result['match']['action'], 'action1') + self.assertEqual(result['match']['article'], 'article1') def test_root_route_matches(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('root') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('', 'root') request = self._getRequest(PATH_INFO='/') result = mapper(request) - environ = request.environ - self.assertEqual(result, 123) - self.assertEqual(environ['bfg.routes.route'].name, 'root') - self.assertEqual(environ['bfg.routes.matchdict'], {}) - self.assertEqual(environ['wsgiorg.routing_args'], ((), {})) - self.assertEqual(request.matchdict, {}) - self.failUnless(req_iface.providedBy(request)) + self.assertEqual(result['route'], mapper.routes['root']) + self.assertEqual(result['match'], {}) def test_root_route_matches2(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('root') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('/', 'root') request = self._getRequest(PATH_INFO='/') result = mapper(request) - environ = request.environ - self.assertEqual(result, 123) - self.assertEqual(environ['bfg.routes.route'].name, 'root') - self.assertEqual(environ['bfg.routes.matchdict'], {}) - self.assertEqual(environ['wsgiorg.routing_args'], ((), {})) - self.assertEqual(request.matchdict, {}) - self.failUnless(req_iface.providedBy(request)) + self.assertEqual(result['route'], mapper.routes['root']) + self.assertEqual(result['match'], {}) def test_root_route_when_path_info_empty(self): - root_factory = DummyRootFactory(123) - req_iface = self._registerRouteRequest('root') - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('/', 'root') request = self._getRequest(PATH_INFO='') result = mapper(request) - environ = request.environ - self.assertEqual(result, 123) - self.assertEqual(environ['bfg.routes.route'].name, 'root') - self.assertEqual(environ['bfg.routes.matchdict'], {}) - self.assertEqual(environ['wsgiorg.routing_args'], ((), {})) - self.assertEqual(request.matchdict, {}) - self.failUnless(req_iface.providedBy(request)) - - def test_fallback_to_default_root_factory(self): - root_factory = DummyRootFactory(123) - mapper = self._makeOne(root_factory) - mapper.connect('wont/:be/:found', 'wont') - request = self._getRequest(PATH_INFO='/archives/action1/article1') - result = mapper(request) - self.assertEqual(result, 123) - self.assertEqual(root_factory.request, request) + self.assertEqual(result['route'], mapper.routes['root']) + self.assertEqual(result['match'], {}) def test_no_path_info(self): - root_factory = DummyRootFactory(123) - mapper = self._makeOne(root_factory) + mapper = self._makeOne() mapper.connect('/', 'root') request = self._getRequest() result = mapper(request) - self.assertEqual(result, 123) - self.assertEqual(root_factory.request, request) + self.assertEqual(result['route'], mapper.routes['root']) + self.assertEqual(result['match'], {}) def test_has_routes(self): - mapper = self._makeOne(None) + mapper = self._makeOne() self.assertEqual(mapper.has_routes(), False) mapper.connect('whatever', 'archives/:action/:article') self.assertEqual(mapper.has_routes(), True) def test_get_routes(self): from repoze.bfg.urldispatch import Route - mapper = self._makeOne(None) + mapper = self._makeOne() self.assertEqual(mapper.get_routes(), []) mapper.connect('whatever', 'archives/:action/:article') routes = mapper.get_routes() @@ -266,7 +145,7 @@ class RoutesRootFactoryTests(unittest.TestCase): self.assertEqual(routes[0].__class__, Route) def test_generate(self): - mapper = self._makeOne(None) + mapper = self._makeOne() def generator(kw): return 123 route = DummyRoute(generator) diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py index 1a7275932..af2b64de6 100644 --- a/repoze/bfg/tests/test_zcml.py +++ b/repoze/bfg/tests/test_zcml.py @@ -2581,53 +2581,62 @@ class TestResourceDirective(unittest.TestCase): def test_no_colons(self): from zope.component import getSiteManager + from repoze.bfg.configuration import Configurator context = DummyContext() self._callFUT(context, 'a', 'b') actions = context.actions self.assertEqual(len(actions), 1) action = actions[0] sm = getSiteManager() - self.assertEqual(action['callable'], sm.resource) + self.assertEqual(action['callable'].im_func, + Configurator.resource.im_func) self.assertEqual(action['discriminator'], None) self.assertEqual(action['args'], ('a', 'b', None)) def test_with_colons(self): from zope.component import getSiteManager + from repoze.bfg.configuration import Configurator context = DummyContext() self._callFUT(context, 'a:foo.pt', 'b:foo.pt') actions = context.actions self.assertEqual(len(actions), 1) action = actions[0] sm = getSiteManager() - self.assertEqual(action['callable'], sm.resource) + self.assertEqual(action['callable'].im_func, + Configurator.resource.im_func) self.assertEqual(action['discriminator'], None) self.assertEqual(action['args'], ('a:foo.pt', 'b:foo.pt', None)) def test_override_module_with_directory(self): from zope.component import getSiteManager + from repoze.bfg.configuration import Configurator context = DummyContext() self._callFUT(context, 'a', 'b:foo/') actions = context.actions self.assertEqual(len(actions), 1) action = actions[0] sm = getSiteManager() - self.assertEqual(action['callable'], sm.resource) + self.assertEqual(action['callable'].im_func, + Configurator.resource.im_func) self.assertEqual(action['discriminator'], None) self.assertEqual(action['args'], ('a', 'b:foo/', None)) def test_override_directory_with_module(self): from zope.component import getSiteManager + from repoze.bfg.configuration import Configurator context = DummyContext() self._callFUT(context, 'a:foo/', 'b') actions = context.actions self.assertEqual(len(actions), 1) action = actions[0] sm = getSiteManager() - self.assertEqual(action['callable'], sm.resource) + self.assertEqual(action['callable'].im_func, + Configurator.resource.im_func) self.assertEqual(action['discriminator'], None) self.assertEqual(action['args'], ('a:foo/', 'b', None)) def test_override_module_with_module(self): + from repoze.bfg.configuration import Configurator from zope.component import getSiteManager context = DummyContext() self._callFUT(context, 'a', 'b') @@ -2635,7 +2644,8 @@ class TestResourceDirective(unittest.TestCase): self.assertEqual(len(actions), 1) action = actions[0] sm = getSiteManager() - self.assertEqual(action['callable'], sm.resource) + self.assertEqual(action['callable'].im_func, + Configurator.resource.im_func) self.assertEqual(action['discriminator'], None) self.assertEqual(action['args'], ('a', 'b', None)) @@ -2697,7 +2707,7 @@ class TestZCMLScanDirective(unittest.TestCase): return scan(context, package, martian) def test_it(self): - from repoze.bfg.registry import BFGMultiGrokker + from repoze.bfg.configuration import BFGMultiGrokker martian = DummyMartianModule() module_grokker = DummyModuleGrokker() dummy_module = DummyModule() @@ -2720,11 +2730,11 @@ class DummyModuleGrokker: self.multi_grokker = grokker class DummyMartianModule: - def grok_dotted_name(self, name, grokker, _info, _registry, + def grok_dotted_name(self, name, grokker, _info, _configurator, exclude_filter=None): self.name = name self.info = _info - self.registry = _registry + self.configurator = _configurator self.exclude_filter = exclude_filter return True -- cgit v1.2.3