From 62267e01d6eeaf8de871487898ad1ce02878c29a Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Sun, 18 Jan 2009 23:38:47 +0000 Subject: Merge "routesmapper branch" to trunk. --- repoze/bfg/tests/fixtureapp/views.py | 2 +- repoze/bfg/tests/routesapp/__init__.py | 1 + repoze/bfg/tests/routesapp/configure.zcml | 16 ++ repoze/bfg/tests/routesapp/models.py | 5 + repoze/bfg/tests/routesapp/templates/fixture.pt | 6 + repoze/bfg/tests/routesapp/views.py | 8 + repoze/bfg/tests/test_registry.py | 15 +- repoze/bfg/tests/test_router.py | 87 ++++++++++ repoze/bfg/tests/test_traversal.py | 55 +++++++ repoze/bfg/tests/test_urldispatch.py | 167 ++++++++++++++++--- repoze/bfg/tests/test_zcml.py | 209 ++++++++++++++++++++++++ 11 files changed, 536 insertions(+), 35 deletions(-) create mode 100644 repoze/bfg/tests/routesapp/__init__.py create mode 100644 repoze/bfg/tests/routesapp/configure.zcml create mode 100644 repoze/bfg/tests/routesapp/models.py create mode 100644 repoze/bfg/tests/routesapp/templates/fixture.pt create mode 100644 repoze/bfg/tests/routesapp/views.py (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/fixtureapp/views.py b/repoze/bfg/tests/fixtureapp/views.py index ccf0e4811..f805b88c9 100644 --- a/repoze/bfg/tests/fixtureapp/views.py +++ b/repoze/bfg/tests/fixtureapp/views.py @@ -1,7 +1,7 @@ from zope.interface import Interface def fixture_view(context, request): - return None + """ """ class IDummy(Interface): pass diff --git a/repoze/bfg/tests/routesapp/__init__.py b/repoze/bfg/tests/routesapp/__init__.py new file mode 100644 index 000000000..546616b2c --- /dev/null +++ b/repoze/bfg/tests/routesapp/__init__.py @@ -0,0 +1 @@ +# fixture application diff --git a/repoze/bfg/tests/routesapp/configure.zcml b/repoze/bfg/tests/routesapp/configure.zcml new file mode 100644 index 000000000..388fc2330 --- /dev/null +++ b/repoze/bfg/tests/routesapp/configure.zcml @@ -0,0 +1,16 @@ + + + + + + + + + diff --git a/repoze/bfg/tests/routesapp/models.py b/repoze/bfg/tests/routesapp/models.py new file mode 100644 index 000000000..a57b06308 --- /dev/null +++ b/repoze/bfg/tests/routesapp/models.py @@ -0,0 +1,5 @@ +from zope.interface import Interface + +class IFixture(Interface): + pass + diff --git a/repoze/bfg/tests/routesapp/templates/fixture.pt b/repoze/bfg/tests/routesapp/templates/fixture.pt new file mode 100644 index 000000000..06dd4e2b1 --- /dev/null +++ b/repoze/bfg/tests/routesapp/templates/fixture.pt @@ -0,0 +1,6 @@ + + + + + diff --git a/repoze/bfg/tests/routesapp/views.py b/repoze/bfg/tests/routesapp/views.py new file mode 100644 index 000000000..f805b88c9 --- /dev/null +++ b/repoze/bfg/tests/routesapp/views.py @@ -0,0 +1,8 @@ +from zope.interface import Interface + +def fixture_view(context, request): + """ """ + +class IDummy(Interface): + pass + diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py index 5a8bc15c6..edd45b458 100644 --- a/repoze/bfg/tests/test_registry.py +++ b/repoze/bfg/tests/test_registry.py @@ -2,7 +2,7 @@ import unittest from zope.testing.cleanup import cleanUp -class TestMakeRegistry(unittest.TestCase): +class TestPopulateRegistry(unittest.TestCase): def setUp(self): cleanUp() @@ -10,8 +10,8 @@ class TestMakeRegistry(unittest.TestCase): cleanUp() def _callFUT(self, *arg, **kw): - from repoze.bfg.registry import makeRegistry - return makeRegistry(*arg, **kw) + from repoze.bfg.registry import populateRegistry + return populateRegistry(*arg, **kw) def test_it(self): from repoze.bfg.tests import fixtureapp @@ -20,11 +20,12 @@ class TestMakeRegistry(unittest.TestCase): import repoze.bfg.registry try: old = repoze.bfg.registry.setRegistryManager(dummyregmgr) - registry = self._callFUT('configure.zcml', - fixtureapp, - lock=dummylock) from zope.component.registry import Components - self.failUnless(isinstance(registry, Components)) + registry = Components('hello') + self._callFUT(registry, + 'configure.zcml', + fixtureapp, + lock=dummylock) self.assertEqual(dummylock.acquired, True) self.assertEqual(dummylock.released, True) self.assertEqual(dummyregmgr.registry, registry) diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py index a4d0cb369..2a8539d4c 100644 --- a/repoze/bfg/tests/test_router.py +++ b/repoze/bfg/tests/test_router.py @@ -123,6 +123,24 @@ class RouterTests(unittest.TestCase): self.failIf('debug_notfound' in result[0]) self.assertEqual(len(logger.messages), 0) + def test_call_root_is_icontextnotfound(self): + from zope.interface import implements + from repoze.bfg.interfaces import IContextNotFound + class NotFound(object): + implements(IContextNotFound) + context = NotFound() + traversalfactory = make_traversal_factory(context, '', []) + self._registerTraverserFactory(traversalfactory, '', None) + environ = self._makeEnviron() + start_response = DummyStartResponse() + rootfactory = make_rootfactory(NotFound()) + self._registerRootFactory(rootfactory) + router = self._makeOne(None) + result = router(environ, start_response) + status = start_response.status + self.assertEqual(status, '404 Not Found') + self.failUnless('http://localhost:8080' in result[0], result) + def test_call_no_view_registered_debug_notfound_false(self): rootfactory = make_rootfactory(None) environ = self._makeEnviron() @@ -587,6 +605,75 @@ class MakeAppTests(unittest.TestCase): finally: repoze.bfg.router.registry_manager = old_registry_manager + def test_routes_in_config_with_rootpolicy(self): + options= {'reload_templates':True, + 'debug_authorization':True} + import repoze.bfg.router + old_registry_manager = repoze.bfg.router.registry_manager + dummy_registry_manager = DummyRegistryManager() + repoze.bfg.router.registry_manager = dummy_registry_manager + from repoze.bfg.urldispatch import RoutesRootFactory + try: + from repoze.bfg.tests import routesapp + rootpolicy = make_rootfactory(None) + app = self._callFUT(rootpolicy, routesapp, options=options) + 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.get_root, rootpolicy) + self.assertEqual(dummy_registry_manager.pushed, True) + self.assertEqual(dummy_registry_manager.popped, True) + finally: + repoze.bfg.router.registry_manager = old_registry_manager + + def test_routes_in_config_no_rootpolicy(self): + options= {'reload_templates':True, + 'debug_authorization':True} + import repoze.bfg.router + old_registry_manager = repoze.bfg.router.registry_manager + dummy_registry_manager = DummyRegistryManager() + repoze.bfg.router.registry_manager = dummy_registry_manager + from repoze.bfg.urldispatch import RoutesRootFactory + try: + from repoze.bfg.tests import routesapp + app = 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 = 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.get_root, None) + self.assertEqual(dummy_registry_manager.pushed, True) + self.assertEqual(dummy_registry_manager.popped, True) + finally: + repoze.bfg.router.registry_manager = old_registry_manager + + def test_no_routes_in_config_no_rootpolicy(self): + options= {'reload_templates':True, + 'debug_authorization':True} + import repoze.bfg.router + old_registry_manager = repoze.bfg.router.registry_manager + dummy_registry_manager = DummyRegistryManager() + repoze.bfg.router.registry_manager = dummy_registry_manager + try: + from repoze.bfg.tests import fixtureapp + self.assertRaises(ValueError, self._callFUT, None, fixtureapp, + options=options) + finally: + repoze.bfg.router.registry_manager = old_registry_manager + class DummyRegistryManager: def push(self, registry): self.pushed = True diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py index e83717843..873291bb8 100644 --- a/repoze/bfg/tests/test_traversal.py +++ b/repoze/bfg/tests/test_traversal.py @@ -198,6 +198,61 @@ class ModelGraphTraverserTests(unittest.TestCase): environ = self._getEnviron(PATH_INFO='/%s' % segment) ctx, name, subpath = policy(environ) # test is: this doesn't fail +class RoutesModelTraverserTests(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.traversal import RoutesModelTraverser + return RoutesModelTraverser + + def _makeOne(self, model): + klass = self._getTargetClass() + return klass(model) + + def test_class_conforms_to_ITraverser(self): + from zope.interface.verify import verifyClass + from repoze.bfg.interfaces import ITraverser + verifyClass(ITraverser, self._getTargetClass()) + + def test_instance_conforms_to_ITraverser(self): + from zope.interface.verify import verifyObject + from repoze.bfg.interfaces import ITraverser + verifyObject(ITraverser, self._makeOne(None)) + + def test_call_with_only_controller(self): + model = DummyContext() + model.controller = 'controller' + traverser = self._makeOne(model) + result = traverser({}) + self.assertEqual(result[0], model) + self.assertEqual(result[1], 'controller') + self.assertEqual(result[2], []) + + def test_call_with_only_view_name(self): + model = DummyContext() + model.view_name = 'view_name' + traverser = self._makeOne(model) + result = traverser({}) + self.assertEqual(result[0], model) + self.assertEqual(result[1], 'view_name') + self.assertEqual(result[2], []) + + def test_call_with_subpath(self): + model = DummyContext() + model.view_name = 'view_name' + model.subpath = '/a/b/c' + traverser = self._makeOne(model) + result = traverser({}) + self.assertEqual(result[0], model) + self.assertEqual(result[1], 'view_name') + self.assertEqual(result[2], ['a', 'b', 'c']) + + def test_call_with_no_view_name_or_controller(self): + model = DummyContext() + traverser = self._makeOne(model) + result = traverser({}) + self.assertEqual(result[0], model) + self.assertEqual(result[1], '') + self.assertEqual(result[2], []) + class FindInterfaceTests(unittest.TestCase): def _callFUT(self, context, iface): from repoze.bfg.traversal import find_interface diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py index 806af28df..82d4af991 100644 --- a/repoze/bfg/tests/test_urldispatch.py +++ b/repoze/bfg/tests/test_urldispatch.py @@ -1,6 +1,14 @@ import unittest class RoutesMapperTests(unittest.TestCase): + def setUp(self): + from zope.deprecation import __show__ + __show__.off() + + def tearDown(self): + from zope.deprecation import __show__ + __show__.on() + def _getEnviron(self, **kw): environ = {'SERVER_NAME':'localhost', 'wsgi.url_scheme':'http'} @@ -72,36 +80,141 @@ class RoutesMapperTests(unittest.TestCase): result = url_for(controller='foo', action='action2', article='article2') self.assertEqual(result, '/archives/action2/article2') -class TestRoutesModelTraverser(unittest.TestCase): +class RoutesRootFactoryTests(unittest.TestCase): + def _getEnviron(self, **kw): + environ = {'SERVER_NAME':'localhost', + 'wsgi.url_scheme':'http'} + environ.update(kw) + return environ + def _getTargetClass(self): - from repoze.bfg.urldispatch import RoutesModelTraverser - return RoutesModelTraverser + from repoze.bfg.urldispatch import RoutesRootFactory + return RoutesRootFactory - def _makeOne(self, model): + def _makeOne(self, get_root): klass = self._getTargetClass() - return klass(model) - - def test_class_conforms_to_ITraverser(self): - from zope.interface.verify import verifyClass - from repoze.bfg.interfaces import ITraverser - verifyClass(ITraverser, self._getTargetClass()) - - def test_instance_conforms_to_ITraverser(self): - from zope.interface.verify import verifyObject - from repoze.bfg.interfaces import ITraverser - verifyObject(ITraverser, self._makeOne(None)) - - def test_call(self): - model = DummyModel() - traverser = self._makeOne(model) - result = traverser({}) - self.assertEqual(result[0], model) - self.assertEqual(result[1], 'controller') - self.assertEqual(result[2], '') - -class DummyModel: - controller = 'controller' - + return klass(get_root) + + def test_no_route_matches(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + environ = self._getEnviron(PATH_INFO='/') + result = mapper(environ) + self.assertEqual(result, marker) + self.assertEqual(mapper.environ, environ) + + def test_route_matches(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + mapper.connect('archives/:action/:article', view_name='foo') + environ = self._getEnviron(PATH_INFO='/archives/action1/article1') + result = mapper(environ) + from repoze.bfg.interfaces import IRoutesContext + self.failUnless(IRoutesContext.providedBy(result)) + self.assertEqual(result.view_name, 'foo') + self.assertEqual(result.action, 'action1') + self.assertEqual(result.article, 'article1') + + def test_unicode_in_route_default(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + class DummyRoute: + routepath = ':id' + context_factory = None + context_interfaces = () + la = unicode('\xc3\xb1a', 'utf-8') + mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute) + mapper.connect(':la') + environ = self._getEnviron(PATH_INFO='/foo') + result = mapper(environ) + from repoze.bfg.interfaces import IRoutesContext + self.failUnless(IRoutesContext.providedBy(result)) + self.assertEqual(getattr(result, la.encode('utf-8')), 'id') + + def test_no_fallback_get_root(self): + marker = () + mapper = self._makeOne(None) + mapper.connect('wont/:be/:found', view_name='foo') + environ = self._getEnviron(PATH_INFO='/archives/action1/article1') + result = mapper(environ) + from repoze.bfg.urldispatch import RoutesContextNotFound + self.failUnless(isinstance(result, RoutesContextNotFound)) + + def test_custom_context_factory(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + from zope.interface import implements, Interface + class IDummy(Interface): + pass + class Dummy(object): + implements(IDummy) + def __init__(self, **kw): + self.__dict__.update(kw) + mapper.connect('archives/:action/:article', view_name='foo', + context_factory=Dummy) + environ = self._getEnviron(PATH_INFO='/archives/action1/article1') + result = mapper(environ) + self.assertEqual(result.view_name, 'foo') + self.assertEqual(result.action, 'action1') + self.assertEqual(result.article, 'article1') + from repoze.bfg.interfaces import IRoutesContext + self.failUnless(IRoutesContext.providedBy(result)) + self.failUnless(isinstance(result, Dummy)) + self.failUnless(IDummy.providedBy(result)) + self.failIf(hasattr(result, 'context_factory')) + + def test_custom_context_interfaces(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + from zope.interface import Interface + class IDummy(Interface): + pass + mapper.connect('archives/:action/:article', view_name='foo', + context_interfaces = [IDummy]) + environ = self._getEnviron(PATH_INFO='/archives/action1/article1') + result = mapper(environ) + self.assertEqual(result.view_name, 'foo') + self.assertEqual(result.action, 'action1') + self.assertEqual(result.article, 'article1') + from repoze.bfg.interfaces import IRoutesContext + self.failUnless(IRoutesContext.providedBy(result)) + self.failUnless(IDummy.providedBy(result)) + self.failIf(hasattr(result, 'context_interfaces')) + + def test_has_routes(self): + mapper = self._makeOne(None) + self.assertEqual(mapper.has_routes(), False) + mapper.connect('archives/:action/:article', view_name='foo') + self.assertEqual(mapper.has_routes(), True) + + def test_url_for(self): + marker = () + get_root = make_get_root(marker) + mapper = self._makeOne(get_root) + mapper.connect('archives/:action/:article', view_name='foo') + environ = self._getEnviron(PATH_INFO='/archives/action1/article1') + result = mapper(environ) + from routes import url_for + result = url_for(view_name='foo', action='action2', article='article2') + self.assertEqual(result, '/archives/action2/article2') + +class TestRoutesContextNotFound(unittest.TestCase): + def _getTargetClass(self): + from repoze.bfg.urldispatch import RoutesContextNotFound + return RoutesContextNotFound + + def _makeOne(self, msg): + return self._getTargetClass()(msg) + + def test_it(self): + inst = self._makeOne('hi') + self.assertEqual(inst.msg, 'hi') + def make_get_root(result): def dummy_get_root(environ): return result diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py index a59f88ae1..26de9481a 100644 --- a/repoze/bfg/tests/test_zcml.py +++ b/repoze/bfg/tests/test_zcml.py @@ -227,7 +227,184 @@ class TestViewDirective(unittest.TestCase): self.assertEqual(regadapt['args'][3], IView) self.assertEqual(regadapt['args'][4], '') self.assertEqual(regadapt['args'][5], None) + +class TestRouteRequirementFunction(unittest.TestCase): + def _callFUT(self, context, attr, expr): + from repoze.bfg.zcml import route_requirement + return route_requirement(context, attr, expr) + + def test_it(self): + context = DummyContext() + context.context = DummyContext() + context.context.requirements = {} + self._callFUT(context, 'a', 'b') + self.assertEqual(context.context.requirements['a'], 'b') + self.assertRaises(ValueError, self._callFUT, context, 'a', 'b') + +class TestConnectRouteFunction(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, directive): + from repoze.bfg.zcml import connect_route + return connect_route(directive) + + def _registerRoutesMapper(self): + from zope.component import getGlobalSiteManager + gsm = getGlobalSiteManager() + mapper = DummyMapper() + from repoze.bfg.interfaces import IRoutesMapper + gsm.registerUtility(mapper, IRoutesMapper) + return mapper + + def test_no_mapper(self): + directive = DummyRouteDirective() + self._callFUT(directive) # doesn't blow up when no routes mapper reg'd + + def test_defaults(self): + mapper = self._registerRoutesMapper() + directive = DummyRouteDirective() + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + self.assertEqual(mapper.connections[0][1], {'requirements': {}}) + + def test_name_and_path(self): + mapper = self._registerRoutesMapper() + directive = DummyRouteDirective(name='abc') + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('abc', 'a/b/c',)) + self.assertEqual(mapper.connections[0][1], {'requirements': {}}) + + def test_all_directives(self): + mapper = self._registerRoutesMapper() + def foo(): + """ """ + directive = DummyRouteDirective( + minimize=True, explicit=True, encoding='utf-8', static=True, + filter=foo, absolute=True, member_name='m', collection_name='c', + parent_member_name='p', parent_collection_name='c', + condition_method='GET', condition_subdomain=True, + condition_function=foo, subdomains=['a'], + context_factory=foo, context_interfaces=[IDummy]) + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + pr = {'member_name':'p', 'collection_name':'c'} + c = {'method':'GET', 'sub_domain':['a'], 'function':foo} + self.assertEqual(mapper.connections[0][1], + {'requirements': {}, + '_minimize':True, + '_explicit':True, + '_encoding':'utf-8', + '_static':True, + '_filter':foo, + '_absolute':True, + '_member_name':'m', + '_collection_name':'c', + '_parent_resource':pr, + 'conditions':c, + 'context_factory':foo, + 'context_interfaces':[IDummy], + }) + + def test_condition_subdomain_true(self): + mapper = self._registerRoutesMapper() + directive = DummyRouteDirective(static=True, explicit=True, + condition_subdomain=True) + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + self.assertEqual(mapper.connections[0][1], + {'requirements': {}, + '_static':True, + '_explicit':True, + 'conditions':{'sub_domain':True} + }) + + def test_condition_function(self): + mapper = self._registerRoutesMapper() + def foo(e, r): + """ """ + directive = DummyRouteDirective(static=True, explicit=True, + condition_function=foo) + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + self.assertEqual(mapper.connections[0][1], + {'requirements': {}, + '_static':True, + '_explicit':True, + 'conditions':{'function':foo} + }) + + def test_condition_method(self): + mapper = self._registerRoutesMapper() + directive = DummyRouteDirective(static=True, explicit=True, + condition_method='GET') + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + self.assertEqual(mapper.connections[0][1], + {'requirements': {}, + '_static':True, + '_explicit':True, + 'conditions':{'method':'GET'} + }) + + def test_subdomains(self): + mapper = self._registerRoutesMapper() + directive = DummyRouteDirective(static=True, explicit=True, + subdomains=['a', 'b']) + self._callFUT(directive) + self.assertEqual(len(mapper.connections), 1) + self.assertEqual(mapper.connections[0][0], ('a/b/c',)) + self.assertEqual(mapper.connections[0][1], + {'requirements': {}, + '_static':True, + '_explicit':True, + 'conditions':{'sub_domain':['a', 'b']} + }) + +class TestRouteGroupingContextDecorator(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _getTargetClass(self): + from repoze.bfg.zcml import Route + return Route + + def _makeOne(self, context, path, **kw): + return self._getTargetClass()(context, path, **kw) + + def test_defaults(self): + context = DummyContext() + route = self._makeOne(context, 'abc') + self.assertEqual(route.requirements, {}) + self.assertEqual(route.parent_member_name, None) + self.assertEqual(route.parent_collection_name, None) + + def test_parent_collection_name_missing(self): + context = DummyContext() + self.assertRaises(ValueError, self._makeOne, context, 'abc', + parent_member_name='a') + + def test_parent_collection_name_present(self): + context = DummyContext() + route = self._makeOne(context, 'abc', + parent_member_name='a', + parent_collection_name='p') + self.assertEqual(route.parent_member_name, 'a') + self.assertEqual(route.parent_collection_name, 'p') + class TestZCMLPickling(unittest.TestCase): i = 0 @@ -565,6 +742,38 @@ class DummyContext: class Dummy: pass +class DummyRouteDirective: + encoding = None + static = False + minimize = False + explicit = False + static = False + filter = None + absolute = False + member_name = False + collection_name = None + parent_member_name = None + parent_collection_name = None + condition_method = None + condition_subdomain = None + condition_function = None + subdomains = None + path = 'a/b/c' + name = None + context_factory = None + context_interfaces = () + def __init__(self, **kw): + if not 'requirements' in kw: + kw['requirements'] = {} + self.__dict__.update(kw) + +class DummyMapper: + def __init__(self): + self.connections = [] + + def connect(self, *arg, **kw): + self.connections.append((arg, kw)) + from zope.interface import Interface class IDummy(Interface): pass -- cgit v1.2.3