Merge "routesmapper branch" to trunk.

author: Chris McDonough <chrism@agendaless.com> 2009-01-18 23:38:47 +0000
committer: Chris McDonough <chrism@agendaless.com> 2009-01-18 23:38:47 +0000
commit: 62267e01d6eeaf8de871487898ad1ce02878c29a (patch)
tree: 234346245e58993c27e139906ee7a19a7b67a8e4 /repoze/bfg/tests
parent: 58afb33d70dece410b998a9c064eba42e3f843d7 (diff)
download: pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.tar.gz
pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.tar.bz2
pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.zip
11 files changed, 536 insertions, 35 deletions
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 @@
+<configure xmlns="http://namespaces.repoze.org/bfg">
+
+  <include package="repoze.bfg.includes" />
+
+  <route
+    path=":id/:view_name"
+    context_interfaces=".models.IFixture"/>
+
+  <view
+      name="default"
+      view=".views.fixture_view"
+      for=".models.IFixture"
+      permission="repoze.view"
+      />
+
+</configure>
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 @@
+<html xmlns="http://www.w3.org/1999/xhtml"
+     xmlns:tal="http://xml.zope.org/namespaces/tal">
+<head></head>
+<body>
+</body>
+</html>
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
author	Chris McDonough <chrism@agendaless.com>	2009-01-18 23:38:47 +0000
committer	Chris McDonough <chrism@agendaless.com>	2009-01-18 23:38:47 +0000
commit	62267e01d6eeaf8de871487898ad1ce02878c29a (patch)
tree	234346245e58993c27e139906ee7a19a7b67a8e4 /repoze/bfg/tests
parent	58afb33d70dece410b998a9c064eba42e3f843d7 (diff)
download	pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.tar.gz pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.tar.bz2 pyramid-62267e01d6eeaf8de871487898ad1ce02878c29a.zip