diff options
23 files changed, 735 insertions, 585 deletions
diff --git a/CHANGES.txt b/CHANGES.txt index d045d261a..9926e7adc 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -9,6 +9,38 @@ Features ``bfg_view`` decorator. See the ``Views`` narrative documentation chapter for more information about these predicates. +- Add ``setUp`` and ``tearDown`` functions to the + ``repoze.bfg.testing`` module. Using ``setUp`` in a test setup and + ``tearDown`` in a test teardown is now the recommended way to do + component registry setup and teardown. Previously, it was + recommended that a single function named + ``repoze.bfg.testing.cleanUp`` be called in both the test setup and + tear down. ``repoze.bfg.testing.cleanUp`` still exists (and will + exist "forever" due to its widespread use); it is now just an alias + for ``repoze.bfg.testing.setUp`` and is nominally deprecated. + +- The BFG component registry is now available in view and event + subscriber code as an attribute of the request + ie. ``request.registry``. This fact is currently undocumented + except for this note, because BFG developers never need to interact + with the registry directly anywhere else. + +- The BFG component registry now inherits from ``dict``, meaning that + it can optionally be used as a simple dictionary. *Component* + registrations performed against it via e.g. ``registerUtility``, + ``registerAdapter``, and similar API methods are kept in a + completely separate namespace than its dict members, so using the + its component API methods won't effect the keys and values in the + dictionary namespace. Likewise, though the component registry + "happens to be" a dictionary, use of mutating dictionary methods + such as ``__setitem__`` will have no influence on any component + registrations made against it. In other words, the registry object + you obtain via e.g. ``repoze.bfg.threadlocal.get_current_registry`` + or ``request.registry`` happens to be both a component registry and + a dictionary, but using its component-registry API won't impact data + added to it via its dictionary API and vice versa. This is a + forward compatibility move based on the goals of "marco". + Documentation ------------- @@ -18,6 +50,56 @@ Documentation - Point all index URLs at the literal 1.1 index (this alpha cycle may go on a while). +- Various tutorial test modules updated to use + ``repoze.bfg.testing.setUp`` and ``repoze.bfg.testing.tearDown`` + methods in order to encourage this as best practice going forward. + +Backwards Incompatibilities +--------------------------- + +- Importing ``getSiteManager`` and ``get_registry`` from + ``repoze.bfg.registry`` is no longer supported. These imports were + deprecated in repoze.bfg 1.0. Import of ``getSiteManager`` should + be done as ``from zope.component import getSiteManager``. Import of + ``get_registry`` should be done as ``from repoze.bfg.threadlocal + import get_current_registry``. This was done to prevent a circular + import dependency. + +- Code bases which alternately invoke both + ``zope.testing.cleanup.cleanUp`` and ``repoze.bfg.testing.cleanUp`` + (treating them equivalently, using them interchangeably) in the + setUp/tearDown of unit tests will begin to experience test failures + due to lack of test isolation. The "right" mechanism is + ``repoze.bfg.testing.cleanUp`` (or the combination of + ``repoze.bfg.testing.setUp`` and + ``repoze.bfg.testing.tearDown``). but a good number of legacy + codebases will use ``zope.testing.cleanup.cleanUp`` instead. We + support ``zope.testing.cleanup.cleanUp`` but not in combination with + ``repoze.bfg.testing.cleanUp`` in the same codebase. You should use + one or the other test cleanup function in a single codebase, but not + both. + +Internal +-------- + +- Created new ``repoze.bfg.configuration`` module which assumes + responsibilities previously held by the ``repoze.bfg.registry`` and + ``repoze.bfg.router`` modules (avoid a circular import dependency). + +- The result of the ``zope.component.getSiteManager`` function in unit + tests set up with ``repoze.bfg.testing.cleanUp`` or + ``repoze.bfg.testing.setUp`` will be an instance of + ``repoze.bfg.registry.Registry`` instead of the global + ``zope.component.globalregistry.base`` registry. This also means + that the threadlocal ZCA API functions such as ``getAdapter`` and + ``getUtility`` as well as internal BFG machinery (such as + ``model_url`` and ``route_url``) will consult this registry within + unit tests. This is a forward compatibility move based on the goals + of "marco". + +- Removed ``repoze.bfg.testing.addCleanUp`` function and associated + module-scope globals. This was never an API. + 1.1a5 (2009-10-10) ================== diff --git a/docs/api/testing.rst b/docs/api/testing.rst index f64d78337..94c231459 100644 --- a/docs/api/testing.rst +++ b/docs/api/testing.rst @@ -25,6 +25,10 @@ .. autofunction:: registerRoute + .. autofunction:: setUp + + .. autofunction:: tearDown + .. autofunction:: cleanUp .. autoclass:: DummyModel diff --git a/docs/narr/unittesting.rst b/docs/narr/unittesting.rst index 064be4739..885d7be36 100644 --- a/docs/narr/unittesting.rst +++ b/docs/narr/unittesting.rst @@ -50,10 +50,10 @@ unittest TestCase that used the testing API. class MyTest(unittest.TestCase): def setUp(self): - testing.cleanUp() + testing.setUp() def tearDown(self): - testing.cleanUp() + testing.tearDown() def test_view_fn_not_submitted(self): from my.package import view_fn @@ -105,11 +105,12 @@ assertion. We assert at the end of this that the renderer's ``say`` attribute is ``Yo``, as this is what is expected of the view function in the branch it's testing. -Note that the test calls the ``repoze.bfg.testing.cleanUp`` function -in its ``setUp`` and ``tearDown`` functions. This is required to +Note that the test calls the ``repoze.bfg.testing.setUp`` function in +its ``setUp`` method and the ``repoze.bfg.testing.tearDown`` function +in its ``tearDown`` method. Use of this pattern is required to perform cleanup between the test runs. If you use any of the testing -API, be sure to call this function at setup and teardown of individual -tests. +API, be sure to call ``repoze.bfg.testing.setUp`` in the test setup +and ``repoze.bfg.testing.tearDown`` in the test teardown. See the :ref:`testing_module` chapter for the entire :mod:`repoze.bfg` -specific testing API. This chapter describes APIs for registering a diff --git a/docs/tutorials/bfgwiki2/src/authorization/tutorial/tests.py b/docs/tutorials/bfgwiki2/src/authorization/tutorial/tests.py index 2a1d43749..52d2fed86 100644 --- a/docs/tutorials/bfgwiki2/src/authorization/tutorial/tests.py +++ b/docs/tutorials/bfgwiki2/src/authorization/tutorial/tests.py @@ -17,6 +17,12 @@ def _registerRoutes(): testing.registerRoute('add_page/:pagename', 'add_page') class ViewWikiTests(unittest.TestCase): + def setUp(self): + testing.setUp() + + def tearDown(self): + testing.tearDown() + def test_it(self): from tutorial.views import view_wiki testing.registerRoute(':pagename', 'view_page') @@ -27,9 +33,11 @@ class ViewWikiTests(unittest.TestCase): class ViewPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import view_page @@ -59,9 +67,11 @@ class ViewPageTests(unittest.TestCase): class AddPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import add_page @@ -89,9 +99,11 @@ class AddPageTests(unittest.TestCase): class EditPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import edit_page diff --git a/docs/tutorials/bfgwiki2/src/views/tutorial/tests.py b/docs/tutorials/bfgwiki2/src/views/tutorial/tests.py index 2a1d43749..52d2fed86 100644 --- a/docs/tutorials/bfgwiki2/src/views/tutorial/tests.py +++ b/docs/tutorials/bfgwiki2/src/views/tutorial/tests.py @@ -17,6 +17,12 @@ def _registerRoutes(): testing.registerRoute('add_page/:pagename', 'add_page') class ViewWikiTests(unittest.TestCase): + def setUp(self): + testing.setUp() + + def tearDown(self): + testing.tearDown() + def test_it(self): from tutorial.views import view_wiki testing.registerRoute(':pagename', 'view_page') @@ -27,9 +33,11 @@ class ViewWikiTests(unittest.TestCase): class ViewPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import view_page @@ -59,9 +67,11 @@ class ViewPageTests(unittest.TestCase): class AddPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import add_page @@ -89,9 +99,11 @@ class AddPageTests(unittest.TestCase): class EditPageTests(unittest.TestCase): def setUp(self): self.session = _initTestingDB() + testing.setUp() def tearDown(self): self.session.remove() + testing.tearDown() def _callFUT(self, request): from tutorial.views import edit_page diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py new file mode 100644 index 000000000..629a58047 --- /dev/null +++ b/repoze/bfg/configuration.py @@ -0,0 +1,134 @@ +import os +import sys +import threading + +import zope.component + +from zope.component import getGlobalSiteManager +from zope.component import getSiteManager + +from repoze.bfg.interfaces import IAuthenticationPolicy +from repoze.bfg.interfaces import IAuthorizationPolicy +from repoze.bfg.interfaces import IDefaultRootFactory +from repoze.bfg.interfaces import ILogger +from repoze.bfg.interfaces import IRootFactory +from repoze.bfg.interfaces import IRoutesMapper +from repoze.bfg.interfaces import ISettings + +from repoze.bfg.authorization import ACLAuthorizationPolicy +from repoze.bfg.log import make_stream_logger +from repoze.bfg.registry import Registry +from repoze.bfg.settings import Settings +from repoze.bfg.settings import get_options +from repoze.bfg.threadlocal import get_current_registry +from repoze.bfg.threadlocal import manager +from repoze.bfg.urldispatch import RoutesRootFactory +from repoze.bfg.zcml import zcml_configure + +def make_registry(root_factory, package=None, filename='configure.zcml', + authentication_policy=None, authorization_policy=None, + options=None, registry=None, debug_logger=None, + manager=manager, os=os, lock=threading.Lock()): + # registry, debug_logger, manager, os and lock *only* for unittests + if options is None: + options = {} + + if not 'configure_zcml' in options: + options['configure_zcml'] = filename + + settings = Settings(get_options(options)) + filename = settings['configure_zcml'] + + # not os.path.isabs below for windows systems + if (':' in filename) and (not os.path.isabs(filename)): + package, filename = filename.split(':', 1) + __import__(package) + package = sys.modules[package] + + if registry is None: + regname = filename + if package: + regname = package.__name__ + registry = Registry(regname) + + registry.registerUtility(settings, ISettings) + + if debug_logger is None: + debug_logger = make_stream_logger('repoze.bfg.debug', sys.stderr) + registry.registerUtility(debug_logger, ILogger, 'repoze.bfg.debug') + + if root_factory is None: + root_factory = DefaultRootFactory + + # register the *default* root factory so apps can find it later + registry.registerUtility(root_factory, IDefaultRootFactory) + + mapper = RoutesRootFactory(root_factory) + registry.registerUtility(mapper, IRoutesMapper) + + if authentication_policy: + debug_logger.warn( + 'The "authentication_policy" and "authorization_policy" ' + 'arguments to repoze.bfg.router.make_app have been deprecated ' + 'in repoze.bfg version 1.0. Instead of using these arguments to ' + 'configure an authorization/authentication policy pair, use ' + 'a pair of ZCML directives (such as "authtktauthenticationpolicy" ' + 'and "aclauthorizationpolicy" documented within the Security ' + 'chapter in the BFG documentation. If you need to use a custom ' + 'authentication or authorization policy, you should make a ZCML ' + 'directive for it and use that directive within your ' + 'application\'s ZCML') + registry.registerUtility(authentication_policy, IAuthenticationPolicy) + if authorization_policy is None: + authorization_policy = ACLAuthorizationPolicy() + registry.registerUtility(authorization_policy, IAuthorizationPolicy) + + # We push our ZCML-defined configuration into an app-local + # component registry in order to allow more than one bfg app to live + # in the same process space without one unnecessarily stomping on + # the other's component registrations (although I suspect directives + # that have side effects are going to fail). The only way to do + # that currently is to override zope.component.getGlobalSiteManager + # for the duration of the ZCML includes. We acquire a lock in case + # another make_app runs in a different thread simultaneously, in a + # vain attempt to prevent mixing of registrations. There's not much + # we can do about non-makeRegistry code that tries to use the global + # site manager API directly in a different thread while we hold the + # lock. Those registrations will end up in our application's + # registry. + + lock.acquire() + manager.push({'registry':registry, 'request':None}) + try: + getSiteManager.sethook(get_current_registry) + zope.component.getGlobalSiteManager = get_current_registry + zcml_configure(filename, package) + finally: + # intentional: do not call getSiteManager.reset(); executing + # this function means we're taking over getSiteManager for the + # lifetime of this process + zope.component.getGlobalSiteManager = getGlobalSiteManager + lock.release() + manager.pop() + + if mapper.has_routes(): + # if the user had any <route/> statements in his configuration, + # use the RoutesRootFactory as the IRootFactory; otherwise use the + # default root factory (optimization; we don't want to go through + # the Routes logic if we know there are no routes to match) + root_factory = mapper + + registry.registerUtility(root_factory, IRootFactory) + + return registry + +class DefaultRootFactory: + __parent__ = None + __name__ = None + def __init__(self, environ): + if 'bfg.routes.matchdict' in environ: + # provide backwards compatibility for applications which + # used routes (at least apps without any custom "context + # factory") in BFG 0.9.X and before + self.__dict__.update(environ['bfg.routes.matchdict']) + diff --git a/repoze/bfg/registry.py b/repoze/bfg/registry.py index 06cd1b804..796ac0dfa 100644 --- a/repoze/bfg/registry.py +++ b/repoze/bfg/registry.py @@ -1,21 +1,15 @@ -import threading - -from zope.component import getGlobalSiteManager -from zope.component import getSiteManager as original_getSiteManager from zope.component.registry import Components -from zope.deprecation import deprecated -import zope.component - -from repoze.bfg.threadlocal import get_current_registry -from repoze.bfg.threadlocal import manager -from repoze.bfg.zcml import zcml_configure -class Registry(Components): +class Registry(Components, dict): # for optimization purposes, if no listeners are listening, don't try # to notify them has_listeners = False + def reset(self): + self.__init__(self.__name__) + self.clear() + def registerSubscriptionAdapter(self, *arg, **kw): result = Components.registerSubscriptionAdapter(self, *arg, **kw) self.has_listeners = True @@ -32,46 +26,3 @@ class Registry(Components): for ignored in self.subscribers(events, None): """ """ -def populateRegistry(registry, filename, package, lock=threading.Lock(), - manager=manager): # lock and manager for testing - - """ We push our ZCML-defined configuration into an app-local - component registry in order to allow more than one bfg app to live - in the same process space without one unnecessarily stomping on - the other's component registrations (although I suspect directives - that have side effects are going to fail). The only way to do - that currently is to override zope.component.getGlobalSiteManager - for the duration of the ZCML includes. We acquire a lock in case - another make_app runs in a different thread simultaneously, in a - vain attempt to prevent mixing of registrations. There's not much - we can do about non-makeRegistry code that tries to use the global - site manager API directly in a different thread while we hold the - lock. Those registrations will end up in our application's - registry.""" - - lock.acquire() - manager.push({'registry':registry, 'request':None}) - try: - original_getSiteManager.sethook(get_current_registry) - zope.component.getGlobalSiteManager = get_current_registry - zcml_configure(filename, package) - finally: - zope.component.getGlobalSiteManager = getGlobalSiteManager - lock.release() - manager.pop() - -getSiteManager = get_current_registry # b/c - -deprecated('getSiteManager', - 'As of repoze.bfg 1.0, any import of getSiteManager from' - '``repoze.bfg.registry`` is ' - 'deprecated. Use ``from zope.compponent import getSiteManager ' - 'instead.') - -get_registry = get_current_registry # b/c - -deprecated('get_registry', - 'As of repoze.bfg 1.0, any import of get_registry from' - '``repoze.bfg.registry`` is ' - 'deprecated. Use ``from repoze.bfg.threadlocal import ' - 'get_current_registry instead.') diff --git a/repoze/bfg/router.py b/repoze/bfg/router.py index e2b2b6830..1b894129b 100644 --- a/repoze/bfg/router.py +++ b/repoze/bfg/router.py @@ -1,40 +1,28 @@ -import os -import sys +from zope.component.event import dispatch from zope.interface import implements from zope.interface import providedBy -from zope.component.event import dispatch - -from repoze.bfg.interfaces import IAuthenticationPolicy -from repoze.bfg.interfaces import IAuthorizationPolicy -from repoze.bfg.interfaces import IDefaultRootFactory from repoze.bfg.interfaces import IForbiddenView from repoze.bfg.interfaces import ILogger from repoze.bfg.interfaces import INotFoundView from repoze.bfg.interfaces import IRootFactory from repoze.bfg.interfaces import IRouter -from repoze.bfg.interfaces import IRoutesMapper from repoze.bfg.interfaces import ISettings from repoze.bfg.interfaces import ITraverserFactory from repoze.bfg.interfaces import IView -from repoze.bfg.authorization import ACLAuthorizationPolicy +from repoze.bfg.configuration import make_registry +from repoze.bfg.configuration import DefaultRootFactory from repoze.bfg.events import NewRequest from repoze.bfg.events import NewResponse from repoze.bfg.events import WSGIApplicationCreatedEvent from repoze.bfg.exceptions import Forbidden from repoze.bfg.exceptions import NotFound -from repoze.bfg.log import make_stream_logger -from repoze.bfg.registry import Registry -from repoze.bfg.registry import populateRegistry from repoze.bfg.request import request_factory -from repoze.bfg.settings import Settings -from repoze.bfg.settings import get_options from repoze.bfg.threadlocal import manager from repoze.bfg.traversal import ModelGraphTraverser from repoze.bfg.traversal import _traverse -from repoze.bfg.urldispatch import RoutesRootFactory from repoze.bfg.view import default_forbidden_view from repoze.bfg.view import default_notfound_view @@ -76,6 +64,14 @@ class Router(object): try: root = self.root_factory(environ) request = request_factory(environ) + + # webob.Request's __setattr__ (as of 0.9.5 and lower) is a + # bottleneck; since we're sure we're using a + # webob.Request, we can go around its back and set stuff + # into the environ directly + attrs = environ.setdefault('webob.adhoc_attrs', {}) + attrs['registry'] = registry + threadlocals['request'] = request registry.has_listeners and registry.notify(NewRequest(request)) traverser = registry.queryAdapter(root, ITraverserFactory) @@ -86,16 +82,7 @@ class Router(object): tdict['context'], tdict['view_name'], tdict['subpath'], tdict['traversed'], tdict['virtual_root'], tdict['virtual_root_path']) - - # webob.Request's __setattr__ (as of 0.9.5 and lower) is a - # bottleneck; since we're sure we're using a - # webob.Request, we can go around its back and set stuff - # into the environ directly - if 'webob.adhoc_attrs' in environ: - attrs = environ.setdefault('webob.adhoc_attrs', {}) - attrs.update(tdict) - else: - environ['webob.adhoc_attrs'] = tdict + attrs.update(tdict) provides = map(providedBy, (context, request)) view_callable = registry.adapters.lookup( @@ -142,11 +129,10 @@ class Router(object): finally: manager.pop() +# make_registry kw arg for unit testing only def make_app(root_factory, package=None, filename='configure.zcml', authentication_policy=None, authorization_policy=None, - options=None, registry=None, debug_logger=None, - manager=manager, os=os): - # registry, debug_logger, manager and os *only* for unittests + options=None, manager=manager, make_registry=make_registry): """ Return a Router object, representing a fully configured ``repoze.bfg`` WSGI application. @@ -180,72 +166,10 @@ def make_app(root_factory, package=None, filename='configure.zcml', PasteDeploy file), with each key representing the option and the key's value representing the specific option value, e.g. ``{'reload_templates':True}``""" - if options is None: - options = {} - - if not 'configure_zcml' in options: - options['configure_zcml'] = filename - - settings = Settings(get_options(options)) - filename = settings['configure_zcml'] - - # not os.path.isabs below for windows systems - if (':' in filename) and (not os.path.isabs(filename)): - package, filename = filename.split(':', 1) - __import__(package) - package = sys.modules[package] - - if registry is None: - regname = filename - if package: - regname = package.__name__ - registry = Registry(regname) - - registry.registerUtility(settings, ISettings) - - if debug_logger is None: - debug_logger = make_stream_logger('repoze.bfg.debug', sys.stderr) - registry.registerUtility(debug_logger, ILogger, 'repoze.bfg.debug') - - if root_factory is None: - root_factory = DefaultRootFactory - - # register the *default* root factory so apps can find it later - registry.registerUtility(root_factory, IDefaultRootFactory) - - mapper = RoutesRootFactory(root_factory) - registry.registerUtility(mapper, IRoutesMapper) - - if authentication_policy: - debug_logger.warn( - 'The "authentication_policy" and "authorization_policy" ' - 'arguments to repoze.bfg.router.make_app have been deprecated ' - 'in repoze.bfg version 1.0. Instead of using these arguments to ' - 'configure an authorization/authentication policy pair, use ' - 'a pair of ZCML directives (such as "authtktauthenticationpolicy" ' - 'and "aclauthorizationpolicy" documented within the Security ' - 'chapter in the BFG documentation. If you need to use a custom ' - 'authentication or authorization policy, you should make a ZCML ' - 'directive for it and use that directive within your ' - 'application\'s ZCML') - registry.registerUtility(authentication_policy, IAuthenticationPolicy) - if authorization_policy is None: - authorization_policy = ACLAuthorizationPolicy() - registry.registerUtility(authorization_policy, IAuthorizationPolicy) - - populateRegistry(registry, filename, package) - - if mapper.has_routes(): - # if the user had any <route/> statements in his configuration, - # use the RoutesRootFactory as the IRootFactory; otherwise use the - # default root factory (optimization; we don't want to go through - # the Routes logic if we know there are no routes to match) - root_factory = mapper - - registry.registerUtility(root_factory, IRootFactory) - + registry = make_registry(root_factory, package, filename, + authentication_policy, authorization_policy, + options) app = Router(registry) - # We push the registry on to the stack here in case any ZCA API is # used in listeners subscribed to the WSGIApplicationCreatedEvent # we send. @@ -256,16 +180,5 @@ def make_app(root_factory, package=None, filename='configure.zcml', dispatch(WSGIApplicationCreatedEvent(app)) finally: manager.pop() - return app -class DefaultRootFactory: - __parent__ = None - __name__ = None - def __init__(self, environ): - if 'bfg.routes.matchdict' in environ: - # provide backwards compatibility for applications which - # used routes (at least apps without any custom "context - # factory") in BFG 0.9.X and before - self.__dict__.update(environ['bfg.routes.matchdict']) - diff --git a/repoze/bfg/testing.py b/repoze/bfg/testing.py index 25a178f66..60a52aa66 100644 --- a/repoze/bfg/testing.py +++ b/repoze/bfg/testing.py @@ -1,12 +1,15 @@ import copy +from zope.configuration.xmlconfig import _clearContext +from zope.component import getSiteManager from zope.deprecation import deprecated - from zope.interface import implements from zope.interface import Interface from repoze.bfg.interfaces import IRequest +from repoze.bfg.registry import Registry + _marker = object() def registerDummySecurityPolicy(userid=None, groupids=(), permissive=True): @@ -171,8 +174,8 @@ def registerUtility(impl, iface=Interface, name=''): <http://www.muthukadan.net/docs/zca.html>`_ for more information about ZCA utilities.""" import zope.component - gsm = zope.component.getGlobalSiteManager() - gsm.registerUtility(impl, iface, name=name) + sm = zope.component.getSiteManager() + sm.registerUtility(impl, iface, name=name) return impl def registerAdapter(impl, for_=Interface, provides=Interface, name=''): @@ -191,10 +194,10 @@ def registerAdapter(impl, for_=Interface, provides=Interface, name=''): <http://www.muthukadan.net/docs/zca.html>`_ for more information about ZCA adapters.""" import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() if not isinstance(for_, (tuple, list)): for_ = (for_,) - gsm.registerAdapter(impl, for_, provides, name=name) + sm.registerAdapter(impl, for_, provides, name=name) return impl def registerSubscriber(subscriber, iface=Interface): @@ -210,10 +213,10 @@ def registerSubscriber(subscriber, iface=Interface): <http://www.muthukadan.net/docs/zca.html>`_ for more information about ZCA subscribers.""" import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() if not isinstance(iface, (tuple, list)): iface = (iface,) - gsm.registerHandler(subscriber, iface) + sm.registerHandler(subscriber, iface) return subscriber def registerTraverserFactory(traverser, for_=Interface): @@ -227,7 +230,6 @@ def registerRoute(path, name, factory=None): from repoze.bfg.interfaces import IRoutesMapper from zope.component import queryUtility from repoze.bfg.urldispatch import RoutesRootFactory - from zope.component import getSiteManager mapper = queryUtility(IRoutesMapper) if mapper is None: mapper = RoutesRootFactory(DummyRootFactory) @@ -457,34 +459,46 @@ class DummyRequest: self.marshalled = params # repoze.monty self.__dict__.update(kw) -_cleanups = [] +def setUp(): + """Set up a fresh BFG testing registry. Use in the ``setUp`` + method of unit tests that use the ``register*`` methods in the + testing module (e.g. if your unit test uses + ``repoze.bfg.testing.registerDummySecurityPolicy``). If you use + the ``register*`` functions without calling ``setUp``, unit tests + will not be isolated with respect to registrations they perform. + Additionally, the *global* component registry will be used, which + may have a different API than is expected by BFG itself. + + .. note:: This feature is new as of :mod:`repoze.bfg` 1.1. + """ + registry = Registry('testing') + getSiteManager.sethook(lambda *arg: registry) + _clearContext() + +def tearDown(): + """Tear down a previously set up (via + ``repoze.bfg.testing.setUp``) testing registry. Use in the + ``tearDown`` method of unit tests that use the ``register*`` + methods in the testing module (e.g. if your unit test uses + ``repoze.bfg.testing.registerDummySecurityPolicy``). Using + ``tearDown`` is effectively optional if you call setUp at the + beginning of every test which requires registry isolation. -def addCleanUp(func, args=(), kw=None): - """Register a cleanup routines + .. note:: This feature is new as of :mod:`repoze.bfg` 1.1. - Pass a function to be called to cleanup global data. - Optional argument tuple and keyword arguments may be passed. """ - if kw is None: - kw = {} - _cleanups.append((func, args, kw)) + getSiteManager.reset() def cleanUp(): - """Clean up BFG testing registrations. Use in the ``tearDown`` of - unit tests that use the ``register*`` methods in the testing - module (e.g. if your unit test uses - ``repoze.bfg.testing.registerDummyRenderer`` or - ``repoze.bfg.testing.registerDummySecurityPolicy``). If you use - the ``register*`` functions without calling cleanUp, unit tests - will not be isolated with respect to registrations they perform.""" - for func, args, kw in _cleanups: - func(*args, **kw) - -from zope.component.globalregistry import base -from zope.configuration.xmlconfig import _clearContext -from repoze.bfg.registry import original_getSiteManager -from repoze.bfg.threadlocal import manager -addCleanUp(original_getSiteManager.reset) -addCleanUp(manager.clear) -addCleanUp(lambda: base.__init__('base')) -addCleanUp(_clearContext) + """ Deprecated (as of BFG 1.1) function whichs sets up a new + registry for BFG testing registrations. Use in the ``setUp`` and + ``tearDown`` of unit tests that use the ``register*`` methods in + the testing module (e.g. if your unit test uses + ``repoze.bfg.testing.registerDummySecurityPolicy``). Use of this + function is deprecated in favor of using + ``repoze.bfg.testing.setUp`` in the test setUp and + ``repoze.bfg.testing.tearDown`` in the test tearDown. This is + currently just an alias for ``repoze.bfg.testing.setUp``. + Although this function is effectively deprecated, due to its + extensive production usage, it will never be removed.""" + setUp() diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py index a6384887f..a0fb946d1 100644 --- a/repoze/bfg/tests/test_chameleon_text.py +++ b/repoze/bfg/tests/test_chameleon_text.py @@ -19,7 +19,14 @@ class Base: import os here = os.path.abspath(os.path.dirname(__file__)) return os.path.join(here, 'fixtures', name) + + def _registerUtility(self, utility, iface, name=''): + from zope.component import getSiteManager + sm = getSiteManager() + sm.registerUtility(utility, iface, name=name) + return sm + class TextTemplateRendererTests(Base, unittest.TestCase): def _getTargetClass(self): from repoze.bfg.chameleon_text import TextTemplateRenderer @@ -92,13 +99,11 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): self.assertEqual(len(result.headerlist), 2) def test_iresponsefactory_override(self): - from zope.component import getGlobalSiteManager - gsm = getGlobalSiteManager() from webob import Response class Response2(Response): pass from repoze.bfg.interfaces import IResponseFactory - gsm.registerUtility(Response2, IResponseFactory) + self._registerUtility(Response2, IResponseFactory) minimal = self._getTemplatePath('minimal.txt') result = self._callFUT(minimal) self.failUnless(isinstance(result, Response2)) @@ -109,40 +114,34 @@ class GetRendererTests(Base, unittest.TestCase): return get_renderer(name) def test_nonabs_registered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_text import TextTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.txt') utility = TextTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result, utility) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_nonabs_unregistered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_text import TextTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.txt') self.assertEqual(queryUtility(ITemplateRenderer, minimal), None) utility = TextTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result, utility) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_explicit_registration(self): - from zope.component import getGlobalSiteManager from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() - gsm = getGlobalSiteManager() utility = Dummy() - gsm.registerUtility(utility, ITemplateRenderer, name='foo') + self._registerUtility(utility, ITemplateRenderer, name='foo') result = self._callFUT('foo') self.failUnless(result is utility) @@ -158,42 +157,36 @@ class GetTemplateTests(unittest.TestCase, Base): return get_template(name) def test_nonabs_registered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_text import TextTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.txt') utility = TextTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result.filename, minimal) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_nonabs_unregistered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_text import TextTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.txt') self.assertEqual(queryUtility(ITemplateRenderer, minimal), None) utility = TextTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result.filename, minimal) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_explicit_registration(self): - from zope.component import getGlobalSiteManager from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() def implementation(self): return self.template - gsm = getGlobalSiteManager() utility = Dummy() - gsm.registerUtility(utility, ITemplateRenderer, name='foo') + self._registerUtility(utility, ITemplateRenderer, name='foo') result = self._callFUT('foo') self.failUnless(result is utility.template) diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py index 381a1d0bf..0a78c1caa 100644 --- a/repoze/bfg/tests/test_chameleon_zpt.py +++ b/repoze/bfg/tests/test_chameleon_zpt.py @@ -13,6 +13,12 @@ class Base(object): import os here = os.path.abspath(os.path.dirname(__file__)) return os.path.join(here, 'fixtures', name) + + def _registerUtility(self, utility, iface, name=''): + from zope.component import getSiteManager + sm = getSiteManager() + sm.registerUtility(utility, iface, name=name) + return sm class ZPTTemplateRendererTests(Base, unittest.TestCase): def _getTargetClass(self): @@ -84,13 +90,11 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): self.assertEqual(len(result.headerlist), 2) def test_iresponsefactory_override(self): - from zope.component import getGlobalSiteManager - gsm = getGlobalSiteManager() from webob import Response class Response2(Response): pass from repoze.bfg.interfaces import IResponseFactory - gsm.registerUtility(Response2, IResponseFactory) + self._registerUtility(Response2, IResponseFactory) minimal = self._getTemplatePath('minimal.pt') result = self._callFUT(minimal) self.failUnless(isinstance(result, Response2)) @@ -101,40 +105,34 @@ class GetRendererTests(Base, unittest.TestCase): return get_renderer(name) def test_nonabs_registered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.pt') utility = ZPTTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result, utility) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_nonabs_unregistered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.pt') self.assertEqual(queryUtility(ITemplateRenderer, minimal), None) utility = ZPTTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result, utility) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_explicit_registration(self): - from zope.component import getGlobalSiteManager from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() - gsm = getGlobalSiteManager() utility = Dummy() - gsm.registerUtility(utility, ITemplateRenderer, name='foo') + self._registerUtility(utility, ITemplateRenderer, name='foo') result = self._callFUT('foo') self.failUnless(result is utility) @@ -144,42 +142,36 @@ class GetTemplateTests(Base, unittest.TestCase): return get_template(name) def test_nonabs_registered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.pt') utility = ZPTTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result.filename, minimal) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_nonabs_unregistered(self): - from zope.component import getGlobalSiteManager from zope.component import queryUtility from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer from repoze.bfg.interfaces import ITemplateRenderer minimal = self._getTemplatePath('minimal.pt') self.assertEqual(queryUtility(ITemplateRenderer, minimal), None) utility = ZPTTemplateRenderer(minimal) - gsm = getGlobalSiteManager() - gsm.registerUtility(utility, ITemplateRenderer, name=minimal) + self._registerUtility(utility, ITemplateRenderer, name=minimal) result = self._callFUT(minimal) self.assertEqual(result.filename, minimal) self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility) def test_explicit_registration(self): - from zope.component import getGlobalSiteManager from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() def implementation(self): return self.template - gsm = getGlobalSiteManager() utility = Dummy() - gsm.registerUtility(utility, ITemplateRenderer, name='foo') + self._registerUtility(utility, ITemplateRenderer, name='foo') result = self._callFUT('foo') self.failUnless(result is utility.template) diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py new file mode 100644 index 000000000..b2fc27e3e --- /dev/null +++ b/repoze/bfg/tests/test_configuration.py @@ -0,0 +1,266 @@ +import unittest + +from repoze.bfg.testing import cleanUp + +class MakeRegistryTests(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, *arg, **kw): + from repoze.bfg.router import make_registry + return make_registry(*arg, **kw) + + def test_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') + from repoze.bfg.tests.fixtureapp.models import IFixture + self.failUnless(registry.queryUtility(IFixture)) # only in c.zcml + + def test_fixtureapp_explicit_filename(self): + manager = DummyRegistryManager() + from repoze.bfg.tests import fixtureapp + rootfactory = DummyRootFactory(None) + registry = self._callFUT( + 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): + 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( + rootfactory, fixtureapp, filename='configure.zcml', + options={'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): + manager = DummyRegistryManager() + rootfactory = DummyRootFactory(None) + from repoze.bfg.tests import fixtureapp + zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml' + registry = self._callFUT( + rootfactory, fixtureapp, filename='configure.zcml', + options={'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): + manager = DummyRegistryManager() + rootfactory = DummyRootFactory(None) + from repoze.bfg.tests import fixtureapp + zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml' + class Dummy: + def isabs(self, name): + return True + os = Dummy() + os.path = Dummy() + self.assertRaises(IOError, self._callFUT, + rootfactory, + fixtureapp, + filename='configure.zcml', + options={'configure_zcml':zcmlfile}, + manager=manager, + os=os) + + def test_custom_settings(self): + manager = DummyRegistryManager() + options= {'mysetting':True} + from repoze.bfg.tests import fixtureapp + rootfactory = DummyRootFactory(None) + registry = self._callFUT(rootfactory, fixtureapp, options=options, + 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): + manager = DummyRegistryManager() + options= {'reload_templates':True, + 'debug_authorization':True} + from repoze.bfg.tests import fixtureapp + rootfactory = DummyRootFactory(None) + registry = self._callFUT(rootfactory, fixtureapp, options=options, + manager=manager) + 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') + rootfactory = registry.getUtility(IRootFactory) + self.assertEqual(logger.name, 'repoze.bfg.debug') + self.assertEqual(settings.reload_templates, True) + self.assertEqual(settings.debug_authorization, True) + 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) + 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.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 + 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) + + 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): + from repoze.bfg.tests import fixtureapp + rootfactory = DummyRootFactory(None) + dummylock = DummyLock() + registry = self._callFUT( + rootfactory, fixtureapp, filename='configure.zcml', + lock=dummylock) + self.assertEqual(dummylock.acquired, True) + self.assertEqual(dummylock.released, True) + +class DummyRegistryManager: + def push(self, registry): + from repoze.bfg.threadlocal import manager + manager.push(registry) + self.pushed = True + + def pop(self): + from repoze.bfg.threadlocal import manager + manager.pop() + self.popped = True + +class DummyRootFactory: + def __init__(self, root): + self.root = root + + def __call__(self, environ): + return self.root + +class DummyLogger: + def __init__(self): + self.messages = [] + def info(self, msg): + self.messages.append(msg) + warn = info + debug = info + +class DummyContext: + pass + +class DummyLock: + def acquire(self): + self.acquired = True + + def release(self): + self.released = True + +class DummyThreadLocalManager: + def __init__(self, data): + self.data = data + + def pop(self): + self.popped = True + return self.data + + def push(self, data): + self.pushed = data + diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py index f1bc6a6f0..57e8134c9 100644 --- a/repoze/bfg/tests/test_registry.py +++ b/repoze/bfg/tests/test_registry.py @@ -1,7 +1,5 @@ import unittest -from repoze.bfg.testing import cleanUp - class TestRegistry(unittest.TestCase): def _getTargetClass(self): from repoze.bfg.registry import Registry @@ -39,47 +37,3 @@ class TestRegistry(unittest.TestCase): registry.registerSubscriptionAdapter(EventHandler, [IFoo], Interface) self.assertEqual(registry.has_listeners, True) -class TestPopulateRegistry(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _callFUT(self, *arg, **kw): - from repoze.bfg.registry import populateRegistry - return populateRegistry(*arg, **kw) - - def test_it(self): - from repoze.bfg.tests import fixtureapp - dummylock = DummyLock() - dummyregmgr = DummyThreadLocalManager({'registry':None}) - from zope.component.registry import Components - registry = Components('hello') - self._callFUT(registry, - 'configure.zcml', - fixtureapp, - lock=dummylock, - manager=dummyregmgr) - self.assertEqual(dummylock.acquired, True) - self.assertEqual(dummylock.released, True) - self.assertEqual(dummyregmgr.data['registry'], None) - -class DummyThreadLocalManager: - def __init__(self, data): - self.data = data - - def pop(self): - self.popped = True - return self.data - - def push(self, data): - self.pushed = data - -class DummyLock: - def acquire(self): - self.acquired = True - - def release(self): - self.released = True - diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py index 5c39b65f0..151734b9b 100644 --- a/repoze/bfg/tests/test_router.py +++ b/repoze/bfg/tests/test_router.py @@ -2,7 +2,7 @@ import unittest from repoze.bfg.testing import cleanUp -class RouterTests(unittest.TestCase): +class TestRouter(unittest.TestCase): def setUp(self): from repoze.bfg.registry import Registry from zope.component import getSiteManager @@ -407,230 +407,6 @@ class RouterTests(unittest.TestCase): self.assertEqual(len(router.threadlocal_manager.pushed), 1) self.assertEqual(len(router.threadlocal_manager.popped), 1) -class MakeAppTests(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _callFUT(self, *arg, **kw): - from repoze.bfg.router import make_app - return make_app(*arg, **kw) - - def test_fixtureapp_default_filename_withpackage(self): - manager = DummyRegistryManager() - from repoze.bfg.tests import fixtureapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, fixtureapp, manager=manager) - self.assertEqual(app.registry.__name__, 'repoze.bfg.tests.fixtureapp') - from repoze.bfg.tests.fixtureapp.models import IFixture - self.failUnless(app.registry.queryUtility(IFixture)) # only in c.zcml - - def test_fixtureapp_explicit_filename(self): - manager = DummyRegistryManager() - from repoze.bfg.tests import fixtureapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, fixtureapp, filename='another.zcml', - manager=manager) - self.assertEqual(app.registry.__name__, 'repoze.bfg.tests.fixtureapp') - from repoze.bfg.tests.fixtureapp.models import IFixture - self.failIf(app.registry.queryUtility(IFixture)) # only in c.zcml - - def test_fixtureapp_explicit_filename_in_options(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') - app = self._callFUT(rootfactory, fixtureapp, filename='configure.zcml', - options={'configure_zcml':zcmlfile}, - manager=manager) - self.assertEqual(app.registry.__name__, 'repoze.bfg.tests.fixtureapp') - from repoze.bfg.tests.fixtureapp.models import IFixture - self.failIf(app.registry.queryUtility(IFixture)) # only in c.zcml - - def test_fixtureapp_explicit_specification_in_options(self): - manager = DummyRegistryManager() - rootfactory = DummyRootFactory(None) - from repoze.bfg.tests import fixtureapp - zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml' - app = self._callFUT(rootfactory, fixtureapp, filename='configure.zcml', - options={'configure_zcml':zcmlfile}, - manager=manager) - self.assertEqual(app.registry.__name__, - 'repoze.bfg.tests.fixtureapp.subpackage') - from repoze.bfg.tests.fixtureapp.models import IFixture - self.failIf(app.registry.queryUtility(IFixture)) # only in c.zcml - - def test_fixtureapp_filename_hascolon_isabs(self): - manager = DummyRegistryManager() - rootfactory = DummyRootFactory(None) - from repoze.bfg.tests import fixtureapp - zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml' - class Dummy: - def isabs(self, name): - return True - os = Dummy() - os.path = Dummy() - self.assertRaises(IOError, self._callFUT, - rootfactory, - fixtureapp, - filename='configure.zcml', - options={'configure_zcml':zcmlfile}, - manager=manager, - os=os) - - def test_event(self): - manager = DummyRegistryManager() - def subscriber(event): - event.app.created = True - from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent - from zope.component import getGlobalSiteManager - getGlobalSiteManager().registerHandler( - subscriber, - (IWSGIApplicationCreatedEvent,) - ) - from repoze.bfg.tests import fixtureapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, fixtureapp, manager=manager) - assert app.created is True - - def test_custom_settings(self): - manager = DummyRegistryManager() - options= {'mysetting':True} - from repoze.bfg.tests import fixtureapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, fixtureapp, options=options, - manager=manager) - from repoze.bfg.interfaces import ISettings - settings = app.registry.getUtility(ISettings) - self.assertEqual(settings.reload_templates, False) - self.assertEqual(settings.debug_authorization, False) - self.assertEqual(settings.mysetting, True) - - def test_registrations(self): - manager = DummyRegistryManager() - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.tests import fixtureapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, fixtureapp, options=options, - manager=manager) - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ILogger - from repoze.bfg.interfaces import IRootFactory - settings = app.registry.getUtility(ISettings) - logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug') - rootfactory = app.registry.getUtility(IRootFactory) - self.assertEqual(logger.name, 'repoze.bfg.debug') - self.assertEqual(settings.reload_templates, True) - self.assertEqual(settings.debug_authorization, True) - self.assertEqual(rootfactory, rootfactory) - self.failUnless(manager.pushed and manager.popped) - - def test_routes_in_config_with_rootfactory(self): - manager = DummyRegistryManager() - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.urldispatch import RoutesRootFactory - from repoze.bfg.tests import routesapp - rootfactory = DummyRootFactory(None) - app = self._callFUT(rootfactory, routesapp, options=options, - manager=manager) - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ILogger - from repoze.bfg.interfaces import IRootFactory - settings = app.registry.getUtility(ISettings) - logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug') - effective_rootfactory = app.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) - self.failUnless(manager.pushed and manager.popped) - - def test_routes_in_config_no_rootfactory(self): - manager = DummyRegistryManager() - options= {'reload_templates':True, - 'debug_authorization':True} - from repoze.bfg.urldispatch import RoutesRootFactory - from repoze.bfg.router import DefaultRootFactory - from repoze.bfg.tests import routesapp - app = self._callFUT(None, routesapp, options=options, - manager=manager) - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ILogger - from repoze.bfg.interfaces import IRootFactory - settings = app.registry.getUtility(ISettings) - logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug') - rootfactory = app.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) - self.failUnless(manager.pushed and manager.popped) - - def test_no_routes_in_config_no_rootfactory(self): - manager = DummyRegistryManager() - 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 - app = self._callFUT(None, fixtureapp, options=options, - manager=manager) - rootfactory = app.registry.getUtility(IRootFactory) - self.assertEqual(rootfactory, DefaultRootFactory) - - def test_authorization_policy_no_authentication_policy(self): - manager = DummyRegistryManager() - from repoze.bfg.interfaces import IAuthorizationPolicy - authzpolicy = DummyContext() - from repoze.bfg.tests import routesapp - logger = DummyLogger() - app = self._callFUT(None, routesapp, authorization_policy=authzpolicy, - debug_logger=logger, manager=manager) - self.failIf(app.registry.queryUtility(IAuthorizationPolicy)) - self.assertEqual(logger.messages, []) - - def test_authentication_policy_no_authorization_policy(self): - manager = DummyRegistryManager() - 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() - app = self._callFUT(None, routesapp, authentication_policy=authnpolicy, - debug_logger=logger, manager=manager) - self.assertEqual(app.registry.getUtility(IAuthenticationPolicy), - authnpolicy) - self.assertEqual( - app.registry.getUtility(IAuthorizationPolicy).__class__, - ACLAuthorizationPolicy) - self.assertEqual(len(logger.messages), 1) # deprecation warning - - def test_authentication_policy_and_authorization_policy(self): - manager = DummyRegistryManager() - from repoze.bfg.interfaces import IAuthorizationPolicy - from repoze.bfg.interfaces import IAuthenticationPolicy - authnpolicy = DummyContext() - authzpolicy = DummyContext() - from repoze.bfg.tests import routesapp - logger = DummyLogger() - app = self._callFUT(None, routesapp, authentication_policy=authnpolicy, - authorization_policy = authzpolicy, - debug_logger=logger, manager=manager) - self.assertEqual(app.registry.getUtility(IAuthenticationPolicy), - authnpolicy) - self.assertEqual(app.registry.getUtility(IAuthorizationPolicy), - authzpolicy) - self.assertEqual(len(logger.messages), 1) # deprecation warning class TestDefaultRootFactory(unittest.TestCase): def _getTargetClass(self): @@ -652,13 +428,38 @@ class TestDefaultRootFactory(unittest.TestCase): self.assertEqual(root.a, 1) self.assertEqual(root.b, 2) +class TestMakeApp(unittest.TestCase): + def setUp(self): + cleanUp() -class DummyRegistryManager: - def push(self, registry): - self.pushed = True + def tearDown(self): + cleanUp() - def pop(self): - self.popped = True + def _callFUT(self, *arg, **kw): + from repoze.bfg.router import make_app + return make_app(None, *arg, **kw) + + def test_it(self): + from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent + from zope.component import getSiteManager + from repoze.bfg.tests import fixtureapp + sm = getSiteManager() + class DummyMakeRegistry(object): + def __call__(self, *arg): + self.arg = arg + return sm + def subscriber(event): + event.app.created = True + dummy_make_registry = DummyMakeRegistry() + manager = DummyRegistryManager() + sm.registerHandler(subscriber, (IWSGIApplicationCreatedEvent,)) + rootfactory = DummyRootFactory(None) + app = self._callFUT(rootfactory, fixtureapp, manager=manager, + make_registry=dummy_make_registry) + self.failUnless(app.created) + self.failUnless(manager.pushed) + self.failUnless(manager.popped) + self.assertEqual(len(dummy_make_registry.arg), 6) class DummyContext: pass @@ -720,3 +521,10 @@ class DummyLogger: warn = info debug = info +class DummyRegistryManager: + def push(self, registry): + self.pushed = True + + def pop(self): + self.popped = True + diff --git a/repoze/bfg/tests/test_security.py b/repoze/bfg/tests/test_security.py index ef08e8641..d3d89923d 100644 --- a/repoze/bfg/tests/test_security.py +++ b/repoze/bfg/tests/test_security.py @@ -124,18 +124,18 @@ class TestViewExecutionPermitted(unittest.TestCase): self.request = request return allow checker = Checker() - gsm = zope.component.getGlobalSiteManager() - gsm.registerAdapter(checker, (Interface, Interface), - ISecuredView, - view_name) + sm = zope.component.getSiteManager() + sm.registerAdapter(checker, (Interface, Interface), + ISecuredView, + view_name) return checker def test_no_permission(self): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import ISettings settings = dict(debug_authorization=True) - gsm.registerUtility(settings, ISettings) + sm.registerUtility(settings, ISettings) context = DummyContext() request = DummyRequest({}) result = self._callFUT(context, request, '') @@ -162,16 +162,16 @@ def _registerAuthenticationPolicy(result): from repoze.bfg.interfaces import IAuthenticationPolicy policy = DummyAuthenticationPolicy(result) import zope.component - gsm = zope.component.getGlobalSiteManager() - gsm.registerUtility(policy, IAuthenticationPolicy) + sm = zope.component.getSiteManager() + sm.registerUtility(policy, IAuthenticationPolicy) return policy def _registerAuthorizationPolicy(result): from repoze.bfg.interfaces import IAuthorizationPolicy policy = DummyAuthorizationPolicy(result) import zope.component - gsm = zope.component.getGlobalSiteManager() - gsm.registerUtility(policy, IAuthorizationPolicy) + sm = zope.component.getSiteManager() + sm.registerUtility(policy, IAuthorizationPolicy) return policy diff --git a/repoze/bfg/tests/test_settings.py b/repoze/bfg/tests/test_settings.py index bef8297bf..ba43fac04 100644 --- a/repoze/bfg/tests/test_settings.py +++ b/repoze/bfg/tests/test_settings.py @@ -35,10 +35,11 @@ class TestGetSettings(unittest.TestCase): self.assertEqual(self._callFUT(), None) def test_it_withsettings(self): + from zope.component import getSiteManager from repoze.bfg.interfaces import ISettings - from zope.component import provideUtility + sm = getSiteManager() settings = {'a':1} - provideUtility(settings, ISettings) + sm.registerUtility(settings, ISettings) self.assertEqual(self._callFUT(), settings) class TestGetOptions(unittest.TestCase): diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py index 05cddc980..7e468725a 100644 --- a/repoze/bfg/tests/test_testing.py +++ b/repoze/bfg/tests/test_testing.py @@ -507,39 +507,52 @@ class TestDummyTemplateRenderer(unittest.TestCase): result = renderer({'a':1, 'b':2}) self.assertEqual(result, 'abc') -class CleanUpTests(object): +class TestSetUp(unittest.TestCase): def setUp(self): - from repoze.bfg.testing import _cleanups - self._old_cleanups = _cleanups[:] - - def tearDown(self): - from repoze.bfg import testing - testing._cleanups = self._old_cleanups - -class TestAddCleanUp(CleanUpTests, unittest.TestCase): - def _getFUT(self, ): - from repoze.bfg.testing import addCleanUp - return addCleanUp + from zope.component import getSiteManager + getSiteManager.reset() + + def _callFUT(self, ): + from repoze.bfg.testing import setUp + return setUp() def test_it(self): - addCleanUp = self._getFUT() - addCleanUp(1, ('a', 'b'), {'foo':'bar'}) - from repoze.bfg.testing import _cleanups - self.assertEqual(_cleanups[-1], (1, ('a', 'b'), {'foo':'bar'})) + from zope.component.globalregistry import base + from zope.interface import Interface + from zope.component import getSiteManager + getSiteManager.sethook(lambda *arg: base) + class IFoo(Interface): + pass + def foo(): + """ """ + base.registerUtility(foo, IFoo) + sm = getSiteManager() + self.assertEqual(sm.queryUtility(IFoo), foo) + self._callFUT() + newsm = getSiteManager() + self.assertEqual(newsm.queryUtility(IFoo), None) -class TestCleanUp(CleanUpTests, unittest.TestCase): - def _getFUT(self, ): +class TestCleanUp(TestSetUp): + def _callFUT(self, ): from repoze.bfg.testing import cleanUp - return cleanUp + return cleanUp() + +class TestTearDown(unittest.TestCase): + def setUp(self): + from zope.component import getSiteManager + getSiteManager.reset() + + def _callFUT(self, ): + from repoze.bfg.testing import tearDown + return tearDown() def test_it(self): - from repoze.bfg.testing import _cleanups - cleanUp = self._getFUT() - L = [] - def f(*arg, **kw): - L.append((arg, kw)) - _cleanups.append((f, ('a', '1'), {'kw':'1'})) - cleanUp() - self.assertEqual(L, [(('a', '1'), {'kw':'1'})]) - + from zope.component.globalregistry import base + from zope.component import getSiteManager + getSiteManager.sethook(lambda *arg: 'foo') + sm = getSiteManager() + self.assertEqual(sm, 'foo') + self._callFUT() + newsm = getSiteManager() + self.assertEqual(newsm, base) diff --git a/repoze/bfg/tests/test_threadlocal.py b/repoze/bfg/tests/test_threadlocal.py index 2cf405508..09a25debd 100644 --- a/repoze/bfg/tests/test_threadlocal.py +++ b/repoze/bfg/tests/test_threadlocal.py @@ -21,10 +21,11 @@ class TestThreadLocalManager(unittest.TestCase): self.assertEqual(local.get(), 1) def test_default(self): - from zope.component import getGlobalSiteManager - local = self._makeOne(getGlobalSiteManager) + def thedefault(): + return '123' + local = self._makeOne(thedefault) self.assertEqual(local.stack, []) - self.assertEqual(local.get(), getGlobalSiteManager()) + self.assertEqual(local.get(), '123') def test_push_and_pop(self): local = self._makeOne() diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py index a4e90bc07..69a8b4b6f 100644 --- a/repoze/bfg/tests/test_traversal.py +++ b/repoze/bfg/tests/test_traversal.py @@ -391,10 +391,10 @@ class FindModelTests(unittest.TestCase): def _registerTraverserFactory(self, traverser): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import ITraverserFactory from zope.interface import Interface - gsm.registerAdapter(traverser, (Interface,), ITraverserFactory) + sm.registerAdapter(traverser, (Interface,), ITraverserFactory) def test_list(self): model = DummyContext() @@ -663,10 +663,10 @@ class TraversalContextURLTests(unittest.TestCase): def _registerTraverserFactory(self, traverser): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import ITraverserFactory from zope.interface import Interface - gsm.registerAdapter(traverser, (Interface,), ITraverserFactory) + sm.registerAdapter(traverser, (Interface,), ITraverserFactory) def test_class_conforms_to_IContextURL(self): from zope.interface.verify import verifyClass @@ -849,12 +849,12 @@ class TestVirtualRoot(unittest.TestCase): return virtual_root(model, request) def test_registered(self): - from zope.component import getGlobalSiteManager + from zope.component import getSiteManager from repoze.bfg.interfaces import IContextURL from zope.interface import Interface - gsm = getGlobalSiteManager() - gsm.registerAdapter(DummyContextURL, (Interface,Interface), - IContextURL) + sm = getSiteManager() + sm.registerAdapter(DummyContextURL, (Interface,Interface), + IContextURL) context = DummyContext() request = DummyRequest() result = self._callFUT(context, request) @@ -880,10 +880,10 @@ class TraverseTests(unittest.TestCase): def _registerTraverserFactory(self, traverser): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import ITraverserFactory from zope.interface import Interface - gsm.registerAdapter(traverser, (Interface,), ITraverserFactory) + sm.registerAdapter(traverser, (Interface,), ITraverserFactory) def test_list(self): model = DummyContext() @@ -977,10 +977,10 @@ class UnderTraverseTests(unittest.TestCase): def _registerTraverserFactory(self, traverser): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import ITraverserFactory from zope.interface import Interface - gsm.registerAdapter(traverser, (Interface,), ITraverserFactory) + sm.registerAdapter(traverser, (Interface,), ITraverserFactory) def test_default_traverser_factory(self): context = DummyContext() diff --git a/repoze/bfg/tests/test_url.py b/repoze/bfg/tests/test_url.py index 1199328e3..6754f6f34 100644 --- a/repoze/bfg/tests/test_url.py +++ b/repoze/bfg/tests/test_url.py @@ -16,15 +16,15 @@ class ModelURLTests(unittest.TestCase): def _registerContextURL(self): from repoze.bfg.interfaces import IContextURL from zope.interface import Interface - from zope.component import getGlobalSiteManager + from zope.component import getSiteManager class DummyContextURL(object): def __init__(self, context, request): pass def __call__(self): return 'http://example.com/context/' - gsm = getGlobalSiteManager() - gsm.registerAdapter(DummyContextURL, (Interface, Interface), - IContextURL) + sm = getSiteManager() + sm.registerAdapter(DummyContextURL, (Interface, Interface), + IContextURL) def test_root_default(self): self._registerContextURL() diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py index 8e2310c09..eee5a61bd 100644 --- a/repoze/bfg/tests/test_view.py +++ b/repoze/bfg/tests/test_view.py @@ -11,9 +11,9 @@ class BaseTest(object): def _registerView(self, app, name, *for_): import zope.component - gsm = zope.component.getGlobalSiteManager() + sm = zope.component.getSiteManager() from repoze.bfg.interfaces import IView - gsm.registerAdapter(app, for_, IView, name) + sm.registerAdapter(app, for_, IView, name) def _makeEnviron(self, **extras): environ = { @@ -466,8 +466,8 @@ class AppendSlashNotFoundView(unittest.TestCase): return self.routelist mapper = DummyMapper() import zope.component - gsm = zope.component.getGlobalSiteManager() - gsm.registerUtility(mapper, IRoutesMapper) + sm = zope.component.getSiteManager() + sm.registerUtility(mapper, IRoutesMapper) return mapper def test_no_mapper(self): diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py index 1f0fc44d8..d592fd902 100644 --- a/repoze/bfg/tests/test_zcml.py +++ b/repoze/bfg/tests/test_zcml.py @@ -1486,11 +1486,11 @@ class TestConnectRouteFunction(unittest.TestCase): return connect_route(path, name, factory) def _registerRoutesMapper(self): - from zope.component import getGlobalSiteManager - gsm = getGlobalSiteManager() + from zope.component import getSiteManager + sm = getSiteManager() mapper = DummyMapper() from repoze.bfg.interfaces import IRoutesMapper - gsm.registerUtility(mapper, IRoutesMapper) + sm.registerUtility(mapper, IRoutesMapper) return mapper def test_defaults(self): diff --git a/repoze/bfg/threadlocal.py b/repoze/bfg/threadlocal.py index 5039ec92f..4fa53fa1e 100644 --- a/repoze/bfg/threadlocal.py +++ b/repoze/bfg/threadlocal.py @@ -1,4 +1,5 @@ import threading + from zope.component import getGlobalSiteManager class ThreadLocalManager(threading.local): @@ -30,10 +31,8 @@ class ThreadLocalManager(threading.local): self.stack[:] = [] def defaults(): - defaults = {'request':None} gsm = getGlobalSiteManager() - defaults['registry'] = gsm - return defaults + return {'request':None, 'registry':gsm} manager = ThreadLocalManager(default=defaults) |